mux/src/eval.cpp File Reference

#include "copyright.h"
#include "autoconf.h"
#include "config.h"
#include "externs.h"
#include "ansi.h"
#include "attrs.h"
#include "functions.h"

Include dependency graph for eval.cpp:

Go to the source code of this file.

Data Structures
struct	tcache_ent
struct	tag_ptrsframe
struct	tag_intsframe
Defines
#define	isSpecial(table, c)   isSpecial_##table[(unsigned char)(c)]
	Accesses the isSpecial_ tables with proper typecast.
#define	NEXTCHAR   *zstr++ = *cstr++;
#define	stacklim   32
#define	stacklim   32
#define	PTRS_PER_FRAME   ((LBUF_SIZE - sizeof(char *) - sizeof(int))/sizeof(char *))
#define	INTS_PER_FRAME   ((LBUF_SIZE - sizeof(char *) - sizeof(int))/sizeof(int))
Typedefs
typedef tcache_ent	TCENT
typedef tag_ptrsframe	PtrsFrame
typedef tag_intsframe	IntsFrame
Functions
static char *	parse_to_cleanup (int eval, int first, char *cstr, char *rstr, char *zstr, char *strFirewall)
char *	parse_to (char **dstr, char delim, int eval)
static char *	parse_to_lite (char **dstr, char delim1, char delim2, int *nLen, int *iWhichDelim)
char *	parse_arglist (dbref executor, dbref caller, dbref enactor, char *dstr, char delim, dbref eval, char *fargs[], dbref nfargs, char *cargs[], dbref ncargs, int *nArgsParsed)
static char *	parse_arglist_lite (dbref executor, dbref caller, dbref enactor, char *dstr, char delim, int eval, char *fargs[], dbref nfargs, char *cargs[], dbref ncargs, int *nArgsParsed)
int	get_gender (dbref player)
void	tcache_init (void)
static bool	tcache_empty (void)
static void	tcache_add (dbref player, char *orig, char *result)
static void	tcache_finish (void)
char **	PushPointers (int nNeeded)
void	PopPointers (char **p, int nNeeded)
int *	PushIntegers (int nNeeded)
void	PopIntegers (int *pi, int nNeeded)
void	mux_exec (char *buff, char **bufc, dbref executor, dbref caller, dbref enactor, int eval, char **dstr, char *cargs[], int ncargs)
void	save_global_regs (const char *funcname, char *preserve[], int preserve_len[])
void	save_and_clear_global_regs (const char *funcname, char *preserve[], int preserve_len[])
void	restore_global_regs (const char *funcname, char *preserve[], int preserve_len[])
Variables
static char	isSpecial_L3 [256]
static const char	isSpecial_L4 [256]
const signed char	mux_RegisterSet [256]
static struct tcache_ent *	tcache_head
static bool	tcache_top
static int	tcache_count
const char *	ColorTable [256]
static bool	isSpecial_L1 [256]
static const unsigned char	isSpecial_L2 [256]
static PtrsFrame *	pPtrsFrame = NULL
static IntsFrame *	pIntsFrame = NULL

---

Define Documentation

#define INTS_PER_FRAME   ((LBUF_SIZE - sizeof(char *) - sizeof(int))/sizeof(int))

Definition at line 1049 of file eval.cpp.

Referenced by PopIntegers(), and PushIntegers().

#define isSpecial	(	table,
		c		)	isSpecial_##table[(unsigned char)(c)]

Accesses the isSpecial_ tables with proper typecast.

Parameters:

	table	indicates which table: L1, L2, L3, or L4.
	c	character being looked up.

Returns:

lvalue of table entry.

Definition at line 78 of file eval.cpp.

Referenced by mux_exec(), parse_to(), and parse_to_lite().

#define NEXTCHAR   *zstr++ = *cstr++;

Definition at line 164 of file eval.cpp.

Referenced by parse_to().

#define PTRS_PER_FRAME   ((LBUF_SIZE - sizeof(char *) - sizeof(int))/sizeof(char *))

Definition at line 1011 of file eval.cpp.

Referenced by PopPointers(), and PushPointers().

#define stacklim   32

#define stacklim   32

Referenced by parse_to(), and parse_to_lite().

---

Typedef Documentation

typedef struct tag_intsframe IntsFrame

typedef struct tag_ptrsframe PtrsFrame

typedef struct tcache_ent TCENT

Definition at line 862 of file eval.cpp.

---

Function Documentation

int get_gender

(

dbref

player

)

Definition at line 837 of file eval.cpp.

References A_SEX, atr_pget, free_lbuf, and mux_tolower.

Referenced by handle_ears(), and mux_exec().

{
    dbref aowner;
    int aflags;
    char *atr_gotten = atr_pget(player, A_SEX, &aowner, &aflags);
    char first = atr_gotten[0];
    free_lbuf(atr_gotten);
    switch (mux_tolower(first))
    {
    case 'p':
        return 4;

    case 'm':
        return 3;

    case 'f':
    case 'w':
        return 2;
    }
    return 1;
}

void mux_exec	(	char *	buff,
		char **	bufc,
		dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	eval,
		char **	dstr,
		char *	cargs[],
		int	ncargs
	)

Definition at line 1087 of file eval.cpp.

References A_VA, alloc_lbuf, alloc_mbuf, ANSI_ENDGOAL_NORMAL, ANSI_String_Copy(), ANSI_String_Finalize(), ANSI_String_In_Init(), ANSI_String_Out_Init(), ufun::atr, atr_get, atr_pget_str_LEN(), CMuxAlarm::bAlarmed, statedata::bStackLimitReached, check_access(), statedata::curr_cmd, EV_EVAL, EV_FCHECK, EV_FMAND, EV_NO_LOCATION, EV_NOFCHECK, EV_NOTRACE, EV_STRIP_CURLY, EV_TOP, tagFun::flags, ufun::flags, FN_NOEVAL, FN_PRES, FN_PRIV, free_lbuf, free_mbuf, tagFun::fun, statedata::func_htab, statedata::func_invk_ctr, confdata::func_invk_lim, statedata::func_nest_lev, confdata::func_nest_lim, get_gender(), statedata::glob_reg_len, statedata::global_regs, Going, hashfindLEN(), ISOUTOFMEMORY, isSpecial, LBUF_SIZE, MAX_ARG, MAX_GLOBAL_REGS, tagFun::maxArgs, tagFun::maxArgsParsed, MEMALLOC, MEMFREE, tagFun::minArgs, mudconf, mudstate, mux_exec(), mux_isazAZ, mux_isspace, mux_ltoa(), mux_RegisterSet, mux_tolower, mux_toupper, MuxAlarm, tagFun::name, Name, notify, confdata::nStackLimit, statedata::nStackNest, ufun::obj, parse_arglist_lite(), parse_to_lite(), ufun::perms, tagFun::perms, PopIntegers(), PopPointers(), statedata::pout, PushIntegers(), PushPointers(), restore_global_regs(), safe_copy_buf(), safe_noperm, safe_str, save_global_regs(), SBUF_SIZE, confdata::space_compress, tcache_add(), tcache_empty(), tcache_finish(), Trace, confdata::trace_limit, confdata::trace_topdown, statedata::ufunc_htab, and where_is().

Referenced by add_mail_message(), add_prefix(), BuildChannelMessage(), check_filter(), default_handler(), delim_check(), did_it(), do_if(), do_postpend(), do_prepend(), do_switch(), do_think(), do_ufun(), eval_boolexp(), filter_handler(), FUNCTION(), get_exit_dest(), get_handler(), look_contents(), look_exits(), look_in(), mail_return(), modSpeech(), mux_exec(), page_return(), parse_arglist(), parse_arglist_lite(), process_cmdent(), process_command(), process_hook(), process_sex(), ReportTopic(), search_perform(), show_a_desc(), switch_handler(), and u_comp().

{
    if (  *dstr == NULL
       || **dstr == '\0'
       || MuxAlarm.bAlarmed)
    {
        return;
    }

    // Stack Limit checking with thanks to RhostMUSH.
    //
    if (mudconf.nStackLimit < mudstate.nStackNest)
    {
        mudstate.bStackLimitReached = true;
        return;
    }

    char *TempPtr;
    char *tstr, *tbuf, *start, *oldp, *savestr;
    const char *constbuf;
    int ch;
    char *realbuff = NULL, *realbp = NULL;
    dbref aowner;
    int nfargs, aflags, feval, i;
    bool ansi = false;
    FUN *fp;
    UFUN *ufp;

    static const char *subj[5] = {"", "it", "she", "he", "they"};
    static const char *poss[5] = {"", "its", "her", "his", "their"};
    static const char *obj[5] =  {"", "it", "her", "him", "them"};
    static const char *absp[5] = {"", "its", "hers", "his", "theirs"};

    // This is scratch buffer is used potentially on every invocation of
    // mux_exec. Do not assume that its contents are valid after you
    // execute any function that could re-enter mux_exec.
    //
    static char mux_scratch[LBUF_SIZE];

    char *pdstr = *dstr;

    int at_space = 1;
    int gender = -1;

    bool is_trace = Trace(executor) && !(eval & EV_NOTRACE);
    bool is_top = false;

    // Extend the buffer if we need to.
    //
    if (LBUF_SIZE - SBUF_SIZE < (*bufc) - buff)
    {
        realbuff = buff;
        realbp = *bufc;
        buff = (char *)MEMALLOC(LBUF_SIZE);
        ISOUTOFMEMORY(buff);
        *bufc = buff;
    }

    oldp = start = *bufc;

    // If we are tracing, save a copy of the starting buffer.
    //
    savestr = NULL;
    if (is_trace)
    {
        is_top = tcache_empty();
        savestr = alloc_lbuf("exec.save");
        strcpy(savestr, pdstr);
    }

    // Save Parser Mode.
    //
    bool bSpaceIsSpecialSave = isSpecial(L1, ' ');
    bool bParenthesisIsSpecialSave = isSpecial(L1, '(');
    bool bBracketIsSpecialSave = isSpecial(L1, '[');

    // Setup New Parser Mode.
    //
    bool bSpaceIsSpecial = mudconf.space_compress && !(eval & EV_NO_COMPRESS);
    isSpecial(L1, ' ') = bSpaceIsSpecial;
    isSpecial(L1, '(') = (eval & EV_FCHECK) != 0;
    isSpecial(L1, '[') = (eval & EV_NOFCHECK) == 0;

    size_t nBufferAvailable = LBUF_SIZE - (*bufc - buff) - 1;
    for (;;)
    {
        // Handle mundane characters specially. There are usually a lot of them.
        // Just copy them.
        //
        if (!isSpecial(L1, *pdstr))
        {
            char *p = pdstr + 1;
            while (!isSpecial(L1, *p++))
            {
                ; // Nothing.
            }
            size_t n = p - pdstr - 1;
            if (nBufferAvailable < n)
            {
                n = nBufferAvailable;
            }
            memcpy(*bufc, pdstr, n);
            nBufferAvailable -= n;
            *bufc += n;
            at_space = 0;
            pdstr = p - 1;
        }


        // At this point, **dstr must be one of the following characters:
        //
        // 0x00 0x20 0x25 0x28 0x5B 0x5C 0x7B
        // NULL  SP   %    (     [    \   {
        //
        // Test softcode shows the following distribution:
        //
        // NULL occurs 116948 times
        //   (  occurs  49567 times
        //   %  occurs  24553 times
        //   [  occurs   7618 times
        //  SP  occurs   1323 times
        //
        if (*pdstr == '\0')
        {
            break;
        }
        else if (*pdstr == '(')
        {
            // *pdstr == '('
            //
            // Arglist start.  See if what precedes is a function. If so,
            // execute it if we should.
            //
            at_space = 0;

            // Load an sbuf with an lowercase version of the func name, and
            // see if the func exists. Trim trailing spaces from the name if
            // configured.
            //
            char *pEnd = *bufc - 1;
            if (mudconf.space_compress && (eval & EV_FMAND))
            {
                while (  oldp <= pEnd
                      && mux_isspace(*pEnd))
                {
                    pEnd--;
                }
            }

            // _strlwr(tbuf);
            //
            char *p2 = mux_scratch;
            for (char *p = oldp; p <= pEnd; p++)
            {
                *p2++ = mux_tolower(*p);
            }
            *p2 = '\0';

            int ntbuf = p2 - mux_scratch;
            fp = (FUN *)hashfindLEN(mux_scratch, ntbuf, &mudstate.func_htab);

            // If not a builtin func, check for global func.
            //
            ufp = NULL;
            if (fp == NULL)
            {
                ufp = (UFUN *)hashfindLEN(mux_scratch, ntbuf, &mudstate.ufunc_htab);
            }

            // Do the right thing if it doesn't exist.
            //
            if (!fp && !ufp)
            {
                if (eval & EV_FMAND)
                {
                    *bufc = oldp;
                    safe_str("#-1 FUNCTION (", buff, bufc);
                    safe_str(mux_scratch, buff, bufc);
                    safe_str(") NOT FOUND", buff, bufc);
                    nBufferAvailable = LBUF_SIZE - (*bufc - buff) - 1;
                    break;
                }
                else if (nBufferAvailable)
                {
                    *(*bufc)++ = '(';
                    nBufferAvailable--;
                }
            }
            else
            {
                // Get the arglist and count the number of args. Neg # of args
                // means catenate subsequent args.
                //
                if (ufp)
                {
                    nfargs = MAX_ARG;
                }
                else
                {
                    nfargs = fp->maxArgsParsed;
                }

                tstr = pdstr;
                if (  fp
                   && (fp->flags & FN_NOEVAL))
                {
                    feval = eval & ~(EV_EVAL|EV_TOP|EV_STRIP_CURLY);
                }
                else
                {
                    feval = eval & ~EV_TOP;
                }

                char **fargs = PushPointers(MAX_ARG);
                pdstr = parse_arglist_lite(executor, caller, enactor,
                      pdstr + 1, ')', feval, fargs, nfargs, cargs, ncargs,
                      &nfargs);


                // If no closing delim, just insert the '(' and continue normally.
                //
                if (!pdstr)
                {
                    pdstr = tstr;
                    if (nBufferAvailable)
                    {
                        *(*bufc)++ = *pdstr;
                        nBufferAvailable--;
                    }
                }
                else
                {
                    pdstr--;

                    // If it's a user-defined function, perform it now.
                    //
                    mudstate.func_nest_lev++;
                    mudstate.func_invk_ctr++;
                    if (mudconf.func_nest_lim <= mudstate.func_nest_lev)
                    {
                         safe_str("#-1 FUNCTION RECURSION LIMIT EXCEEDED", buff, &oldp);
                    }
                    else if (mudconf.func_invk_lim <= mudstate.func_invk_ctr)
                    {
                        safe_str("#-1 FUNCTION INVOCATION LIMIT EXCEEDED", buff, &oldp);
                    }
                    else if (Going(executor))
                    {
                        safe_str("#-1 BAD EXECUTOR", buff, &oldp);
                    }
                    else if (!check_access(executor, ufp ? ufp->perms : fp->perms))
                    {
                        safe_noperm(buff, &oldp);
                    }
                    else if (MuxAlarm.bAlarmed)
                    {
                        safe_str("#-1 CPU LIMITED", buff, &oldp);
                    }
                    else if (ufp)
                    {
                        tstr = atr_get(ufp->obj, ufp->atr, &aowner, &aflags);
                        if (ufp->flags & FN_PRIV)
                        {
                            i = ufp->obj;
                        }
                        else
                        {
                            i = executor;
                        }
                        TempPtr = tstr;

                        char **preserve = NULL;
                        int *preserve_len = NULL;

                        if (ufp->flags & FN_PRES)
                        {
                            preserve = PushPointers(MAX_GLOBAL_REGS);
                            preserve_len = PushIntegers(MAX_GLOBAL_REGS);
                            save_global_regs("eval_save", preserve, preserve_len);
                        }

                        mux_exec(buff, &oldp, i, executor, enactor, feval,
                                 &TempPtr, fargs, nfargs);

                        if (ufp->flags & FN_PRES)
                        {
                            restore_global_regs("eval_restore", preserve, preserve_len);
                            PopIntegers(preserve_len, MAX_GLOBAL_REGS);
                            PopPointers(preserve, MAX_GLOBAL_REGS);
                            preserve = NULL;
                            preserve_len = NULL;
                        }
                        free_lbuf(tstr);
                    }
                    else
                    {
                        // If the number of args is right, perform the func.
                        // Otherwise, return an error message.
                        //
                        if (  fp->minArgs <= nfargs
                           && nfargs <= fp->maxArgs
                           && !MuxAlarm.bAlarmed)
                        {
                            fp->fun(buff, &oldp, executor, caller, enactor,
                                    fargs, nfargs, cargs, ncargs);
                        }
                        else
                        {
                            if (fp->minArgs == fp->maxArgs)
                            {
                                sprintf(mux_scratch,
                                    "#-1 FUNCTION (%s) EXPECTS %d ARGUMENTS",
                                    fp->name, fp->minArgs);
                            }
                            else if (fp->minArgs + 1 == fp->maxArgs)
                            {
                                sprintf(mux_scratch,
                                    "#-1 FUNCTION (%s) EXPECTS %d OR %d ARGUMENTS",
                                    fp->name, fp->minArgs, fp->maxArgs);
                            }
                            else if (MuxAlarm.bAlarmed)
                            {
                                sprintf(mux_scratch, "#-1 CPU LIMITED");
                            }
                            else
                            {
                                sprintf(mux_scratch,
                                    "#-1 FUNCTION (%s) EXPECTS BETWEEN %d AND %d ARGUMENTS",
                                    fp->name, fp->minArgs, fp->maxArgs);
                            }
                            safe_str(mux_scratch, buff, &oldp);
                        }
                    }
                    *bufc = oldp;
                    nBufferAvailable = LBUF_SIZE - (*bufc - buff) - 1;
                    mudstate.func_nest_lev--;
                }

                // Return the space allocated for the arguments.
                //
                for (i = 0; i < nfargs; i++)
                {
                    free_lbuf(fargs[i]);
                }
                PopPointers(fargs, MAX_ARG);
                fargs = NULL;
            }
            eval &= ~EV_FCHECK;
            isSpecial(L1, '(') = false;
        }
        else if (*pdstr == '%')
        {
            // Percent-replace start.  Evaluate the chars following and
            // perform the appropriate substitution.
            //
            at_space = 0;
            if (!(eval & EV_EVAL))
            {
                if (nBufferAvailable)
                {
                    *(*bufc)++ = '%';
                    nBufferAvailable--;
                }
                pdstr++;
                if (nBufferAvailable)
                {
                    *(*bufc)++ = *pdstr;
                    nBufferAvailable--;
                }
            }
            else
            {
                pdstr++;
                ch = *pdstr;
                unsigned char cType_L2 = isSpecial(L2, ch);
                TempPtr = *bufc;
                int iCode = cType_L2 & 0x7F;
                if (iCode == 1)
                {
                    // 30 31 32 33 34 35 36 37 38 39
                    // 0  1  2  3  4  5  6  7  8  9
                    //
                    // Command argument number N.
                    //
                    i = ch - '0';
                    if (  i < ncargs
                       && cargs[i])
                    {
                        safe_str(cargs[i], buff, bufc);
                        nBufferAvailable = LBUF_SIZE - (*bufc - buff) - 1;
                    }
                }
                else if (iCode == 2)
                {
                    // 51
                    // Q
                    //
                    pdstr++;
                    i = mux_RegisterSet[(unsigned char)*pdstr];
                    if (  0 <= i
                       && i < MAX_GLOBAL_REGS)
                    {
                        if (  mudstate.glob_reg_len[i] > 0
                           && mudstate.global_regs[i])
                        {
                            safe_copy_buf(mudstate.global_regs[i],
                                mudstate.glob_reg_len[i], buff, bufc);
                            nBufferAvailable = LBUF_SIZE - (*bufc - buff) - 1;
                        }
                    }
                    else if (*pdstr == '\0')
                    {
                        pdstr--;
                    }
                }
                else if (iCode <= 4)
                {
                    if (iCode == 3)
                    {
                        // 23
                        // #
                        //
                        // Enactor DB number.
                        //
                        mux_scratch[0] = '#';
                        i = mux_ltoa(enactor, mux_scratch+1);
                        safe_copy_buf(mux_scratch, i+1, buff, bufc);
                        nBufferAvailable = LBUF_SIZE - (*bufc - buff) - 1;
                    }
                    else if (iCode == 4)
                    {
                        // 21
                        // !
                        //
                        // iCode == '!'
                        // Executor DB number.
                        //
                        mux_scratch[0] = '#';
                        i = mux_ltoa(executor, mux_scratch+1);
                        safe_copy_buf(mux_scratch, i+1, buff, bufc);
                        nBufferAvailable = LBUF_SIZE - (*bufc - buff) - 1;
                    }
                    else
                    {
                        // iCode == 0
                        //
                        // Just copy
                        //
                        if (nBufferAvailable)
                        {
                            *(*bufc)++ = ch;
                            nBufferAvailable--;
                        }
                    }
                }
                else if (iCode <= 6)
                {
                    if (iCode == 6)
                    {
                        // 43 58
                        // C  X
                        //
                        // Color
                        //
                        const char *pColor = ColorTable[(unsigned char)pdstr[1]];
                        if (pColor)
                        {
                            pdstr++;
                            ansi = true;
                            safe_str(pColor, buff, bufc);
                            nBufferAvailable = LBUF_SIZE - (*bufc - buff) - 1;
                        }
                        else if (pdstr[1] && nBufferAvailable)
                        {
                            *(*bufc)++ = *pdstr;
                            nBufferAvailable--;
                        }
                    }
                    else
                    {
                        // 52
                        // R
                        //
                        // Carriage return.
                        //
                        safe_copy_buf("\r\n", 2, buff, bufc);
                        nBufferAvailable = LBUF_SIZE - (*bufc - buff) - 1;
                    }
                }
                else if (iCode <= 8)
                {
                    if (iCode == 7)
                    {
                        // 42
                        // B
                        //
                        // Blank.
                        //
                        if (nBufferAvailable)
                        {
                            *(*bufc)++ = ' ';
                            nBufferAvailable--;
                        }
                    }
                    else
                    {
                        // 54
                        // T
                        //
                        // Tab.
                        //
                        if (nBufferAvailable)
                        {
                            *(*bufc)++ = '\t';
                            nBufferAvailable--;
                        }
                    }
                }
                else if (iCode <= 10)
                {
                    if (iCode == 9)
                    {
                        // 4C
                        // L
                        //
                        // Enactor Location DB Ref
                        //
                        if (!(eval & EV_NO_LOCATION))
                        {
                            mux_scratch[0] = '#';
                            i = mux_ltoa(where_is(enactor), mux_scratch+1);
                            safe_copy_buf(mux_scratch, i+1, buff, bufc);
                            nBufferAvailable = LBUF_SIZE - (*bufc - buff) - 1;
                        }
                    }
                    else
                    {
                        // 56
                        // V
                        //
                        // Variable attribute.
                        //
                        pdstr++;
                        if (mux_isazAZ(*pdstr))
                        {
                            i = A_VA + mux_toupper(*pdstr) - 'A';
                            size_t nAttrGotten;
                            atr_pget_str_LEN(mux_scratch, executor, i,
                                &aowner, &aflags, &nAttrGotten);
                            if (0 < nAttrGotten)
                            {
                                if (nAttrGotten > nBufferAvailable)
                                {
                                    nAttrGotten = nBufferAvailable;
                                }
                                memcpy(*bufc, mux_scratch, nAttrGotten);
                                *bufc += nAttrGotten;
                                nBufferAvailable -= nAttrGotten;
                            }
                        }
                        else if (*pdstr == '\0')
                        {
                            pdstr--;
                        }
                    }
                }
                else if (iCode <= 14)
                {
                    if (iCode <= 12)
                    {
                        if (iCode == 11)
                        {
                            // 25
                            // %
                            //
                            // Percent - a literal %
                            //
                            if (nBufferAvailable)
                            {
                                *(*bufc)++ = '%';
                                nBufferAvailable--;
                            }
                        }
                        else
                        {
                            // 4E
                            // N
                            //
                            // Enactor name
                            //
                            safe_str(Name(enactor), buff, bufc);
                            nBufferAvailable = LBUF_SIZE - (*bufc - buff) - 1;
                        }
                    }
                    else
                    {
                        if (iCode == 13)
                        {
                            // 7C
                            // |
                            //
                            // piped command output.
                            //
                            safe_str(mudstate.pout, buff, bufc);
                            nBufferAvailable = LBUF_SIZE - (*bufc - buff) - 1;
                        }
                        else
                        {
                            // 53
                            // S
                            //
                            // Subjective pronoun.
                            //
                            if (gender < 0)
                            {
                                gender = get_gender(enactor);
                            }
                            if (!gender)
                            {
                                constbuf  = Name(enactor);
                            }
                            else
                            {
                                constbuf  = subj[gender];
                            }
                            safe_str(constbuf, buff, bufc);
                            nBufferAvailable = LBUF_SIZE - (*bufc - buff) - 1;
                        }
                    }
                }
                else
                {
                    if (iCode <= 16)
                    {
                        if (iCode == 15)
                        {
                            // 50
                            // P
                            //
                            // Personal pronoun.
                            //
                            if (gender < 0)
                            {
                                gender = get_gender(enactor);
                            }

                            if (!gender)
                            {
                                safe_str(Name(enactor), buff, bufc);
                                nBufferAvailable = LBUF_SIZE - (*bufc - buff) - 1;
                                if (nBufferAvailable)
                                {
                                    *(*bufc)++ = 's';
                                    nBufferAvailable--;
                                }
                            }
                            else
                            {
                                safe_str((char *)poss[gender], buff, bufc);
                                nBufferAvailable = LBUF_SIZE - (*bufc - buff) - 1;
                            }
                        }
                        else
                        {
                            // 4F
                            // O
                            //
                            // Objective pronoun.
                            //
                            if (gender < 0)
                            {
                                gender = get_gender(enactor);
                            }
                            if (!gender)
                            {
                                constbuf = Name(enactor);
                            }
                            else
                            {
                                constbuf = obj[gender];
                            }
                            safe_str(constbuf, buff, bufc);
                            nBufferAvailable = LBUF_SIZE - (*bufc - buff) - 1;
                        }
                    }
                    else
                    {
                        if (iCode == 17)
                        {
                            // 41
                            // A
                            //
                            // Absolute posessive.
                            // Idea from Empedocles.
                            //
                            if (gender < 0)
                            {
                                gender = get_gender(enactor);
                            }

                            if (!gender)
                            {
                                safe_str(Name(enactor), buff, bufc);
                                nBufferAvailable = LBUF_SIZE - (*bufc - buff) - 1;
                                if (nBufferAvailable)
                                {
                                    *(*bufc)++ = 's';
                                    nBufferAvailable--;
                                }
                            }
                            else
                            {
                                safe_str(absp[gender], buff, bufc);
                                nBufferAvailable = LBUF_SIZE - (*bufc - buff) - 1;
                            }
                        }
                        else if (iCode == 18)
                        {
                            // 00
                            // \0
                            //
                            // All done.
                            //
                            pdstr--;
                        }
                        else if (iCode == 19)
                        {
                            // 4D
                            // M
                            //
                            // Last command
                            //
                            safe_str(mudstate.curr_cmd, buff, bufc);
                            nBufferAvailable = LBUF_SIZE - (*bufc - buff) - 1;
                        }
                        else
                        {
                            // 40
                            // @
                            //
                            // iCode == '@'
                            // Caller DB number.
                            //
                            mux_scratch[0] = '#';
                            i = mux_ltoa(caller, mux_scratch+1);
                            safe_copy_buf(mux_scratch, i+1, buff, bufc);
                            nBufferAvailable = LBUF_SIZE - (*bufc - buff) - 1;
                        }
                    }
                }

                // For some escape letters, if the escape letter
                // was upper-case, then upper-case the first
                // letter of the value.
                //
                if (cType_L2 & 0x80)
                {
                    *TempPtr = mux_toupper(*TempPtr);
                }
            }
        }
        else if (*pdstr == '[')
        {
            // Function start.  Evaluate the contents of the square brackets
            // as a function. If no closing bracket, insert the '[' and
            // continue.
            //
            tstr = pdstr++;
            mudstate.nStackNest++;
            tbuf = parse_to_lite(&pdstr, ']', '\0', &at_space, &at_space);
            at_space = 0;
            if (pdstr == NULL)
            {
                if (nBufferAvailable)
                {
                    *(*bufc)++ = '[';
                    nBufferAvailable--;
                }
                pdstr = tstr;
            }
            else
            {
                mudstate.nStackNest--;
                TempPtr = tbuf;
                mux_exec(buff, bufc, executor, caller, enactor,
                    (eval | EV_FCHECK | EV_FMAND) & ~EV_TOP, &TempPtr, cargs,
                    ncargs);
                nBufferAvailable = LBUF_SIZE - (*bufc - buff) - 1;
                pdstr--;
            }
        }

        // At this point, *pdstr must be one of the following characters:
        //
        // 0x20 0x5C 0x7B
        // SP    \    {
        //
        else if (*pdstr == ' ')
        {
            // A space. Add a space if not compressing or if previous char was
            // not a space.
            //
            if (bSpaceIsSpecial && !at_space)
            {
                if (nBufferAvailable)
                {
                    *(*bufc)++ = ' ';
                    nBufferAvailable--;
                }
                at_space = 1;
            }
        }
        else if (*pdstr == '{')
        {
            // *pdstr == '{'
            //
            // Literal start.  Insert everything up to the terminating '}'
            // without parsing. If no closing brace, insert the '{' and
            // continue.
            //
            tstr = pdstr++;
            mudstate.nStackNest++;
            tbuf = parse_to_lite(&pdstr, '}', '\0', &at_space, &at_space);
            at_space = 0;
            if (pdstr == NULL)
            {
                if (nBufferAvailable)
                {
                    *(*bufc)++ = '{';
                    nBufferAvailable--;
                }
                pdstr = tstr;
            }
            else
            {
                mudstate.nStackNest--;
                if (!(eval & EV_STRIP_CURLY))
                {
                    if (nBufferAvailable)
                    {
                        *(*bufc)++ = '{';
                        nBufferAvailable--;
                    }
                }

                if (eval & EV_EVAL)
                {
                    // Preserve leading spaces (Felan)
                    //
                    if (*tbuf == ' ')
                    {
                        if (nBufferAvailable)
                        {
                            *(*bufc)++ = ' ';
                            nBufferAvailable--;
                        }
                        tbuf++;
                    }

                    TempPtr = tbuf;
                    mux_exec(buff, bufc, executor, caller, enactor,
                        (eval & ~(EV_STRIP_CURLY | EV_FCHECK | EV_TOP)),
                        &TempPtr, cargs, ncargs);
                }
                else
                {
                    TempPtr = tbuf;
                    mux_exec(buff, bufc, executor, caller, enactor,
                        eval & ~EV_TOP, &TempPtr, cargs, ncargs);
                }
                nBufferAvailable = LBUF_SIZE - (*bufc - buff) - 1;

                if (!(eval & EV_STRIP_CURLY))
                {
                    if (nBufferAvailable)
                    {
                        *(*bufc)++ = '}';
                        nBufferAvailable--;
                    }
                }
                pdstr--;
            }
        }
        else if (*pdstr == '\\')
        {
            // *pdstr must be \.
            //
            // General escape. Add the following char without special
            // processing.
            //
            at_space = 0;
            pdstr++;
            if (*pdstr)
            {
                if (nBufferAvailable)
                {
                    *(*bufc)++ = *pdstr;
                    nBufferAvailable--;
                }
            }
            else
            {
                pdstr--;
            }
        }
        else
        {
            // *pdstr must be ESC.
            //
            at_space = 0;
            if (nBufferAvailable)
            {
                *(*bufc)++ = *pdstr;
                nBufferAvailable--;
            }
            pdstr++;
            if (*pdstr)
            {
                if (nBufferAvailable)
                {
                    *(*bufc)++ = *pdstr;
                    nBufferAvailable--;
                }
            }
            else
            {
                pdstr--;
            }
        }
        pdstr++;
    }

    // If we're eating spaces, and the last thing was a space, eat it up.
    // Complicated by the fact that at_space is initially true. So check to
    // see if we actually put something in the buffer, too.
    //
    if (  bSpaceIsSpecial
       && at_space
       && start != *bufc)
    {
        (*bufc)--;
    }

    **bufc = '\0';

    // Collect and report trace information.
    //
    if (is_trace)
    {
        tcache_add(executor, savestr, start);
        if (  is_top
           || !mudconf.trace_topdown)
        {
            tcache_finish();
        }
        if (  is_top
           && 0 < tcache_count - mudconf.trace_limit)
        {
            tbuf = alloc_mbuf("exec.trace_diag");
            sprintf(tbuf, "%d lines of trace output discarded.", tcache_count
                - mudconf.trace_limit);
            notify(executor, tbuf);
            free_mbuf(tbuf);
        }
    }

    if (  realbuff
       || ansi
       || (eval & EV_TOP))
    {
        // We need to transfer and/or ANSI optimize the result.
        //
        static struct ANSI_In_Context aic;
        static struct