mux/src/wild.cpp File Reference

#include "copyright.h"
#include "autoconf.h"
#include "config.h"
#include "externs.h"

Include dependency graph for wild.cpp:

Go to the source code of this file.

Defines
#define	EQUAL(a, b)   (mux_tolower(a) == mux_tolower(b))
#define	NOTEQUAL(a, b)   (mux_tolower(a) != mux_tolower(b))
Functions
bool	quick_wild (const char *tstr, const char *dstr)
static bool	wild1 (char *tstr, char *dstr, int arg)
bool	wild (char *tstr, char *dstr, char *args[], int nargs)
bool	wild_match (char *tstr, const char *dstr)
Variables
static char **	arglist
static int	numargs

---

Define Documentation

#define EQUAL	(	a,
		b		)	(mux_tolower(a) == mux_tolower(b))

Definition at line 21 of file wild.cpp.

Referenced by quick_wild().

#define NOTEQUAL	(	a,
		b		)	(mux_tolower(a) != mux_tolower(b))

Definition at line 22 of file wild.cpp.

Referenced by quick_wild(), wild(), and wild1().

---

Function Documentation

bool quick_wild	(	const char *	tstr,
		const char *	dstr
	)

Definition at line 35 of file wild.cpp.

References EQUAL, mudconf, mudstate, NOTEQUAL, quick_wild(), statedata::wild_invk_ctr, and confdata::wild_invk_lim.

Referenced by badname_check(), check_filter(), do_chanlist(), do_comlist(), find_wild_attrs(), FUNCTION(), list_vattrs(), quick_wild(), ReportMatchedTopics(), wild(), wild1(), and wild_match().

{
    if (mudstate.wild_invk_ctr >= mudconf.wild_invk_lim)
    {
        return false;
    }
    mudstate.wild_invk_ctr++;

    while (*tstr != '*')
    {
        switch (*tstr)
        {
        case '?':

            // Single character match.  Return false if at end of data.
            //
            if (!*dstr)
            {
                return false;
            }
            break;

        case '\\':

            // Escape character.  Move up, and force literal match of next
            // character.
            //
            tstr++;

            // FALL THROUGH

        default:

            // Literal character.  Check for a match. If matching end of data,
            // return true.
            //
            if (NOTEQUAL(*dstr, *tstr))
            {
                return false;
            }
            if (!*dstr)
            {
                return true;
            }
        }
        tstr++;
        dstr++;
    }

    // Skip over '*'.
    //
    tstr++;

    // Return true on trailing '*'.
    //
    if (!*tstr)
    {
        return true;
    }

    // Skip over wildcards.
    //
    while (  *tstr == '?'
          || *tstr == '*')
    {
        if (*tstr == '?')
        {
            if (!*dstr)
            {
                return false;
            }
            dstr++;
        }
        tstr++;
    }

    // Skip over a backslash in the pattern string if it is there.
    //
    if (*tstr == '\\')
    {
        tstr++;
    }

    // Return true on trailing '*'.
    //
    if (!*tstr)
    {
        return true;
    }

    // Scan for possible matches.
    //
    while (*dstr)
    {
        if (  EQUAL(*dstr, *tstr)
           && quick_wild(tstr + 1, dstr + 1))
        {
            return true;
        }
        dstr++;
    }
    return false;
}

bool wild	(	char *	tstr,
		char *	dstr,
		char *	args[],
		int	nargs
	)

Definition at line 364 of file wild.cpp.

References alloc_lbuf, arglist, free_lbuf, mudstate, NOTEQUAL, numargs, quick_wild(), wild1(), and statedata::wild_invk_ctr.

Referenced by atr_match1(), notify_check(), and process_cmdent().

{
    mudstate.wild_invk_ctr = 0;

    int i;
    char *scan;

    // Initialize the return array.
    //
    for (i = 0; i < nargs; i++)
    {
        args[i] = NULL;
    }

    // Do fast match.
    //
    while (  *tstr != '*'
          && *tstr != '?')
    {
        if (*tstr == '\\')
        {
            tstr++;
        }
        if (NOTEQUAL(*dstr, *tstr))
        {
            return false;
        }
        if (!*dstr)
        {
            return true;
        }
        tstr++;
        dstr++;
    }

    // Allocate space for the return args.
    //
    i = 0;
    scan = tstr;
    while (  *scan
          && i < nargs)
    {
        switch (*scan)
        {
        case '?':

            args[i] = alloc_lbuf("wild.?");
            i++;
            break;

        case '*':

            args[i] = alloc_lbuf("wild.*");
            i++;
        }
        scan++;
    }

    // Put stuff in globals for quick recursion.
    //
    arglist = args;
    numargs = nargs;

    // Do the match.
    //
    bool value = nargs ? wild1(tstr, dstr, 0) : quick_wild(tstr, dstr);

    // Clean out any fake match data left by wild1.
    //
    for (i = 0; i < nargs; i++)
    {
        if (  args[i] != NULL
           && (  !*args[i]
              || !value))
        {
            free_lbuf(args[i]);
            args[i] = NULL;
        }
    }
    return value;
}

static bool wild1	(	char *	tstr,
		char *	dstr,
		int	arg
	)			[static]

Definition at line 147 of file wild.cpp.

References arglist, LBUF_SIZE, mudconf, mudstate, NOTEQUAL, numargs, quick_wild(), statedata::wild_invk_ctr, and confdata::wild_invk_lim.

Referenced by wild().

{
    if (mudstate.wild_invk_ctr >= mudconf.wild_invk_lim)
    {
        return false;
    }
    mudstate.wild_invk_ctr++;

    char *datapos;
    int argpos, numextra;

    while (*tstr != '*')
    {
        switch (*tstr)
        {
        case '?':

            // Single character match.  Return false if at end of data.
            //
            if (!*dstr)
            {
                return false;
            }
            arglist[arg][0] = *dstr;
            arglist[arg][1] = '\0';
            arg++;

            // Jump to the fast routine if we can.
            //
            if (arg >= numargs)
            {
                return quick_wild(tstr + 1, dstr + 1);
            }
            break;

        case '\\':

            // Escape character.  Move up, and force literal match of next
            // character.
            //
            tstr++;

            // FALL THROUGH

        default:

            // Literal character.  Check for a match. If matching end of data,
            // return true.
            //
            if (NOTEQUAL(*dstr, *tstr))
            {
                return false;
            }
            if (!*dstr)
            {
                return true;
            }
        }
        tstr++;
        dstr++;
    }

    // If at end of pattern, slurp the rest, and leave.
    //
    if (!tstr[1])
    {
        strncpy(arglist[arg], dstr, LBUF_SIZE - 1);
        arglist[arg][LBUF_SIZE - 1] = '\0';
        return true;
    }

    // Remember current position for filling in the '*' return.
    //
    datapos = dstr;
    argpos = arg;

    // Scan forward until we find a non-wildcard.
    //
    do
    {
        if (argpos < arg)
        {
            // Fill in arguments if someone put another '*' before a fixed
            // string.
            //
            arglist[argpos][0] = '\0';
            argpos++;

            // Jump to the fast routine if we can.
            //
            if (argpos >= numargs)
            {
                return quick_wild(tstr, dstr);
            }

            // Fill in any intervening '?'s
            //
            while (argpos < arg)
            {
                arglist[argpos][0] = *datapos;
                arglist[argpos][1] = '\0';
                datapos++;
                argpos++;

                // Jump to the fast routine if we can.
                //
                if (argpos >= numargs)
                {
                    return quick_wild(tstr, dstr);
                }
            }
        }

        // Skip over the '*' for now...
        //
        tstr++;
        arg++;

        // Skip over '?'s for now...
        //
        numextra = 0;
        while (*tstr == '?')
        {
            if (!*dstr)
            {
                return false;
            }
            tstr++;
            dstr++;
            arg++;
            numextra++;
        }
    } while (*tstr == '*');

    // Skip over a backslash in the pattern string if it is there.
    //
    if (*tstr == '\\')
    {
        tstr++;
    }

    // Check for possible matches.  This loop terminates either at end of data
    // (resulting in failure), or at a successful match.
    //
    for (;;)
    {
        // Scan forward until first character matches.
        //
        if (*tstr)
        {
            while (NOTEQUAL(*dstr, *tstr))
            {
                if (!*dstr)
                {
                    return false;
                }
                dstr++;
            }
        }
        else
        {
            while (*dstr)
            {
                dstr++;
            }
        }

        // The first character matches, now.  Check if the rest does, using
        // the fastest method, as usual.
        //
        if (  !*dstr
           || ((arg < numargs) ? wild1(tstr + 1, dstr + 1, arg)
                               : quick_wild(tstr + 1, dstr + 1)))
        {
            // Found a match!  Fill in all remaining arguments. First do the
            // '*'...
            //
            strncpy(arglist[argpos], datapos,
                            (dstr - datapos) - numextra);
            arglist[argpos][(dstr - datapos) - numextra] = '\0';
            datapos = dstr - numextra;
            argpos++;

            // Fill in any trailing '?'s that are left.
            //
            while (numextra)
            {
                if (argpos >= numargs)
                {
                    return true;
                }
                arglist[argpos][0] = *datapos;
                arglist[argpos][1] = '\0';
                datapos++;
                argpos++;
                numextra--;
            }

            // It's done!
            //
            return true;
        }
        else
        {
            dstr++;
        }
    }
}

bool wild_match	(	char *	tstr,
		const char *	dstr
	)

Definition at line 452 of file wild.cpp.

References mudstate, mux_atol(), mux_isdigit, quick_wild(), and statedata::wild_invk_ctr.

Referenced by check_attr(), do_switch(), and switch_handler().

{
    switch (*tstr)
    {
    case '>':

        tstr++;
        if (  mux_isdigit(*tstr)
           || *tstr == '-')
        {
            long lt = mux_atol(tstr);
            long ld = mux_atol(dstr);
            return (lt < ld);
        }
        else
        {
            return (strcmp(tstr, dstr) < 0);
        }

    case '<':

        tstr++;
        if (  mux_isdigit(*tstr)
           || *tstr == '-')
        {
            long lt = mux_atol(tstr);
            long ld = mux_atol(dstr);
            return (lt > ld);
        }
        else
        {
            return (strcmp(tstr, dstr) > 0);
        }
    }
    mudstate.wild_invk_ctr = 0;
    return quick_wild(tstr, dstr);
}

---

Variable Documentation

char** arglist [static]

Definition at line 26 of file wild.cpp.

Referenced by wild(), and wild1().

int numargs [static]

Definition at line 27 of file wild.cpp.

Referenced by wild(), and wild1().

---