src/predicates.c File Reference

#include "copyright.h"
#include "config.h"
#include <signal.h>
#include "mudconf.h"
#include "db.h"
#include "interface.h"
#include "externs.h"
#include "match.h"
#include "command.h"
#include "alloc.h"
#include "attrs.h"
#include "powers.h"
#include "ansi.h"
#include "patchlevel.h"
#include "htab.h"

Include dependency graph for predicates.c:

Go to the source code of this file.

Functions
dbref	match_thing (dbref, char *)
int	do_command (DESC *, char *)
void	dump_database (void)
void	dump_restart_db (void)
char *	tprintf (va_alist)
void	safe_tprintf_str (va_alist)
dbref	insert_first (dbref head, dbref thing)
dbref	remove_first (dbref head, dbref thing)
dbref	reverse_list (dbref list)
int	member (dbref thing, dbref list)
int	is_integer (char *str)
int	is_number (char *str)
int	could_doit (dbref player, dbref thing, int locknum)
int	can_see (dbref player, dbref thing, int can_see_loc)
static int	pay_quota (dbref who, int cost)
int	canpayfees (dbref player, dbref who, int pennies, int quota)
int	payfor (dbref who, int cost)
void	add_quota (dbref who, int payment)
void	giveto (dbref who, int pennies)
int	ok_name (const char *name)
int	ok_player_name (const char *name)
int	ok_attr_name (const char *attrname)
int	ok_password (const char *password)
void	handle_ears (dbref thing, int could_hear, int can_hear)
void	do_switch (dbref player, dbref cause, int key, char *expr, char *args[], int nargs, char *cargs[], int ncargs)
void	do_addcommand (dbref player, dbref cause, int key, char *name, char *command)
void	do_listcommands (dbref player, dbref cause, int key, char *name)
void	do_delcommand (dbref player, dbref cause, int key, char *name, char *command)
void	handle_prog (DESC *d, char *message)
void	do_quitprog (dbref player, dbref cause, int key, char *name)
void	do_prog (dbref player, dbref cause, int key, char *name, char *command)
void	do_restart (dbref player, dbref cause, int key)
void	do_comment (dbref player, dbref cause, int key)
static dbref	promote_dflt (dbref old, dbref new)
dbref	match_possessed (dbref player, dbref thing, char *target, dbref dflt, int check_enter)
void	parse_range (char **name, dbref *low_bound, dbref *high_bound)
int	parse_thing_slash (dbref player, char *thing, char **after, dbref *it)
int	get_obj_and_lock (dbref player, char *what, dbref *it, ATTR **attr, char *errmsg, char **bufc)
dbref	where_is (dbref what)
dbref	where_room (dbref what)
int	locatable (dbref player, dbref it, dbref cause)
int	nearby (dbref player, dbref thing)
int	exit_visible (dbref exit, dbref player, int key)
int	exit_displayable (dbref exit, dbref player, int key)
dbref	next_exit (dbref player, dbref this, int exam_here)
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 player, dbref cause, int key, char *victim_str, char *args[], int nargs)
Variables
NAMETAB	lock_sw []

---

Function Documentation

void add_quota	(	dbref	who,
		int	payment
	)

Definition at line 368 of file predicates.c.

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

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

{
        dbref aowner;
        int aflags;
        char buf[20], *quota;

        quota = atr_get(who, A_RQUOTA, &aowner, &aflags);
        sprintf(buf, "%d", atoi(quota) + payment);
        free_lbuf(quota);
        atr_add_raw(who, A_RQUOTA, buf);
}

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

Definition at line 248 of file predicates.c.

References Connected, Dark, confdata::dark_sleepers, isExit, isPlayer, 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 0;
        }
        /*
         * You don't see yourself or exits 
         */

        if((player == thing) || isExit(thing)) {
                return 0;
        }
        /*
         * 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) {
                return (!Dark(thing) || (mudconf.see_own_dark &&
                                                                 MyopicExam(player, thing)));
        } else {
                return ((Light(thing) && !Dark(thing)) || (mudconf.see_own_dark &&
                                                                                                   MyopicExam(player,
                                                                                                                          thing)));
        }
}

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

Definition at line 323 of file predicates.c.

References Free_Money, confdata::many_coins, mudconf, notify, notify_printf(), Owner, pay_quota(), payfor(), Pennies(), confdata::quotas, 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_printf(player, "Sorry, you don't have enough %s.",
                                                  mudconf.many_coins);
                } else {
                        notify_printf(player,
                                                  "Sorry, that player doesn't have enough %s.",
                                                  mudconf.many_coins);
                }
                return 0;
        }
        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 0;
                }
        }
        payfor(who, pennies);
        return 1;
}

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

Definition at line 226 of file predicates.c.

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

Referenced by atr_match1(), check_zone(), check_zone_for_player(), do_drop(), do_enter_internal(), do_get(), do_leave(), do_link(), do_teleport(), do_test_access(), do_use(), fwdlist_load(), give_money(), give_thing(), link_exit(), look_in(), move_exit(), move_via_teleport(), notify_checked(), open_exit(), page_check(), promote_match(), and sp_ok().

{
        char *key;
        dbref aowner;
        int aflags, doit;

        /*
         * no if nonplayer trys to get key 
         */

        if(!isPlayer(player) && Key(thing)) {
                return 0;
        }
        if(Pass_Locks(player))
                return 1;

        key = atr_get(thing, locknum, &aowner, &aflags);
        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
	)

Have player do something to/with thing

Definition at line 1479 of file predicates.c.

References A_CHARGES, A_RUNOUT, alloc_lbuf, alloc_sbuf, atr_add_raw(), atr_pget(), EV_EVAL, EV_FIGNORE, EV_TOP, exec(), free_lbuf, free_sbuf, statedata::global_regs, Good_obj, Has_location, loc, Location, mudstate, Name(), NOTHING, notify, notify_except2(), tprintf(), and wait_que().

Referenced by ChannelEmitKill(), check_events(), do_clone(), do_delcomchannel(), do_drop(), do_enter_internal(), do_get(), do_joinchannel(), do_kill(), do_leave(), do_leavechannel(), do_teleport(), do_trigger(), do_use(), do_verb(), give_money(), give_thing(), look_in(), look_simple(), make_mine_explode(), mech_embark(), mech_enterbase(), move_exit(), move_via_exit(), move_via_generic(), move_via_teleport(), notify_checked(), process_enter_loc(), process_leave_loc(), process_preload(), send_mail(), show_a_desc(), and show_desc().

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

        /*
         * message to player 
         */

        if(what > 0) {
                d = atr_pget(thing, what, &aowner, &aflags);
                if(*d) {
                        buff = bp = alloc_lbuf("did_it.1");
                        str = d;
                        exec(buff, &bp, 0, thing, player,
                                 EV_EVAL | EV_FIGNORE | EV_TOP, &str, args, nargs);
                        *bp = '\0';
                        notify(player, buff);
                        free_lbuf(buff);
                } else if(def) {
                        notify(player, def);
                }
                free_lbuf(d);
        } else 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) {
                        buff = bp = alloc_lbuf("did_it.2");
                        str = d;
                        exec(buff, &bp, 0, thing, player,
                                 EV_EVAL | EV_FIGNORE | EV_TOP, &str, args, nargs);
                        *bp = '\0';
                        if(*buff)
                                notify_except2(loc, player, player, thing, tprintf("%s %s",
                                                                                                                                   Name
                                                                                                                                   (player),
                                                                                                                                   buff));
                        free_lbuf(buff);
                } else if(odef) {
                        notify_except2(loc, player, player, thing, tprintf("%s %s",
                                                                                                                           Name(player),
                                                                                                                           odef));
                }
                free_lbuf(d);
        } else if((owhat < 0) && odef && Has_location(player) &&
                          Good_obj(loc = Location(player))) {
                notify_except2(loc, player, player, thing, tprintf("%s %s",
                                                                                                                   Name(player),
                                                                                                                   odef));
        }
        /*
         * do the action attribute 
         */

        if(awhat > 0) {
                if(*(act = atr_pget(thing, awhat, &aowner, &aflags))) {
                        charges = atr_pget(thing, A_CHARGES, &aowner, &aflags);
                        if(*charges) {
                                num = atoi(charges);
                                if(num > 0) {
                                        buff = alloc_sbuf("did_it.charges");
                                        sprintf(buff, "%d", num - 1);
                                        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);
                        wait_que(thing, player, 0, NOTHING, 0, act, args, nargs,
                                         mudstate.global_regs);
                }
                free_lbuf(act);
        }
}

void do_addcommand	(	dbref	player,
		dbref	cause,
		int	key,
		char *	name,
		char *	command
	)

Definition at line 594 of file predicates.c.

References addedentry::atr, cmdentry::callseq, statedata::command_htab, CS_ADDED, cmdentry::handler, hashfind(), mudstate, addedentry::next, NOTHING, notify, notify_printf(), parse_attrib(), and addedentry::thing.

{
        CMDENT *old, *cmd;
        ADDENT *add, *nextp;

        dbref thing;
        int atr;
        char *s;

        if(!*name) {
                notify(player, "Sorry.");
                return;
        }
        if(!parse_attrib(player, command, &thing, &atr) || (atr == NOTHING)) {
                notify(player, "No such attribute.");
                return;
        }

        /* Let's make this case insensitive... */

        for(s = name; *s; s++) {
                *s = tolower(*s);
        }

        old = (CMDENT *) hashfind(name, &mudstate.command_htab);

        if(old && (old->callseq & CS_ADDED)) {

                /* If it's already found in the hash table, and it's being
                   added using the same object and attribute... */

                for(nextp = (ADDENT *) old->handler; nextp != NULL;
                        nextp = nextp->next) {
                        if((nextp->thing == thing) && (nextp->atr == atr)) {
                                notify_printf(player, "%s already added.", name);
                                return;
                        }
                }

                /* else tack it on to the existing entry... */

                add = (ADDENT *) malloc(sizeof(ADDENT));
                add->thing = thing;
                add->atr = atr;
                add->name = (char *) strdup(name);
                add->next = (ADDENT *) old->handler;
                old->handler = (void *) add;
        } else {
                if(old) {
                        /* Delete the old built-in and rename it __name */
                        hashdelete(name, &mudstate.command_htab);
                }

                cmd = (CMDENT *) malloc(sizeof(CMDENT));

                cmd->cmdname = (char *) strdup(name);
                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;
                }
                add = (ADDENT *) malloc(sizeof(ADDENT));
                add->thing = thing;
                add->atr = atr;
                add->name = (char *) strdup(name);
                add->next = NULL;
                cmd->handler = (void *) add;

                hashadd(name, (int *) cmd, &mudstate.command_htab);

                if(old) {
                        /* Fix any aliases of this command. */
                        hashreplall((int *) old, (int *) cmd, &mudstate.command_htab);
                        hashadd(tprintf("__%s", name), (int *) old,
                                        &mudstate.command_htab);
                }
        }

        /* We reset the one letter commands here so you can overload them */

        set_prefix_cmds();
        notify_printf(player, "%s added.", name);
}

int do_command	(	DESC *	,
		char *
	)

Definition at line 1516 of file netcommon.c.

References confdata::allow_unloggedwho, CMD_DOING, CMD_MASK, CMD_PREFIX, CMD_QUIT, CMD_SUFFIX, CMD_WHO, descriptor_data::command_count, statedata::curr_enactor, statedata::curr_player, statedata::debug_cmd, DS_CONNECTED, dump_users(), name_table::flag, descriptor_data::flags, hashfind(), descriptor_data::last_time, LOG_BUGS, log_error(), statedata::logout_cmd_htab, mudconf, mudstate, statedata::now, descriptor_data::output_prefix, descriptor_data::output_suffix, descriptor_data::player, process_command(), queue_string(), R_QUIT, set_userstring(), and shutdownsock().

Referenced by handle_prog(), and run_command().

{
        char *arg, *cmdsave;
        NAMETAB *cp;

        cmdsave = mudstate.debug_cmd;
        mudstate.debug_cmd = (char *) "< do_command >";
        d->last_time = mudstate.now;

        /*
         * Split off the command from the arguments 
         */

        arg = command;
        while (*arg && !isspace(*arg))
                arg++;
        if(*arg)
                *arg++ = '\0';

#ifdef HUDINFO_SUPPORT
        /* We check for hudinfo before anything else.  This is a fairly dirty
         * hack, and slows down the common case by a strcmp (which is fast on
         * modern processors and libraries) but has many advantages: hudinfo
         * only outputs to the *connection* (rather than the player) that issued
         * the command, and always knows which hud session key to use. I think
         * the payoff is justified, in this case.
         */

        if(mudconf.hudinfo_enabled > 0 && d->flags & DS_CONNECTED
           && !strcmp(command, "hudinfo")) {
                d->command_count++;
                mudstate.curr_player = d->player;
                mudstate.curr_enactor = d->player;
                mudstate.debug_cmd = "hudinfo";
                do_hudinfo(d, arg);
                mudstate.debug_cmd = cmdsave;
                return 1;
        }
#endif

    cp = (NAMETAB *) hashfind(command, &mudstate.logout_cmd_htab);

    if(*arg)
        *--arg = ' ';   
    if(cp == NULL) {
        d->command_count++;
        if(d->output_prefix) {
            queue_string(d, d->output_prefix);
        }
        mudstate.curr_player = d->player;
        mudstate.curr_enactor = d->player;
        process_command(d->player, d->player, 1, command, (char **) NULL, 0);
        if(d->output_suffix) {
            queue_string(d, d->output_suffix);
        }
    } else {
        if(d->output_prefix) {
            queue_string(d, d->output_prefix);
        }
        switch (cp->flag & CMD_MASK) {
            case CMD_QUIT:
                shutdownsock(d, R_QUIT);
                return 0;
            case CMD_WHO:
                if(d->player || mudconf.allow_unloggedwho) {
                    dump_users(d, arg, CMD_WHO);
                } else {
                    queue_string(d, "This MUX does not allow WHO at the login screen.\r\n");
                    queue_string(d, "Please login or create a character first.\r\n");
                }
                break;
            case CMD_DOING:
                if(d->player || mudconf.allow_unloggedwho) {
                    dump_users(d, arg, CMD_DOING);
                } else {
                    queue_string(d, "This MUX does not allow DOING at the login screen.\r\n");
                    queue_string(d, "Please login or create a character first.\r\n");
                }
                break;
            case CMD_SESSION:
                if(d->player || mudconf.allow_unloggedwho) {
                    dump_users(d, arg, CMD_SESSION);
                } else {
                    queue_string(d, "This MUX does not allow SESSION at the login screen.\r\n");
                    queue_string(d, "Please login or create a character first.\r\n");
                }
                break;
            case CMD_PREFIX:
                set_userstring(&d->output_prefix, arg);
                break;
            case CMD_SUFFIX:
                set_userstring(&d->output_suffix, arg);
                break;
            default:
                log_error(LOG_BUGS, "BUG", "PARSE", "Prefix command with no handler: '%s'", command);
        }
        if(d->output_suffix) {
            queue_string(d, d->output_suffix);
        }
    }
    mudstate.debug_cmd = cmdsave;
    return 1;
}

void do_comment	(	dbref	player,
		dbref	cause,
		int	key
	)

Implement the @ (comment) command. Very cpu-intensive :-)

Definition at line 1045 of file predicates.c.

{
}

void do_delcommand	(	dbref	player,
		dbref	cause,
		int	key,
		char *	name,
		char *	command
	)

Definition at line 738 of file predicates.c.

References cmdentry::callseq, statedata::command_htab, CS_ADDED, cmdentry::handler, hashfind(), mudstate, addedentry::name, addedentry::next, NOTHING, notify, and parse_attrib().

{
        CMDENT *old, *cmd;
        ADDENT *prev = NULL, *nextp;

        dbref thing;
        int atr;
        char *s;

        if(!*name) {
                notify(player, "Sorry.");
                return;
        }

        if(*command) {
                if(!parse_attrib(player, command, &thing, &atr) || (atr == NOTHING)) {
                        notify(player, "No such attribute.");
                        return;
                }
        }

        /* Let's make this case insensitive... */

        for(s = name; *s; s++) {
                *s = tolower(*s);
        }

        old = (CMDENT *) hashfind(name, &mudstate.command_htab);

        if(old && (old->callseq & CS_ADDED)) {
                if(!*command) {
                        for(prev = (ADDENT *) old->handler; prev != NULL; prev = nextp) {
                                nextp = prev->next;
                                /* Delete it! */
                                free(prev->name);
                                free(prev);
                        }
                        hashdelete(name, &mudstate.command_htab);
                        if((cmd =
                                (CMDENT *) hashfind(tprintf("__%s", name),
                                                                        &mudstate.command_htab)) != NULL) {
                                hashdelete(tprintf("__%s", name), &mudstate.command_htab);
                                hashadd(name, (int *) cmd, &mudstate.command_htab);
                                hashreplall((int *) old, (int *) cmd, &mudstate.command_htab);
                        }
                        free(old);
                        set_prefix_cmds();
                        notify(player, "Done.");
                        return;
                } else {
                        for(nextp = (ADDENT *) old->handler; nextp != NULL;
                                nextp = nextp->next) {
                                if((nextp->thing == thing) && (nextp->atr == atr)) {
                                        /* Delete it! */
                                        free(nextp->name);
                                        if(!prev) {
                                                if(!nextp->next) {
                                                        hashdelete(name, &mudstate.command_htab);
                                                        if((cmd =
                                                                (CMDENT *) hashfind(tprintf("__%s",
                                                                                                                        name),
                                                                                                        &mudstate.
                                                                                                        command_htab)) != NULL) {
                                                                hashdelete(tprintf("__%s", name),
                                                                                   &mudstate.command_htab);
                                                                hashadd(name, (int *) cmd,
                                                                                &mudstate.command_htab);
                                                                hashreplall((int *) old, (int *) cmd,
                                                                                        &mudstate.command_htab);
                                                        }
                                                        free(old);
                                                } else {
                                                        old->handler = (void *) nextp->next;
                                                        free(nextp);
                                                }
                                        } else {
                                                prev->next = nextp->next;
                                                free(nextp);
                                        }
                                        set_prefix_cmds();
                                        notify(player, "Done.");
                                        return;
                                }
                                prev = nextp;
                        }
                        notify(player, "Command not found in command table.");
                }
        } else {
                notify(player, "Command not found in command table.");
        }
}

void do_listcommands	(	dbref	player,
		dbref	cause,
		int	key,
		char *	name
	)

Definition at line 682 of file predicates.c.

References addedentry::atr, atr_num(), cmdentry::callseq, statedata::command_htab, CS_ADDED, cmdentry::handler, hashfind(), mudstate, addedentry::name, addedentry::next, notify_printf(), and addedentry::thing.

{
        CMDENT *old;
        ADDENT *nextp;
        int didit = 0;

        char *s, *keyname;

        /* Let's make this case insensitive... */

        for(s = name; *s; s++) {
                *s = tolower(*s);
        }

        if(*name) {
                old = (CMDENT *) hashfind(name, &mudstate.command_htab);

                if(old && (old->callseq & CS_ADDED)) {

                        /* If it's already found in the hash table, and it's being
                           added using the same object and attribute... */

                        for(nextp = (ADDENT *) old->handler; nextp != NULL;
                                nextp = nextp->next) {
                                notify_printf(player, "%s: #%d/%s", nextp->name,
                                                          nextp->thing,
                                                          ((ATTR *) atr_num(nextp->atr))->name);
                        }
                } else {
                        notify_printf(player, "%s not found in command table.", name);
                }
                return;
        } else {
                for(keyname = hash_firstkey(&mudstate.command_htab);
                        keyname != NULL; keyname = hash_nextkey(&mudstate.command_htab)) {

                        old = (CMDENT *) hashfind(keyname, &mudstate.command_htab);

                        if(old && (old->callseq & CS_ADDED)) {

                                for(nextp = (ADDENT *) old->handler; nextp != NULL;
                                        nextp = nextp->next) {
                                        if(strcmp(keyname, nextp->name))
                                                continue;
                                        notify_printf(player, "%s: #%d/%s", nextp->name,
                                                                  nextp->thing,
                                                                  ((ATTR *) atr_num(nextp->atr))->name);
                                        didit = 1;
                                }
                        }
                }
        }
        if(!didit)
                notify(player, "No added commands found in command table.");
}

void do_prog	(	dbref	player,
		dbref	cause,
		int	key,
		char *	name,
		char *	command
	)

Definition at line 931 of file predicates.c.

References A_PROGCMD, alloc_lbuf, ANSI_HILITE, ANSI_NORMAL, atr_add_raw(), atr_get_info(), atr_get_raw(), atr_num(), Connected, DESC_ITER_PLAYER, statedata::global_regs, God, Good_obj, isPlayer, match_thing(), MAX_GLOBAL_REGS, mudstate, NOTHING, notify, Owner, parse_attrib(), parse_to(), Prog, descriptor_data::program_data, queue_string(), See_attr, StringCopy, tprintf(), prog_data::wait_cause, prog_data::wait_regs, and Wizard.

{
        DESC *d;
        PROG *program;
        int i, atr, aflags;
        dbref doer, thing, aowner;
        ATTR *ap;
        char *attrib, *msg;

        if(!name || !*name) {
                notify(player, "No players specified.");
                return;
        }
        doer = match_thing(player, name);

        if(!(Prog(player) || Prog(Owner(player))) && (player != doer)) {
                notify(player, "Permission denied.");
                return;
        }
        if(!isPlayer(doer) || !Good_obj(doer)) {
                notify(player, "That is not a player.");
                return;
        }
        if(!Connected(doer)) {
                notify(player, "That player is not connected.");
                return;
        }
        msg = command;
        attrib = parse_to(&msg, ':', 1);

        if(msg && *msg) {
                notify(doer, msg);
        }
        parse_attrib(player, attrib, &thing, &atr);
        if(atr != NOTHING) {
                if(!atr_get_info(thing, atr, &aowner, &aflags)) {
                        notify(player, "Attribute not present on object.");
                        return;
                }
                ap = atr_num(atr);
                if(God(player) || (!God(thing) &&
                                                   See_attr(player, thing, ap, aowner, aflags) &&
                                                   (Wizard(player) || (aowner == Owner(player))))) {
                        atr_add_raw(doer, A_PROGCMD, atr_get_raw(thing, atr));
                } else {
                        notify(player, "Permission denied.");
                        return;
                }
        } else {
                notify(player, "No such attribute.");
                return;
        }

        /*
         * Check to see if the cause already has an @prog input pending 
         */
        DESC_ITER_PLAYER(doer, d) {
                if(d->program_data != NULL) {
                        notify(player, "Input already pending.");
                        return;
                }
        }

        program = (PROG *) malloc(sizeof(PROG));
        program->wait_cause = player;
        for(i = 0; i < MAX_GLOBAL_REGS; i++) {
                program->wait_regs[i] = alloc_lbuf("prog_regs");
                StringCopy(program->wait_regs[i], mudstate.global_regs[i]);
        }

        /*
         * Now, start waiting. 
         */
        DESC_ITER_PLAYER(doer, d) {
                d->program_data = program;

                /*
                 * Use telnet protocol's GOAHEAD command to show prompt 
                 */
                queue_string(d, tprintf("%s>%s \377\371", ANSI_HILITE, ANSI_NORMAL));
        }

}

void do_quitprog	(	dbref	player,
		dbref	cause,
		int	key,
		char *	name
	)

Definition at line 879 of file predicates.c.

References A_PROGCMD, atr_clr(), Connected, DESC_ITER_PLAYER, statedata::desctree, free_lbuf, Good_obj, isPlayer, match_thing(), MAX_GLOBAL_REGS, mudstate, notify, Owner, Prog, descriptor_data::program_data, rb_find(), and prog_data::wait_regs.

{
        DESC *d;
        dbref doer;
        int i, isprog = 0;

        if(*name) {
                doer = match_thing(player, name);
        } else {
                doer = player;
        }

        if(!(Prog(player) || Prog(Owner(player))) && (player != doer)) {
                notify(player, "Permission denied.");
                return;
        }
        if(!isPlayer(doer) || !Good_obj(doer)) {
                notify(player, "That is not a player.");
                return;
        }
        if(!Connected(doer)) {
                notify(player, "That player is not connected.");
                return;
        }
        DESC_ITER_PLAYER(doer, d) {
                if(d->program_data != NULL) {
                        isprog = 1;
                }
        }

        if(!isprog) {
                notify(player, "Player is not in an @program.");
                return;
        }
//    d = (DESC *) nhashfind(doer, &mudstate.desc_htab);
        d = (DESC *) rb_find(mudstate.desctree, &doer);

        for(i = 0; i < MAX_GLOBAL_REGS; i++) {
                free_lbuf(d->program_data->wait_regs[i]);
        }
        free(d->program_data);

        /* Set info for all player descriptors to NULL */

        DESC_ITER_PLAYER(doer, d)
                d->program_data = NULL;

        atr_clr(doer, A_PROGCMD);
        notify(player, "@program cleared.");
        notify(doer, "Your @program has been terminated.");
}

void do_restart	(	dbref	player,
		dbref	cause,
		int	key
	)

Restarts the game.

Definition at line 1018 of file predicates.c.

References confdata::config_file, dump_database_internal(), DUMP_RESTART, dump_restart_db(), dump_restart_db_xdr(), statedata::dumping, ENDLOG, statedata::executable_path, LOG_ALWAYS, log_name(), log_text(), mudconf, mudstate, Name(), notify, Owner, raw_broadcast(), ResetSpecialObjects(), shutdown_services(), and STARTLOG.

Referenced by signal_USR1().

{
        if(key && mudstate.dumping) {
                notify(player, "Dumping. Please try again later.");
                return;
        }

        ResetSpecialObjects();
        raw_broadcast(0, "Game: Restart by %s, please wait.",
                                  Name(Owner(player)));
        shutdown_services();

        STARTLOG(LOG_ALWAYS, "WIZ", "RSTRT") {
                log_text((char *) "Restart by ");
                log_name(player);
                ENDLOG;
        } dump_database_internal(DUMP_RESTART);

        dump_restart_db();
    dump_restart_db_xdr();
        execl(mudstate.executable_path, mudstate.executable_path,
                  mudconf.config_file, NULL);
}

void do_switch	(	dbref	player,
		dbref	cause,
		int	key,
		char *	expr,
		char *	args[],
		int	nargs,
		char *	cargs[],
		int	ncargs
	)

Definition at line 551 of file predicates.c.

References alloc_lbuf, EV_EVAL, EV_FCHECK, EV_TOP, exec(), free_lbuf, statedata::global_regs, mudconf, mudstate, NOTHING, SWITCH_ANY, SWITCH_DEFAULT, confdata::switch_df_all, SWITCH_ONE, wait_que(), and wild_match().

{
        int a, any;
        char *buff, *bp, *str;

        if(!expr || (nargs <= 0))
                return;

        if(key == SWITCH_DEFAULT) {
                if(mudconf.switch_df_all)
                        key = SWITCH_ANY;
                else
                        key = SWITCH_ONE;
        }
        /*
         * now try a wild card match of buff with stuff in coms 
         */

        any = 0;
        buff = bp = alloc_lbuf("do_switch");
        for(a = 0; (a < (nargs - 1)) && args[a] && args[a + 1]; a += 2) {
                bp = buff;
                str = args[a];
                exec(buff, &bp, 0, player, cause, EV_FCHECK | EV_EVAL | EV_TOP,
                         &str, cargs, ncargs);
                *bp = '\0';
                if(wild_match(buff, expr)) {
                        wait_que(player, cause, 0, NOTHING, 0, args[a + 1], cargs,
                                         ncargs, mudstate.global_regs);
                        if(key == SWITCH_ONE) {
                                free_lbuf(buff);
                                return;
                        }
                        any = 1;
                }
        }
        free_lbuf(buff);
        if((a < nargs) && !any && args[a])
                wait_que(player, cause, 0, NOTHING, 0, args[a], cargs, ncargs,
                                 mudstate.global_regs);
}

void do_verb	(	dbref	player,
		dbref	cause,
		int	key,
		char *	victim_str,
		char *	args[],
		int	nargs
	)

Command interface to did_it.

Definition at line 1574 of file predicates.c.

References A_DESC, atr_get_info(), atr_num(), atr_str(), controls, did_it(), EV_STRIP_LS, EV_STRIP_TS, Examinable, free_lbuf, Good_obj, init_match(), MAT_EXIT_PARENTS, match_everything(), mudconf, nearby(), noisy_match_result(), notify, notify_quiet, NOTYPE, attr::number, parse_arglist(), Read_attr, and confdata::read_rem_desc.

{
        dbref actor, victim, aowner;
        int what, owhat, awhat, nxargs, restriction, aflags, i;
        ATTR *ap;
        const char *whatd, *owhatd;
        char *xargs[10];

        /*
         * Look for the victim 
         */

        if(!victim_str || !*victim_str) {
                notify(player, "Nothing to do.");
                return;
        }
        /*
         * Get the victim 
         */

        init_match(player, victim_str, NOTYPE);
        match_everything(MAT_EXIT_PARENTS);
        victim = noisy_match_result();
        if(!Good_obj(victim))
                return;

        /*
         * Get the actor.  Default is my cause 
         */

        if((nargs >= 1) && args[0] && *args[0]) {
                init_match(player, args[0], NOTYPE);
                match_everything(MAT_EXIT_PARENTS);
                actor = noisy_match_result();
                if(!Good_obj(actor))
                        return;
        } else {
                actor = cause;
        }

        /*
         * Check permissions. There are two possibilities 
         *   1: Player controls both victim and actor. In this case, victim
         *      runs his action list. 
         *   2: Player controls actor. In this case, victim does not run his
         *      action list and any attributes that player cannot read from
         *      victim are defaulted.
         */

        if(!controls(player, actor)) {
                notify_quiet(player, "Permission denied,");
                return;
        }
        restriction = !controls(player, victim);

        what = -1;
        owhat = -1;
        awhat = -1;
        whatd = NULL;
        owhatd = NULL;
        nxargs = 0;

        /*
         * Get invoker message attribute 
         */

        if(nargs >= 2) {
                ap = atr_str(args[1]);
                if(ap && (ap->number > 0))
                        what = ap->number;
        }
        /*
         * Get invoker message default 
         */

        if((nargs >= 3) && args[2] && *args[2]) {
                whatd = args[2];
        }
        /*
         * Get others message attribute 
         */

        if(nargs >= 4) {
                ap = atr_str(args[3]);
                if(ap && (ap->number > 0))
                        owhat = ap->number;
        }
        /*
         * Get others message default 
         */

        if((nargs >= 5) && args[4] && *args[4]) {
                owhatd = args[4];
        }
        /*
         * Get action attribute 
         */

        if(nargs >= 6) {
                ap = atr_str(args[5]);
                if(ap)
                        awhat = ap->number;
        }
        /*
         * Get arguments 
         */

        if(nargs >= 7) {
                parse_arglist(victim, actor, args[6], '\0',
                                          EV_STRIP_LS | EV_STRIP_TS, xargs, 10, (char **) NULL,
                                          0);
                for(nxargs = 0; (nxargs < 10) && xargs[nxargs]; nxargs++);
        }
        /*
         * If player doesn't control both, enforce visibility restrictions 
         */

        if(restriction) {
                ap = NULL;
                if(what != -1) {
                        atr_get_info(victim, what, &aowner, &aflags);
                        ap = atr_num(what);
                }
                if(!ap || !Read_attr(player, victim, ap, aowner, aflags) ||
                   ((ap->number == A_DESC) && !mudconf.read_rem_desc &&
                        !Examinable(player, victim) && !nearby(player, victim)))
                        what = -1;

                ap = NULL;
                if(owhat != -1) {
                        atr_get_info(victim, owhat, &aowner, &aflags);
                        ap = atr_num(owhat);
                }
                if(!ap || !Read_attr(player, victim, ap, aowner, aflags) ||
                   ((ap->number == A_DESC) && !mudconf.read_rem_desc &&
                        !Examinable(player, victim) && !nearby(player, victim)))
                        owhat = -1;

                awhat = 0;
        }
        /*
         * Go do it 
         */

        did_it(actor, victim, what, whatd, owhat, owhatd, awhat, xargs, nxargs);

        /*
         * Free user args 
         */

        for(i = 0; i < nxargs; i++)
                free_lbuf(xargs[i]);

}

void dump_database

(

void

)

void dump_restart_db

(

void

)

Definition at line 2079 of file db.c.

References descriptor_data::addr, descriptor_data::command_count, descriptor_data::connected_at, descriptor_data::descriptor, descriptor_list, descriptor_data::doing, statedata::doing_hdr, dprintk, descriptor_data::flags, descriptor_data::host_info, descriptor_data::hudkey, descriptor_data::last_time, mudstate, descriptor_data::next, obq, descriptor_data::output_prefix, descriptor_data::output_suffix, descriptor_data::player, descriptor_data::prev, putref(), putstring(), statedata::record_players, RS_HUDKEY, RS_NEW_STRINGS, RS_RECORD_PLAYERS, statedata::start_time, descriptor_data::timeout, and descriptor_data::username.

Referenced by do_restart(), signal_BUS(), and signal_SEGV().

{
        FILE *f;
        DESC *d;
    OBJQE *obq;
        int version = 0;

        /* We maintain a version number for the restart database,
           so we can restart even if the format of the restart db
           has been changed in the new executable. */

        version |= RS_RECORD_PLAYERS;
        version |= RS_NEW_STRINGS;
        version |= RS_HUDKEY;

        f = fopen("restart.db", "w");
        fprintf(f, "+V%d\n", version);
        putref(f, mudstate.start_time);
        putstring(f, mudstate.doing_hdr);
        putref(f, mudstate.record_players);
        for (d = descriptor_list ; d && d->next ; d = d->next);
        for(; d != NULL ; d = d->prev) {
                dprintk("d: %p dnext: %p dprev: %p", d, d->next, d->prev);
                putref(f, d->descriptor);
                putref(f, d->flags);
                putref(f, d->connected_at);
                putref(f, d->command_count);
                putref(f, d->timeout);
                putref(f, d->host_info);
                putref(f, d->player);
                putref(f, d->last_time);
                putstring(f, d->output_prefix);
                putstring(f, d->output_suffix);
                putstring(f, d->addr);
                putstring(f, d->doing);
                putstring(f, d->username);
                putstring(f, d->hudkey);
        }
        putref(f, 0);
        fclose(f);
}

int exit_displayable	(	dbref	exit,
		dbref	player,
		int	key
	)

Checks to see if the exit is visible to look.

Definition at line 1448 of file predicates.c.

References Dark, Light, VE_BASE_DARK, and VE_LOC_DARK.

Referenced by look_exits().

{
        if(Dark(exit))                          // Dark exit
                return 0;
        if(Light(exit))                         // Light exit
                return 1;
        if(key & (VE_LOC_DARK | VE_BASE_DARK))
                return 0;                               // Dark loc or base    
        return 1;                                       // Default 
}

int exit_visible	(	dbref	exit,
		dbref	player,
		int	key
	)

Checks to see if the exit is visible. Used in lexits().

Definition at line 1430 of file predicates.c.

References Dark, Examinable, Light, VE_BASE_DARK, VE_LOC_DARK, and VE_LOC_XAM.

Referenced by fun_exit(), fun_lexits(), fun_next(), and match_exit_internal().

{
        if(key & VE_LOC_XAM)            // Exam exit's loc
                return 1;
        if(Examinable(player, exit))    // Exam exit 
                return 1;
        if(Light(exit))                         // Exit is light
                return 1;
        if(key & (VE_LOC_DARK | VE_BASE_DARK))
                return 0;                               // Dark loc or base   
        if(Dark(exit))                          // Dark exit
                return 0;
        return 1;                                       // Default
}

int get_obj_and_lock	(	dbref	player,
		char *	what,
		dbref *	it,
		ATTR **	attr,
		char *	errmsg,
		char **	bufc
	)

Definition at line 1264 of file predicates.c.

References A_LOCK, alloc_lbuf, atr_num(), attr, free_lbuf, Good_obj, lock_sw, match_thing(), parse_thing_slash(), safe_str, search_nametab(), and StringCopy.

Referenced by fun_elock(), and fun_lock().

{
        char *str, *tbuf;
        int anum;

        tbuf = alloc_lbuf("get_obj_and_lock");
        StringCopy(tbuf, what);
        if(parse_thing_slash(player, tbuf, &str, it)) {

                /*
                 * <obj>/<lock> syntax, use the named lock 
                 */

                anum = search_nametab(player, lock_sw, str);
                if(anum < 0) {
                        free_lbuf(tbuf);
                        safe_str("#-1 LOCK NOT FOUND", errmsg, bufc);
                        return 0;
                }
        } else {

                /*
                 * Not <obj>/<lock>, do a normal get of the default lock 
                 */

                *it = match_thing(player, what);
                if(!Good_obj(*it)) {
                        free_lbuf(tbuf);
                        safe_str("#-1 NOT FOUND", errmsg, bufc);
                        return 0;
                }
                anum = A_LOCK;
        }

        /*
         * Get the attribute definition, fail if not found 
         */

        free_lbuf(tbuf);
        *attr = atr_num(anum);
        if(!(*attr)) {
                safe_str("#-1 LOCK NOT FOUND", errmsg, bufc);
                return 0;
        }
        return 1;
}

void giveto	(	dbref	who,
		int	pennies
	)

Give moner to a player.

Definition at line 383 of file predicates.c.

References Free_Money, Immortal, Owner, Pennies(), s_Pennies(), and Wizard.

Referenced by connect_player(), destroy_obj(), do_chown(), do_kill(), do_processcom(), do_top(), give_money(), halt_que(), link_exit(), move_object(), and nfy_que().

{
        if(Wizard(who) || Wizard(Owner(who)) || Free_Money(who) ||
           Free_Money(Owner(who)) || Immortal(who) || Immortal(Owner(who))) {
                return;
        }
        who = Owner(who);
        s_Pennies(who, Pennies(who) + pennies);
}

void handle_ears	(	dbref	thing,
		int	could_hear,
		int	can_hear
	)

Generate the 'grows ears' and 'loses ears' messages.

Definition at line 512 of file predicates.c.

References alloc_lbuf, free_lbuf, get_gender(), isExit, MSG_INV, MSG_LOC, MSG_ME, MSG_NBR, Name(), notify_checked(), StringCopy, and tprintf().

Referenced by do_set(), fh_hear_bit(), and set_attr_internal().

{
        char *buff, *bp;
        int gender;
        static const char *poss[5] = { "", "its", "her", "his", "their" };

        if(!could_hear && can_hear) {
                buff = alloc_lbuf("handle_ears.grow");
                StringCopy(buff, Name(thing));
                if(isExit(thing)) {
                        for(bp = buff; *bp && (*bp != ';'); bp++);
                        *bp = '\0';
                }
                gender = get_gender(thing);
                notify_checked(thing, thing,
                                           tprintf("%s grow%s ears and can now hear.", buff,
                                                           (gender == 4) ? "" : "s"),
                                           (MSG_ME | MSG_NBR | MSG_LOC | MSG_INV));
                free_lbuf(buff);
        } else if(could_hear && !can_hear) {
                buff = alloc_lbuf("handle_ears.lose");
                StringCopy(buff, Name(thing));
                if(isExit(thing)) {
                        for(bp = buff; *bp && (*bp != ';'); bp++);
                        *bp = '\0';
                }
                gender = get_gender(thing);
                notify_checked(thing, thing,
                                           tprintf("%s lose%s %s ears and become%s deaf.", buff,
                                                           (gender == 4) ? "" : "s", poss[gender],
                                                           (gender == 4) ? "" : "s"),
                                           (MSG_ME | MSG_NBR | MSG_LOC | MSG_INV));
                free_lbuf(buff);
        }
}

void handle_prog	(	DESC *	d,
		char *	message
	)

'glues' a user's input to a command. Once executed, the first string input from any of the doers's logged in descriptors, will go into A_PROGMSG, which can be substituted in <command> with 0. Commands already queued by the doer will be processed normally.

Definition at line 837 of file predicates.c.

References A_PROGCMD, ANSI_HILITE, ANSI_NORMAL, atr_clr(), atr_get(), DESC_ITER_PLAYER, statedata::desctree, do_command(), free_lbuf, MAX_GLOBAL_REGS, mudstate, NOTHING, descriptor_data::player, descriptor_data::program_data, queue_string(), rb_find(), tprintf(), prog_data::wait_cause, wait_que(), and prog_data::wait_regs.

Referenced by run_command().

{
        DESC *all;
        char *cmd;
        dbref aowner;
        int aflags, i;

        /*
         * Allow the player to pipe a command while in interactive mode. 
         */

        if(*message == '|') {
                do_command(d, message + 1);
                /* Use telnet protocol's GOAHEAD command to show prompt */
                if(d->program_data != NULL)
                        queue_string(d, tprintf("%s>%s \377\371", ANSI_HILITE,
                                                                        ANSI_NORMAL));
                return;
        }
        cmd = atr_get(d->player, A_PROGCMD, &aowner, &aflags);
        wait_que(d->program_data->wait_cause, d->player, 0, NOTHING, 0, cmd,
                         (char **) &message, 1, (char **) d->program_data->wait_regs);

        /* First, set 'all' to a descriptor we find for this player */

        //all = (DESC *) nhashfind(d->player, &mudstate.desc_htab);
        all = (DESC *) rb_find(mudstate.desctree, (void *) d->player);

        for(i = 0; i < MAX_GLOBAL_REGS; i++) {
                free_lbuf(all->program_data->wait_regs[i]);
        }
        free(all->program_data);

        /* Set info for all player descriptors to NULL */

        DESC_ITER_PLAYER(d->player, all)
                all->program_data = NULL;

        atr_clr(d->player, A_PROGCMD);
        free_lbuf(cmd);
}

dbref insert_first	(	dbref	head,
		dbref	thing
	)

Puts an object at the head of a list

Definition at line 91 of file predicates.c.

References s_Next.

Referenced by do_clone(), do_drop(), do_get(), do_teleport(), and move_object().

{
        s_Next(thing, head);
        return thing;
}

int is_integer

(

char *

str

)

Checks for the presence of an integer

Definition at line 148 of file predicates.c.

Referenced by autodetect_list(), fun_space(), and xlate().

{
        while (*str && isspace(*str))
                str++;                                  /*
                                                                 * Leading spaces 
                                                                 */
        if(*str == '-') {                       /*
                                                                 * Leading minus 
                                                                 */
                str++;
                if(!*str)
                        return 0;                       /*
                                                                 * but not if just a minus 
                                                                 */
        }
        if(!isdigit(*str))                      /*
                                                                 * Need at least 1 integer 
                                                                 */
                return 0;
        while (*str && isdigit(*str))
                str++;                                  /*
                                                                 * The number (int) 
                                                                 */
        while (*str && isspace(*str))
                str++;                                  /*
                                                                 * Trailing spaces 
                                                                 */
        return (*str ? 0 : 1);
}

int is_number

(

char *

str

)

Checks for the presence of a number

Definition at line 181 of file predicates.c.

Referenced by autodetect_list(), do_boot(), do_del_macro(), do_edit_macro(), do_ex_macro(), do_gex_macro(), do_give(), do_poor(), do_wait(), fun_dec(), fun_doing(), fun_inc(), fun_isnum(), fun_mail(), fun_shl(), fun_shr(), and lookup_player().

{
        int got_one;

        while (*str && isspace(*str))
                str++;                                  /*
                                                                 * Leading spaces 
                                                                 */
        if(*str == '-') {                       /*
                                                                 * Leading minus 
                                                                 */
                str++;
                if(!*str)
                        return 0;                       /*
                                                                 * but not if just a minus 
                                                                 */
        }
        got_one = 0;
        if(isdigit(*str))
                got_one = 1;                    /*
                                                                 * Need at least one digit 
                                                                 */
        while (*str && isdigit(*str))
                str++;                                  /*
                                                                 * The number (int) 
                                                                 */
        if(*str == '.')
                str++;                                  /*
                                                                 * decimal point 
                                                                 */
        if(isdigit(*str))
                got_one = 1;                    /*
                                                                 * Need at least one digit 
                                                                 */
        while (*str && isdigit(*str))
                str++;                                  /*
                                                                 * The number (fract) 
                                                                 */
        while (*str && isspace(*str))
                str++;                                  /*
                                                                 * Trailing spaces 
                                                                 */
        return ((*str || !got_one) ? 0 : 1);
}

int locatable	(	dbref	player,
		dbref	it,
		dbref	cause
	)

Definition at line 1358 of file predicates.c.

References Examinable, Find_Unfindable, Findable, Good_obj, Hideout, NOTHING, where_is(), where_room(), and Wizard.

Referenced by fun_findable(), fun_loc(), fun_rloc(), fun_room(), and fun_where().

{
        dbref loc_it, room_it;
        int findable_room;

        /*
         * No sense if trying to locate a bad object 
         */

        if(!Good_obj(it))
                return 0;

        loc_it = where_is(it);

        /*
         * Succeed if we can examine the target, if we are the target, * if * 
         * 
         * *  * * we can examine the location, if a wizard caused the lookup, 
         * * or  * *  * if the target caused the lookup. 
         */

        if(Examinable(player, it) || Find_Unfindable(player) ||
           (loc_it == player) || ((loc_it != NOTHING) &&
                                                          (Examinable(player, loc_it)
                                                           || loc_it == where_is(player)))
           || Wizard(cause) || (it == cause))
                return 1;

        room_it = where_room(it);
        if(Good_obj(room_it))
                findable_room = !Hideout(room_it);
        else
                findable_room = 1;

        /*
         * Succeed if we control the containing room or if the target is * *
         * * * findable and the containing room is not unfindable. 
         */

        if(((room_it != NOTHING) && Examinable(player, room_it)) ||
           Find_Unfindable(player) || (Findable(it) && findable_room))
                return 1;

        /*
         * We can't do it. 
         */

        return 0;
}

dbref match_possessed	(	dbref	player,
		dbref	thing,
		char *	target,
		dbref	dflt,
		int	check_enter
	)

Definition at line 1067 of file predicates.c.

References alloc_lbuf, Controls, Dark, Enter_ok, free_lbuf, Good_obj, init_match(), match_neighbor(), match_possessed(), match_possession(), match_result(), NOPERM, NOTHING, NOTYPE, Opaque, and promote_dflt().

Referenced by do_get(), do_look(), and match_possessed().

{
        dbref result, result1;
        int control;
        char *buff, *start, *place, *s1, *d1, *temp;

        /*
         * First, check normally 
         */

        if(Good_obj(dflt))
                return dflt;

        /*
         * Didn't find it directly.  Recursively do a contents check 
         */

        start = target;
        while (*target) {

                /*
                 * Fail if no ' characters 
                 */

                place = target;
                target = (char *) index(place, '\'');
                if((target == NULL) || !*target)
                        return dflt;

                /*
                 * If string started with a ', skip past it 
                 */

                if(place == target) {
                        target++;
                        continue;
                }
                /*
                 * If next character is not an s or a space, skip past 
                 */

                temp = target++;
                if(!*target)
                        return dflt;
                if((*target != 's') && (*target != 'S') && (*target != ' '))
                        continue;

                /*
                 * If character was not a space make sure the following * * * 
                 * 
                 * * character is a space. 
                 */

                if(*target != ' ') {
                        target++;
                        if(!*target)
                                return dflt;
                        if(*target != ' ')
                                continue;
                }
                /*
                 * Copy the container name to a new buffer so we can * * * *
                 * terminate it. 
                 */

                buff = alloc_lbuf("is_posess");
                for(s1 = start, d1 = buff; *s1 && (s1 < temp); *d1++ = (*s1++));
                *d1 = '\0';

                /*
                 * Look for the container here and in our inventory.  Skip *
                 * * * * past if we can't find it. 
                 */

                init_match(thing, buff, NOTYPE);
                if(player == thing) {
                        match_neighbor();
                        match_possession();
                } else {
                        match_possession();
                }
                result1 = match_result();

                free_lbuf(buff);
                if(!Good_obj(result1)) {
                        dflt = promote_dflt(dflt, result1);
                        continue;
                }
                /*
                 * If we don't control it and it is either dark or opaque, *
                 * * * * skip past. 
                 */

                control = Controls(player, result1);
                if((Dark(result1) || Opaque(result1)) && !control) {
                        dflt = promote_dflt(dflt, NOTHING);
                        continue;
                }
                /*
                 * Validate object has the ENTER bit set, if requested 
                 */

                if((check_enter) && !Enter_ok(result1) && !control) {
                        dflt = promote_dflt(dflt, NOPERM);
                        continue;
                }
                /*
                 * Look for the object in the container 
                 */

                init_match(result1, target, NOTYPE);
                match_possession();
                result = match_result();
                result =
                        match_possessed(player, result1, target, result, check_enter);
                if(Good_obj(result))
                        return result;
                dflt = promote_dflt(dflt, result);
        }
        return dflt;
}

dbref match_thing	(	dbref	,
		char *
	)

Definition at line 289 of file functions.c.

References init_match(), MAT_EXIT_PARENTS, match_everything(), noisy_match_result(), and NOTYPE.

{
        init_match(player, name, NOTYPE);
        match_everything(MAT_EXIT_PARENTS);
        return (noisy_match_result());
}

int member	(	dbref	thing,
		dbref	list
	)

Indicate if thing is in list

Definition at line 136 of file predicates.c.

References DOLIST.

Referenced by eval_boolexp().

{
        DOLIST(list, list) {
                if(list == thing)
                        return 1;
        }
        return 0;
}

int nearby	(	dbref	player,
		dbref	thing
	)

Check if thing is nearby player (in inventory, in same room, or IS the room.

Definition at line 1412 of file predicates.c.

References Good_obj, and where_is().

Referenced by check_read_perms(), do_examine(), do_pemit(), do_pemit_list(), do_verb(), exam_wildattrs(), find_wild_attrs(), fun_nearby(), and nearby_or_control().

{
        int thing_loc, player_loc;

        if(!Good_obj(player) || !Good_obj(thing))
                return 0;
        thing_loc = where_is(thing);
        if(thing_loc == player)
                return 1;
        player_loc = where_is(player);
        if((thing_loc == player_loc) || (thing == player_loc))
                return 1;
        return 0;
}

dbref next_exit	(	dbref	player,
		dbref	this,
		int	exam_here
	)

Return next exit that is ok to see.

Definition at line 1462 of file predicates.c.

References Dark, Examinable, isExit, isRoom, Light, Next, and NOTHING.

{
        if(isRoom(this))
                return NOTHING;
        if(isExit(this) && exam_here)
                return this;

        while ((this != NOTHING) && Dark(this) && !Light(this) &&
                   !Examinable(player, this))
                this = Next(this);

        return this;
}

int ok_attr_name

(

const char *

attrname

)

Definition at line 471 of file predicates.c.

Referenced by vattr_define(), vattr_delete(), vattr_find(), and vattr_rename().

{
        const char *scan;

        if(!isalpha(*attrname))
                return 0;
        for(scan = attrname; *scan; scan++) {
                if(isalnum(*scan))
                        continue;
                if(!(index("'?!`/-_.@#$^&~=+<>()%", *scan)))
                        return 0;
        }
        return 1;
}

int ok_name

(

const char *

name

)

Definition at line 393 of file predicates.c.

References AND_TOKEN, ARG_DELIMITER, ESC_CHAR, LBUF_SIZE, LOOKUP_TOKEN, NOT_TOKEN, NUMBER_TOKEN, OR_TOKEN, string_compare(), and strip_ansi_r().

Referenced by create_obj(), do_clone(), do_fixdb(), do_name(), fun_valid(), and ok_player_name().

{
        const char *cp;
        char new[LBUF_SIZE];

        /* Disallow pure ANSI names */
        strncpy(new, name, LBUF_SIZE-1);
        if(strlen(strip_ansi_r(new,name,strlen(name))) == 0)
                return 0;

        /* Disallow leading spaces */

        if(isspace(*name))
                return 0;

        /*
         * Only printable characters 
         */

        for(cp = name; cp && *cp; cp++) {
                if((!isprint(*cp)) && (*cp != ESC_CHAR))
                        return 0;
        }

        /*
         * Disallow trailing spaces 
         */
        cp--;
        if(isspace(*cp))
                return 0;

        /*
         * Exclude names that start with or contain certain magic cookies 
         */

        return (name && *name && *name != LOOKUP_TOKEN && *name != NUMBER_TOKEN
                        && *name != NOT_TOKEN && !index(name, ARG_DELIMITER) &&
                        !index(name, AND_TOKEN) && !index(name, OR_TOKEN) &&
                        string_compare(name, "me") && string_compare(name, "home") &&
                        string_compare(name, "here"));
}

int ok_password

(

const char *

password

)

Definition at line 486 of file predicates.c.

Referenced by create_player(), do_newpassword(), and do_password().

{
        const char *scan;

        if(*password == '\0')
                return 0;

        for(scan = password; *scan; scan++) {
                if(!(isprint(*scan) && !isspace(*scan))) {
                        return 0;
                }
        }

        /*
         * Needed.  Change it if you like, but be sure yours is the same. 
         */
        if((strlen(password) == 13) && (password[0] == 'X') &&
           (password[1] == 'X'))
                return 0;

        return 1;
}

int ok_player_name

(

const char *

name

)

Definition at line 435 of file predicates.c.

References ESC_CHAR, mudconf, confdata::name_spaces, ok_name(), and PLAYER_NAME_LIMIT.

Referenced by create_obj(), do_alias(), do_fixdb(), and do_name().

{
        const char *cp, *good_chars;

        /*
         * No leading spaces 
         */

        if(isspace(*name))
                return 0;

        /*
         * Not too long and a good name for a thing 
         */

        if(!ok_name(name) || (strlen(name) >= PLAYER_NAME_LIMIT))
                return 0;

        if(mudconf.name_spaces)
                good_chars = " `$_-.,'";
        else
                good_chars = "`$_-.,'";

        /*
         * Make sure name only contains legal characters 
         */

        for(cp = name; cp && *cp; cp++) {
                if(isalnum(*cp))
                        continue;
                if((!index(good_chars, *cp)) || (*cp == ESC_CHAR))
                        return 0;
        }
        return 1;
}

void parse_range	(	char **	name,
		dbref *	low_bound,
		dbref *	high_bound
	)

break up <what>,<low>,<high> syntax

Definition at line 1193 of file predicates.c.

References statedata::db_top, EV_STRIP_TS, mudstate, NUMBER_TOKEN, and parse_to().

Referenced by do_entrances(), do_find(), and search_setup().

{
        char *buff1, *buff2;

        buff1 = *name;
        if(buff1 && *buff1)
                *name = parse_to(&buff1, ',', EV_STRIP_TS);
        if(buff1 && *buff1) {
                buff2 = parse_to(&buff1, ',', EV_STRIP_TS);
                if(buff1 && *buff1) {
                        while (*buff1 && isspace(*buff1))
                                buff1++;
                        if(*buff1 == NUMBER_TOKEN)
                                buff1++;
                        *high_bound = atoi(buff1);
                        if(*high_bound >= mudstate.db_top)
                                *high_bound = mudstate.db_top - 1;
                } else {
                        *high_bound = mudstate.db_top - 1;
                }
                while (*buff2 && isspace(*buff2))
                        buff2++;
                if(*buff2 == NUMBER_TOKEN)
                        buff2++;
                *low_bound = atoi(buff2);
                if(*low_bound < 0)
                        *low_bound = 0;
        } else {
                *low_bound = 0;
                *high_bound = mudstate.db_top - 1;
        }
}

int parse_thing_slash	(	dbref	player,
		char *	thing,
		char **	after,
		dbref *	it
	)

Definition at line 1226 of file predicates.c.

References Good_obj, init_match(), MAT_EXIT_PARENTS, match_everything(), match_result(), NOTHING, and NOTYPE.

Referenced by get_obj_and_lock(), parse_attrib(), and parse_attrib_wild().

{
        char *str;

        /*
         * get name up to / 
         */
        for(str = thing; *str && (*str != '/'); str++);

        /*
         * If no / in string, return failure 
         */

        if(!*str) {
                *after = NULL;
                *it = NOTHING;
                return 0;
        }
        *str++ = '\0';
        *after = str;

        /*
         * Look for the object 
         */

        init_match(player, thing, NOTYPE);
        match_everything(MAT_EXIT_PARENTS);
        *it = match_result();

        /*
         * Return status of search 
         */

        return (Good_obj(*it));
}

static int pay_quota	(	dbref	who,
		int	cost
	)			[static]

Definition at line 286 of file predicates.c.

References A_RQUOTA, atr_add_raw(), atr_get(), free_lbuf, Free_Quota, and Owner.

Referenced by canpayfees().

{
        dbref aowner;
        int quota, aflags;
        char buf[20], *quota_str;

        /*
         * If no cost, succeed 
         */

        if(cost <= 0)
                return 1;

        /*
         * determine quota 
         */

        quota = atoi(quota_str = atr_get(Owner(who), A_RQUOTA, &aowner, &aflags));
        free_lbuf(quota_str);

        /*
         * enough to build?  Wizards always have enough. 
         */

        quota -= cost;
        if((quota < 0) && !Free_Quota(who) && !Free_Quota(Owner(who)))
                return 0;

        /*
         * dock the quota 
         */
        sprintf(buf, "%d", quota);
        atr_add_raw(Owner(who), A_RQUOTA, buf);

        return 1;
}

int payfor	(	dbref	who,
		int	cost
	)

Definition at line 352 of file predicates.c.

References Free_Money, Immortal, Owner, Pennies(), s_Pennies(), and Wizard.

Referenced by canpayfees(), do_entrances(), do_find(), do_kill(), do_mail_stats(), do_processcom(), get_stats(), give_money(), open_exit(), page_check(), search_setup(), and setup_que().

{
        dbref tmp;

        if(Wizard(who) || Wizard(Owner(who)) || Free_Money(who) ||
           Free_Money(Owner(who)) || Immortal(who) || Immortal(Owner(who))) {
                return 1;
        }
        who = Owner(who);
        if((tmp = Pennies(who)) >= cost) {
                s_Pennies(who, tmp - cost);
                return 1;
        }
        return 0;
}

static dbref promote_dflt	(	dbref	old,
		dbref	new
	)			[static]

Definition at line 1049 of file predicates.c.

References AMBIGUOUS, NOPERM, and NOTHING.

Referenced by match_possessed().

{
        switch (new) {
        case NOPERM:
                return NOPERM;
        case AMBIGUOUS:
                if(old == NOPERM)
                        return old;
                else
                        return new;
        }

        if((old == NOPERM) || (old == AMBIGUOUS))
                return old;

        return NOTHING;
}

dbref remove_first	(	dbref	head,
		dbref	thing
	)

Definition at line 100 of file predicates.c.

References DOLIST, Next, and s_Next.

Referenced by destroy_exit(), do_drop(), do_get(), do_teleport(), and move_object().

{
        dbref prev;

        if(head == thing)
                return (Next(thing));

        DOLIST(prev, head) {
                if(Next(prev) == thing) {
                        s_Next(prev, Next(thing));
                        return head;
                }
        }
        return head;
}

dbref reverse_list

(

dbref

list

)

Reverse the order of members in a list.

Definition at line 119 of file predicates.c.

References Next, NOTHING, and s_Next.

Referenced by process_sticky_dropto().

{
        dbref newlist, rest;

        newlist = NOTHING;
        while (list != NOTHING) {
                rest = Next(list);
                s_Next(list, newlist);
                newlist = list;
                list = rest;
        }
        return newlist;
}

void safe_tprintf_str

(

va_alist

)

Definition at line 57 of file predicates.c.

References LBUF_SIZE, and safe_str.

{
        static char buff[LBUF_SIZE];
        va_list ap;

#ifdef STDC_HEADERS
        va_start(ap, format);
#else
        char *str;
        char **bp;
        const char *format;

        va_start(ap);
        str = va_arg(ap, char *);
        bp = va_arg(ap, char **);
        format = va_arg(ap, char *);

#endif
        /*
         * Sigh, don't we wish _all_ vsprintf's returned int... 
         */

        vsnprintf(buff, LBUF_SIZE, format, ap);
        va_end(ap);
        buff[LBUF_SIZE - 1] = '\0';
        safe_str(buff, str, bp);
        **bp = '\0';
}

char* tprintf

(

va_alist

)

Definition at line 32 of file predicates.c.

References LBUF_SIZE.

{
        static char buff[LBUF_SIZE];
        va_list ap;

#ifdef STDC_HEADERS
        va_start(ap, format);
#else
        const char *format;

        va_start(ap);
        format = va_arg(ap, char *);

#endif
        vsnprintf(buff, LBUF_SIZE, format, ap);
        va_end(ap);
        buff[LBUF_SIZE - 1] = '\0';
        return buff;
}

dbref where_is

(

dbref

what

)

Returns place where obj is linked into a list. ie. location for players/things, source for exits, NOTHING for rooms.

Definition at line 1316 of file predicates.c.

References Exits, Good_obj, loc, Location, NOTHING, TYPE_EXIT, TYPE_PLAYER, TYPE_THING, and Typeof.

Referenced by do_pemit(), do_say(), exec(), fun_con(), fun_home(), fun_lexits(), fun_next(), fun_where(), locatable(), nearby(), and notify_checked().

{
        dbref loc;

        if(!Good_obj(what))
                return NOTHING;

        switch (Typeof(what)) {
        case TYPE_PLAYER:
        case TYPE_THING:
                loc = Location(what);
                break;
        case TYPE_EXIT:
                loc = Exits(what);
                break;
        default:
                loc = NOTHING;
                break;
        }
        return loc;
}

dbref where_room

(

dbref

what

)

Return room containing player, or NOTHING if no room or recursion exceeded. If player is a room, returns itself.

Definition at line 1342 of file predicates.c.

References Good_obj, Has_location, isRoom, Location, mudconf, NOTHING, and confdata::ntfy_nest_lim.

Referenced by do_teleport(), dump_users(), and locatable().

{
        int count;

        for(count = mudconf.ntfy_nest_lim; count > 0; count--) {
                if(!Good_obj(what))
                        break;
                if(isRoom(what))
                        return what;
                if(!Has_location(what))
                        break;
                what = Location(what);
        }
        return NOTHING;
}

---

Variable Documentation

NAMETAB lock_sw[]

Definition at line 232 of file command.c.

Referenced by fun_setlock(), and get_obj_and_lock().

---