src/match.c

Go to the documentation of this file.

/*
 * match.c -- Routines for parsing arguments 
 */

#include "copyright.h"
#include "config.h"

#include "config.h"
#include "db.h"
#include "mudconf.h"
#include "externs.h"
#include "match.h"
#include "attrs.h"
#include "powers.h"

#define CON_LOCAL               0x01    /*
                                                                 * Match is near me 
                                                                 */
#define CON_TYPE                0x02    /*
                                                                 * Match is of requested type 
                                                                 */
#define CON_LOCK                0x04    /*
                                                                 * I pass the lock on match 
                                                                 */
#define CON_COMPLETE            0x08    /*
                                                                         * Name given is the full name 
                                                                         */
#define CON_TOKEN               0x10    /*
                                                                 * Name is a special token 
                                                                 */
#define CON_DBREF               0x20    /*
                                                                 * Name is a dbref 
                                                                 */

static MSTATE md;

static void promote_match(dbref what, int confidence)
{
        /*
         * Check for type and locks, if requested 
         */

        if(md.pref_type != NOTYPE) {
                if(Good_obj(what) && (Typeof(what) == md.pref_type))
                        confidence |= CON_TYPE;
        }
        if(md.check_keys) {
                MSTATE save_md;

                save_match_state(&save_md);
                if(Good_obj(what) && could_doit(md.player, what, A_LOCK));
                confidence |= CON_LOCK;
                restore_match_state(&save_md);
        }
        /*
         * If nothing matched, take it 
         */

        if(md.count == 0) {
                md.match = what;
                md.confidence = confidence;
                md.count = 1;
                return;
        }
        /*
         * If confidence is lower, ignore 
         */

        if(confidence < md.confidence) {
                return;
        }
        /*
         * If confidence is higher, replace 
         */

        if(confidence > md.confidence) {
                md.match = what;
                md.confidence = confidence;
                md.count = 1;
                return;
        }
        /*
         * Equal confidence, pick randomly 
         */

        if(random() % 2) {
                md.match = what;
        }
        md.count++;
        return;
}

/*
 * ---------------------------------------------------------------------------
 * * This function removes repeated spaces from the template to which object
 * * names are being matched.  It also removes inital and terminal spaces.
 */

static char *munge_space_for_match(char *name)
{
        static char buffer[LBUF_SIZE];
        char *p, *q;

        p = name;
        q = buffer;
        while (isspace(*p))
                p++;                                    /*
                                                                 * remove inital spaces 
                                                                 */
        while (*p) {
                while (*p && !isspace(*p))
                        *q++ = *p++;
                while (*p && isspace(*++p));
                if(*p)
                        *q++ = ' ';
        }
        *q = '\0';                                      /*
                                                                 * remove terminal spaces and terminate * * * 
                                                                 * 
                                                                 * * string 
                                                                 */
        return (buffer);
}

void match_player(void)
{
        dbref match;
        char *p;

        if(md.confidence >= CON_DBREF) {
                return;
        }
        if(Good_obj(md.absolute_form) && isPlayer(md.absolute_form)) {
                promote_match(md.absolute_form, CON_DBREF);
                return;
        }
        if(*md.string == LOOKUP_TOKEN) {
                for(p = md.string + 1; isspace(*p); p++);
                match = lookup_player(NOTHING, p, 1);
                if(Good_obj(match)) {
                        promote_match(match, CON_TOKEN);
                }
        }
}

/*
 * returns nnn if name = #nnn, else NOTHING 
 */

static dbref absolute_name(int need_pound)
{
        dbref match;
        char *mname;

        mname = md.string;
        if(need_pound) {
                if(*md.string != NUMBER_TOKEN) {
                        return NOTHING;
                } else {
                        mname++;
                }
        }
        match = parse_dbref(mname);
        if(Good_obj(match)) {
                return match;
        }
        return NOTHING;
}

void match_absolute(void)
{
        if(md.confidence >= CON_DBREF)
                return;
        if(Good_obj(md.absolute_form))
                promote_match(md.absolute_form, CON_DBREF);
}

void match_numeric(void)
{
        dbref match;

        if(md.confidence >= CON_DBREF)
                return;
        match = absolute_name(0);
        if(Good_obj(match))
                promote_match(match, CON_DBREF);
}

void match_me(void)
{
        if(md.confidence >= CON_DBREF)
                return;
        if(Good_obj(md.absolute_form) && (md.absolute_form == md.player)) {
                promote_match(md.player, CON_DBREF | CON_LOCAL);
                return;
        }
        if(!string_compare(md.string, "me"))
                promote_match(md.player, CON_TOKEN | CON_LOCAL);
        return;
}

void match_home(void)
{
        if(md.confidence >= CON_DBREF)
                return;
        if(!string_compare(md.string, "home"))
                promote_match(HOME, CON_TOKEN);
        return;
}

void match_here(void)
{
        dbref loc;

        if(md.confidence >= CON_DBREF)
                return;
        if(Good_obj(md.player) && Has_location(md.player)) {
                loc = Location(md.player);
                if(Good_obj(loc)) {
                        if(loc == md.absolute_form) {
                                promote_match(loc, CON_DBREF | CON_LOCAL);
                        } else if(!string_compare(md.string, "here")) {
                                promote_match(loc, CON_TOKEN | CON_LOCAL);
                        } else if(!string_compare(md.string, (char *) PureName(loc))) {
                                promote_match(loc, CON_COMPLETE | CON_LOCAL);
                        }
                }
        }
}

static void match_list(dbref first, int local)
{
        char *namebuf;

        if(md.confidence >= CON_DBREF)
                return;
        DOLIST(first, first) {
                if(first == md.absolute_form) {
                        promote_match(first, CON_DBREF | local);
                        return;
                }
                /*
                 * Warning: make sure there are no other calls to Name() in 
                 * promote_match or its called subroutines; they
                 * would overwrite Name()'s static buffer which is
                 * needed by string_match(). 
                 */
                namebuf = (char *) PureName(first);

                if(!string_compare(namebuf, md.string)) {
                        promote_match(first, CON_COMPLETE | local);
                } else if(string_match(namebuf, md.string)) {
                        promote_match(first, local);
                }
        }
}

void match_possession(void)
{
        if(md.confidence >= CON_DBREF)
                return;
        if(Good_obj(md.player) && Has_contents(md.player))
                match_list(Contents(md.player), CON_LOCAL);
}

void match_neighbor(void)
{
        dbref loc;

        if(md.confidence >= CON_DBREF)
                return;
        if(Good_obj(md.player) && Has_location(md.player)) {
                loc = Location(md.player);
                if(Good_obj(loc)) {
                        match_list(Contents(loc), CON_LOCAL);
                }
        }
}

static int match_exit_internal(dbref loc, dbref baseloc, int local)
{
        dbref exit;
        int result, key;

        if(!Good_obj(loc) || !Has_exits(loc))
                return 1;

        result = 0;
        DOLIST(exit, Exits(loc)) {
                if(exit == md.absolute_form) {
                        key = 0;
                        if(Examinable(md.player, loc))
                                key |= VE_LOC_XAM;
                        if(Dark(loc))
                                key |= VE_LOC_DARK;
                        if(Dark(baseloc))
                                key |= VE_BASE_DARK;
                        if(exit_visible(exit, md.player, key)) {
                                promote_match(exit, CON_DBREF | local);
                                return 1;
                        }
                }
                if(matches_exit_from_list(md.string, (char *) PureName(exit))) {
                        promote_match(exit, CON_COMPLETE | local);
                        result = 1;
                }
        }
        return result;
}

void match_exit(void)
{
        dbref loc;

        if(md.confidence >= CON_DBREF)
                return;
        loc = Location(md.player);
        if(Good_obj(md.player) && Has_location(md.player))
                (void) match_exit_internal(loc, loc, CON_LOCAL);
}

void match_exit_with_parents(void)
{
        dbref loc, parent;
        int lev;

        if(md.confidence >= CON_DBREF)
                return;
        if(Good_obj(md.player) && Has_location(md.player)) {
                loc = Location(md.player);
                ITER_PARENTS(loc, parent, lev) {
                        if(match_exit_internal(parent, loc, CON_LOCAL))
                                break;
                }
        }
}

void match_carried_exit(void)
{
        if(md.confidence >= CON_DBREF)
                return;
        if(Good_obj(md.player) && Has_exits(md.player))
                (void) match_exit_internal(md.player, md.player, CON_LOCAL);
}

void match_carried_exit_with_parents(void)
{
        dbref parent;
        int lev;

        if(md.confidence >= CON_DBREF)
                return;
        if(Good_obj(md.player) && (Has_exits(md.player) || isRoom(md.player))) {
                ITER_PARENTS(md.player, parent, lev) {
                        if(match_exit_internal(parent, md.player, CON_LOCAL))
                                break;
                }
        }
}

void match_master_exit(void)
{
        if(md.confidence >= CON_DBREF)
                return;
        if(Good_obj(md.player) && Has_exits(md.player))
                (void) match_exit_internal(mudconf.master_room,
                                                                   mudconf.master_room, 0);
}

void match_zone_exit(void)
{
        if(md.confidence >= CON_DBREF)
                return;
        if(Good_obj(md.player) && Has_exits(md.player))
                (void) match_exit_internal(Zone(md.player), Zone(md.player), 0);
}

void match_everything(int key)
{
        /*
         * Try matching me, then here, then absolute, then player FIRST, since
         * this will hit most cases. STOP if we get something, since those are
         * exact matches.
         */

        match_me();
        match_here();
        match_absolute();
        if(key & MAT_NUMERIC)
                match_numeric();
        if(key & MAT_HOME)
                match_home();
        match_player();
        if(md.confidence >= CON_TOKEN)
                return;

        if(!(key & MAT_NO_EXITS)) {
                if(key & MAT_EXIT_PARENTS) {
                        match_carried_exit_with_parents();
                        match_exit_with_parents();
                } else {
                        match_carried_exit();
                        match_exit();
                }
        }
        match_neighbor();
        match_possession();
}

dbref match_result(void)
{
        switch (md.count) {
        case 0:
                return NOTHING;
        case 1:
                return md.match;
        default:
                return AMBIGUOUS;
        }
}

/*
 * use this if you don't care about ambiguity 
 */

dbref last_match_result(void)
{
        return md.match;
}

dbref match_status(player, match)
         dbref player, match;
{
        switch (match) {
        case NOTHING:
                notify(player, NOMATCH_MESSAGE);
                return NOTHING;
        case AMBIGUOUS:
                notify(player, AMBIGUOUS_MESSAGE);
                return NOTHING;
        case NOPERM:
                notify(player, NOPERM_MESSAGE);
                return NOTHING;
        }
        if(Good_obj(match) && Dark(match) && Good_obj(player) &&
           !WizRoy(Owner(player)) && !Builder(Owner(player)))
                return match_status(player, NOTHING);
        return match;
}

dbref noisy_match_result(void)
{
        return match_status(md.player, match_result());
}

dbref dispatched_match_result(player)
         dbref player;
{
        return match_status(player, match_result());
}

int matched_locally(void)
{
        return (md.confidence & CON_LOCAL);
}

void save_match_state(mstate)
         MSTATE *mstate;
{
        mstate->confidence = md.confidence;
        mstate->count = md.count;
        mstate->pref_type = md.pref_type;
        mstate->check_keys = md.check_keys;
        mstate->absolute_form = md.absolute_form;
        mstate->match = md.match;
        mstate->player = md.player;
        mstate->string = alloc_lbuf("save_match_state");
        StringCopy(mstate->string, md.string);
}

void restore_match_state(mstate)
         MSTATE *mstate;
{
        md.confidence = mstate->confidence;
        md.count = mstate->count;
        md.pref_type = mstate->pref_type;
        md.check_keys = mstate->check_keys;
        md.absolute_form = mstate->absolute_form;
        md.match = mstate->match;
        md.player = mstate->player;
        StringCopy(md.string, mstate->string);
        free_lbuf(mstate->string);
}

void init_match(dbref player, char *name, int type)
{
        md.confidence = -1;
        md.count = md.check_keys = 0;
        md.pref_type = type;
        md.match = NOTHING;
        md.player = player;
        md.string = munge_space_for_match((char *) name);
        md.absolute_form = absolute_name(1);
}

void init_match_check_keys(dbref player, char *name, int type)
{
        init_match(player, name, type);
        md.check_keys = 1;
}

---