# action.t | documentation

    #charset "us-ascii"

    /*
     *   Copyright (c) 2000, 2006 Michael J. Roberts.  All Rights Reserved.
     *
     *   TADS 3 Library: Actions.
     *
     *   This module defines the Action classes.  An Action is an abstract
     *   object representing a command to be performed.
     */

    #include "adv3.h"
    #include "tok.h"

    /* ------------------------------------------------------------------------ */
    /*
     *   Object associations lists.  We use this object to store some lookup
     *   tables that we build during preinitialization to relate object usages
     *   (DirectObject, IndirectObject) to certain properties.
     */
    objectRelations: PreinitObject
        /* preinitialization - build the lookup tables */
        execute()
        {
            /* build the default pre-condition properties table */
            preCondDefaultProps[DirectObject] = &preCondDobjDefault;
            preCondDefaultProps[IndirectObject] = &preCondIobjDefault;

            /* build the catch-all pre-conditions properties table */
            preCondAllProps[DirectObject] = &preCondDobjAll;
            preCondAllProps[IndirectObject] = &preCondIobjAll;

            /* build the default verification properties table */
            verifyDefaultProps[DirectObject] = &verifyDobjDefault;
            verifyDefaultProps[IndirectObject] = &verifyIobjDefault;

            /* build the catch-all verification properties table */
            verifyAllProps[DirectObject] = &verifyDobjAll;
            verifyAllProps[IndirectObject] = &verifyIobjAll;

            /* build the default check properties table */
            checkDefaultProps[DirectObject] = &checkDobjDefault;
            checkDefaultProps[IndirectObject] = &checkIobjDefault;

            /* build the catch-all check properties table */
            checkAllProps[DirectObject] = &checkDobjAll;
            checkAllProps[IndirectObject] = &checkIobjAll;

            /* build the default action properties table */
            actionDefaultProps[DirectObject] = &actionDobjDefault;
            actionDefaultProps[IndirectObject] = &actionIobjDefault;

            /* build the catch-all check properties table */
            actionAllProps[DirectObject] = &actionDobjAll;
            actionAllProps[IndirectObject] = &actionIobjAll;
        }

        /* lookup table for default precondition properties */
        preCondDefaultProps = static new LookupTable()

        /* lookup table for catch-all precondition properties */
        preCondAllProps = static new LookupTable()

        /* lookup table for default verification properties */
        verifyDefaultProps = static new LookupTable()

        /* lookup table for catch-all verification properties */
        verifyAllProps = static new LookupTable()

        /* lookup table for default check properties */
        checkDefaultProps = static new LookupTable()

        /* lookup table for catch-all check properties */
        checkAllProps = static new LookupTable()

        /* lookup table for default action properties */
        actionDefaultProps = static new LookupTable()

        /* lookup table for catch-all action properties */
        actionAllProps = static new LookupTable()
    ;

    /* ------------------------------------------------------------------------ */
    /*
     *   Invoke the given function with the given values for the parser global
     *   variables gActor and gAction.
     */
    withParserGlobals(issuer, actor, action, func)
    {
        local oldIssuer;
        local oldActor;
        local oldAction;

        /* remember the old action and actor, so we can restore them later */
        oldIssuer = gIssuingActor;
        oldActor = gActor;
        oldAction = gAction;

        /* establish our actor and action as the global settings */
        gIssuingActor = issuer;
        gActor = actor;
        gAction = action;

        /* make sure we restore globals on the way out */
        try
        {
            /* invoke the callback and return the result */
            return (func)();
        }
        finally
        {
            /* restore the globals we changed */
            gActor = oldActor;
            gIssuingActor = oldIssuer;
            gAction = oldAction;
        }
    }

    /* ------------------------------------------------------------------------ */
    /*
     *   Pre-condition Descriptor.  This object encapsulates a precondition
     *   object and the argument we want to pass to its condition check method.
     */
    class PreCondDesc: object
        construct(cond, arg)
        {
            /* remember the condition and the check argument */
            cond_ = cond;
            arg_ = arg;
        }

        /* check the precondition */
        checkPreCondition(allowImplicit)
        {
            /* call the precondition's check method with the argument we stored */
            return cond_.checkPreCondition(arg_, allowImplicit);
        }

        /* the precondition object */
        cond_ = nil

        /* the check argument */
        arg_ = nil

        /* our list sorting index */
        index_ = 0
    ;

    /* ------------------------------------------------------------------------ */
    /*
     *   Basic Action class.  An Action is the language-independent definition
     *   of the abstract action of a command.
     */
    class Action: BasicProd
        /*
         *   Are we the given kind of action?  By default, this simply returns
         *   true if we're of the given action class.
         */
        actionOfKind(cls) { return ofKind(cls); }

        /*
         *   Reset the action in preparation for re-execution.  This should
         *   discard any scoped context from any past execution of the
         *   command, such as cached scope information.
         */
        resetAction()
        {
            /* forget any past successful verification passes */
            verifiedOkay = [];
        }

        /*
         *   Repeat the action, for an AGAIN command.
         */
        repeatAction(lastTargetActor, lastTargetActorPhrase,
                     lastIssuingActor, countsAsIssuerTurn)
        {
            /* execute the command */
            executeAction(lastTargetActor, lastTargetActorPhrase,
                          lastIssuingActor, countsAsIssuerTurn, self);
        }

        /*
         *   Cancel iteration of the action.  This can be called during the
         *   'check' or 'action' phases of executing this action.  It tells
         *   the action that we want to stop executing the action when we're
         *   finished with the current object.
         *
         *   Note that this doesn't cause a jump out of the current code, so
         *   it's not like 'exit' or the other termination signals.  Instead,
         *   this simply tells the action to proceed normally for the
         *   remainder of the processing for the current object, and then act
         *   as though there were no more objects to iterate over, ending the
         *   command normally.  If you want to cut off the remainder of the
         *   execution cycle for the current object, you can use 'exit' (for
         *   example) immediately after calling this method.
         */
        cancelIteration() { iterationCanceled = true; }

        /* internal flag: object iteration has been canceled */
        iterationCanceled = nil

        /*
         *   Create an instance of this action, for use by a recursive or
         *   programmatically-generated command.
         *
         *   The generic actions defined in the library are always subclassed
         *   by language-specific library modules, because the language
         *   modules have to define the grammar rules for the verbs - we can't
         *   define the grammar rules generically because the verbs wouldn't
         *   be reusable for non-English translations if we did.  As a result,
         *   library code referring to one of the library verbs by name, say
         *   TakeAction, doesn't get a language-specific subclass of the verb,
         *   but just gets the language-independent base class.
         *
         *   However, to make full use of an Action object in a recursive
         *   command, we do need a final language-specific subclass - without
         *   this, we won't be able to generate text describing the command,
         *   for example.  This method bridges this gap by finding a suitable
         *   language-specific subclass of the given action, then creating an
         *   instance of that subclass rather than an instance of the base
         *   class.
         *
         *   By default, we'll take any subclass of this action that is itself
         *   a class.  However, if any subclass has the property
         *   defaultForRecursion set to true, we'll use that class
         *   specifically - this lets the language module designate a
         *   particular subclass to use as the default for recursive commands,
         *   which might be desirable in cases where the language module
         *   defines more than one subclass of an action.
         */
        createActionInstance()
        {
            local found;

            /*
             *   Iterate over our subclasses.  Initialize 'found' to this base
             *   class, so that if we fail to find any subclasses, we'll at
             *   least be able to create an instance of the generic base
             *   class.
             */
            for (local cur = firstObj(self, ObjClasses), found = self ;
                 cur != nil ; cur = nextObj(cur, self, ObjClasses))
            {
                /*
                 *   if this one is marked as a default for recursion, and the
                 *   last one we found isn't, choose this one over the last
                 *   one we found
                 */
                if (cur.defaultForRecursion && !found.defaultForRecursion)
                    found = cur;

                /*
                 *   If this one is a subclass of the last one we found, pick
                 *   it instead of the last one.  We always want a final
                 *   subclass here, never an intermediate class, so if we find
                 *   a subclass of the one we've tentatively picked, we know
                 *   that the tentative selection isn't final after all.
                 */
                if (cur.ofKind(found))
                    found = cur;
            }

            /* return a new instance of what we found */
            return found.createInstance();
        }

        /*
         *   Create an instance of this action based on another action.  We'll
         *   copy the basic properties of the original action.
         */
        createActionFrom(orig)
        {
            local action;

            /* create a new instance of this action */
            action = createActionInstance();

            /* copy the token list information to the new action */
            action.tokenList = orig.tokenList;
            action.firstTokenIndex = orig.firstTokenIndex;
            action.lastTokenIndex = orig.lastTokenIndex;

            /* the new action is implicit if the original was */
            if (orig.isImplicit)
                action.setImplicit(orig.implicitMsg);

            /* return the new action */
            return action;
        }

        /*
         *   Mark the command as implicit.  'msgProp' is the property (of
         *   gLibMessages) to use to announce the implicit command.
         */
        setImplicit(msgProp)
        {
            /* mark ourselves as implicit */
            isImplicit = true;

            /* do not show default reports for implicit commands */
            showDefaultReports = nil;

            /* all implicit commands are nested */
            setNested();

            /*
             *   do not include implicit commands in undo - since an implicit
             *   command is only a subpart of an explicit command, an implicit
             *   command is not undone individually but only as part of the
             *   enclosing explicit command
             */
            includeInUndo = nil;

            /* remember the implicit command announcement message property */
            implicitMsg = msgProp;
        }

        /*
         *   Mark the command as nested, noting the parent action (which we
         *   take as the global current action).
         */
        setNested()
        {
            /* remember the parent action */
            parentAction = gAction;
        }

        /*
         *   Determine if I'm nested within the given action.  Returns true if
         *   the given action is my parent action, or if my parent action is
         *   nested within the given action.
         */
        isNestedIn(action)
        {
            /* if my parent action is the given action, I'm nested in it */
            if (parentAction == action)
                return true;

            /*
             *   if I have a parent action, and it's nested in the given
             *   action, then I'm nested in the given action because I'm
             *   nested in anything my parent is nested in
             */
            if (parentAction != nil && parentAction.isNestedIn(action))
                return true;

            /* we're not nested in the given action */
            return nil;
        }

        /*
         *   Set the "original" action.  An action with an original action is
         *   effectively part of the original action for the purposes of its
         *   reported results.
         *
         *   An action has an original action if it's a nested or replacement
         *   action for an action.
         */
        setOriginalAction(action)
        {
            /* remember my original action */
            originalAction = action;
        }

        /*
         *   Get the "original" action.  If I'm a replacement or nested action,
         *   this returns the original main action of which I'm a part, for
         *   reporting pruposes.
         *
         *   It's important to note that an implied action does NOT count as a
         *   nested or replacement action for the purposes of this method.
         *   That is, if a command A triggers an implied action B, which
         *   triggers a nested action C, and then after that command A itself
         *   triggers a nested action D, then
         *
         *   A.getOriginalAction -> A
         *.  B.getOriginalAction -> B (B is implied, not nested)
         *.  C.getOriginalAction -> C (C is nested within B)
         *.  D.getOriginalAction -> A (D is nested within A)
         *
         *   The purpose of the original action is to tell us, mainly for
         *   reporting purposes, what we're really trying to do with the
         *   action.  This allows reports to hide the internal details of how
         *   the action is carried out, and instead say what the action was
         *   meant to do from the player's perspective.
         */
        getOriginalAction()
        {
            /* if I have no other original action, I'm the original action */
            if (originalAction == nil)
                return self;

            /* return my original action's original action */
            return originalAction.getOriginalAction();
        }

        /*
         *   Determine if this action is "part of" the given action.  I'm part
         *   of the given action if I am the given action, or the given action
         *   is my "original" action, or my original action is part of the
         *   given action.
         */
        isPartOf(action)
        {
            /* if I'm the same as the given action, I'm obviously part of it */
            if (action == self)
                return true;

            /* if my original action is part of the action, I'm part of it */
            if (originalAction != nil && originalAction.isPartOf(action))
                return true;

            /* I'm not part of the given action */
            return nil;
        }

        /*
         *   Mark the action as "remapped."  This indicates that the action
         *   was explicitly remapped to a different action during the remap()
         *   phase.
         */
        setRemapped(orig) { remappedFrom = gAction; }

        /* determine if I'm remapped, and get the original action if so */
        isRemapped() { return remappedFrom != nil; }
        getRemappedFrom() { return remappedFrom; }

        /*
         *   Get the "simple synonym" remapping for one of our objects, if
         *   any.  'obj' is the resolved object to remap, and 'role' is the
         *   object role identifier (DirectObject, IndirectObject, etc).
         *   'remapProp' is the remapping property for the role; this is
         *   simply the result of our getRemapPropForRole(role), but we ask
         *   the caller to pass this in so that it can be pre-computed in
         *   cases where we'll called in a loop.
         *
         *   A simple synonym remapping is a remapTo that applies the same
         *   verb to a new object in the same role.  For example, if we remap
         *   OPEN DESK to OPEN DRAWER, then the drawer is the simple synonym
         *   remapping for the desk in an OPEN command.  A remapping is
         *   considered a simple synonym remapping only if we're remapping to
         *   the same action, AND the new object is in the same action role as
         *   the original object was.
         *
         *   If there's no simple synonym remapping, we'll return nil.
         */
        getSimpleSynonymRemap(obj, role, remapProp)
        {
            local mapping;
            local remapIdx;

            /* if the object isn't remapped at all, there's no remapping */
            if ((mapping = obj.(remapProp)) == nil)
                return nil;

            /* if the mapping isn't to the same action, it's not a synonym */
            if (!ofKind(mapping[1]))
                return nil;

            /*
             *   Find the specific (non-role) object in the remap vector -
             *   this is the entry that's actually an object rather than a
             *   role identifier.  (The remapping vector is required to have
             *   exactly one such entry.  Look from the right end of the list,
             *   since the first entry is always the new action, which is
             *   itself an object, but not the object we're looking for.)
             */
            remapIdx = mapping.lastIndexWhich({x: dataType(x) == TypeObject});
            if (remapIdx == nil)
                return nil;

            /*
             *   Determine if the object plays the same role in the new action
             *   as the original object did in the original action.  It does
             *   if it's at the index in the mapping vector of our object role
             *   in the action.  Note that the mapping vector has slot 1
             *   filled with the action, so its objects are actually one slot
             *   higher than they are in the action itself.
             *
             *   If the new object isn't in the same role, then this isn't a
             *   simple synonym remapping.
             */
            if (getRoleFromIndex(remapIdx - 1) != role)
                return nil;

            /*
             *   We have the same action applied to a new object in the same
             *   role as the original object, so this is a simple synonym
             *   remapping.  Return the new object we're mapping to.
             */
            return mapping[remapIdx];
        }

        /*
         *   the defaultForRecursion flag must be explicitly set in subclasses
         *   when desired - by default we'll use any language-specific
         *   subclass of an Action for recursive commands
         */
        defaultForRecursion = nil

        /*
         *   Flag: the command is implicit.  An implicit command is one that
         *   is performed as an implied enabling step of another command - for
         *   example, if an actor wants to throw something, the actor must be
         *   holding the object, so will implicitly try to take the object.
         */
        isImplicit = nil

        /*
         *   The parent action.  If the command is performed programmatically
         *   in the course of executing another command, this is set to the
         *   enclosing action.
         *
         *   Note that while all implicit commands are nested, not all nested
         *   commands are implicit.  A nested command may simply be a
         *   component of another command, or another command may be handled
         *   entirely by running a different command as a nested command.  In
         *   any case, a nested but non-implicit command does not appear to
         *   the player as a separate command; it is simply part of the
         *   original command.
         */
        parentAction = nil

        /*
         *   The original action we were remapped from.  This is valid when
         *   the action was explicitly remapped during the remap() phase to a
         *   different action.
         */
        remappedFrom = nil

        /*
         *   the original action - we are effectively part of the original
         *   action for reporting purposes
         */
        originalAction = nil

        /* the libMessage property, if any, to announce the implicit command */
        implicitMsg = nil

        /*
         *   Flag: we are to show default reports for this action.  In most
         *   cases we will do so, but for some types of commands (such as
         *   implicit commands), we suppress default reports.
         */
        showDefaultReports = true

        /*
         *   Get a message parameter object for the action.  Each action
         *   subclass defines this to return its objects according to its own
         *   classifications.  The default action has no objects, but
         *   recognizes 'actor' as the current command's actor.
         */
        getMessageParam(objName)
        {
            switch(objName)
            {
            case 'pc':
                /* return the player character */
                return gPlayerChar;

            case 'actor':
                /* return the current actor */
                return gActor;

            default:
                /*
                 *   if we have an extra message parameters table, look up the
                 *   parameter name in the table
                 */
                if (extraMessageParams != nil)
                    return extraMessageParams[objName];

                /* we don't recognize other names */
                return nil;
            }
        }

        /*
         *   Define an extra message-specific parameter.  Message processors
         *   can use this to add their own special parameters, so that they
         *   can refer to parameters that aren't involved directly in the
         *   command.  For example, a message for "take <dobj>" might want to
         *   refer to the object containing the direct object.
         */
        setMessageParam(objName, obj)
        {
            /*
             *   if we don't yet have an extra message parameters table,
             *   create a small lookup table for it
             */
            if (extraMessageParams == nil)
                extraMessageParams = new LookupTable(8, 8);

            /* add the parameter to the table, indexing by the parameter name */
            extraMessageParams[objName.toLower()] = obj;
        }

        /*
         *   For convenience, this method allows setting any number of
         *   name/value pairs for message parameters.
         */
        setMessageParams([lst])
        {
            /* set each pair from the argument list */
            for (local i = 1, local len = lst.length() ; i+1 <= len ; i += 2)
                setMessageParam(lst[i], lst[i+1]);
        }

        /*
         *   Synthesize a global message parameter name for the given object.
         *   We'll store the association and return the synthesized name.
         */
        synthMessageParam(obj)
        {
            local nm;

            /* synthesize a name */
            nm = 'synth' + toString(synthParamID++);

            /* store the association */
            setMessageParam(nm, obj);

            /* return the synthesized name */
            return nm;
        }

        /* synthesized message object parameter serial number */
        synthParamID = 1

        /*
         *   Extra message parameters.  If a message processor wants to add
         *   special message parameters of its own, we'll create a lookup
         *   table for the extra parameters.  Message processors might want to
         *   add their own special parameters to allow referring to objects
         *   other than the main objects of the command.
         */
        extraMessageParams = nil

        /*
         *   Flag: this command is repeatable with 'again'.  Before executing
         *   a command, we'll save it for use by the 'again' command if this
         *   flag is true.
         */
        isRepeatable = true

        /*
         *   Flag: this command should be included in the undo records.  This
         *   is true for almost every command, but a few special commands
         *   (undo, save) are not subject to undo.
         */
        includeInUndo = true

        /*
         *   Flag: this is a "conversational" command, as opposed to an order.
         *   When this type of command is addressed to another character, it
         *   doesn't ask the other character to do anything, but rather engages
         *   the other character in conversation.  Examples:
         *
         *.  Bob, hello
         *.  Bob, goodbye
         *.  Bob, tell me about the planet
         *.  Bob, yes
         *.  Bob, no
         *
         *   ("Tell me about..." is a little different from the others.  We
         *   treat it as conversational because it means the same thing as "ask
         *   Bob about...", which we consider conversational because it would
         *   be rendered in real life as a question.  In other words, the
         *   action involves the issuing actor stating the question, which
         *   means that issuing actor is the one doing the physical work of the
         *   action.  "Tell me about..." could be seen as an order, but it
         *   seems more appropriate to view it as simply an alternative way of
         *   phrasing a question.)
         *
         *   The issuing actor is passed as a parameter because some actions
         *   are conversational only in some cases; "tell me about the planet"
         *   is conversational, but "tell Bill about the planet" isn't, since
         *   the latter doesn't ask Bob a question but orders Bob to talk to
         *   Bill.
         *
         *   When the issuing actor and target actor are the same, this is
         *   irrelevant.  The purpose of this is to distinguish orders given to
         *   another character from conversational overtures directed to the
         *   other character, so if the command is coming from the player and
         *   bound for the player character, there's obviously no conversation
         *   going on.
         *
         *   Note also that, contrary to what one might think at first glance,
         *   a command like ASK ABOUT is NOT conversational; it's a command to
         *   ask someone about something, and isn't itself a conversational
         *   overture.  The act of asking is itself a conversational overture,
         *   but the asking is the *result* of the command, not the command
         *   itself.  An action is only conversational if the action itself is
         *   a conversational overture.  So, "BOB, HELLO" is conversational;
         *   "BOB, ASK BILL ABOUT COMPUTER" is not, because it orders Bob to do
         *   something.
         */
        isConversational(issuingActor) { return nil; }

        /*
         *   Get the actual verb phrase the player typed in to generate this
         *   Action, expressed in a canonical format.  The canonical format
         *   consists of the lower-case version of all of the actual text the
         *   player typed, but with each noun phrase replaced by a standard
         *   placeholder token describing the slot.  The placeholder tokens are
         *   '(dobj)' for the direct object, '(iobj)' for the indirect object,
         *   '(literal)' for a literal text phrase, and '(topic)' for a topic
         *   phrase.
         *
         *   For example, if the player typed PUT BOOK AND PENCIL IN BOX, the
         *   canonical phrasing we return would be "put (dobj) in (iobj)".
         */
        getEnteredVerbPhrase()
        {
            local orig;
            local txt;

            /*
             *   If there's an original action, let the original action do the
             *   work.  If we've been remapped, or if this is an implied
             *   action, we won't necessarily have been constructed from the
             *   actual player input, so we need to go back to the original
             *   action for this information.
             */
            if (getOriginalAction() != self)
                return getOriginalAction.getEnteredVerbPhrase();

            /* start with the original token list for the predicate */
            orig = getPredicate().getOrigTokenList();

            /* add each token to the result text */
            for (txt = '', local i = 1, local len = orig.length() ;
                 i <= len ; ++i)
            {
                local foundNp;

                /* add a space if this isn't the first element */
                if (i > 1)
                    txt += ' ';

                /*
                 *   Check to see if we're entering one of the noun-phrase
                 *   slots.  We are if we've reached the first token of one of
                 *   the predicate noun phrases.
                 */
                foundNp = nil;
                foreach (local npProp in predicateNounPhrases)
                {
                    local match;

                    /* check to see if we're at this noun phrase */
                    if ((match = self.(npProp)) != nil
                        && i == match.firstTokenIndex)
                    {
                        /*
                         *   we're entering this noun phrase - add the generic
                         *   placeholder token for the noun phrase
                         */
                        txt += (npProp == &dobjMatch ? '(dobj)' :
                                npProp == &iobjMatch ? '(iobj)' :
                                npProp == &topicMatch ? '(topic)' :
                                npProp == &literalMatch ? '(literal)' :
                                '(other)');

                        /* skip the entire run of tokens for the noun phrase */
                        i = match.lastTokenIndex;

                        /* note that we found a noun phrase */
                        foundNp = true;

                        /* stop looking for a noun phrase */
                        break;
                    }
                }

                /*
                 *   if we didn't find a noun phrase, this token is a literal
                 *   part of the predicate grammar, so add it as-is
                 */
                if (!foundNp)
                    txt += getTokVal(orig[i]);
            }

            /* return the phrase, with everything converted to lower-case */
            return txt.toLower();
        }

        /*
         *   Get the grammar match tree object for the predicate that was used
         *   to enter this command.  By default, if we have an original action,
         *   we return the original action; otherwise we just return 'self'.
         *
         *   Language libraries must override this to return the original match
         *   tree object if Actions are separate from predicate match trees.
         *
         *   (The 'predicate' is simply the grammar match tree object for the
         *   entire verb phrase from the player's actual command entry text
         *   that matched this Action.  For example, in "BOB, TAKE BOX", the
         *   predicate is the match tree for the "TAKE BOX" part.  In "BOB,
         *   TAKE BOX AND GO NORTH", the predicate for the Take action is still
         *   the "TAKE BOX" part.  For "BOB, TAKE BOX AND BOOK AND GO NORTH",
         *   the predicate for the Take action is "TAKE BOX AND BOOK" - the
         *   full verb phrase includes any multiple-object lists in the
         *   original command.)
         */
        getPredicate()
        {
            /*
             *   By default, we just return the original Action - we assume
             *   that the language library defines Action subclasses as the
             *   actual match tree objects for predicate grammars.  Language
             *   modules must override this if they use separate object types
             *   for the predicate match tree objects.
             */
            return getOriginalAction();
        }

        /*
         *   Get the noun-phrase information for my predicate grammar.  This
         *   returns a list of the match-tree properties for the noun-phrase
         *   sub-productions in our predicate grammar.  The properties
         *   generally include &dobjMatch, &iobjMatch, &literalMatch, and
         *   &topicMatch.  The order of the slots isn't important; they simply
         *   tell us which ones we should find in our predicate grammar match.
         *
         *   The base Action is intransitive, so it doesn't have any
         *   noun-phrase slots, hence this is an empty list.
         */
        predicateNounPhrases = []

        /*
         *   Get the object "role" identifier for the given index.  This
         *   returns the identifier (DirectObject, IndirectObject, etc.) for
         *   the object at the given slot index, as used in
         *   setResolvedObjects().  The first object is at index 1.
         */
        getRoleFromIndex(idx) { return nil; }

        /*
         *   Get the "other object" role - this is the complement of the given
         *   object role for a two-object action, and is used to determine the
         *   real role of the special OtherObject placeholder in a remapTo().
         *   This is only meaningful with actions of exactly two objects.
         */
        getOtherObjectRole(role) { return nil; }

        /* get the resolved object in a given role */
        getObjectForRole(role) { return nil; }

        /* get the match tree for the noun phrase in the given role */
        getMatchForRole(role) { return nil; }

        /* get the 'verify' property for a given object role */
        getVerifyPropForRole(role)
        {
            return nil;
        }

        /* get the 'preCond' property for a given object role */
        getPreCondPropForRole(role)
        {
            return nil;
        }

        /* get the 'remap' property for a given object role */
        getRemapPropForRole(role)
        {
            return nil;
        }

        /*
         *   Get the ResolveInfo for the given object in the current command.
         *   Since we don't have any objects at all, we'll simply return a new
         *   ResolveInfo wrapping the given object.  'cur' is the object we're
         *   looking for, and 'oldRole' is the role the object previously
         *   played in the action.
         */
        getResolveInfo(obj, oldRole) { return new ResolveInfo(obj, 0, nil); }

        /*
         *   Explicitly set the resolved objects.  This should be overridden
         *   in each subclass for the number of objects specific to the action
         *   (a simple transitive action takes one argument, an action with
         *   both a direct and indirect object takes two arguments, and so
         *   on).  The base action doesn't have any objects at all, so this
         *   takes no arguments.
         *
         *   This method is used to set up an action to be performed
         *   programmatically, rather than based on parsed input.  Since
         *   there's no parsed input in such cases, the objects are specified
         *   directly by the programmatic caller.
         */
        setResolvedObjects() { }

        /*
         *   Explicitly set the object match trees.  This sets the pre-resolved
         *   production match trees.  The arguments are given in the order of
         *   their roles in the action, using the same order that
         *   setResolvedObjects() uses.
         *
         *   The arguments to this routine can either be match tree objects,
         *   which we'll plug into our grammar tree in the respective roles
         *   exactly as given; or they can be ResolveInfo objects giving the
         *   desired resolutions, in which case we'll build the appropriate
         *   kind of PreResolvedProd for each one.  The types can be freely
         *   mixed.
         */
        setObjectMatches() { }

        /*
         *   Check that the resolved objects are all in scope.  Returns true if
         *   so, nil if not.
         *
         *   This routine is meant for use only for actions built
         *   programmatically using setResolvedObjects().  In particular, we
         *   assume that we have only one object in each slot.  For normal
         *   parser-built actions, this check isn't necessary, because the
         *   parser only resolves objects that are in scope in the first place.
         */
        resolvedObjectsInScope()
        {
            /* we have no objects at all, so there is nothing out of scope */
            return true;
        }

        /*
         *   Get the list of bindings for an anaphoric pronoun - this is a
         *   pronoun that refers back to an earlier noun phrase in the same
         *   sentence, such as HIMSELF in ASK BOB ABOUT HIMSELF.  These
         *   obviously make no sense for verbs that take one (or zero)
         *   objects, since there's no earlier phrase to refer back to; these
         *   should return nil to indicate that an anaphoric pronoun is simply
         *   nonsensical in such a context.  Actions of two or more objects
         *   should return a list of objects for the preceding noun phrase.
         *
         *   Actions of two or more objects should set this if possible to the
         *   resolved object list for the previous noun phrase, as a
         *   ResolveInfo list.
         *
         *   The tricky part is that some actions will resolve noun phrases in
         *   a different order than they appear in the actual command grammar;
         *   similarly, it's also possible that some non-English languages use
         *   cataphoric pronouns (i.e., pronouns that refer to noun phrases
         *   that appear later in the sentence).  To allow for these cases,
         *   return an empty list here if a binding is grammatically possible
         *   but not yet available because of the resolution order, and note
         *   internally that the parser asked us for an anaphoric binding.
         *   Afterwards, the action's resolver method must go back and perform
         *   *another* resolve pass on the noun phrase production that
         *   requested the anaphor binding.
         *
         *   'typ' is the PronounType specifier for the corresponding ordinary
         *   pronoun.  For 'himself', for example, typ will be PronounHim.
         */
        getAnaphoricBinding(typ) { return nil; }

        /*
         *   Set a special pronoun override.  This creates a temporary pronoun
         *   definition, which lasts as long as this action (and any nested
         *   actions).  The temporary definition overrides the normal meaning
         *   of the pronoun.
         *
         *   One example of where this is useful is in global action remapping
         *   cases where the target actor changes in the course of the
         *   remapping.  For example, if we remap BOB, GIVE ME YOUR BOOK to ASK
         *   BOB FOR YOUR BOOK, the YOUR qualifier should still refer to Bob
         *   even though the command is no longer addressing Bob directly.
         *   This routine can be used in this case to override the meaning of
         *   'you' so that it refers to Bob.
         */
        setPronounOverride(typ, val)
        {
            /* if we don't have an override table yet, create one */
            if (pronounOverride == nil)
                pronounOverride = new LookupTable(5, 10);

            /* add it to the table */
            pronounOverride[typ] = val;
        }

        /*
         *   Get any special pronoun override in effect for the action, as set
         *   via setPronounOverride().  This looks in our own override table
         *   for a definition; then, if we have no override of our own, we ask
         *   our parent action if we have one, then our original action.
         */
        getPronounOverride(typ)
        {
            local pro;

            /* check our own table */
            if (pronounOverride != nil
                && (pro = pronounOverride[typ]) != nil)
                return pro;

            /* we don't have anything in our own table; check our parent */
            if (parentAction != nil
                && (pro = parentAction.getPronounOverride(typ)) != nil)
                return pro;

            /* if still nothing, check with the original action */
            if (originalAction != nil
                && originalAction != parentAction
                && (pro = originalAction.getPronounOverride(typ)) != nil)
                return pro;

            /* we didn't find an override */
            return nil;
        }

        /*
         *   the pronoun override table - this is nil by default, which means
         *   that no overrides have been defined yet; we create a LookupTable
         *   upon adding the first entry to the table
         */
        pronounOverride = nil

        /* wrap an object with a ResolveInfo */
        makeResolveInfo(val)
        {
            /*
             *   if it's already a ResolveInfo object, return it as-is;
             *   otherwise, create a new ResolveInfo wrapper for it
             */
            if (dataType(val) == TypeObject && val.ofKind(ResolveInfo))
                return val;
            else
                return new ResolveInfo(val, 0, nil);
        }

        /*
         *   Convert an object or list of objects to a ResolveInfo list
         */
        makeResolveInfoList(val)
        {
            /* if we have a non-list collection, make it a list */
            if (dataType(val) == TypeObject && val.ofKind(Collection))
                val = val.toList();

            /* if it's nil or an empty list, return an empty list */
            if (val == nil || val == [])
                return [];

            /* see what we have */
            if (dataType(val) == TypeList)
            {
                /* it's a list - make a ResolveInfo for each item */
                return val.mapAll({x: makeResolveInfo(x)});
            }
            else
            {
                /* it's not a list - return a one-element ResolveInfo list */
                return [makeResolveInfo(val)];
            }
        }

        /*
         *   If the command is repeatable, save it for use by 'again'.
         */
        saveActionForAgain(issuingActor, countsAsIssuerTurn,
                           targetActor, targetActorPhrase)
        {
            /*
             *   Check to see if the command is repeatable.  It's repeatable if
             *   the base action is marked as repeatable, AND it's not nested,
             *   AND it's issued by the player character, AND it's either a PC
             *   command or it counts as an issuer turn.
             *
             *   Nested commands are never repeatable with 'again', since no
             *   one ever typed them in.
             *
             *   "Again" is strictly for the player's use, so it's repeatable
             *   only if this is the player's turn, as opposed to a scripted
             *   action by an NPC.  This is the player's turn only if the
             *   command was issued by the player character (which means it
             *   came from the player), and either it's directed to the player
             *   character OR it counts as a turn for the player character.
             */
            if (isRepeatable
                && parentAction == nil
                && (issuingActor.isPlayerChar()
                    && (targetActor.isPlayerChar() || countsAsIssuerTurn)))
                AgainAction.saveForAgain(issuingActor, targetActor,
                                         targetActorPhrase, self);
        }

        /*
         *   Perform this action.  Throughout execution of the action, the
         *   global parser variables that specify the current actor and action
         *   are valid.
         */
        doAction(issuingActor, targetActor, targetActorPhrase,
                 countsAsIssuerTurn)
        {
            local oldActor;
            local oldIssuer;
            local oldAction;
            local oldResults;

            /*
             *   save the current parser globals, for restoration when we
             *   finish this command - if this command is nested within
             *   another, this will let us ensure that everything is restored
             *   properly when we finish with this command
             */
            oldActor = gActor;
            oldIssuer = gIssuingActor;
            oldAction = gAction;
            oldResults = gVerifyResults;

            /*
             *   set the new globals (note that there are no verification
             *   results or command reports objects yet - these are valid only
             *   while we're running the corresponding command phases)
             */
            gActor = targetActor;
            gIssuingActor = issuingActor;
            gAction = self;
            gVerifyResults = nil;

            /* make sure we restore globals on our way out */
            try
            {
                local pc;

                /* if applicable, save the command for AGAIN */
                saveActionForAgain(issuingActor, countsAsIssuerTurn,
                                   targetActor, targetActorPhrase);

                /* start a new command visually if this isn't a nested action */
                if (parentAction == nil)
                    gTranscript.addCommandSep();

                /* have the player character note initial conditions */
                pc = gPlayerChar;
                pc.noteConditionsBefore();

                /* run the before routine for the entire action */
                beforeActionMain();

                /* run the subclass-specific processing */
                doActionMain();

                /* run the after routine for the entire action */
                afterActionMain();

                /*
                 *   If this is a top-level action, show the command results.
                 *   Don't show results for a nested action, since we want to
                 *   wait and let the top-level action show the results after
                 *   it has the full set of results.
                 */
                if (parentAction == nil)
                {
                    /*
                     *   If the player character didn't change, ask the player
                     *   character to note any condition changes.  If the
                     *   player character did change to a new actor,
                     *   presumably the command will have displayed a specific
                     *   message, since this would be an unusual development
                     *   for which we can generate no generic message.
                     */
                    if (gPlayerChar == pc)
                        pc.noteConditionsAfter();
                }
            }
            finally
            {
                /* restore the parser globals to how we found them */
                gActor = oldActor;
                gIssuingActor = oldIssuer;
                gAction = oldAction;
                gVerifyResults = oldResults;
            }
        }

        /*
         *   Perform processing before running the action.  This is called
         *   just once per action, even if the action will be iterated for a
         *   list of objects.
         */
        beforeActionMain()
        {
        }

        /*
         *   Perform processing after running the entire action.  This is
         *   called just once per action, even if the action was iterated for
         *   a list of objects.
         */
        afterActionMain()
        {
            /* call each registered after-action handler */
            if (afterActionMainList != nil)
            {
                foreach (local cur in afterActionMainList)
                    cur.afterActionMain();
            }

            /*
             *   Mark ourselves as busy for the amount of time this action
             *   takes.  Don't count the time taken for implied actions,
             *   though, since these are meant to be zero-time sub-actions
             *   performed as part of the main action and thus don't have a
             *   separate time cost.
             *
             *   Note that we add our busy time in the main after-action
             *   processing because we only want to count our time cost once
             *   for the whole command, even if we're performing the command on
             *   multiple objects.
             */
            if (!isImplicit)
            {
                local actor;

                /*
                 *   If the command is conversational, the turn counts as an
                 *   issuer turn; otherwise, it counts as a turn for the target
                 *   actor.  Conversational commands are effectively carried
                 *   out by the issuer, even though in form they're directed to
                 *   another actor (as in "BOB, HELLO"), so we need to count
                 *   the time they take as the issuer's time.
                 */
                actor = (isConversational(gIssuingActor)
                         ? gIssuingActor : gActor);

                /* add the busy time to the actor */
                actor.addBusyTime(self, actionTime);
            }

            /*
             *   If the command failed, and this is a top-level (not nested)
             *   action, check to see if the game wants to cancel remaining
             *   commands on the line.
             */
            if (gTranscript.isFailure
                && parentAction == nil
                && gameMain.cancelCmdLineOnFailure)
            {
                /*
                 *   the command failed, and they want to cancel remaining
                 *   commands on failure - throw a 'cancel command line'
                 *   exception to cancel any remaining tokens
                 */
                throw new CancelCommandLineException();
            }
        }

        /*
         *   Register an object for afterActionMain invocation.  After we've
         *   finished with the entire action - including all iterated objects
         *   involved in the action - we'll invoke each registered object's
         *   afterActionMain() method.  This registration is only meaningful
         *   for the current action instance, and can only be set up before
         *   the action has been finished (i.e., before the current gAction
         *   invokes its own afterActionMain() method).
         *
         *   Each object is only registered once.  If a caller attempts to
         *   register the same object repeatedly, we'll simply ignore the
         *   repeated requests.
         *
         *   This is a convenient way to implement a collective follow-up to
         *   the parts of an iterated action.  Since repeated registrations
         *   are ignored, each handler for an iterated object (such as a
         *   "dobjFor" action() handler) can register its follow-up handler
         *   without worrying about redundant registration.  Then, when the
         *   overall action is completed for each iterated object involved,
         *   the follow-up handler will be invoked, and it can do any final
         *   work for the overall action.  For example, the follow-up handler
         *   could display a message summarizing the iterated parts of the
         *   action; or, it could even scan the transcript for particular
         *   messages and replace them with a summary.
         */
        callAfterActionMain(obj)
        {
            /* if we don't have an after-action list yet, create one */
            if (afterActionMainList == nil)
                afterActionMainList = new Vector(8);

            /* if this item isn't already in the list, add it */
            if (afterActionMainList.indexOf(obj) == nil)
                afterActionMainList.append(obj);
        }

        /* list of methods to invoke after we've completed the action */
        afterActionMainList = nil

        /*
         *   the amount of time on the game clock that the action consumes -
         *   by default, each action consumes one unit, but actions can
         *   override this to consume more or less game time
         */
        actionTime = 1

        /*
         *   Zero the action time in this action and any parent actions.  This
         *   should be used when a nested replacement action is to completely
         *   take over the time-keeping responsibility for the entire turn; all
         *   containing actions in this case are to take zero time, since the
         *   nested action is the only part of the turn that will count for
         *   timing.
         */
        zeroActionTime()
        {
            /* clear my action time */
            actionTime = 0;

            /* if we have a parent action, zero it and its parents */
            if (parentAction != nil)
                parentAction.zeroActionTime();
        }

        /*
         *   Execute the action for a single set of objects.  This runs the
         *   full execution sequence for the current set of objects.
         *
         *   Subclasses generally won't override this method, but will instead
         *   override the methods that implement the individual steps in the
         *   execution sequence.
         */
        doActionOnce()
        {
            /*
             *   Perform the sequence of operations to execute the action.  If
             *   an ExitSignal is thrown during the sequence, skip to the
             *   end-of-turn processing.
             */
            try
            {
                local result;
                local impReport;

                /*
                 *   Before doing any actual execution, check the command for
                 *   remapping.  If we end up doing any remapping, the
                 *   remapping routine will simply replace the current command,
                 *   so we the remapping call will terminate the current action
                 *   with 'exit' and thus never return here.
                 */
                checkRemapping();

                /*
                 *   If this is an implicit action, check for danger: we never
                 *   try a command implicitly when the command is obviously
                 *   dangerous.
                 */
                if (isImplicit)
                {
                    /*
                     *   verify the action for an implicit command, checking
                     *   for actions that aren't allowe implicitly - we never
                     *   try a command implicitly when the command is (or
                     *   should be) obviously dangerous or is simply
                     *   non-obvious
                     */
                    result = verifyAction();

                    /*
                     *   If the action can be performed, but can't be performed
                     *   implicitly, abort.  Note that we only silently ignore
                     *   the action if it is allowed normally but not
                     *   implicitly: if it's not even allowed normally, we'll
                     *   simply fail later with the normal failure message,
                     *   since there's no harm in trying.
                     */
                    if (result != nil
                        && result.allowAction
                        && !result.allowImplicit)
                        abortImplicit;
                }

                /*
                 *   If this is an implicit command, display a message
                 *   indicating that we're performing the command.
                 */
                impReport = maybeAnnounceImplicit();

                /*
                 *   Make one or two passes through verifications and
                 *   preconditions.  If any precondition performs an implicit
                 *   command, we must run everything a second time to ensure
                 *   that the implicit command or commands did not invalidate
                 *   any earlier precondition or a verification.
                 *
                 *   Run verifications before preconditions, because there
                 *   would be no point in applying implicit commands from
                 *   preconditions if the command verifies as illogical in the
                 *   first place.
                 */
                for (local iter = 1 ; iter <= 2 ; ++iter)
                {
                    /* verify the action */
                    result = verifyAction();

                    /*
                     *   if verification doesn't allow the command to proceed,
                     *   show the reason and end the command
                     */
                    if (result != nil && !result.allowAction)
                    {
                        /* show the result message */
                        result.showMessage();

                        /* mark the command as a failure */
                        gTranscript.noteFailure();

                        /*
                         *   if we have an implicit report, mark it as a mere
                         *   attempt, since the action can't be completed
                         */
                        if (impReport != nil)
                            impReport.noteJustTrying();

                        /* terminate the command */
                        exit;
                    }

                    /*
                     *   Check preconditions of the action.  If we don't invoke
                     *   any implicit commands, we can stop here: nothing in
                     *   the game state will have changed, so there is no need
                     *   to re-verify or re-check preconditions.
                     *
                     *   Only allow implicit actions on the first pass.  Do not
                     *   perform implicit actions on the second pass, because
                     *   if we did so we could get into an infinite loop of
                     *   conflicting preconditions, where each pass would
                     *   reverse the state from the last pass.
                     */
                    if (!checkPreConditions(iter == 1))
                        break;
                }

                /*
                 *   Disable sense caching once we start the action phase -
                 *   once we start making changes to game state, it's too much
                 *   work to figure out when to invalidate the cache, so simply
                 *   turn off caching entirely.
                 *
                 *   Note that the sense cache will already be disabled if we
                 *   executed any implied commands, because the first implied
                 *   command will have disabled the cache as soon as it reached
                 *   its execution phase, and no one will have turned caching
                 *   back on.  It does no harm to disable it again here.
                 */
                libGlobal.disableSenseCache();

                /* if desired, run the "before" notifications before "check" */
                if (gameMain.beforeRunsBeforeCheck)
                    runBeforeNotifiers();

                /*
                 *   Invoke the action's execution method.  Catch any "exit
                 *   action" exceptions - these indicate that the action is
                 *   finished but that the rest of the command processing is to
                 *   proceed as normal.
                 */
                try
                {
                    /* notify the actor of what we're about to do */
                    gActor.actorAction();

                    /* check the action */
                    checkAction();

                    /* if desired, run the "before" notifications after "check" */
                    if (!gameMain.beforeRunsBeforeCheck)
                        runBeforeNotifiers();

                    /* execute the action */
                    execAction();
                }
                catch (ExitActionSignal eaSig)
                {
                    /*
                     *   an exit action signal was thrown - since we've now
                     *   skipped past any remaining action processing, simply
                     *   continue with the rest of the command processing as
                     *   normal
                     */
                }

                /* call afterAction for each object in the notify list */
                notifyBeforeAfter(&afterAction);

                /* notify the actor's containers of the completed action */
                gActor.forEachContainer(callRoomAfterAction);

                /* run the after-action processing */
                afterAction();
            }
            catch (ExitSignal exc)
            {
                /* the execution sequence is finished - simply stop here */
            }
        }

        /*
         *   Run the "before" notifiers: this calls beforeAction on everything
         *   in scope, and calls roomBeforeAction on the actor's containers.
         */
        runBeforeNotifiers()
        {
            /* run the before-action processing */
            beforeAction();

            /*
             *   notify the actor's containers that an action is about
             *   to take place within them
             */
            gActor.forEachContainer(callRoomBeforeAction);

            /* call beforeAction for each object in the notify list */
            notifyBeforeAfter(&beforeAction);
        }

        /*
         *   Reset the message generation context for a sense change.  This
         *   can be called when something substantial happens in the midst of
         *   a command, and we might need different message generation rules
         *   before and after the change.  For example, this is used when a
         *   non-player character moves from one location to another, because
         *   the NPC might want to generate leaving and arriving messages
         *   differently in the two locations.
         */
        recalcSenseContext()
        {
            /* tell the sense context capturer to recalculate the context */
            senseContext.recalcSenseContext();
        }

        /*
         *   Maybe announce the action as an implied action.
         */
        maybeAnnounceImplicit()
        {
            /*
             *   if we're a remapped action, we'll actually want to announce
             *   the original, not the remapping
             */
            if (remappedFrom != nil)
                return remappedFrom.maybeAnnounceImplicit();

            /*
             *   if we're implicit, and we have an implicit announcement
             *   message, announce the implicit action
             */
            if (isImplicit && implicitMsg != nil)
                return gTranscript.announceImplicit(self, implicitMsg);

            /* we don't need to announce the implied action */
            return nil;
        }

        /*
         *   Announce the object of an action.  This should be used for each
         *   iteration of a command that takes objects to announce the objects
         *   on this iteration.
         *
         *   We announce an object under several circumstances:
         *
         *   - If we are iterating through multiple objects, we'll show the
         *   current object to show the player the individual step in the
         *   command being performed.
         *
         *   - If 'all' was used to specify the object, we'll announce it even
         *   if only one object is involved, to make it clear to the player
         *   exactly what we chose as a match.
         *
         *   - If we are executing the command on a single object, and the
         *   object was chosen through disambiguation of a set of ambiguous
         *   choices, and some of the discarded possibilities were logical but
         *   less so than the chosen object, we'll show the assumption we
         *   made.  In such cases, our assumption is not necessarily correct,
         *   so we'll tell the user about our choice explicitly by way of
         *   confirmation - this gives the user a better chance of noticing
         *   quickly if our assumption was incorrect.
         *
         *   - If we supplied a default for a missing noun phrase in the
         *   player's command, we'll show what we chose.  Since the player
         *   didn't say what they meant, we'll make it plain that we're
         *   providing an assumption about what we thought they must have
         *   meant.
         *
         *   'info' is the ResolveInfo object describing this resolved object,
         *   and 'numberInList' is the total number of objects we're iterating
         *   over for this object function (direct object, indirect object,
         *   etc).  'whichObj' is one of the object function constants
         *   (DirectObject, IndirectObject, etc) describing which object we're
         *   mentioning; the language-specific message generator might use
         *   this in conjunction with the action to include a preposition with
         *   the displayed phrase, for example, or choose an appropriate
         *   inflection.
         */
        announceActionObject(info, numberInList, whichObj)
        {
            /*
             *   Show prefix announcements only if the player character is
             *   performing the action.  For NPC's, we don't use the prefix
             *   format, because it doesn't work as well for NPC result
             *   reports; instead, the NPC versions of the library messages
             *   tend to use sufficiently detailed reports that the prefix
             *   isn't required (for example, "Bob takes the iron key" rather
             *   than just "Taken").
             */
            if (gActor.isPlayerChar)
            {
                /* check for the various announcements */
                if (maybeAnnounceMultiObject(info, numberInList, whichObj))
                {
                    /* we've done a multi announcement, so we're now done */
                }
                else if ((info.flags_ & UnclearDisambig) != 0
                         || ((info.flags_ & ClearDisambig) != 0
                             && gameMain.ambigAnnounceMode == AnnounceClear))
                {
                    /* show the object, since we're not certain it's right */
                    gTranscript.announceAmbigActionObject(info.obj_, whichObj);
                }
                else if ((info.flags_ & DefaultObject) != 0
                         && !(info.flags_ & AnnouncedDefaultObject))
                {
                    /*
                     *   Show the object, since we supplied it as a default.
                     *   At this stage in the command, we have resolved
                     *   everything.
                     */
                    gTranscript.announceDefaultObject(
                        info.obj_, whichObj, self, true);

                    /* note that we've announced this object */
                    info.flags_ |= AnnouncedDefaultObject;
                }
            }
        }

        /* announce a multi-action object, if appropriate */
        maybeAnnounceMultiObject(info, numberInList, whichObj)
        {
            /*
             *   announce if we have more than one object, or we're set to
             *   announce this object in any case
             */
            if (numberInList > 1 || (info.flags_ & AlwaysAnnounce) != 0)
            {
                /* show the current object of a multi-object action */
                gTranscript.announceMultiActionObject(
                    info.multiAnnounce, info.obj_, whichObj);

                /* tell the caller we made an announcement */
                return true;
            }

            /* tell the caller we didn't make an announcement */
            return nil;
        }

        /*
         *   Pre-calculate the multi-object announcement text for each object.
         *   This is important because these announcements might choose a form
         *   for the name that distinguishes it from the other objects in the
         *   iteration, and the basis for distinction might be state-dependent
         *   (such as the object's current owner or location), and the relevant
         *   state might change as we iterate over the objects.  From the
         *   user's perspective, they're referring to the objects based on the
         *   state at the start of the command, so the user will expect to see
         *   names based on the that state.
         */
        cacheMultiObjectAnnouncements(lst, whichObj)
        {
            /* run through the list and cache each object's announcement */
            foreach (local cur in lst)
            {
                /* calculate and cache this object's multi-object announcement */
                cur.multiAnnounce = libMessages.announceMultiActionObject(
                    cur.obj_, whichObj, self);
            }
        }

        /* get the list of resolved objects in the given role */
        getResolvedObjList(which)
        {
            /*
             *   the base action doesn't have any objects in any roles, so just
             *   return nil; subclasses need to override this
             */
            return nil;
        }

        /*
         *   Announce a defaulted object list, if appropriate.  We'll announce
         *   the object if we have a single object in the given resolution
         *   list, it was defaulted, and it hasn't yet been announced.
         */
        maybeAnnounceDefaultObject(lst, which, allResolved)
        {
            /*
             *   if the list has exactly one element, and it's marked as a
             *   defaulted object, and it hasn't yet been announced, announce
             *   it
             */
            if (lst != nil
                && lst.length() == 1
                && (lst[1].flags_ & DefaultObject) != 0
                && !(lst[1].flags_ & AnnouncedDefaultObject))
            {
                /* announce the object */
                gTranscript.announceDefaultObject(
                    lst[1].obj_, which, self, allResolved);

                /*
                 *   we've now announced the object; mark it as announced so
                 *   we don't show the same announcement again
                 */
                lst[1].flags_ |= AnnouncedDefaultObject;
            }
        }

        /*
         *   "Pre-announce" a common object for a command that might involve
         *   iteration over other objects.  For example, in "put all in box",
         *   the box is common to all iterations of the command, so we would
         *   want to preannounce it, if it needs to be announced at all,
         *   before the iterations of the command.
         *
         *   We'll announce the object only if it's marked as defaulted or
         *   unclearly disambiguated, and then only if the other list will be
         *   announcing its objects as multi-action objects.  However, we do
         *   not pre-announce anything for a remapped action, because we'll
         *   show the full action description for each individually announced
         *   object, so we don't need or want a separate announcement for the
         *   group.
         *
         *   Returns true if we did any pre-announcing, nil otherwise.  If we
         *   return true, the caller should not re-announce this object during
         *   the iteration, since our pre-announcement is common to all
         *   iterations.
         */
        preAnnounceActionObject(info, mainList, whichObj)
        {
            /* do not pre-announce anything for a remapped action */
            if (isRemapped())
                return nil;

            /*
             *   determine if the main list will be announcing its objects -
             *   it will if it has more than one object, or if its one object
             *   is marked as "always announce"
             */
            if (mainList.length() > 1
                || (mainList[1].flags_ & AlwaysAnnounce) != 0)
            {
                /*
                 *   we will be announcing the main list object or objects, so
                 *   definitely pre-announce this object if appropriate
                 */
                announceActionObject(info, 1, whichObj);

                /* tell the caller we pre-announced the object */
                return true;
            }

            /* we didn't pre-announce the object */
            return nil;
        }

        /*
         *   Run our action-specific pre-processing.  By default, we do
         *   nothing here.
         */
        beforeAction()
        {
        }

        /*
         *   Check the action.  This runs the 'check' phase, and must be
         *   overridden for each subclass.
         *
         *   Intransitive actions don't generally have to do anything in the
         *   'check' phase, since they can simply do any necessary checks in
         *   the 'execute' phase that runs immediately after 'check'.  This
         *   phase is separated out from 'execute' mostly for the benefit of
         *   transitive actions, where the 'check' phase gives the involved
         *   objects a chance to object to the action.
         */
        checkAction() { }

        /*
         *   Execute the action.  This must be overridden by each subclass.
         *
         *   Intransitive actions must do all of their work in this routine.
         *   In most cases, transitive actions will delegate processing to one
         *   or more of the objects involved in the command - for example,
         *   most single-object commands will call a method in the direct
         *   object to carry out the command.
         */
        execAction()
        {
            /* by default, just show the 'no can do' message */
            mainReport(&cannotDoThatMsg);
        }

        /*
         *   Run our action-specific post-processing.  By default, we do
         *   nothing here.
         */
        afterAction()
        {
        }

        /*
         *   Verify the action.  Action subclasses with one or more objects
         *   should call object verification routines here.  Returns a
         *   VerifyResultList with the results, or nil if there are no
         *   verification results at all.  A nil return should be taken as
         *   success, not failure, because it means that we found no objection
         *   to the command.
         */
        verifyAction()
        {
            /*
             *   there are no objects in the default action, but we might have
             *   pre-condition verifiers
             */
            return callVerifyPreCond(nil);
        }

        /*
         *   Initialize tentative resolutions for other noun phrases besides
         *   the one indicated.
         */
        initTentative(issuingActor, targetActor, whichObj)
        {
            /* by default, we have no noun phrases to tentatively resolve */
        }

        /*
         *   Check for remapping the action.  This should check with each
         *   resolved object involved in the command to see if the object wants
         *   to remap the action to a new action; if it does, the object must
         *   replace the current action (using replaceAction or equivalent).
         *   Note that replacing the action must use 'exit' to terminate the
         *   original action, so this will never return if remapping actually
         *   does occur.
         */
        checkRemapping()
        {
            /* by default, we have no objects, so we do nothing here */
        }

        /*
         *   Invoke a callback with a verify results list in gVerifyResults,
         *   using the existing results list or creating a new one if there is
         *   no existing one.  Returns the results list used.
         */
        withVerifyResults(resultsSoFar, obj, func)
        {
            local oldResults;

            /* if we don't already have a result list, create one */
            if (resultsSoFar == nil)
                resultsSoFar = new VerifyResultList();

            /* remember the old global results list */
            oldResults = gVerifyResults;

            /* install the new one */
            gVerifyResults = resultsSoFar;

            /* make sure we restore the old result list on the way out */
            try
            {
                /* invoke the callback */
                (func)();
            }
            finally
            {
                /* restore the old result list */
                gVerifyResults = oldResults;
            }

            /* return the result list */
            return resultsSoFar;
        }

        /*
         *   Verify the non-object-related pre-conditions.  This runs
         *   verification on each of the pre-condition objects defined for the
         *   action.
         */
        callVerifyPreCond(resultSoFar)
        {
            /* look at each of our preconditions */
            foreach (local cond in preCond)
            {
                /*
                 *   If this precondition defines a verifier, call it.  Check
                 *   to see if we have a verifier defined first so that we can
                 *   avoid creating a result list if we won't have any use for
                 *   it.
                 */
                if (cond.propDefined(&verifyPreCondition))
                {
                    /*
                     *   invoke the pre-condition verifier - this is an
                     *   action-level verifier, so there's no object involved
                     */
                    resultSoFar = withVerifyResults(resultSoFar, nil,
                        {: cond.verifyPreCondition(nil) });
                }
            }

            /* return the latest result list */
            return resultSoFar;
        }

        /*
         *   Call a catch-all property on the given object.
         *
         *   actionProp is the custom per-object/per-action property that we
         *   normally invoke to process the action.  For example, if we're
         *   processing verification for the direct object of Take, this would
         *   be &verifyDobjTake.
         *
         *   defProp is the default property that corresponds to actionProp.
         *   This is the per-object/default-action property that we invoke
         *   when the object doesn't provide a "more specialized" version of
         *   actionProp - that is, if the object doesn't define or inherit
         *   actionProp at a point in its class hierarchy that is more
         *   specialized than the point at which it defines defProp, we'll
         *   call defProp.  If there is a more specialized definition of
         *   actionProp for the object, it effectively overrides the default
         *   handler, so we do not invoke the default handler.
         *
         *   allProp is the catch-all property corresponding to actionProp.
         *   We invoke this property in all cases.
         *
         *   Returns true if there is indeed a Default property that overrides
         *   the action, nil if not.
         */
        callCatchAllProp(obj, actionProp, defProp, allProp)
        {
            /* always invoke the catch-all property first */
            obj.(allProp)();

            /*
             *   invoke the default property only if the object doesn't have a
             *   "more specialized" version of actionProp
             */
            if (!obj.propHidesProp(actionProp, defProp))
            {
                /* the Default overrides the action-specific method */
                obj.(defProp)();

                /* tell the caller the Default routine handled it */
                return true;
            }
            else
            {
                /* tell the caller to call the action-specific property */
                return nil;
            }
        }

        /*
         *   Call a verification routine.  This creates a results object and
         *   makes it active, then invokes the given verification routine on
         *   the given object.
         *
         *   We call verification directly on the object, and we also call
         *   verification on the object's preconditions.
         *
         *   If resultSoFar is non-nil, it is a VerifyResultList that has the
         *   results so far - this can be used for multi-object verifications
         *   to gather all of the verification results for all of the objects
         *   into a single result list.  If resultSoFar is nil, we'll create a
         *   new result list.
         */
        callVerifyProp(obj, verProp, preCondProp, remapProp,
                       resultSoFar, whichObj)
        {
            local remapInfo;

            /* check for remapping */
            if ((remapInfo = obj.(remapProp)()) != nil)
            {
                /* call the remapped verify */
                resultSoFar = remapVerify(whichObj, resultSoFar, remapInfo);

                /*
                 *   If the original object has a verify that effectively
                 *   "overrides" the remap - i.e., defined by an object that
                 *   inherits from the object where the remap is defined - then
                 *   run it by the overriding verify as well.
                 */
                local remapSrc = obj.propDefined(remapProp, PropDefGetClass);
                if (obj.propDefined(verProp)
                    && overrides(obj, remapSrc, verProp))
                {
                    resultSoFar = withVerifyResults(
                        resultSoFar, obj, function() { obj.(verProp)(); });
                }

                /* return the results */
                return resultSoFar;
            }

            /* initialize tentative resolutions for other noun phrases */
            initTentative(gIssuingActor, gActor, whichObj);

            /*
             *   run the verifiers in the presence of a results list, and
             *   return the result list
             */
            return withVerifyResults(resultSoFar, obj, function()
            {
                local lst;

                /*
                 *   check the object for a default or catch-all verifier, and
                 *   call it if present; if there isn't a default that
                 *   overrides the action-specific verifier, continue to the
                 *   action-specific verifer
                 */
                if (!callCatchAllProp(
                    obj, verProp, objectRelations.verifyDefaultProps[whichObj],
                    objectRelations.verifyAllProps[whichObj]))
                {
                    /*
                     *   invoke the action-specific verifier method - this
                     *   will update the global verification results object
                     *   with the appropriate status for this action being
                     *   performed on this object
                     */
                    obj.(verProp)();
                }

                /*
                 *   Check the pre-conditions defined for this action on this
                 *   object.  For each one that has a verifier, invoke the
                 *   verifier.
                 */
                lst = getObjPreConditions(obj, preCondProp, whichObj);
                if (lst != nil)
                    foreach (local cur in lst)
                        cur.verifyPreCondition(obj);
            });
        }

        /*
         *   Get the precondition list for an object.  whichObj is the object
         *   role of the object whose preconditions we're retrieving; this is
         *   nil if we're looking for action-level preconditions.
         */
        getObjPreConditions(obj, preCondProp, whichObj)
        {
            local allPreProp;
            local defPreProp;
            local pre;

            /*
             *   if we're looking for action preconditions, there are no
             *   default or catch-all properties, so simply get the
             *   preconditions from the action
             */
            if (whichObj == nil)
                return obj.(preCondProp);

            /* get the default-action and catch-all precondition properties */
            defPreProp = objectRelations.preCondDefaultProps[whichObj];
            allPreProp = objectRelations.preCondAllProps[whichObj];

            /*
             *   Check for an "overriding" default-action handler.  If we have
             *   a default-action handler that hides the specific handler for
             *   this action, use the default handler's precondition list
             *   instead.  Otherwise, use the specific action preconditions.
             */
            if (obj.propHidesProp(defPreProp, preCondProp))
                pre = obj.(defPreProp);
            else
                pre = obj.(preCondProp);

            /* if we have catch-all preconditions, add them to the list */
            if (obj.propDefined(allPreProp))
            {
                /* get the catch-all preconditions */
                local allPre = obj.(allPreProp);

                /* add them to the list so far (if any) */
                pre = (pre == nil ? allPre : pre + allPre);
            }

            /* return the precondition list */
            return pre;
        }

        /*
         *   Verify that some sort of handling for this action is defined on
         *   at least one of the given objects.  If we have no handlers at all
         *   definfed, we'll add an "illogical" status to the verification
         *   results to indicate that the action is not defined on this
         *   object.  This check provides a last resort for verbs with no
         *   handling at all defined on the involved objects, to ensure that
         *   the verb won't go completely unprocessed.
         *
         *   Each entry in objList is an object involved in the action.  For
         *   each entry in objList, there must be *THREE* entries in propList:
         *   a verify property, a check property, and an action property.  If
         *   any of these three properties is defined on the corresponding
         *   object, we'll allow the command to proceed.  If we can find none
         *   of the given handler properties on any of our objects, we'll add
         *   an "illogical" verify result.
         */
        verifyHandlersExist(objList, propList, result)
        {
            /*
             *   check each object to see if any define their corresponding
             *   action property
             */
            for (local i = 1, local j = 1, local len = objList.length() ;
                 i <= len ; ++i, j += 3)
            {
                /* check each of the associated handler properties */
                for (local k = 0 ; k < 3 ; ++k)
                {
                    /* check this handler property */
                    if (objList[i].propDefined(propList[j + k]))
                    {
                        /* we've found a handler, so we can proceed */
                        return result;
                    }
                }
            }

            /*
             *   None of the objects defines an appropriate action method, so
             *   this verifies as illogical.  If there's no result list so
             *   far, create one.
             */
            if (result == nil)
                result = new VerifyResultList();

            /* add an "illogical" status to the results */
            result.addResult(new IllogicalVerifyResult(&cannotDoThatMsg));

            /* return the result */
            return result;
        }

        /*
         *   Call the beforeAction or afterAction method for each object in
         *   the notification list.
         */
        notifyBeforeAfter(prop)
        {
            local lst;

            /* get a table of potential notification receivers */
            lst = getNotifyTable();

            /* go through the table and notify each object */
            lst.forEachAssoc({obj, val: obj.(prop)()});
        }

        /*
         *   Get the list of objects to notify before or after the action has
         *   been performed.
         */
        getNotifyTable()
        {
            local tab;
            local curObjs;
            local actor;

            /* stash the current actor in a local for faster reference */
            actor = gActor;

            /* start with everything connected by containment to the actor */
            tab = actor.connectionTable();

            /* add the actor's explicitly registered notification list */
            foreach (local cur in actor.getActorNotifyList())
                tab[cur] = true;

            /* add the items explicitly registered in the actor's location(s) */
            actor.forEachContainer(
                {loc: loc.getRoomNotifyList().forEach(
                    {obj: tab[obj] = true})
                });

            /* get the list of objects directly involved in the command */
            curObjs = getCurrentObjects();

            /*
             *   add any objects explicitly registered with the objects
             *   directly involved in the command
             */
            foreach (local cur in curObjs)
            {
                /* add each item in the object's notify list */
                foreach (local ncur in cur.getObjectNotifyList())
                    tab[ncur] = true;
            }

            /*
             *   Remove from the list all of the actor's containers.  These
             *   will be notified via the more specific room notification
             *   methods, so we don't want to send them generic notifiers as
             *   well.
             */
            tab.forEachAssoc(function(obj, val)
            {
                if (actor.isIn(obj))
                    tab.removeElement(obj);
            });

            /* if we have any explicitly registered objects, add them */
            if (beforeAfterObjs != nil)
            {
                /* add each object in the list of explicitly registered objects */
                foreach (local cur in beforeAfterObjs)
                    tab[cur] = true;
            }

            /* return the final table */
            return tab;
        }

        /*
         *   Register an object for explicit inclusion in beforeAction and
         *   afterAction notifications.  This can be used to register objects
         *   that might not be connected by containment or otherwise
         *   notifiable by normal means.  If this is called after the
         *   beforeAction notification loop has already started, then the
         *   object will only be sent an afterAction notification.
         */
        addBeforeAfterObj(obj)
        {
            /* if we don't yet have a before/after list, create one */
            if (beforeAfterObjs == nil)
                beforeAfterObjs = new Vector(16);

            /* add the object to the list */
            beforeAfterObjs.append(obj);
        }

        /* vector of objects requiring explicit before/after notification */
        beforeAfterObjs = nil

        /*
         *   Get the list of all of the objects (direct object, indirect
         *   object, and any additional objects for actions with three or more
         *   object roles) involved in the current execution.  This is valid
         *   only during a call to doActionOnce(), since that's the only time
         *   a particular set of objects are selected for the action.
         *
         *   By default, an action has no objects roles at all, so we'll just
         *   return an empty list.
         */
        getCurrentObjects()
        {
            return [];
        }

        /*
         *   Set the current objects.  This takes a list of the same form
         *   returned by getCurrentObjects().
         */
        setCurrentObjects(lst) { }

        /*
         *   Check any pre-conditions for the action.
         *
         *   This should check all of the conditions that must be met for the
         *   action to proceed.  If any pre-condition can be met by running an
         *   implicit command first, that implicit command should be executed
         *   here.  If any pre-condition cannot be met, this routine should
         *   notify the actor and throw an ExitSignal.
         *
         *   Returns true if any implicit commands are executed, nil if not.
         *   Implicit commands can only be attempted if allowImplicit is true;
         *   if this is nil, a precondition must simply fail (by displaying an
         *   appropriate failure report and using 'exit') without attempting
         *   an implicit command if its assertion does not hold.
         */
        checkPreConditions(allowImplicit)
        {
            /* check each condition in our action preconditions */
            return callPreConditions(getPreCondDescList(), allowImplicit);
        }

        /*
         *   Get the precondition descriptor list for the action.  For the base
         *   intransitive action type, this simply returns the list of
         *   conditions for the action itself.
         */
        getPreCondDescList()
        {
            /* get the action-level preconditions */
            return getObjPreCondDescList(self, &preCond, nil, nil);
        }

        /*
         *   Get a precondition descriptor list for the given object.  This
         *   returns a list of PreCondDesc objects that wrap the preconditions
         *   for the given object in the given role for this action.
         */
        getObjPreCondDescList(obj, preCondProp, checkArg, whichObj)
        {
            local lst;

            /* get the list of preconditions for the given object in its role */
            lst = getObjPreConditions(obj, preCondProp, whichObj);

            /* if there are no preconditions, return an empty list */
            if (lst == nil)
                return [];

            /*
             *   wrap the precondition objects in descriptors, so that we can
             *   keep track of the check argument that goes with these
             *   preconditions
             */
            return lst.mapAll({x: new PreCondDesc(x, checkArg)});
        }

        /*
         *   Call a method on all of the precondition objects in the
         *   precondition list obtained from the given property of the given
         *   object.
         */
        callPreConditions(lst, allowImplicit)
        {
            local ret;
            local i;

            /* presume we won't call any implicit commands */
            ret = nil;

            /*
             *   note the original descriptor list order, so that we can retain
             *   the current ordering when the execution order doesn't require
             *   changes
             */
            i = 0;
            lst.forEach({x: x.index_ = i++});

            /* sort the precondition list by execution order */
            lst = lst.sort(SortAsc, function(a, b) {
                local delta;

                /* if the execution orders differ, sort by execution order */
                delta = a.cond_.preCondOrder - b.cond_.preCondOrder;
                if (delta != 0)
                    return delta;

                /* otherwise, retain the original list order */
                return a.index_ - b.index_;
            });

            /* catch any 'exit' signals within the preconditions */
            try
            {
                /* invoke the check method for each condition in the list */
                foreach (local cur in lst)
                {
                    /*
                     *   call this precondition; if it runs an implicit
                     *   command, note that we have run an implicit command
                     */
                    if (cur.checkPreCondition(allowImplicit))
                        ret = true;
                }
            }
            catch (ExitSignal es)
            {
                /*
                 *   any 'exit' that occurs within a precondition is a failure
                 *   for the enclosing action
                 */
                gTranscript.noteFailure();

                /* re-throw the 'exit' to cancel the enclosing action */
                throw es;
            }

            /* return true if any implicit commands were executed */
            return ret;
        }

        /*
         *   Our list of action-level pre-condition objects.  These are the
         *   conditions that apply to the overall action, not to the
         *   individual objects involved.  (Object-level pre-conditions are
         *   attached to the objects, not to the action.)
         */
        preCond = []

        /*
         *   Finish the result list for a resolved noun phrase.  This is used
         *   just before disambiguation.  We'll give each object in the list a
         *   chance to filter the list with filterResolveList, and we'll note
         *   the noun phrase we matched in each resolved object.
         */
        finishResolveList(lst, whichObj, np, requiredNum)
        {
            /* give each object a chance to filter the list */
            foreach (local cur in lst)
                lst = cur.obj_.filterResolveList(
                    lst, self, whichObj, np, requiredNum);

            /* stash the noun phrase in each object in the list */
            foreach (local cur in lst)
                cur.np_ = np;

            /* return the list */
            return lst;
        }

        /*
         *   Get a list of verification results for the given ResolveInfo
         *   objects, sorted from best to worst.  Each entry in the returned
         *   list will be a VerifyResultList object whose obj_ property is set
         *   to the ResolveInfo object for which it was generated.
         */
        getSortedVerifyResults(lst, verProp, preCondProp, remapProp,
                               whichObj, np, requiredNum)
        {
            local results;
            local idx;

            /* if there's nothing in the list, we're done */
            if (lst == [])
                return lst;

            /*
             *   Before we run verification, give each object in the list a
             *   chance to do its own filtering on the entire list.  This form
             *   of filtering allows an object to act globally on the list, so
             *   that it can take special action according to the presence or
             *   absence of other objects, and can affect the presence of other
             *   objects.
             */
            lst = finishResolveList(lst, whichObj, np, requiredNum);

            /* create a vector to hold the verification results */
            results = new Vector(lst.length());

            /*
             *   Call the given verifier method on each object, noting each
             *   result.
             */
            idx = 0;
            foreach (local cur in lst)
            {
                local curResult;

                /* call the verifier method and note the current result */
                curResult = callVerifyProp(cur.obj_, verProp, preCondProp,
                                           remapProp, nil, whichObj);

                /*
                 *   save the ResolveInfo in the verify result list object, so
                 *   that we can figure out later (after sorting the results)
                 *   which original ResolveInfo this verification result
                 *   applies to
                 */
                curResult.obj_ = cur;

                /* remember the original list order */
                curResult.origOrder = idx++;

                /* add this verify result to our result vector */
                results.append(curResult);
            }

            /*
             *   Sort the results in descending order of logicalness, and
             *   return the sorted list.  When results are equivalently
             *   logical, keep the results in their existing order.
             */
            return results.toList().sort(SortDesc, function(x, y)
            {
                /* compare the logicalness */
                local c = x.compareTo(y);

                /*
                 *   if it's the same, keep in ascending pluralOrder - note
                 *   that we must reverse the sense of this comparison, since
                 *   we're sorting the overall list in descending order
                 */
                if (c == 0)
                    c = (y.obj_.obj_.pluralOrder - x.obj_.obj_.pluralOrder);

                /* if they're otherwise the same, preserve the original order */
                if (c == 0)
                    c = (y.origOrder - x.origOrder);

                /* return the result */
                return c;
            });
        }

        /*
         *   Combine any remapped verify results in the given verify result
         *   list.  We will remove any result that was remapped to a different
         *   object if and only if the target of the remapping appears in the
         *   list and has the same results as the remapped original.  When
         *   objects are remapped in this fashion, they become effectively
         *   equivalent for the purposes of this command, so we don't have to
         *   distinguish between them for disambiguation or defaulting
         *   purposes.
         */
        combineRemappedVerifyResults(lst, role)
        {
            /* scan each element in the list */
            for (local i = 1, local len = lst.length() ; i <= len ; ++i)
            {
                local cur = lst[i];

                /* if this element has been remapped, consider it further */
                if (cur.remapTarget_ != nil)
                {
                    local other;

                    /*
                     *   scan for another entry in the list that matches us
                     *   for remapping purposes
                     */
                    other = lst.indexWhich(
                        {x: x != cur
                            && cur.matchForCombineRemapped(x, self, role)});

                    /*
                     *   if we found another entry, delete the other entry,
                     *   since it is indistinguishable from this entry
                     */
                    if (other != nil)
                    {
                        /* remove this element from the list */
                        lst -= cur;

                        /* adjust our list counters for the deletion */
                        --i;
                        --len;
                    }
                }
            }

            /* return the updated list */
            return lst;
        }

        /*
         *   Filter an ambiguous object list using the given verification
         *   method.  We call the given verification method on each object,
         *   noting the result, then find the best (most logical) result in
         *   the list.  We reduce the set to the objects that all have the
         *   same best value - everything else in the list is less logical, so
         *   we discard it.  This gives us a set of objects that are all of
         *   equivalent likelihood and all of the best likelihood of all the
         *   objects.
         *
         *   This is the typical way that we disambiguate a list of objects,
         *   but this is merely a service routine, so individual actions can
         *   choose to use this or other mechanisms as appropriate.
         */
        filterAmbiguousWithVerify(lst, requiredNum, verProp,
                                  preCondProp, remapProp, whichObj, np)
        {
            local results;
            local discards;
            local keepers;
            local bestResult;
            local uniqueKeepers;

            /* if there's nothing in the list, there's nothing to do */
            if (lst == [])
                return lst;

            /* first, filter out redundant facets */
            lst = filterFacets(lst);

            /*
             *   Call the verifier method on each object, and sort the results
             *   from best to worst.
             */
            results = getSortedVerifyResults(lst, verProp, preCondProp,
                                             remapProp, whichObj,
                                             np, requiredNum);

            /* note the best result value */
            bestResult = results[1];

            /*
             *   ask the noun phrase to filter this list down to the ones it
             *   wants to keep
             */
            keepers = np.getVerifyKeepers(results);

            /*
             *   Count the number of unique keepers - this is the number of
             *   items in the keepers list that don't have any equivalents in
             *   the keepers list.
             *
             *   To calculate this number, start with the total number of
             *   items in the list, and reduce it by one for each item with an
             *   earlier equivalent in the list.  Note that we only ignore
             *   items with unique equivalents *earlier* in the list so that
             *   we keep exactly one of each equivalent - if we ignored every
             *   element with a unique equivalent elsewhere in the list, we'd
             *   ignore every equivalent item, so we'd only count the items
             *   with no equivalents at all.
             */
            uniqueKeepers = keepers.length();
            for (local i = 1, local cnt = keepers.length() ; i <= cnt ; ++i)
            {
                local eqIdx;

                /* check for a unique equivalent earlier in the list */
                eqIdx = keepers.indexWhich(
                    {x: x.obj_.obj_.isVocabEquivalent(keepers[i].obj_.obj_)});
                if (eqIdx != nil && eqIdx < i)
                {
                    /*
                     *   this one has an earlier equivalent, so don't include
                     *   it in the unique item count
                     */
                    --uniqueKeepers;
                }
            }

            /*
             *   If we found more items to keep than were required by the
             *   caller, we were not able to reduce the set to an unambiguous
             *   subset.  In this case, keep *all* of the items that are
             *   logical.
             */
            if (uniqueKeepers > requiredNum)
            {
                local allAllowed;

                /* filter so that we keep all of the logical results */
                allAllowed = results.subset({x: x.allowAction});

                /* if that list is non-empty, use it as the keepers */
                if (allAllowed.length() != 0)
                    keepers = allAllowed;
            }

            /*
             *   Get the list of discards - this is the balance of the
             *   original result list after removing the best ones.
             */
            discards = results - keepers;

            /*
             *   We now have the set of objects we want, but the entries in
             *   the list are all VerifyResultList instances, and we just want
             *   the objects - pull out a list of just the ResolveInfo, and
             *   return that.
             */
            keepers = keepers.mapAll({x: x.obj_});

            /*
             *   Check to see if we should set flags in the results.  If we
             *   eliminated any objects, flag the remaining objects as having
             *   been selected through disambiguation.  If the best of the
             *   discarded objects were logical, flag the survivors as
             *   "unclear," because we only selected them as better than the
             *   discards, and not because they were the only possible
             *   choices.
             */
            if (discards != [])
            {
                local addedFlags;

                /*
                 *   We have reduced the set.  If the best of the discards was
                 *   ranked as highly as the survivors at the coarsest level,
                 *   flag the survivors as having been "unclearly"
                 *   disambiguated; otherwise, mark them as "clearly"
                 *   disambiguated.
                 */
                if (keepers.indexOf(bestResult.obj_) != nil
                    && (discards[1].getEffectiveResult().resultRank ==
                        bestResult.getEffectiveResult().resultRank))
                {
                    /*
                     *   we had to make a choice that discarded possibilities
                     *   that were valid, though not as good as the one we
                     *   chose - mark the objects as being not perfectly clear
                     */
                    addedFlags = UnclearDisambig;

                    /*
                     *   if the keepers and the rejects are all basic
                     *   equivalents, don't bother flagging this as unclear,
                     *   since there's no point in mentioning that we chose
                     *   one basic equivalent over another, as they all have
                     *   the same name
                     */
                    if (BasicResolveResults.filterWithDistinguisher(
                        keepers + discards.mapAll({x: x.obj_}),
                        basicDistinguisher).length() == 1)
                    {
                        /* they're all basic equivalents - mark as clear */
                        addedFlags = ClearDisambig;
                    }
                }
                else
                {
                    /* the choice is clear */
                    addedFlags = ClearDisambig;
                }

                /* add the flags to each survivor */
                foreach (local cur in keepers)
                    cur.flags_ |= addedFlags;
            }

            /* return the results */
            return keepers;
        }

        /*
         *   Filter a plural list with a verification method.  We'll reduce
         *   the list to the subset of objects that verify as logical, if
         *   there are any.  If there are no logical objects in the list,
         *   we'll simply return the entire original list.
         */
        filterPluralWithVerify(lst, verProp, preCondProp, remapProp, whichObj, np)
        {
            local results;

            /* if there's nothing in the list, there's nothing to do */
            if (lst == [])
                return lst;

            /* first, filter out redundant facets */
            lst = filterFacets(lst);

            /*
             *   Call the verifier method on each object, and sort the results
             *   from best to worst.
             */
            results = getSortedVerifyResults(lst, verProp, preCondProp,
                                             remapProp, whichObj, np, nil);

            /*
             *   If the best (and thus first) result allows the action, filter
             *   the list to keep only the "keepers," as determined by the noun
             *   phrase.  Otherwise, there are no allowed results, so return
             *   the original list.
             */
            if (results[1].allowAction)
                results = np.getVerifyKeepers(results);

            /* return the resolve results objects from the list */
            return results.mapAll({x: x.obj_});
        }

        /*
         *   Filter out redundant facets of the same object.  The various
         *   facets of an object are equivalent to the parser.  An object that
         *   has multiple facets is meant to appear to be one game world
         *   object from the perspective of a character - the multiple facet
         *   objects are an internal implementation detail.
         */
        filterFacets(lst)
        {
            local result;
            local actor = gActor;

            /*
             *   create a vector for the result list, presuming we'll keep all
             *   of the original list elements
             */
            result = new Vector(lst.length(), lst);

            /* check for facets */
            foreach (local cur in lst)
            {
                local allFacets;

                /* if this item has any facets, check for them in our results */
                allFacets = cur.obj_.getFacets() + cur.obj_;
                if (allFacets.length() != 0)
                {
                    local inScopeFacets;
                    local best;

                    /* make a new list of the facets that appear in the results */
                    inScopeFacets = allFacets.subset(
                        {f: result.indexWhich({r: r.obj_ == f}) != nil});

                    /* pick the best of those facets */
                    best = findBestFacet(actor, inScopeFacets);

                    /*
                     *   remove all of the facets besides the best one from the
                     *   result list - this will ensure that we have only the
                     *   single best facet in the final results
                     */
                    foreach (local r in result)
                    {
                        /*
                         *   if this result list item is in the facet list, and
                         *   it's not the best facet, delete it from the result
                         *   list
                         */
                        if (r.obj_ != best
                            && inScopeFacets.indexOf(r.obj_) != nil)
                            result.removeElement(r);
                    }

                }
            }

            /* return the result list */
            return result.toList();
        }

        /*
         *   Get a default object using the given verification method.  We'll
         *   start with the 'all' list, then use the verification method to
         *   reduce the list to the most likely candidates.  If we find a
         *   unique most likely candidate, we'll return a ResolveInfo list
         *   with that result; otherwise, we'll return nothing, since there is
         *   no suitable default.
         */
        getDefaultWithVerify(resolver, verProp, preCondProp, remapProp,
                             whichObj, np)
        {
            local lst;
            local results;
            local bestResult;

            /*
             *   Start with the 'all' list for this noun phrase.  This is the
             *   set of every object that we consider obviously suitable for
             *   the command, so it's a good starting point to guess at a
             *   default object.
             */
            lst = resolver.getAllDefaults();

            /* eliminate objects that can't be defaults for this action */
            lst = lst.subset({x: !x.obj_.hideFromDefault(self)});

            /*
             *   reduce equivalent items to a single instance of each
             *   equivalent - if we have several equivalent items that are
             *   equally good as defaults, we can pick just one
             */
            lst = resolver.filterAmbiguousEquivalents(lst, np);

            /* if we have no entries in the list, there is no default */
            if (lst == [])
                return nil;

            /*
             *   get the verification results for these objects, sorted from
             *   best to worst
             */
            results = getSortedVerifyResults(lst, verProp, preCondProp,
                                             remapProp, whichObj, np, nil);

            /* eliminate redundant remapped objects */
            results = combineRemappedVerifyResults(results, whichObj);

            /* note the best result */
            bestResult = results[1];

            /*
             *   if the best item is not allowed as an implied object, there
             *   is no default
             */
            if (!bestResult.allowImplicit)
                return nil;

            /*
             *   The best item must be uniquely logical in order to be a
             *   default - if more than one item is equally good, it makes no
             *   sense to assume anything about what the user meant.  So, if
             *   we have more than one item, and the second item is equally as
             *   logical as the first item, we cannot supply a default.  (The
             *   second item cannot be better than the first item, because of
             *   the sorting - at most, it can be equally good.)
             */
            if (results.length() != 1 && bestResult.compareTo(results[2]) == 0)
                return nil;

            /*
             *   We have a uniquely logical item, so we can assume the user
             *   must have been referring to this item.  Return the
             *   ResolveInfo for this item (which the verify result sorter
             *   stashed in the obj_ property of the verify result object).
             *
             *   Before returning the list, clear the 'all' flag in the result
             *   (getAll() set that flag), and replace it with the 'default'
             *   flag, since the object is an implied default.
             */
            bestResult.obj_.flags_ &= ~MatchedAll;
            bestResult.obj_.flags_ |= DefaultObject;

            /* return the result list */
            return [bestResult.obj_];
        }

        /*
         *   A synthesized Action (one that's generated by something other than
         *   parsing a command line, such as an event action or nested action)
         *   won't have a parser token list attached to it.  If we're asked to
         *   get the token list, we need to check for this possibility.  If we
         *   don't have a token list, but we do have a parent action, we'll
         *   defer to the parent action.  Otherwise, we'll simply return nil.
         */
        getOrigTokenList()
        {
            /* if we don't have a token list, look elsewhere */
            if (tokenList == nil)
            {
                /* if we have a parent action, defer to it */
                if (parentAction != nil)
                    return parentAction.getOrigTokenList();

                /* we have nowhere else to look, so return an empty list */
                return [];
            }

            /* inherit the standard handling from BasicProd */
            return inherited();
        }

        /*
         *   Create a topic qualifier resolver.  This type of resolver is used
         *   for qualifier phrases (e.g., possessives) within topic phrases
         *   within objects of this verb.  Topics *usually* only apply to
         *   TopicActionBase subclasses, but not exclusively: action remappings
         *   can sometimes require a topic phrase from one action to be
         *   resolved in the context of another action that wouldn't normally
         *   involve a topic phrase.  That's why this is needed on the base
         *   Action class.
         */
        createTopicQualifierResolver(issuingActor, targetActor)
        {
            /* create and return a topic qualifier object resolver */
            return new TopicQualifierResolver(self, issuingActor, targetActor);
        }

        /*
         *   List of objects that verified okay on a prior pass.  This is a
         *   scratch-pad for use by verifier routines, to keep track of work
         *   they've already done.  A few verifiers use this as a way to
         *   detect when an implicit action actually finished the entire job,
         *   which would in many cases result in a verify failure if not
         *   checked (because a command that effects conditions that already
         *   hold is normally illogical); by tracking that the verification
         *   previously succeeded, the verifier can know that the action
         *   should be allowed to proceed and do nothing.
         */
        verifiedOkay = []

        /*
         *   Get the missing object response production for a given resolver
         *   role.  (The base action doesn't have any objects, so there's no
         *   such thing as a missing object query.)
         */
        getObjResponseProd(resolver) { return nil; }
    ;

    /*
     *   Call the roomBeforeAction method on a given room's containing rooms,
     *   then on the room itself.
     */
    callRoomBeforeAction(room)
    {
        /* first, call roomBeforeAction on the room's containers */
        room.forEachContainer(callRoomBeforeAction);

        /* call roomBeforeAction on this room */
        room.roomBeforeAction();
    }

    /*
     *   Call the roomAfterAction method on a given room, then on the room's
     *   containing rooms.
     */
    callRoomAfterAction(room)
    {
        /* first, call roomAfterAction on this room */
        room.roomAfterAction();

        /* next, call roomAfterAction on the room's containers */
        room.forEachContainer(callRoomAfterAction);
    }

    /* ------------------------------------------------------------------------ */
    /*
     *   Intransitive Action class - this is an action that takes no objects.
     *   In general, each subclass should implement its action handling in its
     *   execAction() method.
     */
    class IAction: Action
        /*
         *   resolve my noun phrases to objects
         */
        resolveNouns(issuingActor, targetActor, results)
        {
            /*
             *   We have no objects to resolve.  The only thing we have to do
             *   is note in the results our number of structural noun slots
             *   for the verb, which is zero, since we have no objects at all.
             */
            results.noteNounSlots(0);
        }

        /*
         *   Execute the action.
         */
        doActionMain()
        {
            /*
             *   we have no objects to iterate, so simply run through the
             *   execution sequence once
             */
            doActionOnce();
        }
    ;

    /* ------------------------------------------------------------------------ */
    /*
     *   "All" and "Default" are a pseudo-actions used for dobjFor(All),
     *   iobjFor(Default), and similar catch-all handlers.  These are never
     *   executed as actual actions, but we define them so that dobjFor(All)
     *   and the like won't generate any warnings for undefined actions.
     */
    class AllAction: object
    ;
    class DefaultAction: object
    ;

    /* ------------------------------------------------------------------------ */
    /*
     *   Transitive Action class - this is an action that takes a direct
     *   object.
     *
     *   For simplicity, this object is its own object resolver - we really
     *   don't need a separate resolver object because we have only one object
     *   list for this verb.  (In contrast, an action with both a direct and
     *   indirect object might need separate resolution rules for the two
     *   objects, and hence would need separate resolver objects for the two.)
     *
     *   The advantage of implementing the Resolver behavior in this object,
     *   rather than using a separate object, is that it's less trouble to
     *   override object resolution rules - simply override the resolver
     *   methods in the subclass where you define the grammar rule for the
     *   action.
     */
    class TAction: Action, Resolver
        construct()
        {
            /* inherit only the Action constructor */
            inherited Action.construct();
        }

        resetAction()
        {
            /* inherit default handling */
            inherited();

            /* discard our cached resolver */
            dobjResolver_ = nil;
        }

        /*
         *   Create an action for retrying an original action with changes.
         */
        createForRetry(orig)
        {
            local action;

            /* create the new action based on the original action */
            action = createActionFrom(orig);

            /*
             *   do not include the new command in undo, since it's merely
             *   part of the enclosing explicit command
             */
            action.includeInUndo = nil;

            /* mark the action as nested */
            action.setNested();

            /*
             *   Even if the original action is implicit, don't announce this
             *   action as implicit, because it's good enough to have
             *   announced the original implicit action.  Now, this new
             *   command actually still is implicit if the original was - we
             *   simply don't want to announce it as such.  To suppress the
             *   extra announcement while still retaining the rest of the
             *   desired implicitness, simply set the implicitMsg property of
             *   the new action to nil; when there's no implicitMsg, there's
             *   no announcement.
             */
            action.implicitMsg = nil;

            /* return the new action */
            return action;
        }

        /*
         *   Retry an intransitive action as a single-object action.  We'll
         *   obtain a indirect object using the normal means (first looking
         *   for a default, then prompting the player if we can't find a
         *   suitable default).  'orig' is the original zero-object action.
         *
         *   This routine terminates with 'exit' if it doesn't throw some
         *   other error.
         */
        retryWithMissingDobj(orig, asker)
        {
            /* resolve and execute the replacement action */
            resolveAndReplaceAction(createForMissingDobj(orig, asker));
        }

        /*
         *   Retry an action as a single-object action with an ambiguous
         *   direct object.  We'll ask which of the given possible objects is
         *   intended.
         */
        retryWithAmbiguousDobj(orig, objs, asker, objPhrase)
        {
            local action;
            local resolver;

            /* create a missing-direct-object replacement action */
            action = createForMissingDobj(orig, asker);

            /* reduce the object list to the objects in scope */
            resolver = action.getDobjResolver(gIssuingActor, gActor, true);
            objs = objs.subset({x: resolver.objInScope(x)});

            /* plug in the ambiguous direct object list */
            action.dobjMatch = new PreResolvedAmbigProd(objs, asker, objPhrase);

            /* resolve and execute the replacement action */
            resolveAndReplaceAction(action);
        }

        /*
         *   Test to see if askForDobj() would find a default direct object.
         *   Returns true if there's a default, nil if not.  If this returns
         *   true, then askForDobj() will simply take the default and proceed;
         *   otherwise, it will have to actually ask the user for the missing
         *   information.
         */
        testRetryDefaultDobj(orig)
        {
            /* create the new action for checking for a direct object */
            local action = createForMissingDobj(orig, ResolveAsker);

            /* get the default dobj */
            local def = action.getDefaultDobj(
                action.dobjMatch,
                action.getDobjResolver(gIssuingActor, gActor, nil));

            /* if there's exactly one result, then we have a default */
            return (def != nil && def.length() == 1);
        }

        /*
         *   Create an instance of this action for retrying a given
         *   single-object action with a missing direct object.
         */
        createForMissingDobj(orig, asker)
        {
            /* create the action for a retry */
            local action = createForRetry(orig);

            /* use an empty noun phrase for the new action's direct object */
            action.dobjMatch = new EmptyNounPhraseProd();

            /* set our custom response production and ResolveAsker */
            action.dobjMatch.setPrompt(action.askDobjResponseProd, asker);

            /* initialize the new action with any pre-resolved parts */
            action.initForMissingDobj(orig);

            /* return the new action */
            return action;
        }

        /*
         *   Initialize this action in preparation for retrying with a missing
         *   direct object.  This routine must copy any phrases from the
         *   original action that have already been resolved.  This base
         *   TAction implementation obviously can't have anything pre-resolved
         *   in the original, since the original must simply be an IAction.
         *   Subclasses must override as appropriate for the kinds of base
         *   actions from which they can be retried.
         */
        initForMissingDobj(orig) { }

        /*
         *   The root production to use to parse missing direct object
         *   responses.  By default, this is nounList, but individual actions
         *   can override this as appropriate.
         *
         *   Note that language modules might want to override this to allow
         *   for special responses.  For example, in English, some verbs might
         *   want to override this with a specialized production that allows
         *   the appropriate preposition in the response.
         */
        askDobjResponseProd = nounList

        /* get the missing object response production for a given role */
        getObjResponseProd(resolver)
        {
            /* if it's the direct object, return the dobj response prod */
            if (resolver.whichObject == DirectObject)
                return askDobjResponseProd;

            /* otherwise use the default handling */
            return inherited(resolver);
        }

        /*
         *   Can the direct object potentially resolve to the given simulation
         *   object?  This only determines if the object is a *syntactic*
         *   match, meaning that it can match at a vocabulary and grammar
         *   level.  This doesn't test it for logicalness or check that it's an
         *   otherwise valid resolution.
         */
        canDobjResolveTo(obj)
        {
            /* check our dobj match tree to see if it can resolve to 'obj' */
            return dobjMatch.canResolveTo(
                obj, self, issuer_, actor_, DirectObject);
        }

        /*
         *   Resolve objects.  This is called at the start of command
         *   execution to resolve noun phrases in the command to specific
         *   objects.
         */
        resolveNouns(issuingActor, targetActor, results)
        {
            /* note that we have a single noun slot (the direct object) */
            results.noteNounSlots(1);

            /*
             *   Ask the direct object noun phrase list to resolve itself, and
             *   store the resulting object list.  Since we're starting a
             *   resolution pass through our objects, reset the resolver if
             *   we're reusing it.
             */
            dobjList_ = dobjMatch.resolveNouns(
                getDobjResolver(issuingActor, targetActor, true), results);
        }

        /* a transitive action has one noun phrase: the direct object */
        predicateNounPhrases = [&dobjMatch]

        /* get the role of an object */
        getRoleFromIndex(idx)
        {
            /* we only take a single object role - the direct object */
            return (idx == 1 ? DirectObject : inherited(idx));
        }

        /* get the resolved object in a given role */
        getObjectForRole(role)
        {
            /* return the direct object if requested */
            return (role == DirectObject ? getDobj() : inherited(role));
        }

        /* get the match tree for the noun phrase in the given role */
        getMatchForRole(role)
        {
            /* return the direct object match tree if requested */
            return (role == DirectObject ? dobjMatch : inherited(role));
        }

        /* get the 'verify' property for a given object role */
        getVerifyPropForRole(role)
        {
            return (role == DirectObject ? verDobjProp : inherited(role));
        }

        /* get the 'preCond' property for a given object role */
        getPreCondPropForRole(role)
        {
            return (role == DirectObject ? preCondDobjProp : inherited(role));
        }

        /* get the 'remap' property for a given object role */
        getRemapPropForRole(role)
        {
            return (role == DirectObject ? remapDobjProp : inherited(role));
        }

        /* get the ResolveInfo for the given object */
        getResolveInfo(obj, oldRole)
        {
            local info = nil;

            /* scan our resolved direct object list for the given object */
            if (dobjList_ != nil)
                info = dobjList_.valWhich({x: x.obj_ == obj});

            /* if we didn't find one, create one from scratch */
            if (info == nil)
            {
                /*
                 *   if there's anything in the old dobj role, copy the flags
                 *   and noun phrase to the new role
                 */
                if (dobjList_.length() > 0)
                {
                    /* get the flags and noun phrase from the old role */
                    info = new ResolveInfo(
                        obj, dobjList_[1].flags_, dobjList_[1].np_);
                }
                else
                {
                    /* there's no old role, so start from scratch */
                    info = new ResolveInfo(obj, 0, nil);
                }
            }

            /* return what we found (or created) */
            return info;
        }

        /* get the list of resolved objects in the given role */
        getResolvedObjList(which)
        {
            return (which == DirectObject ? getResolvedDobjList()
                    : inherited(which));
        }

        /* get the list of resolved direct objects */
        getResolvedDobjList()
        {
            /*
             *   if we have a direct object list, return the objects from it;
             *   otherwise, return an empty list
             */
            return (dobjList_ == nil ? nil : dobjList_.mapAll({x: x.obj_}));
        }

        /* manually set the resolved objects - we'll set the direct object */
        setResolvedObjects(dobj)
        {
            /* set the resolved direct object */
            setResolvedDobj(dobj);
        }

        /* set the resolved direct object */
        setResolvedDobj(dobj)
        {
            /*
             *   set the direct object tree to a fake grammar tree that
             *   resolves to our single direct object, in case we're asked to
             *   resolve explicitly
             */
            dobjMatch = new PreResolvedProd(dobj);

            /*
             *   Set the resolved direct object list to the single object or
             *   to the list of objects, depending on what we received.
             */
            dobjList_ = makeResolveInfoList(dobj);

            /* set the current object as well */
            dobjCur_ = (dobjList_.length() > 0 ? dobjList_[1].obj_ : nil);
            dobjInfoCur_ = (dobjList_.length() > 0 ? dobjList_[1] : nil);
        }

        /* manually set the unresolved object noun phrase match trees */
        setObjectMatches(dobj)
        {
            /*
             *   if it's a ResolveInfo, handle it as a resolved object;
             *   otherwise handle it as a match tree to be resolved
             */
            if (dobj.ofKind(ResolveInfo))
                setResolvedDobj(dobj);
            else
                dobjMatch = dobj;
        }

        /* check that the resolved objects are in scope */
        resolvedObjectsInScope()
        {
            /* check the direct object */
            return getDobjResolver(gIssuingActor, gActor, true)
                .objInScope(dobjList_[1].obj_);
        }

        /*
         *   Get a message parameter object for the action.  We define 'dobj'
         *   as the direct object, in addition to any inherited targets.
         */
        getMessageParam(objName)
        {
            switch(objName)
            {
            case 'dobj':
                /* return the current direct object */
                return dobjCur_;

            default:
                /* inherit default handling */
                return inherited(objName);
            }
        }

        /*
         *   Execute the action.  We'll run through the execution sequence
         *   once for each resolved direct object.
         */
        doActionMain()
        {
            /*
             *   Set the direct object list as the antecedent, using the
             *   language-specific pronoun setter.  Don't set pronouns for a
             *   nested command, because the player didn't necessarily refer to
             *   the objects in a nested command.
             */
            if (parentAction == nil)
                gActor.setPronoun(dobjList_);

            /* we haven't yet canceled the iteration */
            iterationCanceled = nil;

            /* pre-calculate the multi-object announcement text for each dobj */
            cacheMultiObjectAnnouncements(dobjList_, DirectObject);

            /* run through the sequence once for each direct object */
            for (local i = 1, local len = dobjList_.length() ;
                 i <= len && !iterationCanceled ; ++i)
            {
                /* make this object our current direct object */
                dobjCur_ = dobjList_[i].obj_;
                dobjInfoCur_ = dobjList_[i];

                /* announce the object if appropriate */
                announceActionObject(dobjList_[i], len, whichMessageObject);

                /* run the execution sequence for the current direct object */
                doActionOnce();

                /* if we're top-level, count the iteration in the transcript */
                if (parentAction == nil)
                    gTranscript.newIter();
            }
        }

        /* get the precondition descriptor list for the action */
        getPreCondDescList()
        {
            /*
             *   return the inherited preconditions plus the conditions that
             *   apply to the direct object
             */
            return inherited()
                + getObjPreCondDescList(dobjCur_, preCondDobjProp, dobjCur_,
                                        DirectObject);
        }

        /*
         *   Get the list of active objects.  We have only a direct object, so
         *   we'll return a list with the current direct object.
         */
        getCurrentObjects()
        {
            return [dobjCur_];
        }

        /* set the current objects */
        setCurrentObjects(lst)
        {
            dobjCur_ = lst[1];
            dobjInfoCur_ = nil;
        }

        /*
         *   Verify the action.
         */
        verifyAction()
        {
            local result;

            /* invoke any general (non-object) pre-condition verifiers */
            result = callVerifyPreCond(nil);

            /*
             *   invoke the verifier routine ("verXxx") on the current direct
             *   object and return the result
             */
            result = callVerifyProp(dobjCur_, verDobjProp, preCondDobjProp,
                                    remapDobjProp, result, DirectObject);

            /* verify that the action routine ("doXxx") exists on the object */
            return verifyHandlersExist(
                [dobjCur_], [verDobjProp, actionDobjProp, checkDobjProp],
                result);
        }

        /* initialize tentative resolutions for other noun phrases */
        initTentative(issuingActor, targetActor, whichObj)
        {
            /*
             *   we have only one noun phrase, so there's nothing else to
             *   tentatively resolve
             */
        }

        /*
         *   Check for remapping
         */
        checkRemapping()
        {
            local remapInfo;

            /* check for remapping in the direct object */
            if ((remapInfo = dobjCur_.(remapDobjProp)) != nil)
            {
                /*
                 *   we have a remapping, so apply it - note that this won't
                 *   return, since this will completely replace the command
                 *   and thus terminate the old command with 'exit'
                 */
                remapAction(nil, DirectObject, remapInfo);
            }
        }

        /*
         *   Check the command.
         *
         *   For a single-object transitive action, this runs the catch-all
         *   'check' properties (the dobjFor(Default) and dobjFor(All) 'check'
         *   methods) on the direct object, then calls the individual 'check'
         *   routine for this specific action.
         */
        checkAction()
        {
            try
            {
                /* call the catch-all 'check' properties */
                if (!callCatchAllProp(dobjCur_, checkDobjProp,
                                      &checkDobjDefault, &checkDobjAll))
                {
                    /*
                     *   the action-specific check routine overrides any
                     *   Default catch-all, so call the direct object's check
                     *   routine (its "checkXxx") method
                     */
                    dobjCur_.(checkDobjProp)();
                }
            }
            catch (ExitSignal es)
            {
                /* mark the action as a failure in the transcript */
                gTranscript.noteFailure();

                /* re-throw the signal */
                throw es;
            }
        }

        /*
         *   Execute the command.
         */
        execAction()
        {
            /* call the catch-all 'action' properties */
            if (!callCatchAllProp(dobjCur_, actionDobjProp,
                                  &actionDobjDefault, &actionDobjAll))
            {
                /*
                 *   the verb-specific 'action' handler overrides any Default
                 *   action handler, so call the verb-specific 'action'
                 *   routine in the direct object (the "doXxx" method)
                 */
                dobjCur_.(actionDobjProp)();
            }
        }

        /*
         *   The direct object preconditions, verifier, remapper, check, and
         *   action methods for this action.  Each concrete action must define
         *   these appropriately.  By convention, the methods are named like
         *   so:
         *
         *.  preconditions: preCondDobjAction
         *.  verifier: verDobjAction
         *.  remap: remapDobjAction
         *.  check: checkDobjAction
         *.  action: actionDobjAction
         *
         *   where the 'Action' suffix is replaced by the name of the action.
         *   The DefineTAction macro applies this convention, so in most cases
         *   library and game authors will never have to create all of those
         *   property names manually.
         */
        verDobjProp = nil
        preCondDobjProp = nil
        remapDobjProp = nil
        checkDobjProp = nil
        actionDobjProp = nil

        /*
         *   Get my direct object resolver.  If I don't already have one,
         *   create one and cache it; if I've already cached one, return it.
         *   Note that we cache the resolver because it can sometimes take a
         *   bit of work to set one up (the scope list can in some cases be
         *   complicated to calculate).  We use the resolver only during the
         *   object resolution phase; since game state can't change during
         *   this phase, it's safe to keep a cached copy.
         */
        getDobjResolver(issuingActor, targetActor, reset)
        {
            /* create a new resolver if we don't already have one cached */
            if (dobjResolver_ == nil)
                dobjResolver_ = createDobjResolver(issuingActor, targetActor);

            /* reset the resolver if desired */
            if (reset)
                dobjResolver_.resetResolver();

            /* return it */
            return dobjResolver_;
        }

        /*
         *   Create a resolver for the direct object.  By default, we are our
         *   own resolver.  Some actions might want to override this to create
         *   and return a specialized resolver instance if special resolution
         *   rules are needed.
         */
        createDobjResolver(issuingActor, targetActor)
        {
            /* initialize myself as a resolver */
            initResolver(issuingActor, targetActor);

            /* return myself */
            return self;
        }

        /*
         *   Does this action allow "all" to be used in noun phrases?  By
         *   default, we allow it or not according to a gameMain property.
         *
         *   Note that the inventory management verbs (TAKE, TAKE FROM, DROP,
         *   PUT IN, PUT ON) override this to allow "all" to be used, so
         *   disallowing "all" here (or via gameMain) won't disable "all" for
         *   those verbs.
         */
        actionAllowsAll = (gameMain.allVerbsAllowAll)

        /*
         *   Resolve 'all' for the direct object, given a list of everything
         *   in scope.  By default, we'll simply return everything in scope;
         *   some actions might want to override this to return a more
         *   specific list of objects suitable for 'all'.
         */
        getAllDobj(actor, scopeList)
        {
            return scopeList;
        }

        /* filter an ambiguous direct object noun phrase */
        filterAmbiguousDobj(lst, requiredNum, np)
        {
            /* filter using the direct object verifier method */
            return filterAmbiguousWithVerify(lst, requiredNum, verDobjProp,
                                             preCondDobjProp, remapDobjProp,
                                             DirectObject, np);
        }

        /* filter a plural phrase */
        filterPluralDobj(lst, np)
        {
            /* filter using the direct object verifier method */
            return filterPluralWithVerify(lst, verDobjProp, preCondDobjProp,
                                          remapDobjProp, DirectObject, np);
        }

        /* get the default direct object */
        getDefaultDobj(np, resolver)
        {
            /* get a default direct object using the verify method */
            return getDefaultWithVerify(resolver, verDobjProp, preCondDobjProp,
                                        remapDobjProp, DirectObject, np);
        }

        /* get the current direct object of the command */
        getDobj() { return dobjCur_; }

        /* get the full ResolveInfo associated with the current direct object */
        getDobjInfo() { return dobjInfoCur_; }

        /* get the object resolution flags for the direct object */
        getDobjFlags() { return dobjInfoCur_ != nil ? dobjInfoCur_.flags_ : 0; }

        /* get the number of direct objects */
        getDobjCount() { return dobjList_ != nil ? dobjList_.length() : 0; }

        /* get the original token list of the current direct object phrase */
        getDobjTokens()
        {
            return dobjInfoCur_ != nil && dobjInfoCur_.np_ != nil
                ? dobjInfoCur_.np_.getOrigTokenList() : nil;
        }

        /* get the original words (as a list of strings) of the current dobj */
        getDobjWords()
        {
            local l = getDobjTokens();
            return l != nil ? l.mapAll({x: getTokOrig(x)}) : nil;
        }

        /* the predicate must assign the direct object production tree here */
        dobjMatch = nil

        /* my resolved list of direct objects */
        dobjList_ = []

        /*
         *   The resolved direct object on which we're currently executing the
         *   command.  To execute the command, we iterate through the direct
         *   object list, calling the execution sequence for each object in
         *   the list.  We set this to the current object in each iteration.
         */
        dobjCur_ = nil

        /* the full ResolveInfo associated with dobjCur_ */
        dobjInfoCur_ = nil

        /* my cached direct object resolver */
        dobjResolver_ = nil

        /* -------------------------------------------------------------------- */
        /*
         *   Resolver interface implementation - for the moment, we don't need
         *   any special definitions here, since the basic Resolver
         *   implementation (which we inherit) is suitable for a single-object
         *   action.
         */

        /* -------------------------------------------------------------------- */
        /*
         *   private Resolver implementation details
         */

        /*
         *   Initialize me as a resolver.
         */
        initResolver(issuingActor, targetActor)
        {
            /* remember the actors */
            issuer_ = issuingActor;
            actor_ = targetActor;

            /* I'm the action as well as the resolver */
            action_ = self;

            /* cache the actor's default scope list */
            cacheScopeList();
        }

        /* issuing actor */
        issuer_ = nil

        /* target actor */
        actor_ = nil

        /*
         *   By default, our direct object plays the direct object role in
         *   generated messages.  Subclasses can override this if the resolved
         *   object is to play a different role.  Note that this only affects
         *   generated messages; for parsing purposes, our object is always in
         *   the DirectObject role.
         */
        whichMessageObject = DirectObject
    ;

    /* ------------------------------------------------------------------------ */
    /*
     *   "Tentative" noun resolver results gather.  This type of results
     *   gatherer is used to perform a tentative pre-resolution of an object
     *   of a multi-object action.
     *
     *   Consider what happens when we resolve a two-object action, such as
     *   "put <dobj> in <iobj>".  Since we have two objects, we obviously must
     *   resolve one object or the other first; but this means that we must
     *   resolve one object with no knowledge of the resolution of the other
     *   object.  This often makes it very difficult to resolve that first
     *   object intelligently, because we'd really like to know something
     *   about the other object.  For example, if we first resolve the iobj of
     *   "put <dobj> in <iobj>", it would be nice to know which dobj we're
     *   talking about, since we could reduce the likelihood that the iobj is
     *   the dobj's present container.
     *
     *   Tentative resolution addresses this need by giving us some
     *   information about a later-resolved object while resolving an
     *   earlier-resolved object, even though we obviously can't have fully
     *   resolved the later-resolved object.  In tentative resolution, we
     *   perform the resolution of the later-resolved object, completely in
     *   the dark about the earlier-resolved object(s), and come up with as
     *   much information as we can.  The important thing about this stage of
     *   resolution is that we don't ask any interactive questions and we
     *   don't count anything for ranking purposes - we simply do the best we
     *   can and note the results, leaving any ranking or interaction for the
     *   true resolution phase that we'll perform later.
     */
    class TentativeResolveResults: ResolveResults
        construct(target, issuer) { setActors(target, issuer); }

        /*
         *   ignore most resolution problems, since this is only a tentative
         *   resolution pass
         */
        noMatch(action, txt) { }
        noMatchPoss(action, txt) { }
        noVocabMatch(action, txt) { }
        noMatchForAll() { }
        noteEmptyBut() { }
        noMatchForAllBut() { }
        noMatchForListBut() { }
        noMatchForPronoun(typ, txt) { }
        reflexiveNotAllowed(typ, txt) { }
        wrongReflexive(typ, txt) { }
        noMatchForPossessive(owner, txt) { }
        noMatchForLocation(loc, txt) { }
        noteBadPrep() { }
        nothingInLocation(loc) { }
        unknownNounPhrase(match, resolver) { return []; }
        noteLiteral(txt) { }
        emptyNounPhrase(resolver) { return []; }
        zeroQuantity(txt) { }
        insufficientQuantity(txt, matchList, requiredNum) { }
        uniqueObjectRequired(txt, matchList) { }
        noteAdjEnding() { }
        noteIndefinite() { }
        noteMiscWordList(txt) { }
        notePronoun() { }
        noteMatches(matchList) { }
        incCommandCount() { }
        noteActorSpecified() { }
        noteNounSlots(cnt) { }
        noteWeakPhrasing(level) { }
        allowActionRemapping = nil

        /*
         *   during the tentative phase, keep all equivalents - we don't want
         *   to make any arbitrary choices among equivalents during this
         *   phase, because doing so could improperly force a choice among
         *   otherwise ambiguous resolutions to the other phrase
         */
        allowEquivalentFiltering = nil

        /*
         *   for ambiguous results, don't attempt to narrow things down - just
         *   keep the entire list
         */
        ambiguousNounPhrase(keeper, asker, txt,
                            matchList, fullMatchList, scopeList,
                            requiredNum, resolver)
        {
            return matchList;
        }

        /*
         *   no interaction is allowed, so return nothing if we need to ask
         *   for a missing object
         */
        askMissingObject(asker, resolver, responseProd)
        {
            /* note that we have a missing noun phrase */
            npMissing = true;

            /* return nothing */
            return nil;
        }

        /*
         *   no interaction is allowed, so return no tokens if we need to ask
         *   for a literal
         */
        askMissingLiteral(action, which) { return []; }

        /* no interaction is allowed during tentative resolution */
        canResolveInteractively() { return nil; }

        /*
         *   flag: the noun phrase we're resolving is a missing noun phrase,
         *   which means that we'll ask for it to be filled in when we get
         *   around to resolving it for real
         */
        npMissing = nil
    ;

    /*
     *   A dummy object that we use for the *tentative* resolution of a noun
     *   phrase when the noun phrase doesn't match anything.  This lets us
     *   distinguish cases where we have a noun phrase that has an error from a
     *   noun phrase that's simply missing.
     */
    dummyTentativeObject: object
    ;

    dummyTentativeInfo: ResolveInfo
        obj_ = dummyTentativeObject
        flags_ = 0
    ;

    /* ------------------------------------------------------------------------ */
    /*
     *   Transitive-with-indirect Action class - this is an action that takes
     *   both a direct and indirect object.  We subclass the basic one-object
     *   action to add the indirect object handling.
     */
    class TIAction: TAction
        resetAction()
        {
            /* inherit defaulting handling */
            inherited();

            /* discard our cached iobj resolver */
            iobjResolver_ = nil;
        }

        /*
         *   Retry a single-object action as a two-object action.  We'll treat
         *   the original action's direct object list as our direct object
         *   list, and obtain an indirect object using the normal means (first
         *   looking for a default, then prompting the player if we can't find
         *   a suitable default).  'orig' is the original single-object action.
         *
         *   This routine terminates with 'exit' if it doesn't throw some
         *   other error.
         */
        retryWithMissingIobj(orig, asker)
        {
            /* resolve and execute the replacement action */
            resolveAndReplaceAction(createForMissingIobj(orig, asker));
        }

        /*
         *   Retry an action as a two-object action with an ambiguous indirect
         *   object.  We'll ask which of the given possible objects is
         *   intended.
         */
        retryWithAmbiguousIobj(orig, objs, asker, objPhrase)
        {
            /* create a missing-indirect-object replacement action */
            local action = createForMissingIobj(orig, asker);

            /* reduce the object list to the objects in scope */
            local resolver = action.getIobjResolver(gIssuingActor, gActor, true);
            objs = objs.subset({x: resolver.objInScope(x)});

            /* plug in the ambiguous indirect object list */
            action.iobjMatch = new PreResolvedAmbigProd(objs, asker, objPhrase);

            /* resolve and execute the replacement action */
            resolveAndReplaceAction(action);
        }

        /*
         *   Test to see if askForIobj() would find a default indirect object.
         *   Returns true if there's a default, nil if not.  If this returns
         *   true, then askForIobj() will simply take the default and proceed;
         *   otherwise, it will have to actually ask the user for the missing
         *   information.
         */
        testRetryDefaultIobj(orig)
        {
            local action;
            local def;

            /* create the new action for checking for an indirect object */
            action = createForMissingIobj(orig, ResolveAsker);

            /* get the default iobj */
            def = action.getDefaultIobj(
                action.iobjMatch,
                action.getIobjResolver(gIssuingActor, gActor, nil));

            /* if there's exactly one result, then we have a default */
            return (def != nil && def.length() == 1);
        }

        /*
         *   Create an instance of this action for retrying a given
         *   single-object action with a missing indirect object.
         */
        createForMissingIobj(orig, asker)
        {
            /* create the new action based on the original action */
            local action = createForRetry(orig);

            /* use an empty noun phrase for the new action's indirect object */
            action.iobjMatch = new EmptyNounPhraseProd();

            /* set our custom response production and ResolveAsker */
            action.iobjMatch.setPrompt(action.askIobjResponseProd, asker);

            /* copy what we've resolved so far */
            action.initForMissingIobj(orig);

            /* return the action */
            return action;
        }

        /*
         *   Initialize the action for retrying with a missing direct object.
         *
         *   If we're trying a TIAction, we can only be coming from a TAction
         *   (since that's the only kind of original action that can turn into
         *   a two-object, at least in the base library).  That means the
         *   original action already has a direct object.  Now, since we're
         *   asking for a MISSING direct object, the only possibility is that
         *   the original action's direct object is our INDIRECT object.  For
         *   example: SWEEP WITH BROOM is turning into SWEEP <what> WITH
         *   BROOM.
         */
        initForMissingDobj(orig)
        {
            local origDobj = orig.getDobj();

            /*
             *   Set the indirect object in the new action to the direct object
             *   from the original action.  If there's no individual direct
             *   object yet, we must be retrying the overall command, before we
             *   started iterating through the individual dobjs, so copy the
             *   entire dobj list from the original.
             */
            iobjMatch = new PreResolvedProd(origDobj != nil
                                            ? origDobj : orig.dobjList_ );
        }

        /*
         *   Initialize the action for retrying with a missing indirect object.
         *
         *   We can only be coming from a TAction, so the TAction will have a
         *   direct object already.  Simply copy that as our own direct
         *   object.  For example: UNLOCK DOOR is turning into UNLOCK DOOR
         *   WITH <what>.
         */
        initForMissingIobj(orig)
        {
            local origDobj = orig.getDobj();

            /*
             *   Copy the direct object from the original.  If there's no
             *   individual direct object yet, we must be retrying the overall
             *   command, before we started iterating through the individual
             *   dobjs, so copy the entire dobj list.
             */
            dobjMatch = new PreResolvedProd(origDobj != nil
                                            ? origDobj : orig.dobjList_);
        }

        /*
         *   The root production to use to parse missing indirect object
         *   responses.  By default, this is singleNoun, but individual
         *   actions can override this as appropriate.
         *
         *   Note that language modules might want to override this to allow
         *   for special responses.  For example, in English, most verbs will
         *   want to override this with a specialized production that allows
         *   the appropriate preposition in the response.
         */
        askIobjResponseProd = singleNoun

        /* get the missing object response production for a given role */
        getObjResponseProd(resolver)
        {
            /* if it's the indirect object, return the iobj response prod */
            if (resolver.whichObject == IndirectObject)
                return askIobjResponseProd;

            /* otherwise use the default handling */
            return inherited(resolver);
        }

        /*
         *   Resolution order - returns DirectObject or IndirectObject to
         *   indicate which noun phrase to resolve first in resolveNouns().
         *   By default, we'll resolve the indirect object first, but
         *   individual actions can override this to resolve in a non-default
         *   order.
         */
        resolveFirst = IndirectObject

        /*
         *   Empty phrase resolution order.  This is similar to the standard
         *   resolution order (resolveFirst), but is used only when both the
         *   direct and indirect objects are empty phrases.
         *
         *   When both phrases are empty, we will either use a default or
         *   prompt interactively for the missing phrase.  In most cases, it
         *   is desirable to prompt interactively for a missing direct object
         *   first, regardless of the usual resolution order.
         */
        resolveFirstEmpty = DirectObject

        /*
         *   Determine which object to call first for action processing.  By
         *   default, we execute in the same order as we resolve, but this can
         *   be overridden if necessary.
         */
        execFirst = (resolveFirst)

        /*
         *   Can the indirect object potentially resolve to the given
         *   simulation object?  This only determines if the object is a
         *   *syntactic* match, meaning that it can match at a vocabulary and
         *   grammar level.  This doesn't test it for logicalness or check that
         *   it's an otherwise valid resolution.
         */
        canIobjResolveTo(obj)
        {
            /* check our iobj match tree to see if it can resolve to 'obj' */
            return iobjMatch.canResolveTo(
                obj, self, issuer_, actor_, IndirectObject);
        }

        /*
         *   resolve our noun phrases to objects
         */
        resolveNouns(issuingActor, targetActor, results)
        {
            local first;
            local objMatch1, objMatch2;
            local objList1, objList2;
            local getResolver1, getResolver2;
            local objCur1;
            local remapProp;
            local reResolveFirst;

            /*
             *   note in the results that we have two noun slots (the direct
             *   and indirect objects)
             */
            results.noteNounSlots(2);

            /* we have no current known direct or indirect object yet */
            dobjCur_ = nil;
            iobjCur_ = nil;

            /*
             *   presume we won't have to re-resolve the first noun phrase,
             *   and clear out our record of anaphor bindings
             */
            reResolveFirst = nil;
            needAnaphoricBinding_ = nil;
            lastObjList_ = nil;

            /*
             *   Determine which object we want to resolve first.  If both
             *   phrases are empty, use the special all-empty ordering;
             *   otherwise, use the standard ordering for this verb.
             */
            if (dobjMatch.isEmptyPhrase && iobjMatch.isEmptyPhrase)
            {
                /* both phrases are empty - use the all-empty ordering */
                first = resolveFirstEmpty;
            }
            else
            {
                /*
                 *   we have at least one non-empty phrase, so use our
                 *   standard ordering
                 */
                first = resolveFirst;
            }

            /*
             *   The resolution process is symmetrical for the two possible
             *   resolution orders (direct object first or indirect object
             *   first); all we need to do is to set up the parameters we'll
             *   need according to which order we're using.
             *
             *   This parameterized approach makes the code further below a
             *   little mind-boggling, because it's using so much indirection.
             *   But the alternative is worse: the alternative is to
             *   essentially make two copies of the code below (one for the
             *   dobj-first case and one for the iobj-first case), which is
             *   prone to maintenance problems because of the need to keep the
             *   two copies synchronized when making any future changes.
             */
            if (first == DirectObject)
            {
                objMatch1 = dobjMatch;
                objMatch2 = iobjMatch;
                objList1 = &dobjList_;
                objList2 = &iobjList_;
                getResolver1 = &getDobjResolver;
                getResolver2 = &getIobjResolver;
                objCur1 = &dobjCur_;
                remapProp = remapDobjProp;
            }
            else
            {
                objMatch1 = iobjMatch;
                objMatch2 = dobjMatch;
                objList1 = &iobjList_;
                objList2 = &dobjList_;
                getResolver1 = &getIobjResolver;
                getResolver2 = &getDobjResolver;
                objCur1 = &iobjCur_;
                remapProp = remapIobjProp;
            }

            /*
             *   Get the unfiltered second-resolved object list - this will
             *   give the first-resolved object resolver access to some
             *   minimal information about the possible second-resolved object
             *   or objects.
             *
             *   Note that we're not *really* resolving the second object here
             *   - it is the second-resolved object, after all.  What we're
             *   doing is figuring out the *potential* set of objects that
             *   could resolve to the second phrase, with minimal
             *   disambiguation, so that the first object resolver is not
             *   totally in the dark about the second object's potential
             *   resolution.
             */
            initTentative(issuingActor, targetActor, first);

            /* resolve the first-resolved noun phrase */
            self.(objList1) = objMatch1.resolveNouns(
                self.(getResolver1)(issuingActor, targetActor, true), results);

            /*
             *   If the first-resolved noun phrase asked for an anaphoric
             *   binding, we'll need to go back and re-resolve that noun
             *   phrase after we resolve our other noun phrase, since the
             *   first-resolved phrase refers to the second-resolved phrase.
             */
            reResolveFirst = needAnaphoricBinding_;

            /*
             *   if the second-resolved phrase uses an anaphoric pronoun, the
             *   anaphor can be taken as referring to the first-resolved
             *   phrase's results
             */
            lastObjList_ = self.(objList1);

            /*
             *   if the first-resolved phrase resolves to just one object, we
             *   can immediately set the current resolved object, so that we
             *   can use it while resolving the second-resolved object list
             */
            if (self.(objList1).length() == 1)
            {
                /* set the current first-resolved object */
                self.(objCur1) = self.(objList1)[1].obj_;

                /* if remapping is allowed at this point, look for a remapping */
                if (results.allowActionRemapping)
                {
                    withParserGlobals(issuingActor, targetActor, self,
                                      function()
                    {
                        local remapInfo;

                        /* check for a remapping */
                        if ((remapInfo = self.(objCur1).(remapProp)) != nil)
                        {
                            /*
                             *   we have a remapping, so apply it - note that
                             *   we're still in the process of resolving noun
                             *   phrases (since we've only resolved one of our
                             *   two noun phrases so far), so pass 'true' for
                             *   the inResolve parameter
                             */
                            remapAction(true, first, remapInfo);
                        }
                    });
                }
            }

            /* resolve the second-resolved object */
            self.(objList2) = objMatch2.resolveNouns(
                self.(getResolver2)(issuingActor, targetActor, true), results);

            /*
             *   if we have to re-resolve the first noun phrase due to an
             *   anaphoric pronoun, go back and do that now
             */
            if (reResolveFirst)
            {
                /*
                 *   use the second-resolved noun phrase as the referent of
                 *   the anaphoric pronoun(s) in the first-resolved phrase
                 */
                lastObjList_ = self.(objList2);

                /* re-resolve the first object list */
                self.(objList1) = objMatch1.resolveNouns(
                    self.(getResolver1)(issuingActor, targetActor, true),
                    results);
            }
        }

        /* we have a direct and indirect object */
        predicateNounPhrases = [&dobjMatch, &iobjMatch]

        /* get an object role */
        getRoleFromIndex(idx)
        {
            /*
             *   the second object is always our indirect object; for other
             *   roles, defer to the inherited behavior
             */
            return (idx == 2 ? IndirectObject : inherited(idx));
        }

        /* get the resolved object in a given role */
        getObjectForRole(role)
        {
            /* return the indirect object if requested; otherwise inherit */
            return (role == IndirectObject ? getIobj() : inherited(role));
        }

        /* get the ResolveInfo for the given resolved object */
        getResolveInfo(obj, oldRole)
        {
            local info;

            /* scan our resolved direct object list for the given object */
            if (dobjList_ != nil)
                info = dobjList_.valWhich({x: x.obj_ == obj});

            /* if we didn't find it there, try the indirect object list */
            if (info == nil && iobjList_ != nil)
                info = iobjList_.valWhich({x: x.obj_ == obj});

            /* if we didn't find one, create one from scratch */
            if (info == nil)
            {
                /* get the list for the old role */
                local lst = (oldRole == DirectObject ? dobjList_ : iobjList_);

                /*
                 *   if there's anything in the old role, copy its flags and
                 *   noun phrase to the new role
                 */
                if (lst.length() > 0)
                {
                    /* copy the old role's attributes */
                    info = new ResolveInfo(obj, lst[1].flags_, lst[1].np_);
                }
                else
                {
                    /* nothing in the old role - start from scratch */
                    info = new ResolveInfo(obj, 0, nil);
                }
            }

            /* return what we found (or created) */
            return info;
        }

        /* get the OtherObject role for the given role */
        getOtherObjectRole(role)
        {
            /* the complementary roles are DirectObject and IndirectObject */
            return (role == IndirectObject ? DirectObject : IndirectObject);
        }

        /* get the match tree for the noun phrase in the given role */
        getMatchForRole(role)
        {
            /* return the indirect object match tree if requested; else inherit */
            return (role == IndirectObject ? iobjMatch : inherited(role));
        }

        /* get the 'verify' property for a given object role */
        getVerifyPropForRole(role)
        {
            return (role == IndirectObject ? verIobjProp : inherited(role));
        }

        /* get the 'preCond' property for a given object role */
        getPreCondPropForRole(role)
        {
            return (role == IndirectObject ? preCondIobjProp : inherited(role));
        }

        /* get the 'remap' property for a given object role */
        getRemapPropForRole(role)
        {
            return (role == IndirectObject ? remapIobjProp : inherited(role));
        }

        /* get the list of resolved objects in the given role */
        getResolvedObjList(which)
        {
            return (which == IndirectObject ? getResolvedIobjList()
                    : inherited(which));
        }

        /* get the list of resolved indirect objects */
        getResolvedIobjList()
        {
            /*
             *   if we have an indirect object list, return the objects from
             *   it; otherwise, return an empty list
             */
            return (iobjList_ == nil ? nil : iobjList_.mapAll({x: x.obj_}));
        }

        /*
         *   Manually set the resolved objects.  We'll set our direct and
         *   indirect objects.
         */
        setResolvedObjects(dobj, iobj)
        {
            /* inherit the base class handling to set the direct object */
            inherited(dobj);

            /* set the resolved iobj */
            setResolvedIobj(iobj);
        }

        /* set a resolved iobj */
        setResolvedIobj(iobj)
        {
            /* build a pre-resolved production for the indirect object */
            iobjMatch = new PreResolvedProd(iobj);

            /* set the resolved indirect object */
            iobjList_ = makeResolveInfoList(iobj);

            /* set the current indirect object as well */
            iobjCur_ = (iobjList_.length() > 0 ? iobjList_[1].obj_ : nil);
            iobjInfoCur_ = (iobjList_.length() > 0 ? iobjList_[1] : nil);
        }

        /* manually set the unresolved object noun phrase match trees */
        setObjectMatches(dobj, iobj)
        {
            /* inherit default handling */
            inherited(dobj);

            /*
             *   if the iobj is a ResolveInfo, set it as a resolved object;
             *   otherwise set it as an unresolved match tree
             */
            if (iobj.ofKind(ResolveInfo))
                setResolvedIobj(iobj);
            else
                iobjMatch = iobj;
        }

        /*
         *   Get the anaphoric binding for the noun phrase we're currently
         *   resolving.
         */
        getAnaphoricBinding(typ)
        {
            /* if we've resolved a prior noun phrase, return it */
            if (lastObjList_ != nil)
                return lastObjList_;

            /*
             *   we don't have a prior noun phrase - make a note that we have
             *   to come back and re-resolve the current noun phrase
             */
            needAnaphoricBinding_ = true;

            /*
             *   return an empty list to indicate that the anaphor is
             *   acceptable in this context but has no binding yet
             */
            return [];
        }

        /*
         *   The last object list we resolved.  We keep track of this so that
         *   we can provide it as the anaphoric binding, if an anaphor binding
         *   is requested.
         */
        lastObjList_ = nil

        /*
         *   Flag: we have been asked for an anaphoric binding, but we don't
         *   have a binding available.  We'll check this after resolving the
         *   first-resolved noun phrase so that we can go back and re-resolve
         *   it again after resolving the other noun phrase.
         */
        needAnaphoricBinding_ = nil

        /* check that the resolved objects are in scope */
        resolvedObjectsInScope()
        {
            /*
             *   check the indirect object, and inherit the base class handling
             *   to check the direct object
             */
            return (inherited()
                    && (getIobjResolver(gIssuingActor, gActor, true)
                        .objInScope(iobjList_[1].obj_)));
        }

        /*
         *   get our indirect object resolver, or create one if we haven't
         *   already cached one
         */
        getIobjResolver(issuingActor, targetActor, reset)
        {
            /* if we don't already have one cached, create a new one */
            if (iobjResolver_ == nil)
                iobjResolver_ = createIobjResolver(issuingActor, targetActor);

            /* reset the resolver if desired */
            if (reset)
                iobjResolver_.resetResolver();

            /* return the cached resolver */
            return iobjResolver_;
        }

        /*
         *   Create our indirect object resolver.  By default, we'll use a
         *   basic indirect object resolver.
         */
        createIobjResolver(issuingActor, targetActor)
        {
            /* create and return a new basic indirect object resolver */
            return new IobjResolver(self, issuingActor, targetActor);
        }

        /*
         *   Resolve 'all' for the indirect object.  By default, we'll return
         *   everything in the scope list.
         */
        getAllIobj(actor, scopeList)
        {
            return scopeList;
        }

        /* filter an ambiguous indirect object noun phrase */
        filterAmbiguousIobj(lst, requiredNum, np)
        {
            /* filter using the indirect object verifier method */
            return filterAmbiguousWithVerify(lst, requiredNum, verIobjProp,
                                             preCondIobjProp, remapIobjProp,
                                             IndirectObject, np);
        }

        /* filter a plural phrase */
        filterPluralIobj(lst, np)
        {
            /* filter using the direct object verifier method */
            return filterPluralWithVerify(lst, verIobjProp, preCondIobjProp,
                                          remapIobjProp, IndirectObject, np);
        }

        /* get the default indirect object */
        getDefaultIobj(np, resolver)
        {
            /* get a default indirect object using the verify method */
            return getDefaultWithVerify(resolver, verIobjProp, preCondIobjProp,
                                        remapIobjProp, IndirectObject, np);
        }

        /*
         *   Execute the action.  We'll run through the execution sequence
         *   once for each resolved object in our direct or indirect object
         *   list, depending on which one is the list and which one is the
         *   singleton.
         */
        doActionMain()
        {
            local lst;
            local preAnnouncedDobj;
            local preAnnouncedIobj;

            /*
             *   Get the list of resolved objects for the multiple object.  If
             *   neither has multiple objects, it doesn't matter which is
             *   iterated, since we'll just do the command once anyway.
             */
            lst = (iobjList_.length() > 1 ? iobjList_ : dobjList_);

            /*
             *   Set the pronoun antecedents, using the game-specific pronoun
             *   setter.  Don't set an antecedent for a nested command.
             */
            if (parentAction == nil)
            {
               /*
                *   Set both direct and indirect objects as potential
                *   antecedents.  Rather than trying to figure out right now
                *   which one we might want to refer to in the future, remember
                *   both - we'll decide which one is the logical antecedent
                *   when we find a pronoun to resolve in a future command.
                */
               gActor.setPronounMulti(dobjList_, iobjList_);

                /*
                 *   If one or the other object phrase was specified in the
                 *   input as a pronoun, keep the meaning of that pronoun the
                 *   same, overriding whatever we just did.  Note that the
                 *   order we use here doesn't matter: if a given pronoun
                 *   appears in only one of the two lists, then the list where
                 *   it's not set has no effect on the pronoun, hence it
                 *   doesn't matter which comes first; if a pronoun appears in
                 *   both lists, it will have the same value in both lists, so
                 *   we'll just do the same thing twice, so, again, order
                 *   doesn't matter.
                 */
                setPronounByInput(dobjList_);
                setPronounByInput(iobjList_);
            }

            /*
             *   pre-announce the non-list object if appropriate - this will
             *   provide a common pre-announcement if we iterate through
             *   several announcements of the main list objects
             */
            if (lst == dobjList_)
            {
                /* pre-announce the single indirect object if needed */
                preAnnouncedIobj = preAnnounceActionObject(
                    iobjList_[1], dobjList_, IndirectObject);

                /* we haven't announced the direct object yet */
                preAnnouncedDobj = nil;

                /* pre-calculate the multi-object announcements */
                cacheMultiObjectAnnouncements(dobjList_, DirectObject);
            }
            else
            {
                /* pre-announce the single direct object if needed */
                preAnnouncedDobj = preAnnounceActionObject(
                    dobjList_[1], iobjList_, DirectObject);

                /* we haven't announced the indirect object yet */
                preAnnouncedIobj = nil;

                /* pre-calculate the multi-object announcements */
                cacheMultiObjectAnnouncements(iobjList_, IndirectObject);
            }

            /* we haven't yet canceled the iteration */
            iterationCanceled = nil;

            /* iterate over the resolved list for the multiple object */
            for (local i = 1, local len = lst.length() ;
                 i <= len && !iterationCanceled ; ++i)
            {
                local dobjInfo;
                local iobjInfo;

                /*
                 *   make the current list item the direct or indirect object,
                 *   as appropriate
                 */
                if (lst == dobjList_)
                {
                    /* the direct object is the multiple object */
                    dobjInfo = dobjInfoCur_ = lst[i];
                    iobjInfo = iobjInfoCur_ = iobjList_[1];
                }
                else
                {
                    /* the indirect object is the multiple object */
                    dobjInfo = dobjInfoCur_ = dobjList_[1];
                    iobjInfo = iobjInfoCur_ = lst[i];
                }

                /* get the current dobj and iobj from the resolve info */
                dobjCur_ = dobjInfo.obj_;
                iobjCur_ = iobjInfo.obj_;

                /*
                 *   if the action was remapped, and we need to announce
                 *   anything, announce the entire action
                 */
                if (isRemapped())
                {
                    /*
                     *   We were remapped.  The entire phrasing of the new
                     *   action might have changed from what the player typed,
                     *   so it might be nonsensical to show the objects as we
                     *   usually would, as sentence fragments that are meant
                     *   to combine with what the player actually typed.  So,
                     *   instead of showing the usual sentence fragments, show
                     *   the entire phrasing of the command.
                     *
                     *   Only show the announcement if we have a reason to: we
                     *   have unclear disambiguation in one of the objects, or
                     *   one of the objects is defaulted.
                     *
                     *   If we don't want to announce the remapped action,
                     *   still consider showing a multi-object announcement,
                     *   if we would normally need to do so.
                     */
                    if (needRemappedAnnouncement(dobjInfo)
                        || needRemappedAnnouncement(iobjInfo))
                    {
                        /* show the remapped announcement */
                        gTranscript.announceRemappedAction();
                    }
                    else
                    {
                        /* announce the multiple dobj if necessary */
                        if (!preAnnouncedDobj)
                            maybeAnnounceMultiObject(
                                dobjInfo, dobjList_.length(), DirectObject);

                        /* announce the multiple iobj if necessary */
                        if (!preAnnouncedIobj)
                            maybeAnnounceMultiObject(
                                iobjInfo, iobjList_.length(), IndirectObject);
                    }
                }
                else
                {
                    /* announce the direct object if appropriate */
                    if (!preAnnouncedDobj)
                        announceActionObject(dobjInfo, dobjList_.length(),
                                             DirectObject);

                    /* announce the indirect object if appropriate */
                    if (!preAnnouncedIobj)
                        announceActionObject(iobjInfo, iobjList_.length(),
                                             IndirectObject);
                }

                /* run the execution sequence for the current direct object */
                doActionOnce();

                /* if we're top-level, count the iteration in the transcript */
                if (parentAction == nil)
                    gTranscript.newIter();
            }
        }

        /*
         *   Set the pronoun according to the pronoun type actually used in
         *   the input.  For example, if we said PUT BOX ON IT, we want IT to
         *   continue referring to whatever IT referred to before this command
         *   - we specifically do NOT want IT to refer to the BOX in this
         *   case.
         */
        setPronounByInput(lst)
        {
            local objs;

            /* get the subset of the list that was specified by pronoun */
            lst = lst.subset({x: x.pronounType_ != nil});

            /*
             *   Get a list of the unique objects in the list.  This will
             *   ensure that we can distinguish THEM from IT AND IT AND IT: if
             *   we have the same pronoun appearing with multiple objects,
             *   we'll know that it's because the pronoun was actually plural
             *   (THEM) rather than a singular pronoun that was repeated (IT
             *   AND IT AND IT).
             */
            objs = lst.mapAll({x: x.obj_}).getUnique();

            /*
             *   Now retain one 'lst' element for each 'objs' element.  This
             *   is a bit tricky: we're mapping each element in 'objs' to pick
             *   out one element of 'lst' where the 'lst' element points to
             *   the 'objs' element.
             */
            lst = objs.mapAll({o: lst.valWhich({l: l.obj_ == o})});

            /*
             *   Now we can set the pronouns.  Go through the list, and set
             *   each different pronoun type that appears.  Set it to the
             *   subset of the list with that matches that pronoun type, and
             *   then remove that subset and keep iterating to pick up the
             *   remaining pronoun types.
             */
            while (lst.length() != 0)
            {
                local cur;
                local typ;

                /* on this iteration, handle the first pronoun type in the list */
                typ = lst[1].pronounType_;

                /* pick out the subset with the current pronoun type */
                cur = lst.subset({x: x.pronounType_ == typ});

                /* set the current pronoun to the current list */
                gActor.setPronounByType(typ, cur);

                /* remove the subset we just handled from the remaining list */
                lst -= cur;
            }
        }

        /*
         *   Determine if we need to announce this action when the action was
         *   remapped, based on the resolution information for one of our
         *   objects.  We need to announce a remapped action when either
         *   object had unclear disambiguation or was defaulted.
         */
        needRemappedAnnouncement(info)
        {
            /*
             *   if it's a defaulted object that hasn't been announced, or it
             *   was unclearly disambiguated, we need an announcement
             */
            return (((info.flags_ & DefaultObject) != 0
                     && (info.flags_ & AnnouncedDefaultObject) == 0)
                    || (info.flags_ & UnclearDisambig) != 0);
        }

        /*
         *   Verify the action.
         */
        verifyAction()
        {
            local result;

            /* invoke any general (non-object) pre-condition verifiers */
            result = callVerifyPreCond(nil);

            /* check the direct object */
            result = callVerifyProp(dobjCur_, verDobjProp, preCondDobjProp,
                                    remapDobjProp, result, DirectObject);

            /*
             *   Check the indirect object, combining the results with the
             *   direct object results.  We combine the results for the two
             *   objects because we're simply looking for any reason that we
             *   can't perform the command.
             */
            result = callVerifyProp(iobjCur_, verIobjProp, preCondIobjProp,
                                    remapIobjProp, result, IndirectObject);

            /*
             *   check that the action method ("doXxx") is defined on at least
             *   one of the objects
             */
            return verifyHandlersExist(
                [dobjCur_, iobjCur_],
                [verDobjProp, checkDobjProp, actionDobjProp,
                verIobjProp, checkIobjProp, actionIobjProp],
                result);
        }

        /* initialize tentative resolutions for other noun phrases */
        initTentative(issuingActor, targetActor, whichObj)
        {
            local tRes;
            local ti, td;

            /*
             *   remember the old tentative direct and indirect objects, then
             *   set them to empty lists - this will ensure that we don't
             *   recursively try to get a tentative resolution for the object
             *   we're working on right now, which would cause infinite
             *   recursion
             */
            td = tentativeDobj_;
            ti = tentativeIobj_;

            /* set them to empty lists to indicate they don't need resolving */
            tentativeDobj_ = [];
            tentativeIobj_ = [];

            /* make sure our built-in dobj resolver is initialized */
            issuer_ = issuingActor;
            actor_ = targetActor;

            /* make sure we set things back when we're done */
            try
            {
                /* initialize the other noun phrase */
                if (whichObj == DirectObject && ti == nil)
                {
                    /* tentatively resolve the indirect object */
                    tRes = new TentativeResolveResults(targetActor, issuingActor);
                    ti = iobjMatch.resolveNouns(
                        getIobjResolver(issuingActor, targetActor, true), tRes);

                    /*
                     *   if the list is empty, and we didn't have a missing
                     *   noun phrase, use a dummy object as the tentative
                     *   resolution - this distinguishes erroneous noun phrases
                     *   from those that are simply missing
                     */
                    if (ti == [] && !tRes.npMissing)
                        ti = [dummyTentativeInfo];
                }
                else if (whichObj == IndirectObject && td == nil)
                {
                    /* tentatively resolve the direct object */
                    tRes = new TentativeResolveResults(targetActor, issuingActor);
                    td = dobjMatch.resolveNouns(
                        getDobjResolver(issuingActor, targetActor, true), tRes);

                    /* use a dummy object if appropriate */
                    if (td == [] && !tRes.npMissing)
                        td = [dummyTentativeInfo];
                }
            }
            finally
            {
                /* set the original (or updated) tentative lists */
                tentativeDobj_ = td;
                tentativeIobj_ = ti;
            }
        }

        /*
         *   Check for remapping
         */
        checkRemapping()
        {
            local remapInfo;
            local role;

            /* presume we'll find remapping for the first-resolved object */
            role = resolveFirst;

            /* check remapping for each object, in the resolution order */
            if (resolveFirst == DirectObject)
            {
                /* the direct object is resolved first, so try it first */
                if ((remapInfo = dobjCur_.(remapDobjProp)) == nil)
                {
                    remapInfo = iobjCur_.(remapIobjProp);
                    role = IndirectObject;
                }
            }
            else
            {
                /* the indirect object is resolved first, so remap it first */
                if ((remapInfo = iobjCur_.(remapIobjProp)) == nil)
                {
                    remapInfo = dobjCur_.(remapDobjProp);
                    role = DirectObject;
                }
            }

            /* if we found a remapping, apply it */
            if (remapInfo != nil)
                remapAction(nil, role, remapInfo);
        }

        /*
         *   Check the command.
         *
         *   For a two-object action, this first calls the catch-all 'check'
         *   methods (the dobjFor(Default) and dobjFor(All) methods) on the two
         *   objects (indirect object first), then calls the 'check' methods
         *   for this specific action (direct object first).
         */
        checkAction()
        {
            try
            {
                /* invoke the catch-all 'check' methods on each object */
                local defIo = callCatchAllProp(
                    iobjCur_, checkIobjProp, &checkIobjDefault, &checkIobjAll);
                local defDo = callCatchAllProp(
                    dobjCur_, checkDobjProp, &checkDobjDefault, &checkDobjAll);

                /*
                 *   invoke the 'check' method on each object, as long as it
                 *   overrides any corresponding Default 'check' handler
                 */
                if (!defDo)
                    dobjCur_.(checkDobjProp)();
                if (!defIo)
                    iobjCur_.(checkIobjProp)();
            }
            catch (ExitSignal es)
            {
                /* mark the action as a failure in the transcript */
                gTranscript.noteFailure();

                /* re-throw the signal */
                throw es;
            }
        }

        /*
         *   Execute the command.
         */
        execAction()
        {
            local defIo, defDo;

            /* invoke the catch-all 'action' method on each object */
            defIo = callCatchAllProp(iobjCur_, actionIobjProp,
                                     &actionIobjDefault, &actionIobjAll);
            defDo = callCatchAllProp(dobjCur_, actionDobjProp,
                                     &actionDobjDefault, &actionDobjAll);

            /*
             *   Invoke the action method on each object, starting with the
             *   non-list object.  Call these only if the corresponding
             *   default 'action' methods didn't override the verb-specific
             *   methods.
             */
            if (execFirst == DirectObject)
            {
                if (!defDo)
                    dobjCur_.(actionDobjProp)();
                if (!defIo)
                    iobjCur_.(actionIobjProp)();
            }
            else
            {
                if (!defIo)
                    iobjCur_.(actionIobjProp)();
                if (!defDo)
                    dobjCur_.(actionDobjProp)();
            }
        }

        /* get the precondition descriptor list for the action */
        getPreCondDescList()
        {
            /*
             *   return the inherited preconditions plus the conditions that
             *   apply to the indirect object
             */
            return inherited()
                + getObjPreCondDescList(iobjCur_, preCondIobjProp, iobjCur_,
                                        IndirectObject);
        }

        /*
         *   Get a message parameter object for the action.  We define 'dobj'
         *   as the direct object and 'iobj' as the indirect object, in
         *   addition to any inherited targets.
         */
        getMessageParam(objName)
        {
            switch(objName)
            {
            case 'iobj':
                /* return the current indirect object */
                return iobjCur_;

            default:
                /* inherit default handling */
                return inherited(objName);
            }
        }

        /* get the current indirect object being executed */
        getIobj() { return iobjCur_; }

        /* get the full ResolveInfo associated with the current indirect object */
        getIobjInfo() { return iobjInfoCur_; }

        /* get the object resolution flags for the indirect object */
        getIobjFlags() { return iobjInfoCur_ != nil ? iobjInfoCur_.flags_ : 0; }

        /* get the number of direct objects */
        getIobjCount() { return iobjList_ != nil ? iobjList_.length() : 0; }

        /* get the original token list of the current indirect object phrase */
        getIobjTokens()
        {
            return iobjInfoCur_ != nil && iobjInfoCur_.np_ != nil
                ? iobjInfoCur_.np_.getOrigTokenList() : nil;
        }

        /* get the original words (as a list of strings) of the current iobj */
        getIobjWords()
        {
            local l = getIobjTokens();
            return l != nil ? l.mapAll({x: getTokOrig(x)}) : nil;
        }

        /*
         *   Get the list of active objects.  We have a direct and indirect
         *   object.
         */
        getCurrentObjects()
        {
            return [dobjCur_, iobjCur_];
        }

        /* set the current objects */
        setCurrentObjects(lst)
        {
            /* remember the current direct and indirect objects */
            dobjCur_ = lst[1];
            iobjCur_ = lst[2];

            /* we don't have ResolveInfo objects for this call */
            dobjInfoCur_ = iobjInfoCur_ = nil;
        }

        /*
         *   Copy one tentative object list to the other.  This is useful when
         *   an object's verifier for one TIAction wants to forward the call
         *   to the other object verifier for a different TIAction.
         */
        copyTentativeObjs()
        {
            /* copy whichever tentative list is populated to the other slot */
            if (tentativeDobj_ != nil)
                tentativeDobj_ = tentativeIobj_;
            else
                tentativeIobj_ = tentativeDobj_;
        }

        /*
         *   Get the tentative direct/indirect object resolution lists.  A
         *   tentative list is available for the later-resolved object while
         *   resolving the earlier-resolved object.
         */
        getTentativeDobj() { return tentativeDobj_; }
        getTentativeIobj() { return tentativeIobj_; }

        /*
         *   the predicate grammar must assign the indirect object production
         *   tree to iobjMatch
         */
        iobjMatch = nil

        /* the indirect object list */
        iobjList_ = []

        /* current indirect object being executed */
        iobjCur_ = nil

        /* the full ResolveInfo associated with iobjCur_ */
        iobjInfoCur_ = nil

        /* my cached indirect object resolver */
        iobjResolver_ = nil

        /*
         *   The tentative direct and indirect object lists.  A tentative list
         *   is available for the later-resolved object while resolving the
         *   earlier-resolved object.
         */
        tentativeDobj_ = nil
        tentativeIobj_ = nil

        /*
         *   Verification and action properties for the indirect object.  By
         *   convention, the verification method for the indirect object of a
         *   two-object action is verIobjXxx; the check method is
         *   checkIobjXxx; and the action method is actionIobjXxx.
         */
        verIobjProp = nil
        preCondIobjProp = nil
        checkIobjProp = nil
        actionIobjProp = nil

        /*
         *   Action-remap properties for the indirect object.  By convention,
         *   the remapper properties are named remapDobjAction and
         *   remapIobjAction, for the direct and indirect objects,
         *   respectively, where Action is replaced by the root name of the
         *   action.
         */
        remapIobjProp = nil
    ;

    /* ------------------------------------------------------------------------ */
    /*
     *   Common base class for actions involving literal phrases.  This is a
     *   mix-in class that can be combined with Action subclasses to create
     *   specific kinds of literal actions.
     */
    class LiteralActionBase: object
        /*
         *   Get a message parameter.  We define 'literal' as the text of the
         *   literal phrase, in addition to inherited targets.
         */
        getMessageParam(objName)
        {
            switch(objName)
            {
            case 'literal':
                /* return the text of the literal phrase */
                return text_;

            default:
                /* inherit default handling */
                return inherited(objName);
            }
        }

        /* manually set the resolved objects */
        setResolvedObjects(txt)
        {
            /* remember the literal text */
            text_ = txt;
        }

        /* manually set the pre-resolved match trees */
        setObjectMatches(lit)
        {
            /* if it's not already a PreResolvedLiteralProd, wrap it */
            if (!lit.ofKind(PreResolvedLiteralProd))
            {
                /* save the literal text */
                text_ = lit;

                /* wrap it in a match tree */
                lit = new PreResolvedLiteralProd(lit);
            }

            /* note the new literal match tree */
            literalMatch = lit;
        }

        /* get the current literal text */
        getLiteral() { return text_; }

        /* the text of the literal phrase */
        text_ = nil
    ;

    /* ------------------------------------------------------------------------ */
    /*
     *   An action with a literal phrase as its only object, such as "say <any
     *   text>".  We'll accept anything as the literal phrase - a number, a
     *   quoted string, or arbitrary words - and treat them all simply as text.
     *
     *   The grammar rules that produce these actions must set literalMatch to
     *   the literal phrase's match tree.
     *
     *   Because we don't have any actual resolved objects, we're based on
     *   IAction.  Subclasses that implement particular literal actions should
     *   override execAction() to carry out the action; this method can call
     *   the getLiteral() method of self to get a string giving the literal
     *   text.
     */
    class LiteralAction: LiteralActionBase, IAction
        /*
         *   Resolve objects.  We don't actually have any objects to resolve,
         *   but we do have to get the text for the literal phrase.
         */
        resolveNouns(issuingActor, targetActor, results)
        {
            /* the literal phrase counts as one noun slot */
            results.noteNounSlots(1);

            /*
             *   "Resolve" our literal phrase.  The literal phrase doesn't
             *   resolve to an object list the way a regular noun phrase would,
             *   but rather just resolves to a text string giving the original
             *   literal contents of the phrase.
             */
            literalMatch.resolveLiteral(results);

            /* retrieve the text of the phrase, exactly as the player typed it */
            text_ = literalMatch.getLiteralText(results, self, DirectObject);
        }

        /* we have a literal phrase as our only noun phrase */
        predicateNounPhrases = [&literalMatch]
    ;

    /* ------------------------------------------------------------------------ */
    /*
     *   An action with a direct object and a literal, such as "turn dial to
     *   <setting>" or "type <string> on keypad".  We'll accept anything as the
     *   literal phrase - a number, a quoted string, or arbitrary words - and
     *   treat them all simply as text.
     *
     *   The grammar rules that produce these actions must set dobjMatch to the
     *   resolvable object of the command, and must set literalMatch to the
     *   literal phrase's match tree.  Note that we use dobjMatch as the
     *   resolvable object even if the object serves grammatically as the
     *   indirect object - this is a simplification, and the true grammatical
     *   purpose of the object isn't important since there's only one true
     *   object in the command.
     *
     *   When referring to objects by role (such as in remapTo), callers should
     *   ALWAYS refer to the resolvable object as DirectObject, and the literal
     *   phrase as IndirectObject.
     *
     *   Each subclass must set the property whichMessageLiteral to the
     *   grammatical role (DirectObject, IndirectObject) the literal phrase
     *   plays for message generation purposes.  This only affects messages; it
     *   doesn't affect anything else; in particular, regardless of the
     *   whichMessageLiteral setting, callers should always refer to the
     *   literal as IndirectObject when calling getObjectForRole() and the
     *   like, and should always call getDobj() to get the resolved version of
     *   the resolvable object phrase.
     */
    class LiteralTAction: LiteralActionBase, TAction
        /*
         *   Resolve objects.
         */
        resolveNouns(issuingActor, targetActor, results)
        {
            /*
             *   the literal phrase counts as one noun slot, and the direct
             *   object as another
             */
            results.noteNounSlots(2);

            /*
             *   If the literal phrase serves as the direct object in generated
             *   messages, ask for its literal text first, so that we ask for
             *   it interactively first.  Otherwise, get the tentative literal
             *   text, in case it's useful to have in resolving the other
             *   object.
             */
            if (whichMessageLiteral == DirectObject)
                text_ = literalMatch.getLiteralText(results, self, DirectObject);
            else
                text_ = literalMatch.getTentativeLiteralText();

            /* resolve the direct object */
            dobjList_ = dobjMatch.resolveNouns(
                getDobjResolver(issuingActor, targetActor, true), results);

            /*
             *   "Resolve" the literal, ignoring the result - we call this so
             *   that the literal can do any scoring it wants to do during
             *   resolution; but since we're treating it literally, it
             *   obviously has no actual resolved value.
             */
            literalMatch.resolveLiteral(results);

            /* the literal phrase resolves to the text only */
            text_ = literalMatch.getLiteralText(results, self,
                                                whichMessageLiteral);
        }

        /* we have a direct object and a literal phrase */
        predicateNounPhrases = [&dobjMatch, &literalMatch]

        /* get an object role */
        getRoleFromIndex(idx)
        {
            /*
             *   index 2 is the literal object, which is always in the indirect
             *   object role; for others, inherit the default handling
             */
            return (idx == 2 ? IndirectObject : inherited(idx));
        }

        /* get the OtherObject role for the given role */
        getOtherObjectRole(role)
        {
            /* the complementary roles are DirectObject and IndirectObject */
            return (role == DirectObject ? IndirectObject : DirectObject);
        }

        /* get the resolved object in a given role */
        getObjectForRole(role)
        {
            /*
             *   the literal is in the IndirectObject role; inherit the default
             *   for others
             */
            return (role == IndirectObject ? text_ : inherited(role));
        }

        /* get the match tree for the given role */
        getMatchForRole(role)
        {
            /*
             *   the literal is in the IndirectObject role; inherit the default
             *   for anything else
             */
            return (role == IndirectObject ? literalMatch : inherited(role));
        }

        /* manually set the resolved objects */
        setResolvedObjects(dobj, txt)
        {
            /* inherit default TAction handling for the direct object */
            inherited TAction(dobj);

            /* inherit the LiteralActionBase handling for the literal text */
            inherited LiteralActionBase(txt);
        }

        /* manually set the pre-resolved match trees */
        setObjectMatches(dobj, lit)
        {
            /* inherit default TAction handling for the direct object */
            inherited TAction(dobj);

            /* inherit the default LiteralActionBase handling for the literal */
            inherited LiteralActionBase(lit);
        }

        /*
         *   Get a list of the current objects.  We include only the direct
         *   object here, since the literal text is not a resolved object but
         *   simply literal text.
         */
        getCurrentObjects() { return [dobjCur_]; }

        /* set the current objects */
        setCurrentObjects(lst)
        {
            dobjCur_ = lst[1];
            dobjInfoCur_ = nil;
        }

        /*
         *   Retry a single-object action as an action taking both an object
         *   and a literal phrase.  We'll treat the original action's direct
         *   object list as our direct object list, and obtain a literal
         *   phrase interactively.
         *
         *   This routine terminates with 'exit' if it doesn't throw some
         *   other error.
         */
        retryWithMissingLiteral(orig)
        {
            local action;

            /* create the new action based on the original action */
            action = createForRetry(orig);

            /* use an empty literal phrase for the new action */
            action.literalMatch = new EmptyLiteralPhraseProd();

            /* initialize for the missing literal phrase */
            action.initForMissingLiteral(orig);

            /* resolve and execute the replacement action */
            resolveAndReplaceAction(action);
        }

        /* initialize with a missing direct object phrase */
        initForMissingDobj(orig)
        {
            /*
             *   Since we have a missing direct objet, we must be coming from
             *   a LiteralAction.  The LiteralAction will already have a
             *   literal phrase, so copy it.  For example: WRITE HELLO ->
             *   WRITE HELLO ON <what>.
             */
            literalMatch = new PreResolvedLiteralProd(orig.getLiteral());
        }

        /* initialize for a missing literal phrase */
        initForMissingLiteral(orig)
        {
            local origDobj = orig.getDobj();

            /*
             *   Since we have a missing literal, we must be coming from a
             *   TAction.  The TAction will already have a direct object,
             *   which we'll want to keep as our own direct object.  For
             *   example: WRITE ON SLATE -> WRITE <what> ON SLATE.
             */
            dobjMatch = new PreResolvedProd(origDobj != nil
                                            ? origDobj : orig.dobjList_);
        }

        /* object role played by the literal phrase */
        whichMessageLiteral = nil

        /* -------------------------------------------------------------------- */
        /*
         *   Direct Object Resolver implementation.  We serve as our own
         *   direct object resolver, so we define any special resolver
         *   behavior here.
         */

        /*
         *   the true grammatical role of the resolved object is always the
         *   direct object
         */
        whichObject = DirectObject

        /*
         *   What we call our direct object might actually be playing the
         *   grammatical role of the indirect object - in order to inherit
         *   easily from TAction, we call our resolved object our direct
         *   object, regardless of which grammatical role it actually plays.
         *   For the most part it doesn't matter which is which; but for the
         *   purposes of our resolver, we actually do care about its real role.
         *   So, override the resolver method whichMessageObject so that it
         *   returns whichever role is NOT served by the topic object.
         */
        whichMessageObject =
            (whichMessageLiteral == DirectObject ? IndirectObject : DirectObject)
    ;

    /* ------------------------------------------------------------------------ */
    /*
     *   Base class for actions that include a "topic" phrase.  This is a
     *   mix-in class that can be used in different types of topic actions.  In
     *   all cases, the topic phrase must be assigned to the 'topicMatch'
     *   property in grammar rules based on this class.
     */
    class TopicActionBase: object
        /*
         *   Resolve the topic phrase.  This resolves the match tree in out
         *   'topicMatch' property, and stores the result in topicList_.  This
         *   is for use in resolveNouns().
         */
        resolveTopic(issuingActor, targetActor, results)
        {
            /* get the topic resolver */
            local resolver = getTopicResolver(issuingActor, targetActor, true);

            /* resolve the topic match tree */
            topicList_ = topicMatch.resolveNouns(resolver, results);

            /* make sure it's properly packaged as a ResolvedTopic */
            topicList_ = resolver.packageTopicList(topicList_, topicMatch);
        }

        /*
         *   Set the resolved topic to the given object list.  This is for use
         *   in setResolvedObjects().
         */
        setResolvedTopic(topic)
        {
            /* if the topic isn't given as a ResolvedTopic, wrap it in one */
            if (!topic.ofKind(ResolvedTopic))
                topic = ResolvedTopic.wrapObject(topic);

            /* use the match object from the ResolvedTopic */
            topicMatch = topic.topicProd;

            /* finally, make a ResolveInfo list out of the ResolvedTopic */
            topicList_ = makeResolveInfoList(topic);
        }

        /*
         *   Set the topic match tree.  This is for use in setObjectMatches().
         */
        setTopicMatch(topic)
        {
            /*
             *   If it's given as a ResolveInfo, wrap it in a PreResolvedProd.
             *   Otherwise, if it's not a topic match (a TopicProd object), and
             *   it has tokens, re-parse it as a topic match to make sure we
             *   get the grammar optimized for global scope.
             */
            if (topic.ofKind(ResolveInfo))
            {
                /* it's a resolved object, so wrap it in a fake match tree */
                topic = new PreResolvedProd(topic);
            }
            else if (!topic.ofKind(TopicProd))
            {
                /*
                 *   Re-parse it as a topic phrase.  If our dobj resolver knows
                 *   the actors, use those; otherwise default to the player
                 *   character.
                 */
                local issuer = (issuer_ != nil ? issuer_ : gPlayerChar);
                local target = (actor_ != nil ? actor_ : gPlayerChar);
                topic = reparseMatchAsTopic(topic, issuer, target);
            }

            /* save the topic match */
            topicMatch = topic;
        }

        /*
         *   Re-parse a match tree as a topic phrase.  Returns a TopicProd
         *   match tree, if possible.
         */
        reparseMatchAsTopic(topic, issuingActor, targetActor)
        {
            local toks;

            /* we can only proceed if the match tree has a token list */
            if ((toks = topic.getOrigTokenList()) != nil && toks.length() > 0)
            {
                /* parse it as a topic phrase */
                local match = topicPhrase.parseTokens(toks, cmdDict);

                /*
                 *   if we parsed it successfully, and we have more than one
                 *   match, get the best of the bunch
                 */
                if (match != nil && match.length() > 1)
                {
                    /* set up a topic resolver for the match */
                    local resolver = getTopicResolver(
                        issuingActor, targetActor, true);

                    /* sort it and return the best match */
                    return CommandRanking.sortByRanking(match, resolver)[1].match;
                }
                else if (match != nil && match.length() > 0)
                {
                    /* we found exactly one match, so use it */
                    return match[1];
                }
            }

            /*
             *   if we make it this far, we couldn't parse it as a topic, so
             *   just return the original
             */
            return topic;
        }

        /*
         *   get the topic resolver
         */
        getTopicResolver(issuingActor, targetActor, reset)
        {
            /* create one if we don't already have one */
            if (topicResolver_ == nil)
                topicResolver_ = createTopicResolver(issuingActor, targetActor);

            /* reset the resolver if desired */
            if (reset)
                topicResolver_.resetResolver();

            /* return the cached resolver */
            return topicResolver_;
        }

        /*
         *   Create the topic resolver.
         */
        createTopicResolver(issuingActor, targetActor)
        {
            return new TopicResolver(
                self, issuingActor, targetActor, topicMatch, whichMessageTopic,
                getTopicQualifierResolver(issuingActor, targetActor, nil));
        }

        /*
         *   Get a message parameter by name.  We'll return the topic for the
         *   keyword 'topic', and inherit the default handling for anything
         *   else.
         */
        getMessageParam(objName)
        {
            switch(objName)
            {
            case 'topic':
                /* return the topic */
                return getTopic();

            default:
                /* inherit default handling */
                return inherited(objName);
            }
        }

        /* get the current topic */
        getTopic()
        {
            /*
             *   Because the topic list always contains one entry (a
             *   ResolvedTopic object encapsulating the topic information),
             *   our current topic is always simply the first and only element
             *   of the topic list.
             */
            return topicList_[1].obj_;
        }

        /*
         *   Get the resolver for qualifiers we find in the topic phrase
         *   (qualifiers that might need resolution include things like
         *   possessive adjectives and locational phrases).
         */
        getTopicQualifierResolver(issuingActor, targetActor, reset)
        {
            /* if we don't already have a qualifier resolver, create one */
            if (topicQualResolver_ == nil)
                topicQualResolver_ = createTopicQualifierResolver(
                    issuingActor, targetActor);

            /* reset it if desired */
            if (reset)
                topicQualResolver_.resetResolver();

            /* return it */
            return topicQualResolver_;
        }

        /* the topic qualifier resolver */
        topicQualResolver_ = nil

        /* the resolved topic object list */
        topicList_ = nil

        /* my cached topic resolver */
        topicResolver_ = nil
    ;

    /* ------------------------------------------------------------------------ */
    /*
     *   An action with a topic phrase as its only object, such as "think about
     *   <topic>".
     *
     *   The grammar rules that produce these actions must set topicMatch to
     *   the topic match tree.
     *
     *   Because we don't have any actual resolved objects, we're based on
     *   IAction.  Subclasses that implement particular topic actions should
     *   override execAction() to carry out the action; this method can call
     *   the getTopic() method of self to get a string giving the topic.
     */
    class TopicAction: TopicActionBase, IAction
        /*
         *   Resolve objects.  We don't actually have any normal objects to
         *   resolve, but we do have to get the resolved topic phrase.
         */
        resolveNouns(issuingActor, targetActor, results)
        {
            /* the topic phrase counts as one noun slot */
            results.noteNounSlots(1);

            /* resolve the topic */
            resolveTopic(issuingActor, targetActor, results);
        }

        /* manually set the resolved objects */
        setResolvedObjects(topic)
        {
            /* set the resolved topic */
            setResolvedTopic(topic);
        }

        /* manually set the pre-resolved match trees */
        setObjectMatches(topic)
        {
            /* note the new topic match tree */
            setTopicMatch(topic);
        }

        /* we have a topic noun phrase */
        predicateNounPhrases = [&topicMatch]
    ;

    /* ------------------------------------------------------------------------ */
    /*
     *   An Action with a direct object and a topic, such as "ask <actor> about
     *   <topic>".  Topics differ from ordinary noun phrases in scope: rather
     *   than resolving to simulation objects based on location, we resolve
     *   these based on the actor's knowledge.
     *
     *   The grammar rules that produce these actions must set dobjMatch to the
     *   resolvable object of the command (the <actor> in "ask <actor> about
     *   <topic>"), and must set topicMatch to the topic match tree object,
     *   which must be a TopicProd object.  Note that, in some cases, the
     *   phrasing might make the dobjMatch the indirect object, grammatically
     *   speaking: "type <topic> on <object>"; even in such cases, use
     *   dobjMatch for the resolvable object.
     *
     *   When we resolve the topic, we will always resolve it to a single
     *   object of class ResolvedTopic.  This contains the literal tokens of
     *   the original command plus a list of simulation objects matching the
     *   topic name, ordered from best to worst.  This is different from the
     *   way most commands work, since we do not resolve the topic to a simple
     *   game world object.  We keep all of this extra information because we
     *   don't want to perform disambiguation in the normal fashion, but
     *   instead resolve as much as we can with what we're given, and then give
     *   the specialized action code as much information as we can to let the
     *   action code figure out how to respond to the topic.
     */
    class TopicTAction: TopicActionBase, TAction
        /*
         *   reset the action
         */
        resetAction()
        {
            /* reset the inherited state */
            inherited();

            /* forget our topic resolver */
            topicResolver_ = nil;
        }

        /*
         *   resolve our noun phrases to objects
         */
        resolveNouns(issuingActor, targetActor, results)
        {
            local dobjRes;

            /*
             *   the topic phrase counts as one noun slot, and the direct
             *   object as another
             */
            results.noteNounSlots(2);

            /* resolve the direct object, if we have one */
            if (dobjMatch != nil)
            {
                /* presume we won't find an unbound anaphor */
                needAnaphoricBinding_ = nil;

                /*
                 *   if the direct object phrase is an empty phrase, resolve
                 *   the topic first
                 */
                if (dobjMatch.isEmptyPhrase)
                    resolveTopic(issuingActor, targetActor, results);

                /* get the direct object resolver */
                dobjRes = getDobjResolver(issuingActor, targetActor, true);

                /* resolve the direct object */
                dobjList_ = dobjMatch.resolveNouns(dobjRes, results);

                /*
                 *   if that turned up an anaphor (LOOK UP BOOK IN ITSELF),
                 *   resolve the topic phrase as though it were the direct
                 *   object
                 */
                if (needAnaphoricBinding_ && topicMatch != nil)
                    dobjList_ = topicMatch.resolveNouns(dobjRes, results);
            }

            /* resolve the topic */
            resolveTopic(issuingActor, targetActor, results);
        }

        /*
         *   Filter the resolved topic.  This is called by our
         *   TActionTopicResolver, which refers the resolution back to us.
         */
        filterTopic(lst, np, resolver)
        {
            /* by default, simply put everything in an undifferentiated list */
            return new ResolvedTopic(lst, [], [], topicMatch);
        }

        /*
         *   Retry a single-object action as an action taking both an object
         *   and a topic phrase.  We'll treat the original action's direct
         *   object list as our direct object list, and we'll obtain a topic
         *   phrase interactively.
         *
         *   This routine terminates with 'exit' if it doesn't throw some other
         *   error.
         */
        retryWithMissingTopic(orig)
        {
            local action;

            /* create the new action based on the original action */
            action = createForRetry(orig);

            /* use an empty topic phrase for the new action */
            action.topicMatch = new EmptyTopicPhraseProd();

            /* initialize for the missing topic */
            action.initForMissingTopic(orig);

            /* resolve and execute the replacement action */
            resolveAndReplaceAction(action);
        }

        /* initialize a new action we're retrying for a missing direct object */
        initForMissingDobj(orig)
        {
            /*
             *   The original action must have been a TopicAction, so we
             *   already have a topic.  Simply copy the original topic to use
             *   as our own topic.  For example: ASK ABOUT BOOK -> ASK <whom>
             *   ABOUT BOOK.
             */
            topicMatch = new PreResolvedProd(orig.getTopic());
        }

        /* initialize for retrying with a missing topic phrase */
        initForMissingTopic(orig)
        {
            local origDobj = orig.getDobj();

            /*
             *   The original action must have been a TAction, so we already
             *   have a direct object.  Simply copy the original direct object
             *   for use as our own.  For example: ASK BOB -> ASK BOB ABOUT
             *   <what>.
             */
            dobjMatch = new PreResolvedProd(origDobj != nil
                                            ? origDobj : orig.dobjList_);
        }

        /* create our TAction topic resolver */
        createTopicResolver(issuingActor, targetActor)
        {
            return new TActionTopicResolver(
                self, issuingActor, targetActor, topicMatch, whichMessageTopic,
                getTopicQualifierResolver(issuingActor, targetActor, nil));
        }

        /*
         *   In the topic phrase, we can use an anaphoric pronoun to refer
         *   back to the direct object.  Since we resolve the direct object
         *   phrase first, we can simply return the direct object list as the
         *   binding.  If the direct object isn't resolved yet, make a note to
         *   come back and re-bind the anaphor.
         */
        getAnaphoricBinding(typ)
        {
            /* if we've already resolved the direct object phrase, return it */
            if (dobjList_ not in (nil, []))
                return dobjList_;

            /* no dobj yet - make a note that we need to re-bind the anaphor */
            needAnaphoricBinding_ = true;

            /*
             *   return an empty list for now to indicate that the anaphor is
             *   acceptable but has no binding yet
             */
            return [];
        }

        /*
         *   Flag: we have been asked for an anaphoric binding, but we don't
         *   have a binding available.  We'll check this after resolving the
         *   first-resolved noun phrase so that we can go back and re-resolve
         *   it again after resolving the other noun phrase.
         */
        needAnaphoricBinding_ = nil

        /* we have a direct object and a topic phrase */
        predicateNounPhrases = [&dobjMatch, &topicMatch]

        /* get an object role */
        getRoleFromIndex(idx)
        {
            /*
             *   index 2 is the topic object, which is always in the indirect
             *   object role; for others, inherit the default handling
             */
            return (idx == 2 ? IndirectObject : inherited(idx));
        }

        /* get the OtherObject role for the given role */
        getOtherObjectRole(role)
        {
            /* the complementary roles are DirectObject and IndirectObject */
            return (role == DirectObject ? IndirectObject : DirectObject);
        }

        /* get the resolved object in a given role */
        getObjectForRole(role)
        {
            /*
             *   the topic is in the IndirectObject role; inherit the default
             *   for others
             */
            return (role == IndirectObject ? getTopic() : inherited(role));
        }

        /* get the match tree for the given role */
        getMatchForRole(role)
        {
            /*
             *   the topic is in the IndirectObject role; inherit the default
             *   for anything else
             */
            return (role == IndirectObject ? topicMatch : inherited(role));
        }

        /*
         *   Manually set the resolved objects.  We'll set our direct and
         *   indirect objects.
         */
        setResolvedObjects(dobj, topic)
        {
            /* inherit default handling for the direct object */
            inherited(dobj);

            /* set the resolved topic */
            setResolvedTopic(topic);
        }

        /* manually set the pre-resolved match trees */
        setObjectMatches(dobj, topic)
        {
            /* inherit default handling for the direct object */
            inherited(dobj);

            /* note the new topic match tree */
            setTopicMatch(topic);
        }

        /*
         *   Get the list of active objects.  We return only our direct
         *   object, since our topic isn't actually a simulation object.
         */
        getCurrentObjects()
        {
            return [dobjCur_];
        }

        /* set the current objects */
        setCurrentObjects(lst)
        {
            dobjCur_ = lst[1];
            dobjInfoCur_ = nil;
        }

        /* the resolved topic object list */
        topicList_ = nil

        /* my cached topic resolver */
        topicResolver_ = nil

        /* grammatical role played by topic phrase in generated messages */
        whichMessageTopic = nil

        /* -------------------------------------------------------------------- */
        /*
         *   Direct Object Resolver implementation.  We serve as our own
         *   direct object resolver, so we define any special resolver
         *   behavior here.
         */

        /* the true role of the resolved object is always as the direct object */
        whichObject = DirectObject

        /*
         *   What we call our direct object might actually be playing the
         *   grammatical role of the indirect object - in order to inherit
         *   easily from TAction, we call our resolved object our direct
         *   object, regardless of which grammatical role it actually plays.
         *   For the most part it doesn't matter which is which; but for the
         *   purposes of our resolver, we actually do care about its real role.
         *   So, override the resolver method whichMessageObject so that it
         *   returns whichever role is NOT served by the topic object.
         */
        whichMessageObject = (whichMessageTopic == DirectObject
                              ? IndirectObject : DirectObject)
    ;

    /*
     *   "Conversation" TopicTAction.  Many TopicTAction verbs involve
     *   conversation with an actor, who's specified as the direct object: ASK
     *   <actor> ABOUT <topic>, TELL <actor> ABOUT <topic>, ASK <actor> FOR
     *   <topic>.  For these common cases, the most likely default direct
     *   object is the last interlocutor of the actor performing the command -
     *   that is, ASK ABOUT BOOK should by default be directed to whomever we
     *   were speaking to last.
     *
     *   This subclass is suitable for such verbs.  When asked for a default
     *   direct object, we'll check for a current interlocutor, and use it as
     *   the default if available.  If no interlocutor is available, we'll
     *   inherit the standard default handling.
     */
    class ConvTopicTAction: TopicTAction
        getDefaultDobj(np, resolver)
        {
            /*
             *   check to see if the actor has a default interlocutor; if so,
             *   use it as the default actor to be addressed here, otherwise
             *   use the default handling
             */
            local obj = resolver.getTargetActor().getCurrentInterlocutor();
            if (obj != nil)
                return [new ResolveInfo(obj, 0, nil)];
            else
                return inherited(np, resolver);
        }

        /*
         *   Create the topic resolver.  Use a conversational topic resolver
         *   for this type of action.
         */
        createTopicResolver(issuingActor, targetActor)
        {
            return new ConvTopicResolver(
                self, issuingActor, targetActor, topicMatch, whichMessageTopic,
                getTopicQualifierResolver(issuingActor, targetActor, nil));
        }
    ;

    /* ------------------------------------------------------------------------ */
    /*
     *   A conversational intransitive action.  This class is for actions such
     *   as Hello, Goodbye, Yes, No - conversational actions that don't involve
     *   any topics or other objects, but whose expression is entirely
     *   contained in the verb.
     */
    class ConvIAction: IAction
        /* this action is conversational */
        isConversational(issuer) { return true; }
    ;

    /* ------------------------------------------------------------------------ */
    /*
     *   Resolved Topic object.  The topic of a TopicTAction always resolves to
     *   one of these objects.
     */
    class ResolvedTopic: object
        construct(inScope, likely, others, prod)
        {
            /*
             *   Remember our lists of objects.  We keep three separate lists,
             *   so that the action knows how we've classified the objects
             *   matching our phrase.  We keep a list of objects that are in
             *   scope; a list of objects that aren't in scope but which the
             *   actor thinks are likely topics; and a list of all of the other
             *   matches.
             *
             *   We keep only the simulation objects in these retained lists -
             *   we don't keep the full ResolveInfo data here.
             */
            inScopeList = inScope.mapAll({x: x.obj_});
            likelyList = likely.mapAll({x: x.obj_});
            otherList = others.mapAll({x: x.obj_});

            /* keep the production match tree */
            topicProd = prod;

            /*
             *   But it might still be interesting to have the ResolveInfo
             *   data, particularly for information on the vocabulary match
             *   strength.  Keep that information in a separate lookup table
             *   indexed by simulation object.
             */
            local rt = new LookupTable();
            others.forEach({x: rt[x.obj_] = x});
            likely.forEach({x: rt[x.obj_] = x});
            inScope.forEach({x: rt[x.obj_] = x});

            /* save the ResolvedInfo lookup table */
            resInfoTab = rt;
        }

        /*
         *   Static method: create a ResolvedTopic to represent an object
         *   that's already been resolved to a game object for the current
         *   action.  'role' is the object role to wrap (DirectObject,
         *   IndirectObject, etc).
         */
        wrapActionObject(role)
        {
            local rt;

            /* create a ResolvedTopic with just the match tree */
            rt = new ResolvedTopic([],  [], [], gAction.getMatchForRole(role));

            /*
             *   add the current resolved object in the role as the one
             *   in-scope match
             */
            rt.inScopeList += gAction.getObjectForRole(role);

            /* return the ResolvedTopic wrapper */
            return rt;
        }

        /*
         *   Static method: create a ResolvedTopic to represent the given
         *   object.
         */
        wrapObject(obj)
        {
            local rt;

            /* create a ResolvedTopic with a PreResolvedProd for the object */
            rt = new ResolvedTopic([], [], [], new PreResolvedProd(obj));

            /* add the given object or objects as the in-scope match list */
            rt.inScopeList += obj;

            /* return the ResolvedTopic wrapper */
            return rt;
        }

        /*
         *   Get the best object match to the topic.  This is a default
         *   implementation that can be changed by game authors or library
         *   extensions to implement different topic-matching strategies.  This
         *   implementation simply picks an object arbitrarily from the
         *   "strongest" of the three lists we build: if there's anything in
         *   the inScopeList, we choose an object from that list; otherwise, if
         *   there's anything in the likelyList, we choose an object from that
         *   list; otherwise we choose an object from the otherList.
         */
        getBestMatch()
        {
            /* if there's an in-scope match, pick one */
            if (inScopeList.length() != 0)
                return inScopeList[1];

            /* nothing's in scope, so try to pick a likely match */
            if (likelyList.length() != 0)
                return likelyList[1];

            /*
             *   there's not even anything likely, so pick an "other", if
             *   there's anything in that list
             */
            if (otherList.length() != 0)
                return otherList[1];

            /* there are no matches at all - return nil */
            return nil;
        }

        /*
         *   Is the given object among the possible matches for the topic?
         */
        canMatchObject(obj)
        {
            return inScopeList.indexOf(obj) != nil
                || likelyList.indexOf(obj) != nil
                || otherList.indexOf(obj) != nil;
        }

        /* get the original text of the topic phrase */
        getTopicText() { return topicProd.getOrigText(); }

        /*
         *   Are we allowed to match the topic text literally, for parsing
         *   purposes?  If this is true, it means that we can match the literal
         *   text the player entered against strings, regular expressions,
         *   etc.; for example, we can match a TopicMatchTopic's matchPattern
         *   regular expression.  If this is nil, it means that we can only
         *   interpret the meaning of the resolved topic by looking at the
         *   various topic match lists (inScopeList, likelyList, otherList).
         *
         *   By default, we simply return true.  Note that the base library
         *   never has any reason of its own to disallow literal matching of
         *   topic text; this property is purely for the use of language
         *   modules, to handle language-specific input that parses at a high
         *   level as a topic phrase but which has some idiomatic or
         *   grammatical function that makes it in appropriate to try to
         *   extract the meaning of the resolved topic from the literal text of
         *   the topic phrase in isolation.  This case doesn't seem to arise in
         *   English, but does occur in other languages: Michel Nizette cites
         *   "parlez-en a Bob" as an example in French, where "en" is
         *   essentially a particle modifying the verb, not a full-fledged
         *   phrase that we can interpret separately as a topic.
         */
        canMatchLiterally = true

        /*
         *   get the original tokens of the topic phrase, in canonical
         *   tokenizer format
         */
        getTopicTokens() { return topicProd.getOrigTokenList(); }

        /*
         *   get the original word strings of the topic phrase - this is
         *   simply a list of the original word strings (in their original
         *   case), without any of the extra information of the more
         *   complicated canonical tokenizer format
         */
        getTopicWords()
        {
            /* return just the original text strings from the token list */
            return topicProd.getOrigTokenList().mapAll({x: getTokOrig(x)});
        }

        /*
         *   Get the parser ResolveInfo object for a given matched object.
         *   This recovers the ResolveInfo describing the parsing result for
         *   any object in the resolved object lists (inScopeList, etc).
         */
        getResolveInfo(obj) { return resInfoTab[obj]; }

        /*
         *   Our lists of resolved objects matching the topic phrase,
         *   separated by classification.
         */
        inScopeList = nil
        likelyList = nil
        otherList = nil

        /*
         *   The production match tree object that matched the topic phrase in
         *   the command.  This can be used to obtain the original tokens of
         *   the command or the original text of the phrase.
         */
        topicProd = nil

        /*
         *   ResolveInfo table for the resolved objects.  This is a lookup
         *   table indexed by simulation object.  Each entry in the resolved
         *   object lists (inScopeList, etc) has have a key in this table, with
         *   the ResolveInfo object as the value for the key.  This can be used
         *   to recover the ResolveInfo object describing the parser results
         *   for this object.
         */
        resInfoTab = nil
    ;

    /*
     *   A special topic for "nothing."  It's occasionally useful to be able
     *   to construct a TopicTAction with an empty topic phrase.  For the
     *   topic phrase to be well-formed, we need a valid ResolvedTopic object,
     *   even though it won't refer to anything.
     */
    resolvedTopicNothing: ResolvedTopic
        inScopeList = []
        likelyList = []
        otherList = []

        getTopicText() { return ''; }
        getTopicTokens() { return []; }
        getTopicWords() { return []; }
    ;

    /*
     *   Topic Resolver
     */
    class TopicResolver: Resolver
        construct(action, issuingActor, targetActor, prod, which,
                  qualifierResolver)
        {
            /* inherit the base class constructor */
            inherited(action, issuingActor, targetActor);

            /* the topic phrase doesn't have a true resolved role */
            whichObject = nil;

            /* remember the grammatical role of our object in the command */
            whichMessageObject = which;

            /* remember our topic match tree */
            topicProd = prod;

            /* remember the resolver for qualifier phrases */
            qualifierResolver_ = qualifierResolver;
        }

        resetResolver()
        {
            /* inherit the default handling */
            inherited();

            /* reset our qualifier resolver as well */
            qualifierResolver_.resetResolver();
        }

        /*
         *   package a resolved topic list - if it's not already represented as
         *   a ResolvedTopic object, we'll apply that wrapping
         */
        packageTopicList(lst, match)
        {
            /*
             *   if the topic is other than a single ResolvedTopic object, run
             *   it through the topic resolver's ambiguous noun phrase filter
             *   to get it into that canonical form
             */
            if (lst != nil
                && (lst.length() > 1
                    || (lst.length() == 1 && !lst[1].obj_.ofKind(ResolvedTopic))))
            {
                /* it's not in canonical form, so get it in canonical form now */
                lst = filterAmbiguousNounPhrase(lst, 1, match);
            }

            /* return the result */
            return lst;
        }

        /* our qualifier resolver */
        qualifierResolver_ = nil

        /* get our qualifier resolver */
        getQualifierResolver() { return qualifierResolver_; }
        getPossessiveResolver() { return qualifierResolver_; }

        /*
         *   Determine if the object is in scope.  We consider any vocabulary
         *   match to be in scope for the purposes of a topic phrase, since the
         *   subject matter of topics is mere references to things, not the
         *   things themselves; we can, for example, ASK ABOUT things that
         *   aren't physically present, or even about completely abstract
         *   ideas.
         */
        objInScope(obj) { return true; }

        /*
         *   our scope is global, because we don't limit the scope to the
         *   physical senses
         */
        isGlobalScope = true

        /*
         *   Determine if an object is in physical scope.  We'll accept
         *   anything that's in physical scope, and we'll also accept any topic
         *   object that the actor knows about.
         *
         *   Note that this isn't part of the basic Resolver interface.  It's
         *   instead provided as a service routine for our subclasses, so that
         *   they can easily determine the physical scope of an object if
         *   needed.
         */
        objInPhysicalScope(obj)
        {
            /*
             *   it's in physical scope, or if the actor knows about it as a
             *   topic, it's in scope
             */
            return (scope_.indexOf(obj) != nil);
        }

        /*
         *   Filter an ambiguous noun phrase list using the strength of
         *   possessive qualification, if any.  For a topic phrase, we want to
         *   keep all of the possibilities.
         */
        filterPossRank(lst, num)
        {
            return lst;
        }

        /*
         *   Filter an ambiguous noun list.
         *
         *   It is almost always undesirable from a user interface perspective
         *   to ask for help disambiguating a topic phrase.  In the first
         *   place, since all topics tend to be in scope all the time, we
         *   might reveal too much about the inner model of the story if we
         *   were to enumerate all of the topic matches to a phrase.  In the
         *   second place, topics are used in conversational contexts, so it
         *   almost never make sense for the parser to ask for clarification -
         *   the other member of the conversation might ask, but not the
         *   parser.  So, we'll always filter the list to the required number,
         *   even if it means we choose arbitrarily.
         *
         *   As a first cut, we prefer objects that are physically in scope to
         *   those not in scope: if the player is standing next to a control
         *   panel and types "ask bob about control panel," it makes little
         *   sense to consider any other control panels in the simulation.
         *
         *   As a second cut, we'll ask the actor to filter the list.  Games
         *   that keep track of the actor's knowledge can use this to filter
         *   according to topics the actor is likely to know about.
         */
        filterAmbiguousNounPhrase(lst, requiredNum, np)
        {
            /* ask the action to create the ResolvedTopic */
            local rt = resolveTopic(lst, requiredNum, np);

            /* wrap the ResolvedTopic in the usual ResolveInfo list */
            return [new ResolveInfo(rt, 0, np)];
        }

        /*
         *   Resolve the topic phrase.  This returns a ResolvedTopic object
         *   encapsulating the resolution of the phrase.
         *
         *   This default base class implementation simply creates a resolved
         *   topic list with the whole set of possible matches
         *   undifferentiated.  Subclasses for specialized actions might want
         *   to differentiate the items in the list, based on things like the
         *   actor's knowledge so far or what's in physical scope.
         */
        resolveTopic(lst, requiredNum, np)
        {
            /* return a ResolvedTopic that lumps everything in the main list */
            return new ResolvedTopic(lst, [], [], topicProd);
        }

        /*
         *   Resolve an unknown phrase.  We allow unknown words to be used in
         *   topics; we simply return a ResolvedTopic that doesn't refer to
         *   any simulation objects at all.
         */
        resolveUnknownNounPhrase(tokList)
        {
            /*
             *   Create our ResolvedTopic object for the results.  We have
             *   words we don't know, so we're not referring to any objects,
             *   so our underlying simulation object list is empty.
             */
            local rt = new ResolvedTopic([], [], [], topicProd);

            /* return a resolved topic object with the empty list */
            return [new ResolveInfo(rt, 0, new TokenListProd(tokList))];
        }

        /* filter a plural */
        filterPluralPhrase(lst, np)
        {
            /*
             *   Handle this the same way we handle an ambiguous noun phrase,
             *   so that we yield only one object.  Topics are inherently
             *   singular; we'll allow asking about a grammatically plural
             *   term, but we'll turn it into a single topic result.
             */
            return filterAmbiguousNounPhrase(lst, 1, np);
        }

        /* get a default object */
        getDefaultObject(np)
        {
            /* there is never a default for a topic */
            return nil;
        }

        /* it's fine not to match a topic phrase */
        noVocabMatch(action, txt) { }
        noMatch(action, txt) { }
        noMatchPoss(action, txt) { }

        /* we don't allow ALL or provide defaults */
        getAll(np) { return []; }
        getAllDefaults() { return []; }

        /* the production match tree for the topic phrase we're resolving */
        topicProd = nil
    ;

    /*
     *   A topic resolver specialized for TopicTActions - actions involving a
     *   topic and a physical object, such as CONSULT ABOUT.  For these topics,
     *   we'll let the action handle the resolution.
     */
    class TActionTopicResolver: TopicResolver
        resolveTopic(lst, requiredNum, np)
        {
            /* let the action handle it */
            return action_.filterTopic(lst, np, self);
        }
    ;

    /*
     *   A topic resolver specialized for conversational actions (ASK ABOUT,
     *   TELL ABOUT, etc).  When we resolve the topic, we'll differentiate the
     *   resolution to differentiate based on the knowledge of the actor who's
     *   performing the command.
     */
    class ConvTopicResolver: TopicResolver
        /*
         *   Resolve the topic phrase.  We'll break up the vocabulary matches
         *   into three sublists: the objects that are either in physical scope
         *   or known to the actor performing the command; objects that the
         *   actor considers likely topics; and everything else.
         */
        resolveTopic(lst, requiredNum, np)
        {
            local inScope;
            local actorPrefs;

            /*
             *   First, get the subset of items that are in conversational
             *   scope - we'll consider this the best set of matches.
             */
            inScope = lst.subset({x: objInConvScope(x.obj_)});

            /*
             *   eliminate the in-scope items from the list, so we can
             *   consider only what remains
             */
            lst -= inScope;

            /*
             *   ask the actor to pick out the most likely set of topics from
             *   the ones that remain
             */
            actorPrefs = lst.subset({x: actor_.isLikelyTopic(x.obj_)});

            /* eliminate those items from the list */
            lst -= actorPrefs;

            /* create our ResolvedTopic object and return it */
            return new ResolvedTopic(inScope, actorPrefs, lst, topicProd);
        }

        /*
         *   Determine if an object is in "conversational" scope - this returns
         *   true if the object is in physical scope or it's known to the actor
         *   performing the command.
         */
        objInConvScope(obj)
        {
            /*
             *   if it's in physical scope, or the actor knows about it, it's
             *   in conversation scope
             */
            return (objInPhysicalScope(obj) || actor_.knowsTopic(obj));
        }
    ;

    /* ------------------------------------------------------------------------ */
    /*
     *   System action.  These actions are for out-of-game meta-verbs (save,
     *   restore, undo).  These verbs take no objects, must be performed by
     *   the player (thus by the player character, not an NPC), and consume no
     *   game clock time.
     */
    class SystemAction: IAction
        /* execute the action */
        execAction()
        {
            /*
             *   Conceptually, system actions are performed by the player
             *   directly, not by any character in the game (not even the
             *   player character).  However, we don't distinguish in the
             *   command-entry user interface between a command the player is
             *   performing and a command to the player character, hence we
             *   can merely ensure that the command is not directed to a
             *   non-player character.
             */
            if (!gActor.isPlayerChar)
            {
                gLibMessages.systemActionToNPC();
                exit;
            }

            /*
             *   system actions sometimes need to prompt for interactive
             *   responses, so deactivate the report list - this will allow
             *   interactive prompts to be shown immediately, not treated as
             *   reports to be deferred until the command is finished
             */
            gTranscript.showReports(true);
            gTranscript.clearReports();

            /* perform our specific action */
            execSystemAction();

            /* re-activate the transcript for the next command */
            gTranscript.activate();
        }

        /* each subclass must override this to perform its actual action */
        execSystemAction() { }

        /*
         *   Ask for an input file.  We call the input manager, which freezes
         *   the real-time clock, displays the appropriate local file selector
         *   dialog, and restarts the clock.
         */
        getInputFile(prompt, dialogType, fileType, flags)
        {
            return inputManager.getInputFile(prompt, dialogType, fileType, flags);
        }

        /* system actions consume no game time */
        actionTime = 0
    ;

    /* ------------------------------------------------------------------------ */
    /*
     *   An exception class for remappings that we can't handle.
     */
    class ActionRemappingTooComplexError: Exception
    ;

TADS 3 Library Manual
Generated on 5/16/2013 from TADS version 3.1.3