# parser.t | documentation

    #charset "us-ascii"
    #include "advlite.h"

    /* ------------------------------------------------------------------------ */
    /*
     *   Temporary scaffolding for the game world.  This gives us information
     *   on scope, pronoun antecedents, and other information the parser needs
     *   from the game world.
     */
    World: PreinitObject
        /*
         *   Get the list of objects in scope
         */
        scope()
        {
            local s = scope_;

            if (s == nil)
                scope_ = s = Q.scopeList(gPlayerChar);

            return s;
        }

        /* cached scope list */
        scope_ = nil

        /*
         *   A list of all Mentionables in the game, useful for building scope lists
         *   for resolving Topics.
         */
        universalScope = nil

        buildUniversalScope()
        {
            local vec = new Vector(100);
            forEachInstance(Mentionable, {o: vec.append(o) });
            universalScope = vec.toList;
        }

        execute()
        {
            buildUniversalScope();
        }

    ;

    /* ------------------------------------------------------------------------ */
    /*
     *   Parser is the class that implements the main parsing procedure, namely
     *   taking a line of text from the player, figuring out what it means, and
     *   executing it.
     *
     *   The conventional IF parsing loop simply consists of reading a line of
     *   text from the player, calling Parser.parse() on the string, and
     *   repeating.
     *
     *   In most cases you'll just need a single Parser instance.  The Parser
     *   object keeps track of unfinished commands, such as when we need to ask
     *   for disambiguation help or for a missing object.  If for some reason
     *   you want to keep multiple sets of this kind of state (reading input
     *   from more than one player, for example), you can create as many Parser
     *   instances as needed.
     */
    class Parser: object
        /*
         *   Auto-Look: Should we treat an empty command line (i.e., the user
         *   just presses Return) as a LOOK AROUND command?
         *
         *   The traditional handling since the Infocom era has always been to
         *   treat an empty command line as a parsing error, and display an
         *   error message along the lines of "I beg your pardon?".  Given that
         *   an empty command line has no conflicting meaning, though, we
         *   *could* assign it a meaning.
         *
         *   But what meaning should that be?  A blank line is the simplest
         *   possible command for a player to enter, so it would make sense to
         *   define it as some very commonly used command.  It's also fairly
         *   easy to enter a blank line accidentally (which is partly why the
         *   traditional reply is an error message), so the command should be
         *   benign - it shouldn't be a problem to enter it unintentionally.
         *   It can't be anything with parallel verbs, like NORTH, since then
         *   there'd be no good reason to pick NORTH instead of, say, SOUTH.
         *   Finally, it has to be intransitive, since it obviously won't
         *   involve an object name.  The obvious candidates that fit all of
         *   these criteria are LOOK and INVENTORY.  LOOK is probably the more
         *   useful and the more frequently used of the two, so it's the one we
         *   choose by default.
         *
         *   If this property is set to true, we'll perform a LOOK AROUND
         *   command when the player enters a blank command line.  If nil,
         *   we'll show an error message.
         */
        autoLook = true

        /*
         *   Default Actions: Should we treat a command line that consists entirely
         *   of a single noun phrase to be a "Default Action" on the named object?
         *   The precise meaning of the default action varies by object.  For most
         *   objects, it's EXAMINE.  For locations, it's GO TO.
         *
         *   We make the default value nil since setting it to true can result in
         *   some rather odd parser behaviour.
         */

        defaultActions = true

        /*
         *   Should we attempt automatic spelling correction?  If this is true, whenever a command
         *   fails, we'll check for a word that we don't recognize; if we find one, we'll try applying
         *   spelling correction to see if we can come up with a working command.
         *
         *   Our spelling correction algorithm is designed to be quite conservative.  In particular, we
         *   generally limit candidates for "correct" words to the vocabulary for objects that are
         *   actually in scope, which avoids revealing the existence of objects that haven't been seen
         *   yet; and we only apply a correction when it yields a command that parses and resolves
         *   correctly.  When we can't correct a command and get something resolvable, we don't even
         *   mention that we tried.  This avoids the bizarre, random guesses at "corrections" that often
         *   show up in other applications, and more importantly avoids giving away information that the
         *   player shouldn't know yet.
         *
         *   We set this to true by default, in an attempt to reduce the player's typing workload by
         *   automatically correcting simple typos when possible.  If for some reason the spelling
         *   corrector is problematic in a particular game, you can disable it by setting this property
         *   to nil.
         *
         *   As an experiment, change the default value to be nil when we're in a conversation and true
         *   otherwise, since over-zealous spelling corrections can be particularly troublesome in a
         *   conversational context.
         */
        autoSpell = (gPlayerChar.currentInterlocutor == nil)

        /*
         *   Maximum spelling correction time, in milliseconds.  The spelling
         *   correction process is iterative, and each iteration involves a new
         *   parsing attempt.  On a fast machine this doesn't tend to be
         *   noticeable, but it's conceivable that a pathological case could
         *   involve a large number of attempts that could be noticeably slow
         *   on an older machine.  To avoid stalling the game while we
         *   overanalyze the spelling possibilities, we set an upper bound to
         *   the actual elapsed time for spelling correction.  Each time we
         *   consider a new correction candidate, we'll check the elapsed time,
         *   and abort the process if it exceeds this limit.  Note that this
         *   limit doesn't limit the parsing time itself - we'll never
         *   interrupt that mid-stream.
         */
        spellTimeLimit = 250

        /*
         *   When the parser doesn't recognize a word, should it say so?  If
         *   this property is set to true, when parsing fails, we'll scan the
         *   command line for a word that's not in the dictionary and show a
         *   message such as "I don't know the word <foo>."  If this property
         *   is nil, the parser will instead simply say that it doesn't
         *   recognize the syntax, or that the object in question isn't
         *   present, without saying specifically which word wasn't recognized,
         *   or indeed even admitting that there was such a thing.
         *
         *   There are two schools of thought on this, both concerned with
         *   optimizing the user experience.
         *
         *   The first school holds that the parser's job is to be as helpful
         *   as possible.  First and foremost, that means we should understand
         *   the user's input as often as possible.  But when we can't, it
         *   means that we should be do our best to explain what we didn't
         *   understand, to help the user formulate a working command next
         *   time.  In the case of a word the parser doesn't recognize, we can
         *   be pretty sure that the unknown word is the reason we can't
         *   understand the input.  The best way to help the user correct the
         *   problem is to let them know exactly which word we didn't know,
         *   rather than make them guess at what we didn't understand.  This is
         *   the way the classic Infocom games worked, and it's the traditional
         *   TADS default as well.
         *
         *   The second school holds that the user's overriding interest is
         *   maintaining suspension of disbelief, and that the parser should do
         *   its best not to interfere with that.  A major aspect of this in IF
         *   the illusion that the game world is as boundless as the real
         *   world.  Missing dictionary words tend to break this illusion: if
         *   the user types EXAMINE ZEBRA, and the parser replies that it
         *   doesn't know the word "zebra", we've suddenly exposed a limit of
         *   the game world.  If we instead play coy and simply say that
         *   there's no zebra currently present, we allow the player to imagine
         *   that a zebra might yet turn up.  This is the way Inform games
         *   typically work.
         *
         *   Each approach has its advantages and disadvantages, adherents and
         *   detractors, and it seems that neither one is objectively "right".
         *   It comes down to taste.  But there seems to be a clear preference
         *   among the majority of players in the modern era for the second
         *   approach.  The key factor is probably that typical IF commands are
         *   so short that it's easy enough to spot a typo without help from
         *   the parser, so the clarity benefits of "unknown word" messages
         *   seem considerably outweighed by the harm they do to the illusion
         *   of boundlessness.  So, our default is the second option, playing
         *   coy.
         */
        showUnknownWords = nil

        /*
         *   Parse and execute a command line.  This is the main parsing
         *   routine.  We take the text of a command line, parse it against the
         *   grammar defined in the language module, resolve the noun phrases
         *   to game-world objects, and execute the action.  If the command
         *   line has more than one verb phrase, we repeat the process for each
         *   one.
         *
         *   'str' is the text of the command line, as entered by the player.
         */
        parse(str)
        {
            /* tokenize the input */
            local toks;
            try
            {
                /* run the command tokenizer over the input string */
                toks = cmdTokenizer.tokenize(str);

                /* Dispose of any unwanted terminal punctuation */
                while(toks.length > 0 && getTokType(toks[toks.length]) == tokPunct)
                    toks = toks.removeElementAt(toks.length);

            }
            catch (TokErrorNoMatch err)
            {
                /*
                 *   The tokenizer found a character (usually a punctuation
                 *   mark) that doesn't fit any of the token rules.
                 */
                DMsg(token error, 'I don\'t understand the punctuation {1}',
                     err.curChar_);

                /* give up on the parse */
                return;
            }

            /*
             *   Assume initially that the actor is the player character, but only
             *   if we don't have a question, since if the player is replying to a
             *   question the actor may already have been resolved.
             */
            if(question == nil)
                gActor = gPlayerChar;

            /* no spelling corrections have been attempted yet */
            local history = new transient SpellingHistory(self);

            /* we're starting with the first command in the string */
            local firstCmd = true;

            /* parse the tokens */
            try
            {
                /* if there are no tokens, simply perform the empty command */
                if (toks.length() == 0)
                {
                    /*
                     *   this counts as a new command, so forget any previous
                     *   question or typo information
                     */
                    question = nil;
                    lastTokens = nil;

                    /* process an empty command */
                    emptyCommand();

                    /* we're done */
                    return;
                }

                /* check for an OOPS command */
                local lst = oopsCommand.parseTokens(toks, cmdDict);
                if (lst.length() != 0)
                {
                    /* this only works if we have an error to correct */
                    local ui;
                    if (lastTokens == nil
                        || (ui = spellingCorrector.findUnknownWord(lastTokens))
                            == nil)
                    {
                        /* OOPS isn't available - throw an error */
                        throw new CantOopsError();
                    }

                    /* apply the correction, and proceed to parse the result */
                    toks = OopsProduction.applyCorrection(lst[1], lastTokens, ui);
                }

                /*
                 *   Parse each predicate in the command line, until we run out
                 *   of tokens.  The beginning of a whole new command line is
                 *   definitely the beginning of a sentence, so start parsing
                 *   with firstCommandPhrase.
                 */
                for (local root = firstCommandPhrase ; toks.length() != 0 ; )
                {
                    /* we don't have a parse list yet */
                    local cmdLst = nil;

                    /*
                     *   we haven't found a resolution error in a non-command
                     *   parsing yet
                     */
                    local qErr = nil, defErr = nil;

                    /*
                     *   If we have an outstanding question, and it takes
                     *   priority over interpreting input as a new command, try
                     *   parsing the input against the question.  Only do this
                     *   on the first command on the line - a question answer
                     *   has to be the entire input, so if we've already parsed
                     *   earlier commands on the same line, this definitely
                     *   isn't an answer to a past question.
                     */
                    if (firstCmd && question != nil && question.priority)
                    {
                        /* try parsing against the Question */
                        local l = question.parseAnswer(toks, cmdDict);

                        /* if it parsed and resolved, this is our command */
                        if (l != nil && l.cmd != nil)
                            cmdLst = l;

                        /* if it parsed but didn't resolved, note the error */
                        if (l != nil)
                            qErr = l.getResErr();
                    }

                    /*
                     *   if the question didn't grab it, try parsing as a whole
                     *   new command against the ordinary command grammar
                     */
                    if (cmdLst == nil || cmdLst.cmd == nil)
                    {
                        cmdLst = new CommandList(
                            root, toks, cmdDict, { p: new Command(p) });
                    }

                    /*
                     *   If we didn't find any resolvable commands, and this is
                     *   the first command, check to see if it's an answer to
                     *   an outstanding query.  We only check this if the
                     *   regular grammar parsing fails, because anything that
                     *   looks like a valid new command overrides a past query.
                     *   This is important because some of the short, common
                     *   commands sometimes can look like noun phrases, so we
                     *   explicitly give preference to interpreting these as
                     *   brand new commands.
                     */
                    if (cmdLst.cmd == nil
                        && firstCmd
                        && question != nil
                        && !question.priority)
                    {
                        /* try parsing against the Question */
                        local l = question.parseAnswer(toks, cmdDict);

                        /* if it parsed and resolved, this is our command */
                        if (l != nil && l.cmd != nil)
                            cmdLst = l;

                        /* if it parsed but didn't resolved, note the error */
                        if (l != nil)
                            qErr = l.getResErr();
                    }

                    /*
                     *   If we don't have a command yet, and this is the first
                     *   command on the line, handle it as a conversational command
                     *   if conversation is in progress; otherwise if default
                     *   actions are enabled, check to see if the command looks like
                     *   a single noun phrase.  If so, handle it as the default
                     *   action on the noun.
                     */
                    if (cmdLst.cmd == nil
                        && firstCmd)
                    {
                        local l;

                        /*
                         *   If a conversation is in progress parse the command line
                         *   as the single topic object phrase of a Say command,
                         *   provided that the first word on the command line
                         *   doesn't match a possible action.
                         */

                        if(gPlayerChar.currentInterlocutor != nil
                           && cmdLst.length == 0
                           && Q.canTalkTo(gPlayerChar,
                                          gPlayerChar.currentInterlocutor)
                           && str.find(',') == nil
                           && gPlayerChar.currentInterlocutor.allowImplicitSay())
                        {
                             l = new CommandList(
                                topicPhrase, toks, cmdDict,
                                { p: new Command(SayAction, p) });

                            libGlobal.lastCommandForUndo = str;
                            savepoint();
                        }
                        /*
                         *   If the player char is not in conversation with anyone,
                         *   or the first word of the command matches a possible
                         *   command verb, then try parsing the command line as a
                         *   single direct object phrase for the DefaultAction verb,
                         *   provided defaultActions are enabled (which they aren't
                         *   by default).
                         */
                        else if(defaultActions)
                            l = new CommandList(
                                defaultCommandPhrase, toks, cmdDict,
                                { p: new Command(p) });

                        /* accept a curable reply */
                        if (l != nil && l.acceptCurable() != nil)
                        {
                            cmdLst = l;

                            /* note any resolution error */
                            defErr = l.getResErr();
                        }
                    }

                    /*
                     *   If we've applied a spelling correction, and the
                     *   command match didn't consume the entire input, make
                     *   sure what's left of the input has a valid parsing as
                     *   another command.  This ensures that we don't get a
                     *   false positive by excessively shortening a command,
                     *   which we can sometimes do by substituting a word like
                     *   "then" for another word.
                     */
                    if (cmdLst.length() != nil
                        && history.hasCorrections())
                    {
                        /* get the best available parsing */
                        local c = cmdLst.getBestCmd();

                        /* if it doesn't use all the tokens, check what's left */
                        if (c != nil && c.tokenLen < toks.length())
                        {
                            /* try parsing the next command */
                            local l = commandPhrase.parseTokens(
                                c.nextTokens, cmdDict);

                            /*
                             *   if that didn't work, invalidate the command by
                             *   substituting an empty command list
                             */
                            if (l.length() == 0)
                                cmdLst = new CommandList();
                        }
                    }

                    /*
                     *   If we didn't find a parsing at all, it's a generic "I
                     *   don't understand" error.  If we found a parsing, but
                     *   not a resolution, reject it if it's a spelling
                     *   correction.  We only want completely clean spelling
                     *   corrections, without any errors.
                     */
                    if (cmdLst.length() == 0
                        || (history.hasCorrections()
                            && cmdLst.getResErr() != nil
                            && !cmdLst.getResErr().allowOnRespell))
                    {
                        /*
                         *   If we were able to parse the input using one of
                         *   the non-command interpretations, use the
                         *   resolution error from that parsing.  Otherwise, we
                         *   simply can't make any sense of this input, so use
                         *   the generic "I don't understand" error.
                         */
                        local err = (qErr != nil ? qErr :
                                     defErr != nil ? defErr :
                                     new NotUnderstoodError());

                        /* look for a spelling correction */
                        local newToks = history.checkSpelling(toks, err);
                        if (newToks != nil)
                        {
                            /* parse again with the new tokens */
                            toks = newToks;
                            continue;
                        }

                        /*
                         *   There's no spelling correction available.  If we've
                         *   settled on an auto-examine or question error, skip
                         *   that and go back to "I don't understand" after
                         *   all.  We don't want to assume Auto-Examine unless we
                         *   actually have something to examine, since we can
                         *   parse noun phrase grammar out of practically any
                         *   input.
                         */
                        if (err is in (defErr, qErr))
                        {
                            /* return to the not-understood error */
                            err = new NotUnderstoodError();

                            /* check spelling again with this error */
                            newToks = history.checkSpelling(toks, err);
                            if (newToks != nil)
                            {
                                /* parse again with the new tokens */
                                toks = newToks;
                                continue;
                            }

                            /*
                             *   We didn't find any spelling corrections this time
                             *   through.  Since we're rolling back to the
                             *   not-understood error, discard any spelling
                             *   corrections we attempted with other
                             *   interpretations.
                             */
                            history.clear();
                        }

                        /* fail with the error */
                        throw err;
                    }

                    /* if we found a resolvable command, execute it */
                    if (cmdLst.cmd != nil)
                    {
                        /* get the winning Command */
                        local cmd = cmdLst.cmd;

                        /*
                         *   We next have to ensure that the player hasn't entered
                         *   multiple nouns in a slot that only allows a single noun
                         *   in the grammar. If the player has entered two objects
                         *   like "the bat and the ball" in such a case, the
                         *   badMulti flag will be set on the command object, so we
                         *   first test for that and abort the command with a
                         *   suitable error message if badMulti is not nil (by
                         *   throwing a BadMultiError
                         *
                         *   Unfortunately the badMulti flag doesn't get set if the
                         *   player enters a multiple object as a plural (e.g.
                         *   "bats"), so we need to trap this case too. We do that
                         *   by checking whether there's multiple objects in the
                         *   direct, indirect and accessory object slots at the same
                         *   time as the grammar tag matching the slot in question
                         *   is 'normal', which it is only for a single noun match.
                         */

                        if(cmd && cmd.verbProd != nil &&
                            (cmd.badMulti != nil
                           || (cmd.verbProd.dobjMatch != nil &&
                               cmd.verbProd.dobjMatch.grammarTag == 'normal'
                               && cmd.dobjs.length > 1)
                           ||
                           (cmd.verbProd.iobjMatch != nil &&
                               cmd.verbProd.iobjMatch.grammarTag == 'normal'
                               && cmd.iobjs.length > 1)
                            ||
                           (cmd.verbProd.accMatch != nil &&
                               cmd.verbProd.accMatch.grammarTag == 'normal'
                               && cmd.accs.length > 1)
                               ))
                            cmd.cmdErr = new BadMultiError(cmd.np);

                        /* if this command has a pending error, throw it */
                        if (cmd.cmdErr != nil)
                            throw cmd.cmdErr;

                        /*
                         *   Forget any past question and typo information.
                         *   The new command is either an answer to this
                         *   question, or it's simply ignoring the question; in
                         *   either case, the question is no longer in play for
                         *   future input.
                         */
                        question = nil;
                        lastTokens = nil;

                        /* note any spelling changes */
                        history.noteSpelling(toks);

                        /* execute the command */
                        cmd.exec();

                        /* start over with a new spelling correction history */
                        history = new transient SpellingHistory(self);

                        /*
                         *   Set the root grammar production for the next
                         *   predicate.  If the previous command ended the
                         *   sentence, start a new sentence; otherwise, use the
                         *   additional clause syntax.
                         */
                        root = cmd.endOfSentence
                            ? firstCommandPhrase : commandPhrase;

                        /* we're no longer on the first command in the string */
                        firstCmd = nil;

                        /* go back and parse the remainder of the command line */
                        toks = cmd.nextTokens;
                        continue;
                    }

                    /*
                     *   We weren't able to resolve any of the parse trees.  If
                     *   one of the errors is "curable", meaning that the
                     *   player can fix it by answering a question, pick the
                     *   first of those, in predicate priority order.
                     *   Otherwise, just pick the first command overall in
                     *   predicate priority order.  In either case, since we
                     *   didn't find any working alternatives, it's time to
                     *   actually show the error and fail the command.
                     */
                    local c = cmdLst.acceptAny();

                    /*
                     *   If the error isn't curable, check for spelling errors,
                     *   time permitting.  Don't bother doing this with a
                     *   curable error, since that will have its own way of
                     *   solving the problem that reflects a better
                     *   understanding of the input than considering it a
                     *   simple typo.
                     */
                    if (!c.cmdErr.curable)
                    {
                        /*
                         *   For spelling correction purposes, if this is an
                         *   unmatched noun error, but the command has a misc
                         *   word list and an empty noun phrase, treat this as
                         *   a "not understood" error.  The combination of noun
                         *   phrase errors suggests that we took a word that
                         *   was meant to be part of the verb, and incorrectly
                         *   parsed it as part of a noun phrase, leaving the
                         *   verb structure and other noun phrase incomplete.
                         *   This is really a verb syntax error, not a noun
                         *   phrase error.
                         */
                        local spellErr = c.cmdErr;
                        if (c.cmdErr.ofKind(UnmatchedNounError)
                            && c.miscWordLists.length() > 0
                            && c.missingNouns > 0)
                            spellErr = new NotUnderstoodError();

                        /* try spelling correction */
                        local newToks = history.checkSpelling(toks, spellErr);

                        /* if that worked, try the corrected command */
                        if (newToks != nil)
                        {
                            /* parse again with the new tokens */
                            toks = newToks;
                            continue;
                        }
                    }

                    /* re-throw the error that caused the resolution to fail */
                    throw c.cmdErr;
                }
            }
            catch (ParseError err)
            {
                /*
                 *   roll back any spelling changes to the last one that
                 *   improved matters
                 */
                local h = history.rollback(toks, err);
                toks = h.oldToks;
                err = h.parseError;

                /*
                 *   if this is a curable error, it poses a question, which the
                 *   player can answer on the next input
                 */
                if (err.curable)
                    question = new ParseErrorQuestion(err);

                /*
                 *   If the current error isn't curable, and unknown word
                 *   disclosure is enabled, and there's a word in the command
                 *   that's not in the dictionary, replace the parsing error
                 *   with an unknown word error.
                 */
                local ui;
                if (!err.curable
                    && showUnknownWords
                    && (ui = spellingCorrector.findUnknownWord(toks)) != nil)
                {
                    /* find the misspelled word in the original tokens */
                    err = new UnknownWordError(getTokOrig(toks[ui]));
                }

                /*
                 *   If the new error isn't an error in an OOPS command, save
                 *   the token list for an OOPS command next time out.
                 */
                if (!err.ofKind(OopsError))
                    lastTokens = toks;

                /* log any spelling changes we kept */
                history.noteSpelling(toks);

                /* display the error we finally decided upon */
                err.display();
            }
            catch (CommandSignal sig)
            {
                /*
                 *   On any command signal we haven't caught so far, simply
                 *   stop processing this command line.
                 */
            }
        }

        /*
         *   The token list from the last command, if an error occurred.  This
         *   is the token list that we'll retry if the player enters an OOPS
         *   command.
         */
        lastTokens = nil

        /*
         *   The outstanding Question object.  When we ask an interactive
         *   question (such as a disambiguation query, a missing noun phrase
         *   query, or a custom question from the game), this is set to the
         *   Question waiting to be answered.  We parse the next command
         *   against the Question to see if it's a reply, and if so we execute
         *   the reply.
         */
        question = nil

        /*
         *   Execute an empty command line.  The parse() routine calls this
         *   when given a blank command line (i.e., the user simply pressed the
         *   Return key).  By default, we execute a Look Around command if
         *   autoLook is enabled, otherwise we show the "I beg your pardon"
         *   error.
         */
        emptyCommand()
        {
            if (autoLook)
                new Command(Look).exec();
            else
            {
                /*
                 *   The player entered an empty command line (i.e., pressed
                 *   Return at the command prompt, without typing anything else
                 *   first).  Note that this error can only occur if Auto-Look
                 *   is disabled, since otherwise an empty command implicitly
                 *   means LOOK AROUND.
                 */
                DMsg(empty command line, 'I beg your pardon?');

            }
        }

        /*
         *   The action to be tried if the parser can't find a verb in the command
         *   line and tries to parse the command line as the single object of a
         *   DefaultAction command instead.
         */

        DefaultAction = ExamineOrGoTo

        /*  Return an rmcXXXX enum code depending on the state of Parser.question */
        rmcType()
        {
            if(Parser.question != nil && Parser.question.err != nil)
            {
                /*
                 *   If the Parser error is an EmptyNounError then we're asking for
                 *   an object.
                 */
                if(Parser.question.err.ofKind(EmptyNounError))
                    return rmcAskObject;

                /*
                 *   If the Parser error is an AmbiguousError then we're requesting
                 *   disambiguation.
                 */
                if(Parser.question.err.ofKind(AmbiguousError))
                    return rmcDisambig;
            }

            /*
             *   If there's no special situation, assume we're reading a standard
             *   command.
             */
            return rmcCommand;
        }
    ;

    /* ------------------------------------------------------------------------ */
    /*
     *   Base class for command execution signals.  These allow execution
     *   handlers to terminate execution for the current command line or
     *   portion of the command line.
     */
    class CommandSignal: Exception
    ;

    /*
     *   Terminate the entire command line.
     */
    class ExitCommandLineSignal: CommandSignal
    ;

    /* ------------------------------------------------------------------------ */
    /*
     *   A CommandList is a set of potential parsings for a given input with a
     *   given grammar.
     */
    class CommandList: object
        /*
         *   new CommandList(prod, toks, dict, wrapper) - construct a new
         *   CommandList object by parsing an input token list.  'prod' is the
         *   GrammarProd to parse against; 'toks' is the token list; 'dict' is
         *   the main parser dictionary; 'wrapper' is a callback function that
         *   maps a parse tree to a Command object.
         *
         *   new CommandList(Command) - construct a CommandList containing a
         *   single pre-resolved Command object.
         */
        construct([args])
        {
            /* check which argument list we have */
            if (args.matchProto([GrammarProd, Collection, Dictionary, TypeFuncPtr]))
            {
                /* retrieve the arguments */
                local prod = args[1], toks = args[2], dict = args[3],
                    wrapper = args[4];

                /* parse the token list, and map the list to Command objects  */
                cmdLst = prod.parseTokens(toks, dict).mapAll(wrapper);

                /* sort in priority order */
                cmdLst = Command.sortList(cmdLst);

                /*
                 *   Go through the list, looking for an item with noun phrases we
                 *   can resolve.  Take the first item that we can properly
                 *   resolve.
                 */
                foreach (local c in cmdLst)
                {
                    try
                    {
                        /* resolve this phrase */
                        c.resolveNouns();

                        /* success - take this as the result; look no further */
                        /*
                         *   But only if we haven't yet got a command or the new
                         *   command didn't have to create a new Topic object.
                         */
                        if(cmd == nil || !c.madeTopic)
                            cmd = c;

                        /*
                         *   But if this command had to create a new Topic object,
                         *   let's go on to see if we can find a better match.
                         */
                        if(!cmd.madeTopic)
                           break;
                    }
                    catch(InsufficientNounsError err)
                    {
                        c.cmdErr = err;
                        throw err;
                    }
                    catch(NoneInOwnerError err)
                    {
                        c.cmdErr = err;
                        throw err;
                    }

                    catch (ParseError err)
                    {
                        /* save the error with the command */
                        c.cmdErr = err;

                        /*
                         *   That didn't resolve correctly.  But don't actually
                         *   show the error message yet; instead, continue through
                         *   the list to see if we can find another alternative
                         *   that we can resolve.
                         *
                         *   If it's the first curable error we've seen, note it.
                         */
                        if (err.curable && curable == nil)
                            curable = c;
                    }
                }
            }
            else if (args.matchProto([Command]))
            {
                /* get the command - it's the single list entry */
                cmd = args[1];
                cmdLst = [cmd];
            }
            else if (args.matchProto([]))
            {
                /* empty command list */
                cmd = nil;
                cmdLst = [];
            }
            else
                throw new ArgumentMismatchError();
        }

        /* number of parsings in the list */
        length() { return cmdLst.length(); }

        /*
         *   Accept a curable resolution as the actual resolution.  If we don't
         *   have an error-free resolution, we'll set 'cmd' to the curable
         *   resolution.  Returns true if we have any resolution, nil if not.
         */
        acceptCurable()
        {
            /* if we don't have an error-free resolution, accept a curable one */
            if (cmd == nil)
                cmd = curable;

            /* indicate whether we have a resolution now */
            return cmd;
        }

        /*
         *   Accept ANY command, with or without a resolution error, curable or
         *   not.  We'll take the error-free resolution if we have one,
         *   otherwise the resolution with a curable error, otherwise just the
         *   first parsing in priority order.
         */
        acceptAny()
        {
            /* accept the best command, and return it */
            return cmd = getBestCmd();
        }

        /*
         *   Get the most promising command from the available parsings.  This
         *   returns the first successfully resolved command in priority order,
         *   if any; otherwise the first command with a curable error, if any;
         *   otherwise the first command in priority order.
         */
        getBestCmd()
        {
            /* if we have a parsed and resolved command, return it */
            if (cmd != nil)
                return cmd;

            /* if we have a curable command, return it */
            if (curable != nil)
                return curable;

            /* if we have any parsing at all, return the first one */
            if (cmdLst.length() > 0)
                return cmdLst[1];

            /* we don't have any parsing */
            return nil;
        }

        /*
         *   Get the resolution error, if any.  If we parsed but didn't
         *   resolve, this returns the error from the first parsing in priority
         *   order.
         */
        getResErr()
        {
            /* if we resolved a command, return any error from it */
            if (cmd != nil)
                return cmd.cmdErr;

            /* if we have a curable error, return it */
            if (curable != nil)
                return curable.cmdErr;

            /* otherwise, return the first item with a cmdErr */
            local c = cmdLst.valWhich({ c: c.cmdErr != nil });
            return (c != nil ? c.cmdErr : nil);
        }

        /* our list of Command objects */
        cmdLst = []

        /*
         *   Our resolved Command.  This is the first parsing in our list that
         *   (in priority order) we were able to resolve with no errors.
         */
        cmd = nil

        /*
         *   Our semi-resolved Command.  When we can't find a command that
         *   resolves without errors, we'll set this to the first one (in
         *   priority order) that resolves with a curable error.
         */
        curable = nil
    ;

    /* ------------------------------------------------------------------------ */
    /*
     *   A Question is an interactive question we ask the player via the
     *   regular command line.  The player then has the option to answer the
     *   question, or to ignore the question and enter a new command.
     *
     *   The parser uses Question objects internally to handle certain errors
     *   that the player can fix by entering additional information, such as
     *   disambiguation queries and missing noun phrase queries.  Games can use
     *   Question objects for other, custom interactions.
     *
     *   The basic Question object is incomplete - you have to subclass it to
     *   get a functional question handler.  In particular, you must provide a
     *   parseAnswer() routine that parses the reply and creates a Command to
     *   carry out the action of answering the question.
     */
    class Question: object
        /*
         *   Priority: Should the answer be parsed before checking for a
         *   regular command entry?  If this is true, the parser will try
         *   parsing the player's input as an answer to this question BEFORE it
         *   tries parsing the input as a regular command.  If the answer
         *   parses, we'll assume it really is an answer to the question, and
         *   we won't even try parsing it as a new command.
         *
         *   For disambiguation and missing noun queries, the parser only
         *   parses question replies AFTER parsing regular commands.  Replies
         *   to these questions are frequently very short, abbreviated noun
         *   phrases - maybe just a single adjective or noun.  It's fairly
         *   common for there be at least a few nouns that are the same as
         *   verbs in the game, so the input after a disambiguation or missing
         *   noun reply can often be interpreted equally well as a new verb or
         *   as a reply to the question.  There's probably no theoretical basis
         *   for choosing one over the other when this happens, but in practice
         *   it seems that it's usually better to treat the reply as a new
         *   command.  So, by default we set this property to nil, to give
         *   priority to a new command.
         *
         *   Custom questions posed by the game might want to give higher
         *   priority to the answer interpretation, though.  Yes/No questions
         *   in particular will probably want to do this, because otherwise the
         *   parser would take the answer as a conversational overture to any
         *   nearby NPC.
         */
        priority = nil

        /*
         *   Parse the answer.  'toks' is the token list of the user's input,
         *   and 'dict' is the main parser Dictionary object.
         *
         *   If the input does look like a valid answer to the question,
         *   returns a CommandList with the parsed reply.  If not, returns nil,
         *   in which case the parser will continue trying to parse the input
         *   as a whole new command.
         *
         *   By default, we simply return nil.  Subclasses/instances must
         *   override this to provide the custom answer parsing.
         */
        parseAnswer(toks, dict) { return nil; }

        /* the answer template */
        answerTemplate = nil
    ;

    /*
     *   A GramQuestion is a question handler that parses an answer using a
     *   grammar rule.
     */
    class GramQuestion: Question
        /*
         *   Create a simple question.  'prod' is the root GrammarProd to use
         *   for parsing the reply.  'func' is a callback function that carries
         *   out the action of the answering the question.  'func' is invoked
         *   with a single argument giving the Command object representing the
         *   answer; you can get the match tree from the Command if you need
         *   the parsed form of the answer input.
         */
        construct(prod, func)
        {
            answerProd = prod;
            answerFunc = func;
        }

        /*
         *   Parse the answer.  We'll match the token list against the grammar
         *   rule.  If we find a match, we'll call makeCommand() to create the
         *   command to carry out the action of answering the question.
         */
        parseAnswer(toks, dict)
        {
            /* try parsing against our grammar rule */
            return new CommandList(
                answerProd, toks, dict, { p: makeCommand(p) });
        }

        /*
         *   Create a Command object for a successful grammar match.  'prod' is
         *   the root match object of the grammar match.  This returns a
         *   suitable Command that carries out the action of answering the
         *   question.
         */
        makeCommand(prod) { return new FuncCommand(prod, answerFunc); }

        /* the GrammarProd rule that we use to parse the answer */
        answerProd = nil

        /* the callback function that carries out the reply action */
        answerFunc = nil
    ;

    /*
     *   A YesNoQuestion is a simple subclass of Question for asking
     *   interactive questions with Yes or No answers.
     */
    class YesNoQuestion: GramQuestion
        /*
         *   Create - 'func' is the callback function to invoke on answering
         *   the question.  This is invoked with one argument, true if the
         *   answer was Yes, nil if the answer was No.
         */
        construct(func)
        {
            /*
             *   Parse our answer against the simple yes-or-no grammar.  To
             *   execute the answer, call the user's callback, providing the
             *   yes/no result from the Command.  The yes-or-no production sets
             *   the yesOrNoAnswer property in the Command during the build
             *   process.
             */
            inherited(yesOrNoPhrase, { cmd: func(cmd.yesOrNoAnswer) });
        }

        /*
         *   parse Yes/No replies ahead of new commands, since we'd otherwise
         *   never get an answer - the parser would always match the reply to a
         *   conversational verb instead
         */
        priority = true
    ;

    /*
     *   A RexQuestion is a simple subclass of Question for parsing answers
     *   with regular expressions.
     */
    class RexQuestion: Question
        /*
         *   Create - 'pat' is the regular expression pattern, as either a
         *   string or a RexPattern object.  We'll parse an answer simply by
         *   matching it against the regular expression; if we match, we'll
         *   take it as an answer.  'func' is a callback function that we'll
         *   call to carry out the action of answering the question.  We'll
         *   invoke this with one argument giving the literal text of the
         *   input.
         */
        construct(pat, func)
        {
            answerPat = pat;
            answerFunc = func;
        }

        parseAnswer(toks, dict)
        {
            /* reconstruct the string input */
            local str = cmdTokenizer.buildOrigText(toks);

            /* check for a match to our pattern */
            if (rexMatch(answerPat, str,) != nil)
            {
                /* set up a single-entry command list for the answer */
                return new CommandList(new FuncCommand(
                    nil, { cmd: answerFunc(str) }));
            }
            else
            {
                /* no match */
                return nil;
            }
        }

        /* the regular expression pattern to match */
        answerPat = nil

        /* the callback to invoke on answering */
        answerFunc = nil
    ;

    /*
     *   An ErrorQuestion is a subclass of Question for curable parsing errors.
     */
    class ParseErrorQuestion: Question
        construct(err)
        {
            /* remember the ParseError object */
            self.err = err;
        }

        parseAnswer(toks, dict)
        {
            /* ask the error to parse the response */
            return err.tryCuring(toks, dict);
        }

        /* the curable ParseError that posed the question */
        err = nil

        /*
         *   Should we prioritize interpreting player input to a parser query as a response to that
         *   query over interpreting it as a nea command (where the latter is possible)? By default we
         *   do (since this seems more likely to reflect player intention in this case), although game
         *   code can override if desired.
         */
        priority = true
    ;

    /* ------------------------------------------------------------------------ */
    /*
     *   A Distinguisher is an abstract parser object that represents one way
     *   that we can tell two objects apart, both in the name we display and in
     *   command input.
     *
     *   Note that this class is designed primarily for the parser's internal
     *   use, to facilitate some bookkeeping that we have to do during
     *   disambiguation.  It's not really designed as an extensibility
     *   mechanism, because it's not usually enough to just add a new instance:
     *   you usually also have to add grammar for whatever new phrasing the new
     *   distinguisher represents, plus object resolution code to handle the
     *   new form of qualification.
     */
    class Distinguisher: object
        /*
         *   Sorting order.  The parser sorts the master list of distinguishers
         *   in ascending order of this value to determine the order of
         *   application.
         */
        sortOrder = 0

        /*
         *   Compare two objects for equivalence under this distinguisher.
         *   Returns true if the objects are equivalent, nil others.
         */
        equal(a, b) { return nil; }

        /*
         *   Is this distinguisher applicable to the given object?  Some
         *   distinguishers can only apply to certain objects.  For example, a
         *   Lit/Unlit distinguisher can only be applied to objects with that
         *   state variable, because there's no vocabulary that we can add to
         *   an object without the variable.  (We can talk about "lit" and
         *   "unlit" matches, but we don't have any standard vocabulary to talk
         *   about "unlightable" matches.)
         */
        appliesTo(obj) { return true; }

        /*
         *   Apply the distinguisher.  Returns a DistResult object with the
         *   results.
         */
        apply(lst)
        {
            /* create the results object */
            local r = new DistResult(self);

            /* set up the list of applicable objects */
            r.appliesTo = lst.subset({ obj: appliesTo(obj) });

            /* make a to-do vector, starting with all applicable items */
            local toDo = new Vector(10, r.appliesTo);

            /* process each item in the to-do list */
            while (toDo.length() > 0)
            {
                /* pop the last item */
                local obj = toDo.pop();

                /* start a partition list for this item and its equivalents */
                local sv = new Vector(10);

                /* start the partition with the current object */
                sv.append(obj);

                /* add the new partition to the partition list */
                r.partitioned.append(sv);

                /* scan the to-do list for items equivalent to obj */
                for (local i = toDo.length() ; i > 0 ; --i)
                {
                    /* get this item and check for equivalence to obj */
                    local obj2 = toDo[i];
                    if (equal(obj, obj2))
                    {
                        /* it's equivalent to obj, so add it to obj's partition */
                        sv.append(obj2);

                        /* it's been processed; remove it from the to-do list */
                        toDo.removeElementAt(i);
                    }
                }
            }

            /* return the result object */
            return r;
        }

        /* class property: master list of all distinguishers */
        all = []

        /* during initialization, build the master list */
        classInit()
        {
            /* add each instance to the master list */
            forEachInstance(Distinguisher, {d: all += d});

            /* arrange by sortOrder */
            all = all.sort(SortAsc, {a, b: a.sortOrder - b.sortOrder});
        }

        /* make sure the StateDistinguisher instances are constructed first */
        classInitFirst = [StateDistinguisher]

        /*
         *   Class method: generate distinguishing names for a list of objects.
         *   This generates names that distinguish the objects from one
         *   another, by applying as many Distinguishers as needed to come up
         *   with unique names.
         *
         *   If 'article' is true, we'll use a definite or indefinite article,
         *   as appropriate: definite if the name we settle upon uniquely
         *   identifies the object within the list, indefinite if not.  If
         *   'article' is nil, the names don't have articles at all.
         *
         *   Returns a list of [name, [objects]] sublists.  The name is a
         *   string giving the distinguished name; the [objects] sub-sublist is
         *   a list of the objects known under that name.
         */
        getNames(objs, article)
        {
            /* start with an empty result list */
            local names = new Vector(objs.length());

            /* start with an empty list of distinguisher results */
            local dres = new Vector(Distinguisher.all.length());

            /* apply each distinguisher to our objects, saving the results */
            foreach (local d in Distinguisher.all)
                dres.append(d.apply(objs));

            /* find the distinguishing characteristics for each object */
            while (objs.length() != 0)
            {
                /* treat the to-do list as a stack: pop an object */
                local obj = objs.pop();

                /* get the subset of dist results that apply to this object */
                local ores = dres.subset({ r: r.appliesTo.indexOf(obj) != nil });

                /*
                 *   What we're after is the minimum set of distinguishers that
                 *   can tell this object apart from as many of the others as
                 *   possible.
                 *
                 *   In the best case, there's a single distinguisher that can
                 *   pick out this object uniquely.  For example, if this is
                 *   the lit match, and all the other matches are unlit, the
                 *   Lit/Unlit State distinguisher is all we need: 'lit'
                 *   uniquely identifies this object among our set.  If that's
                 *   the case, obj will appear in the Lit/Unlit list in its own
                 *   partition, with no other objects.
                 *
                 *   It might be that there's no one distinguisher that can
                 *   tell obj apart from all of the others.  But perhaps a
                 *   combination of two distinguishers can: perhaps obj is one
                 *   of two lit matches, and one of two matches belonging to
                 *   Bob, but it's the only lit match belonging to Bob.  We'd
                 *   thus find obj in two partitions of two objects each;
                 *   intersecting the two will yield a list with just one
                 *   element, so we'd get down to a unique object again.
                 *
                 *   We might not ever get down to a single-object partition,
                 *   even after combining several distinguishers, since we
                 *   might be truly indistinguishable from one or more other
                 *   objects.  In such a case, we'll have to group the objects
                 *   and ask if the player means "*a* lit match of Bob's", say.
                 *
                 *   In any case, our fastest route to the smallest set is to
                 *   start with the smallest set, and intersect against larger
                 *   sets until we get down to one object or run out of other
                 *   sets to intersect.  So start by sorting the results by the
                 *   size of the partition in which obj appears, smallest to
                 *   largest.
                 */
                ores.sort(SortAsc, new function(a, b)
                {
                    /* sort by partition size */
                    local asiz = a.partSize(obj);
                    local bsiz = b.partSize(obj);

                    /* if they differ, sort according to the relative sizes */
                    if (asiz != bsiz)
                        return asiz - bsiz;

                    /* same size partitions; sort by Distinguisher order */
                    return a.distinguisher.sortOrder - b.distinguisher.sortOrder;
                });

                /* we haven't used any distinguishers yet */
                local used = new Vector(10);

                /*
                 *   Start with the first distinguisher in the list, and its
                 *   initial set.  Note that we're guaranteed to have at least
                 *   one result in the list, since the basic name distinguisher
                 *   applies to everything.
                 */
                used.append(ores[1].distinguisher);
                local rem = ores[1].partition(obj).toList();

                /*
                 *   now apply additional distinguishers until we get the set
                 *   down to one object, or run out of distinguishers
                 */
                for (local i = 2, local olen = ores.length() ;
                     rem.length() > 1 && i <= olen ; ++i)
                {
                    /*
                     *   figure the intersection of this distinguisher
                     *   partition with the remaining set
                     */
                    local rcur = ores[i];
                    local isect = rem.intersect(rcur.partition(obj).toList());

                    /*
                     *   If that reduced the set size, keep the result.  Ignore
                     *   distinguishers that don't reduce the set size, because
                     *   they don't help - they'd just add words to the
                     *   generated name without helping to tell things apart.
                     */
                    if (isect.length() < rem.length())
                    {
                        /* keep the reduced list */
                        rem = isect;

                        /* note that we used this distinguisher */
                        used.append(rcur.distinguisher);
                    }
                }

                /*
                 *   We've thrown out as many distinguishable items as
                 *   possible, and in the process we've built a list of the
                 *   distinguishing characteristics that we needed in order to
                 *   tell this object apart from the others.  Generate the
                 *   name, based on that list of characteristics.  If we
                 *   whittled the set size down to a single object, use a
                 *   definite article; otherwise, we have a group of
                 *   indistinguishable objects, so use an indefinite article to
                 *   refer to an arbitrary one of these.
                 */
                local rlen = rem.length();
                local nm = obj.distinguishedName(
                    article ? (rlen == 1 ? Definite : Indefinite) : Unqualified,
                    used);

                /*
                 *   This name covers the whole group, so remove all of the of
                 *   additional objects from the to-do list.  (We've already
                 *   removed the first one, so don't waste time looking for it
                 *   again.)
                 */
                for (local i = 2 ; i <= rlen ; ++i)
                    objs.removeElement(rem[i]);

                /* append this name result */
                names.append([nm, rem]);
            }

            /* return the name list */
            return names;
        }
    ;

    /*
     *   Result object from applying a Distinguisher to a set of objects.
     */
    class DistResult: object
        construct(dist)
        {
            /* remember the distinguisher */
            distinguisher = dist;

            /* set up a vector for the partition list */
            partitioned = new Vector(10);
        }

        /* get the partition in which 'obj' appears */
        partition(obj)
        {
            return partitioned.valWhich({ p: p.indexOf(obj) != nil });
        }

        /* get the size of the partition in which 'obj' appears */
        partSize(obj)
        {
            return partition(obj).length();
        }

        /* the objects that the distinguisher applies to */
        appliesTo = []

        /*
         *   The partitioned list of objects.  This is a list of lists.  Each
         *   sublist is a group of objects we can't distinguish from one
         *   another.  Each object in appliesTo appears once in a sublist, and
         *   each object in a sublist appears in appliesTo.
         */
        partitioned = []

        /* the Distinguisher that these results come from */
        distinguisher = nil
    ;

    /*
     *   The basic name distinguisher distinguishes objects by their base names.
     *   This is the first distinguisher we apply, since the name is always the
     *   easiest way to tell objects apart in parsing. However since one name could
     *   be entirely contained within another (e.g. 'ball' and 'red ball') we
     *   consider the names as equal for this purpose if one of them is part of the
     *   other.
     */
    nameDistinguisher: Distinguisher
        sortOrder = 100
        equal(a, b) { return a.name.find(b.name) || b.name.find(a.name); }
    ;

    /*
     *   The disambiguation name distinguisher.  This distinguishes objects by
     *   their disambiguation names.  We apply this immediately after the basic
     *   name distinguisher, since the disambiguation name is a custom name
     *   provided by the author for the express purpose of distinguishing the
     *   object in parsing.
     */
    disambigNameDistinguisher: Distinguisher
        sortOrder = 200
        equal(a, b) { return a.disambigName == b.disambigName; }
    ;

    /*
     *   The class for state distinguishers.  A state distinguisher tells
     *   objects apart based on their having distinct current values for a
     *   given state.  During preinit, we create a separate instance of this
     *   for each State object in the game.
     */
    class StateDistinguisher: Distinguisher
        sortOrder = 300

        /* we distinguish based on each object's current value for the state */
        equal(a, b) { return a.(state.stateProp) == b.(state.stateProp); }

        /* we only apply to objects that have our state variable */
        appliesTo(obj) { return state.appliesTo(obj); }

        /* build from a State */
        construct(st)
        {
            /* remember the state object */
            state = st;
        }

        /* during preinit, build an instance for each State */
        classInit()
        {
            forEachInstance(State, {st: stateList += new StateDistinguisher(st)});
        }

        /* the State this distinguisher tests */
        state = nil

        /* class property: the list of state distinguisher instances */
        stateList = []
    ;

    /*
     *   Owner distinguisher.  This tells objects apart based on their nominal
     *   owners (and only applies to objects with nominal owners at all).
     */
    ownerDistinguisher: Distinguisher
        sortOrder = 400
        appliesTo(obj) { return obj.nominalOwner() != nil; }
        equal(a, b) { return a.nominalOwner() == b.nominalOwner(); }
    ;

    /*
     *   Location distinguisher.  This tells objects apart based on their
     *   immediate containers.
     */
    locationDistinguisher: Distinguisher
        sortOrder = 500
        equal(a, b) { return a.location == b.location; }
    ;

    /*
     *   Contents distinguisher.  This tells objects apart based on their
     *   nominal contents (and only applies to objects with nominal contents at
     *   all).  Note that we're interested in the *names* of the contents, so
     *   even if two objects have different contents objects, they're still
     *   considered equal if the contents' names match.  (E.g., two "buckets of
     *   water" are indistinguishable, even if the contents are two distinct
     *   "water" objects.  But "bucket of water" and "bucket of fish" are
     *   distinguishable.)
     */
    contentsDistinguisher: Distinguisher
        sortOrder = 600
        appliesTo(obj) { return obj.distinguishByContents != nil; }
        equal(a, b)
        {
            local ac = a.nominalContents(), bc = b.nominalContents();
            return (ac != nil ? ac.name : nil) == (bc != nil ? bc.name : nil);
        }
    ;

    /* ------------------------------------------------------------------------ */
    /*
     *   A NounPhrase object represents a noun phrase within a command line.
     *   This class handles the mapping from the text of the noun phrase in the
     *   input to the game-world objects that the noun phrase refers to.
     *
     *   This object encompasses a core noun phrase plus all of its qualifiers.
     *   Qualifiers can themselves be noun phrases: possessives, locationals,
     *   and contents phrases contain subsidiary noun phrases, so we represent
     *   these qualifiers with subsidiary NounPhrase objects.
     */
    class NounPhrase: object
        /* create */
        construct(parent, prod)
        {
            /*
             *   remember the parent NounPhrase and the grammar production
             *   match object that's the source of the noun phrase
             */
            self.parent = parent;
            self.prod = self.coreProd = prod;
        }

        /* clone - create a modifiable copy based on this original noun phrase */
        clone()
        {
            /* create a new object with my same property values */
            local cl = createClone();

            /* make safe copies of any vectors */
            foreach (local p in cl.getPropList())
            {
                local v;
                if (cl.propType(p) == TypeObject && (v = cl.(p)).ofKind(Vector))
                    cl.(p) = new Vector(v.length(), v);
            }

            /* return the clone */
            return cl;
        }

        /*
         *   By default, use the original input text of my "core" production as
         *   the name we show for this noun phrase in error messages.  The core
         *   production is the noun phrase minus any qualifiers (articles,
         *   possessives, locational phrases, etc).
         *
         *   As we successfully resolve qualifiers, we'll expand this to
         *   include the qualifying phrases.  Any error we find after resolving
         *   a qualifier will necessary apply to the qualified form, so we want
         *   to include the qualifier in any error message.
         *
         *   For example, if the original phrase is BUCKET OF FISH ON TABLE,
         *   we'll start out with the core phrase of BUCKET.  We'll next
         *   resolve the contents qualifier, OF FISH.  Assuming that we find a
         *   BUCKET OF FISH, that becomes the new error name.  If we then fail
         *   to find such an object ON TABLE, we'll be able to report that
         *   there's no BUCKET OF FISH on the table.  This is better than
         *   reporting that we don't see any BUCKET on the table, because there
         *   could in fact be a different bucket on the table.
         */
        errName = (errNameProd.getText())

        /* the source of the error name is initially the core production */
        errNameProd = (coreProd)

        /*
         *   Expand the error-message name to include the given qualifier.
         *   We'll find the common parent of the core production and the given
         *   qualifier's production, and use its text as the new error name.
         */
        expandErrName(np)
        {
            /*
             *   look for the common parent of 'np' and the current error name
             *   source
             */
            for (local prod = np.prod ; prod != nil ; prod = prod.parent)
            {
                /*
                 *   if this is also a parent of errNameProd, we've found the
                 *   common parent
                 */
                if (prod == errNameProd || errNameProd.isChildOf(prod))
                {
                    /* establish this as the new error name source */
                    errNameProd = prod;

                    /* no need to keep looking */
                    break;
                }
            }
        }

        /*
         *   Does this NounPhrase contain the given NounPhrase?  Returns true
         *   if NounPhrase is self, or one of our qualifier noun phrases
         *   contains it.
         */
        contains(np)
        {
            return (np == self
                    || (possQual != nil && possQual.contains(np))
                    || (locQual != nil && locQual.contains(np))
                    || (exclusions != nil
                        && exclusions.indexWhich({ x: x.contains(np) }) != nil));
        }

        /*
         *   Get the list of objects matching the vocabulary words in our noun
         *   phrase.  Populates our 'matches' property with a vector of matching
         *   objects.  This doesn't look at any of our qualifiers, or attempt
         *   to disambiguate contextually; it simply finds everything in scope
         *   that the noun phrase could refer to.
         */
        matchVocab(cmd)
        {
            /* start with an empty vector */
            local v = new Vector(32);

            /* get the current scope list */
            cmd.action.buildScopeList();
            local scope = cmd.action.scopeList;

            /* check what kind of phrase we have */
            if (pronoun != nil)
            {
                /* it's a pronoun - resolved based on the antecedent */
                addMatches(v, pronoun.resolve(), 0);

                /* if there are no antecedents, flag the error */
                if (v.length() == 0)
                    throw new NoAntecedentError(self, pronoun);

                /* filter for in-scope objects (or reflexive placeholders) */
                v = v.subset(
                    { m: m.obj.ofKind(Pronoun) || scope.find(m.obj) });

                /* if that leaves nothing, flag the error */
                if (v.length() == 0)
                    throw new AntecedentScopeError(cmd, self, pronoun);

            }
            else if (determiner == All && tokens == [])
            {
                /* ALL - use everything in scope applicable to the verb */
                addMatches(v, cmd.action.getAllUnhidden(cmd, role), 0);
                cmd.matchedAll = true;
            }
            else
            {
                /*
                 *   It's a named object.  Our 'tokens' property is a list of
                 *   the words in the noun phrase in the user input.  Match it
                 *   against the objects in physical scope.
                 */
                v.appendAll(matchNameScope(cmd, scope));
            }

            /* save the match list so far */
            matches = v;

            /* if we have a contents qualifier, match its vocabulary */
            if (contQual != nil)
            {
                /* match vocabulary */
                contQual.matchVocab(cmd);

                /* apply the qualifier to keep only matching items */
                contQual.applyContQual();

                /* if that empties our list, flag it */
                if (matches.length() == 0)
                    throw new NoneWithContentsError(cmd, self, contQual);

                /*
                 *   Expand the error text name to include the contents
                 *   qualifier, since any subsequent failure to match will be
                 *   against the result of this qualification.  For example, if
                 *   the phrase is BUCKET OF FISH ON TABLE, we've now limited
                 *   the scope to just BUCKET OF FISH, so if we fail to find
                 *   such an object on the table it'll be because there's no
                 *   BUCKET OF FISH on the table, not because there's simply no
                 *   BUCKET.
                 */
                expandErrName(contQual);
            }

            /* if we have a possessive qualifier, apply it */
            if (possQual != nil)
            {
                /* match vocabulary for the possessive phrase */
                possQual.matchVocabPoss(cmd);

                /*
                 *   apply the qualifier, filtering out things not owned by the
                 *   object named in the qualifier
                 */
                possQual.applyPossessive();

                /* if that empties our list, flag it */
                if (matches.length() == 0)
                    throw new NoneInOwnerError(cmd, self, possQual);

                /* expand the error text to include the possessive qualifier */
                expandErrName(possQual);
            }

            /* if we have a locational qualifier, match its vocabulary */
            if (locQual != nil)
            {
                /* match vocabulary */
                locQual.matchVocab(cmd);

                /* apply the qualifier to keep only properly located items */
                locQual.applyLocational();

                /* if that empties our list, flag it */
                if (matches.length() == 0)
                    throw new NoneInLocationError(cmd, self, locQual);

                /* expand the error name to include the locational */
                expandErrName(locQual);
            }

            /* if there's an exclusion list, apply it */
            if (exclusions != nil)
                exclusions.forEach({ x: x.applyExclusion(cmd) });
        }

        /*
         *   Add matching objects to a match vector.  'lst' can be a list or
         *   vector of objects, or a single object.  'match' is the MatchXxx
         *   flag value returned from the object name match, if applicable.
         */
        addMatches(vec, lst, match)
        {
            /* ignore nil */
            if (lst == nil)
                return;

            /* wrap each item in an NPMatch object and add it to the vector */
            vec.appendAll(valToList(lst).mapAll({ obj: new NPMatch(self, obj, match) }));
        }

        /*
         *   Find the vocabulary matches for a given noun phrase within a given
         *   scope list.  Add all of the matches to the given vector.
         */
        matchNameScope(cmd, scope)
        {
            /* set up a vector for the results */
            local v = new Vector(32);

            /*
             *   Run through the scope list and ask each object if it matches
             *   the noun phrase.  Keep the ones that match.
             */
            foreach (local obj in scope)
            {
                /* ask this object if it matches */
                local match = obj.matchName(tokens);

                /* if it matches, include it in the results */
                if (match)
                    v.append(new NPMatch(self, obj, match));
            }

            /*
             *   Now narrow the list according to the match strength.  Only
             *   keep the matches that have the maximum strength of the list.
             */
            if (v.length() > 0)
            {
                /* sort in descending order of strength */
                v.sort(SortDesc, { a, b: a.strength - b.strength });

                /*
                 *   discard everything that doesn't match the highest strength
                 *   (which is the first element's strength, since we've sorted
                 *   in descending order)
                 */
                v = v.subset({ a: a.strength == v[1].strength });
            }
            else
            {
                /* the list is empty - complain about it */
                throw new UnmatchedNounError(cmd, self);
            }

            /* return the list */
            return v;
        }

        /*
         *   Match vocabulary for a possessive qualifier phrase.
         *
         *   Possessive matching has somewhat different rules than for ordinary
         *   noun phrases.
         *
         *   First, possessive pronouns (HIS, HER, ITS, THEIR) *can* act like
         *   reflexives, in that they can refer back to earlier clauses in the
         *   same predicate: ASK BOB ABOUT HIS MOTHER.  However, they can also
         *   refer to previous commands: SEARCH BOB; TAKE HIS WALLET.  The
         *   deciding factor is whether or not there's an earlier noun phrase
         *   in the command that matches in gender and number; if so, we use
         *   the reflexive meaning, otherwise we use the external referent.
         *
         *   Second, the scope for ordinary noun phrases has to be expanded to
         *   include the owners of the objects in scope.  If we have a wallet
         *   that we know belongs to Bob, we should be able to refer to it as
         *   "Bob's wallet" whether or not Bob himself is in scope.  So, for
         *   the purposes of the possessive, Bob is in scope even if he
         *   wouldn't be for an ordinary noun phrase.
         */
        matchVocabPoss(cmd)
        {
            /* start with an empty vector */
            local v = matches = new Vector(32);

            /* check what kind of phrase we have */
            if (pronoun != nil)
            {
                /*
                 *   It's a possessive pronoun (HIS, HER, ITS, etc).
                 *   Possessive pronouns can refer back to something in the
                 *   same sentence (ASK BOB ABOUT HIS WALLET) or to earlier
                 *   commands (SEARCH BOB; TAKE HIS WALLET).
                 *
                 *   If it's a second-person possessive (YOUR), and there's an
                 *   addressee actor, it refers to the actor.  For example,
                 *   "Bob, give me your wallet".
                 *
                 *   Look at the preceding noun phrases in the predicate to see
                 *   if we can find an object that matches this pronoun.  If
                 *   so, use it as the antecedent.  If not, use the regular
                 *   antecedent.
                 */
                local done = nil;
                cmd.forEachNP(new function(np)
                {
                    /* if we've already finished, ignore this noun phrase */
                    if (done)
                        return;

                    /*
                     *   if this is our parent, stop looking - pronoun
                     *   references of this sort are always back references
                     */
                    if (np == parent)
                    {
                        done = true;
                        return;
                    }

                    /*
                     *   If this is the addressee actor, and we have a
                     *   second-person possessive pronoun (YOUR), the pronoun
                     *   refers to the actor.
                     */
                    if (np.role == ActorRole && pronoun.person == 2)
                    {
                        v.appendAll(np.matches);
                        done = true;
                        return;
                    }

                    /* check for matches to this pronoun in this match list */
                    local s = np.matches.subset(
                        { o: pronoun.matchObj(o.obj) });

                    /*
                     *   if we found any matches, use them, and stop looking -
                     *   we only want to use the nearest match
                     */
                    if (s.length() != 0)
                    {
                        v.appendAll(s);
                        done = true;
                    }
                });

                /*
                 *   if we didn't find any matches, use the antecedent from a
                 *   previous command, if available
                 */
                if (v.length() == 0)
                    v.appendAll(pronoun.resolve().mapAll({
                        x: new NPMatch(self, x, 0) }));
            }
            else
            {
                /*
                 *   It's a named object.  We need an expanded scope list that
                 *   includes the owners of the objects referred to by the
                 *   underlying noun phrase that we qualify.
                 */
                local expScope = new Vector(32);
                foreach (local obj in parent.matches)
                {
                    /*
                     *   if this object has an owner or owners, add it/them to
                     *   the expanded scope list
                     */
                    local owner = obj.obj.owner;
                    if (owner != nil)
                        expScope.appendAll(owner);
                }

                /* add the objects in scope, filtering out duplicates */
                expScope.appendUnique(World.scope.toList());

                /* now build the match list using the expanded scope */
                v.appendAll(matchNameScope(cmd, expScope));
            }

            /*
             *   a possessive qualifier can itself have a possessive qualifier
             *   (BOB'S MOTHER'S HAT), so go resolve that as well
             */
            if (possQual != nil)
                possQual.matchVocabPoss(cmd);
        }

        /*
         *   Apply this possessive phrase's qualification.  This filters the
         *   underlying (parent) noun list to keep only objects owned by the
         *   object(s) named in this noun phrase.
         */
        applyPossessive()
        {
            /*
             *   First, do "reverse" filtering: consider only owners who own
             *   something that's in the underlying noun list.  For example, if
             *   there are two guards present, but only one of them is carrying
             *   a sword, GUARD'S SWORD must refer to the guard who's carrying
             *   a sword.
             *
             *   (Take a subset of our own objects, keeping each object 'o'
             *   where there's something in the parent list owned by 'o'.  That
             *   is, there's an object 'p' in the parent list where 'p' is
             *   owned by 'o'.)
             */
            local m = matches.subset(
                { o: parent.matches.indexWhich(
                    { p: p.obj.ownedBy(o.obj) }) != nil });

            /* if the reverse filter didn't rule everything out, apply it */
            if (m.length() > 0)
                matches = m;

            /* next, apply any possessive qualifier of my own */
            if (possQual != nil)
                possQual.applyPossessive();

            /* filter parent objects not owned by anything in my list */
            parent.matches = parent.matches.subset(
                { p: matches.indexWhich(
                    { o: p.obj.ownedBy(o.obj) }) != nil });
        }

        /*
         *   Apply this contents qualifier phrase's qualification.  This
         *   filters the underlying (parent) noun list to keep only objects
         *   that contain the object(s) named in this noun list.
         */
        applyContQual()
        {
            /*
             *   First, do the reverse filtering, to keep only objects that
             *   could be inside objects in the underlying list.
             */
            local m = matches.subset(
                { o: parent.matches.indexWhich(
                    { p: o.obj.isChild(p.obj, nil) }) != nil });

            /* if that didn't rule everything out, apply the filter */
            if (m.length() > 0)
                matches = m;

            /* next, apply any locational qualifier of my own */
            if (contQual != nil)
                contQual.applyContQual();

            /* filter parent objects not containing anything in my list */
            parent.matches = parent.matches.subset(
                { p: matches.indexWhich(
                    { o: o.obj.isChild(p.obj, nil) }) != nil });
        }

        /*
         *   Apply this locational phrase's qualification.  This filters the
         *   underlying (parent) noun list to keep only objects located within
         *   the object(s) named in this noun phrase.
         */
        applyLocational()
        {
            /*
             *   First, do the reverse filtering, to keep only objects that
             *   could contain objects in the underlying list.
             */
            local m = matches.subset(
                { o: parent.matches.indexWhich(
                    { p: p.obj.isChild(o.obj, locType) }) != nil });

            /* if that didn't rule everything out, apply the filter */
            if (m.length() > 0)
                matches = m;

            /* next, apply any locational qualifier of my own */
            if (locQual != nil)
                locQual.applyLocational();

            /* first, try limiting to items DIRECTLY in the location */
            m = parent.matches.subset(
                { p: matches.indexWhich(
                    { o: p.obj.isDirectChild(o.obj, locType) }) != nil });

            /* if there weren't any, try items indirectly in the location */
            if (m.length() == 0)
                m = parent.matches.subset(
                    { p: matches.indexWhich(
                        { o: p.obj.isChild(o.obj, locType) }) != nil });

            /* save the filtered list in the parent */
            parent.matches = m;
        }

        /*
         *   Apply an exclusion item.  This resolves the vocabulary for the
         *   exclusion phrase and filters the matching item(s) noun phrase out
         *   of the parent list.
         */
        applyExclusion(cmd)
        {
            /* do our vocabulary matching */
            matchVocab(cmd);

            /* filter the parent list to exclude everything we matched */
            parent.matches = parent.matches.subset(
                { p: matches.indexWhich(
                    { o: o.obj == p.obj }) == nil });
        }

        /*
         *   Select the objects from among the vocabulary matches.  This
         *   narrows the list of possible vocabulary matches for our noun
         *   phrase to find the actual object or objects the player is
         *   referencing.
         *
         *   When this is called, we've already filled in the match list with
         *   all objects in scope that match the vocabulary of the core noun
         *   phrase (including non-reflexive pronouns and ALL), and we've
         *   applied any possessive, locational, and exclusion qualifiers.
         *   What we're left with is the list of in-scope objects that meet all
         *   of the specifications contained in the entire noun phrase.  In
         *   other words, we've squeezed all available information out of the
         *   noun phrase itself.  If the result is ambiguous, then, we'll have
         *   to look beyond the noun phrase, to the broader semantic content of
         *   the overall command.
         *
         *   There are three possible "goals" for what our final object list
         *   should look like after disambiguation.  Only one goal applies to
         *   each particular noun phrase; which it is depends on the grammar of
         *   the phrase:
         *
         *   1.  Definite mode: TAKE BOOK, TAKE THE BOOK, TAKE BOTH BOOKS, TAKE
         *   THE THREE BOOKS.  The goal in definite mode is to choose the given
         *   number of objects, *and* to make sure that the player could *only*
         *   have meant those precise objects.  In other words, we're not
         *   allowed to make an arbitrary choice: in natural language, the
         *   definite mode says that the speaker believes the listener knows
         *   which *particular* object or objects the speaker is referring to.
         *   If we're not absolutely sure which objects the player is talking
         *   about, we have a disagreement with the player's apparent
         *   expectations and must ask for clarification.
         *
         *   2.  Indefinite mode: TAKE A BOOK, TAKE ANY BOOK, TAKE TWO BOOKS.
         *   The goal is to choose the given number of objects from the
         *   possible matches, arbitrarily choosing from the available objects.
         *
         *   3. Plural mode: TAKE BOOKS, TAKE THE BOOKS, TAKE ALL BOOKS.  The
         *   goal here is to choose all of the matching objects.
         */
        selectObjects(cmd)
        {
            /* take the mode from the determiner */
            local mode = determiner;

            /*
             *   If the player typed ALL or ANY or some such response in response to
             *   a disambiguation respose, that response will have set a determiner
             *   we need to use instead.
             */
            if(cmd.disambig.length > 0)
                mode = cmd.disambig[1][1].determiner;

            /*
             *   Sort the matches by listing order.  If we have a plural, this
             *   will make the order of processing more logical when there's
             *   some kind of natural order (such as alphabetized or numbered
             *   items).
             */
            matches.groupSort(
                { ent, idx: [ent.obj.disambigGroup, ent.obj.disambigOrder] });

            /* if there's no determiner, assume definite */
            if (mode == nil)
                mode = Definite;

            /*
             *   If we're in Definite mode and we don't have a quantifier,
             *   check for a plural noun phrase.  A plural without a specific
             *   number puts us in Plural mode.  Consider the noun phrase to be
             *   plural if it matched any of our objects with plural usage.
             *   Even if some objects were singular in usage, one plural is
             *   enough to suggest that the name has plural usage.
             */
            if (mode == Definite
                && quantifier == nil
                && matches.indexWhich({ m: m.match & MatchPlural }) != nil)
                mode = All;

            /*
             *   Figure the target quantity.  If there's a quantifier, it's the
             *   quantifier value; otherwise we implicitly want a singleton.
             *   Note that the quantifier is ignored in Plural mode, since we
             *   simply want to match all of the objects in this case.
             */
            local num = (quantifier != nil ? quantifier : 1);

            /*
             *   If we don't have enough objects to satisfy the request,
             *   complain about it.
             */
            if (num > matches.length()
                && objs.indexWhich({o: o.canSupply}) == nil)
                throw new InsufficientNounsError(cmd, self);

            if (mode == Definite && isAllEquivalent(matches) && matches.length > 1)
                mode = Indefinite;

            for(local cur in objs)
                cur.filterResolveList(self, cmd, mode);

            /* select the goal based on the mode */
            switch (mode)
            {
            case Definite:
                /*
                 *   Definite mode.  If we have more than the desired number,
                 *   we must disambiguate.
                 */
                if (matches.length() > num)
                    disambiguate(cmd, num, cmd.action);
                else
                    /*
                     *   If we don't disambiguate we don't run the verify routine
                     *   that stores a reference to the object selected for this
                     *   role so that it can be available to the verify routine for
                     *   the other role; so we store a reference now.
                     */
                    cmd.action.(role.objProp) = cmd.(role.objListProp)[1].obj;
                break;

            case Indefinite:
                /*
                 *   Indefinite mode - we must select the desired number, but
                 *   we can do so arbitrarily.  Simply select the first 'num'
                 *   in the list.
                 */

                /* start by getting object rankings from the verb */
                cmd.action.scoreObjects(cmd, role, matches);

                /* sort by score (highest to lowest), except for the ActorRole */
                matches.sort(SortDesc, { a, b: a.score - b.score });

                if (matches.length() > num)
                    matches.removeRange(num + 1, matches.length());

                /* flag the objects as arbitrarily chosen */
                matches.forEach({ m: m.flags |= SelArbitrary });
                break;

            case All:
                /*
                 *   Plural mode - select all of the objects.  Simply use the
                 *   set we've already built.  Flag the selections as plural.
                 */
                matches.forEach({ m: m.flags |= SelPlural });
                cmd.matchedMulti = true;
                break;
            }
        }

        /*
         *   Determine whether all matches in the matchList are impossible to
         *   disambiguate.
         */
        isAllEquivalent(matchList){
            local names = Distinguisher.getNames(
                matchList.mapAll({ x: x.obj }), nil);
            return (names.length() == 1);
        }

        /*
         *   Disambiguate the match list to select the given target number of
         *   objects.
         */
        disambiguate(cmd, num, action)
        {
            /* start by getting object rankings from the verb */
            action.scoreObjects(cmd, role, matches);

            /* sort by score (highest to lowest) */
            matches.sort(SortDesc, { a, b: a.score - b.score });

            /*
             *   To pick automatically, we need exactly 'num' objects at the
             *   highest score.  The sort put the object with the highest score
             *   at the start of the list, so the high-scoring subset is the
             *   subset that matches the first object's score.
             *
             *   We only disambiguate in definite mode, and definite mode in
             *   input is the player's way of telling us that they think there
             *   are exactly this many objects that obviously apply to their
             *   command.  The score tells us which objects *we* think are the
             *   obvious choices for the command.  If we come up with the same
             *   set size that the player expressed, then we presumably
             *   understand what the player is saying.  If our set size differs
             *   from theirs, we're not thinking alike, so we need to ask for
             *   clarification.
             */
            local sub = matches.subset({x: x.score == matches[1].score});

            if (isAllEquivalent(sub))
                sub.setLength(num);

            if (sub.length() == num)
            {
                /*
                 *   We have the desired number of most obvious matches, so
                 *   we've successfully disambiguated it.  We might want to
                 *   announce the selection, since we're making a guess, so
                 *   generate a name for each that distinguishes it from the
                 *   other items we could have matched.
                 */
                local names = Distinguisher.getNames(
                    matches.mapAll({ x: x.obj }), nil);

                /* save the disambiguated subset */
                matches = sub;

                /* mark each as disambiguated, and save the distinctive name */
                foreach (local m in matches)
                {
                    m.flags |= SelDisambig;
                    m.name = names.valWhich({ n: n[2].indexOf(m.obj) != nil })[1];
                }

                /* we've successfully disambiguated the phrase */
                return;
            }
            else if (sub.length() > num && num > 1)
            {
                /*
                 *   We've asked for a definite number of 2 or more items, but there
                 *   are different options among the best matches.  This poses a
                 *   problem because there's no good disambiguation we can possibly
                 *   ask here. So we just give up and ask them to be more specific.
                 *   I can imagine someone responding to this message by just
                 *   retyping a more specific form of the noun phrase. For example,
                 *   after GET THE TWO MATCHES doesn't work, they might just want to
                 *   type THE LIT MATCH AND AN UNLIT MATCH, but currently the parser
                 *   does not do this.  Probably the DMsg should also refer to the
                 *   specific noun phrase that is ambiguous in its message.
                 */
                throw new AmbiguousMultiDefiniteError(cmd,self);
            }

            /*
             *   We have more than what we need in the highest scoring section,
             *   so make this the matches and proceed with disambiguation.
             *   This line makes it so that when you say something like "drop match"
             *   it will only try to disambiguate among the things you are holding.
             *   I think this behavior is more desirable, but am not certain.
             */
            matches = sub;

            /* it's still ambiguous, so throw an error to ask for help */
            ambigError(cmd);
            matches.setLength(num);
        }

        /*
         *   Throw an ambiguous noun phrase error for the current match list.
         */
        ambigError(cmd)
        {
            /* if we have a reply to a past disambiguation question, apply it */
            local disambig = cmd.fetchDisambigReply();
            if (disambig != nil)
            {
                /* start a list for the result */
                local dmatches = new Vector(matches.length());

                /* add the object(s) selected by each noun phrase in the reply */
                foreach (local dnp in disambig)
                {
                    /*
                     *   resolve this noun phrase of the reply and add its
                     *   selections to the master list
                     */
                    dmatches.appendAll(
                        dnp.applyDisambig(cmd, matches, disambigNameList));
                }

                /*
                 *   If we get this far, we have a valid result set now, even
                 *   if it's not of the original size.  The reply can select a
                 *   different number of objects than originally implied, since
                 *   the reply can say something like "the red one and the blue
                 *   one" to pick more than one of the offered objects.
                 */
                matches = dmatches;
                return;
            }

            /*
             *   Still ambiguous, so we need to ask for clarification, with a
             *   question like "Which do you mean, the red book, or the blue
             *   book?"  Generate the list of names.
             */
            local nameList = Distinguisher.getNames(
                matches.mapAll({ x: x.obj }), true);

            /*
             *   Sort by disambigGroup and disambigOrder.  Note that it's
             *   possible for a set to have more than one item with a
             *   disambigGroup, and these might not match.  We can't break up a
             *   set, though, so we'll just have to pick one group arbitrarily
             *   for the whole set.
             */
            nameList.groupSort(new function(entry, idx)
            {
                /* find an arbitrary entry in the set with a disambigGroup */
                local gobj = entry[2].valWhich({ x: x.disambigGroup != nil });

                /* if we found one, use its group and order; otherwise use nil */
                return gobj != nil
                    ? [gobj.disambigGroup, gobj.disambigOrder]
                    : [nil, idx];
            });

            /*
             *   remember this list, since it determines the meanings of
             *   ordinals ("the second one") in the reply
             */
            disambigNameList = nameList;

            /* throw the still-ambiguous error */
            throw new AmbiguousError(cmd, self, nameList);

        }

        /*
         *   Apply this noun phrase as a disambiguation reply to the given
         *   original list of matches to an ambiguous noun phrase.
         */
        applyDisambig(cmd, ambigMatches, nameList)
        {
            /*
             *   Start with the ambiguous list.  Our goal is to narrow the list
             *   that the original noun phrase matched, so start with the list
             *   and remove items that don't match the additional vocabulary
             *   and/or qualifiers in the reply.
             */
            matches = ambigMatches;

            /* if there's an ordinal, pick out the selected item */
            if (ordinal != nil)
            {
                /* pick the name list entry based on the list position */
                local n;
                if (ordinal == -1 && nameList.length() > 0)
                    n = nameList[nameList.length()];
                else if (ordinal >= 1 && ordinal <= nameList.length())
                    n = nameList[ordinal];
                else
                    throw new OrdinalRangeError(self, ordinal);

                /*
                 *   take the first object from the group, and build a resolved
                 *   object list with this object
                 */
                n = n[2][1];
                matches = matches.subset({ m: m.obj == n });
            }

            /* if there's a locational qualifier, apply it */
            if (locQual != nil)
            {
                /* apply the locational qualifier */
                locQual.matchVocab(cmd);
                locQual.applyLocational();

                /* if that empties our list, flag it */
                if (matches.length() == 0)
                    throw new NoneInLocationError(cmd, parent, locQual);
            }

            /* if there's a possessive qualifier, apply it */
            if (possQual != nil)
            {
                /* apply the possessive qualifier */
                possQual.matchVocabPoss(cmd);
                possQual.applyPossessive();

                /* if that empties our list, flag it */
                if (matches.length() == 0)
                    throw new NoneInOwnerError(cmd, parent, possQual);
            }

            /* if there's a contents qualifier, apply it */
            if (contQual != nil)
            {
                /* apply the qualifier */
                contQual.matchVocab(cmd);
                contQual.applyContQual();

                /* if that empties our list, flag it */
                if (matches.length() == 0)
                    throw new NoneWithContentsError(cmd, parent, contQual);
            }

            /* if there's vocabulary, apply it */
            if (tokens.length() > 0)
            {
                /*
                 *   The basic vocabulary of the reply isn't as simple to
                 *   handle as it might seem, since the words could refer to
                 *   the object itself, a container, an owner, or the nominal
                 *   contents.  Consider:
                 *
                 *   Which bucket do you mean, the empty bucket, the bucket on
                 *   the shelf, the tall fisherman's bucket, or the bucket of
                 *   water?
                 *
                 *   Players are accustomed to being able to answer these
                 *   questions by entering just a word or two from the prompt,
                 *   so we'd want to accept EMPTY, SHELF, TALL, and WATER for
                 *   the respective choices.
                 *
                 *   So: first assume that the reply refers to the object
                 *   itself.  If we don't find any matches, try the other
                 *   possibilities: containers, owners, and nominal contents.
                 */
                if (tokens.length() > 0 && matches.length() > 0)
                {
                    /* first try applying the words to the object itself */
                    local m = matches.subset(
                        { o: o.obj.matchNameDisambig(tokens) != 0 });

                    /* if that didn't match anything, try containers */
                    if (m.length() == 0)
                    {
                        /* get the list of in-scope objects matching the tokens */
                        local locs = World.scope.subset(
                            { o: o.matchNameDisambig(tokens) != 0 });

                        /* get the subset of 'matches' that are in 'locs' */
                        m = matches.subset(
                            { o: locs.indexWhich(
                                { l: o.obj.isChild(l, nil) }) != nil });
                    }

                    /* if we still don't have any matches, try owners */
                    if (m.length() == 0)
                    {
                        /* get the list of scope objects plus potential owners */
                        local owners = new Vector(50, World.scope.toList());
                        foreach (local obj in matches)
                        {
                            local owner = obj.obj.owner;
                            if (owner != nil)
                                owners.appendAll(owner);
                        }

                        /* get the subset matching the tokens */
                        owners = owners.subset(
                            { o: o.matchNameDisambig(tokens) != 0 });

                        /* get the subset of 'matches' with owners in 'owners' */
                        m = matches.subset(
                            { o: owners.indexWhich(
                                { l: o.obj.ownedBy(l) }) != nil });
                    }

                    /* if we still don't have any matches, try nominal contents */
                    if (m.length() == 0)
                    {
                        /* get the list of in-scope objects matching the tokens */
                        local conts = World.scope.subset(
                            { c: c.matchNameDisambig(tokens) != 0 });

                        /* get the subset of 'matches' with contents in 'conts' */
                        m = matches.subset(
                            { o: conts.indexOf(o.obj.nominalContents) != nil });
                    }

                    /* if we've eliminated everything, it's an error */
                    if (m.length() == 0)
                        throw new UnmatchedNounError(cmd, self);

                    /* we're out of things to try, so take what we have */
                    matches = m;
                }
            }

            /* determine how many the reply *wants* to select */
            local num = (quantifier != nil ? quantifier : 1);

            /* if we don't have enough, it's an error */
            if (matches.length() < num)
                throw new InsufficientNounsError(cmd, self);

            if (determiner == Definite && isAllEquivalent(matches))
                determiner = Indefinite;

            /* determine the actual number available */
            switch (determiner)
            {
            case Definite:
                /*
                 *   They want exactly the number indicated.  If we still have
                 *   more than this, it's *still* ambiguous, so throw another
                 *   ambiguity error to further disambiguate the new list.
                 *   Otherwise, we're set.
                 */
                if (num < matches.length())
                    ambigError(cmd);
                break;

            case Indefinite:
                /* indefinite - arbitrarily select any 'num' of the items */
                if (matches.length() > num)
                    matches.removeRange(num + 1, matches.length());

                /* mark them as arbitrary */
                matches.forEach({ m: m.flags |= SelArbitrary });
                break;

            case All:
                /* all - keep all of the items */
                break;
            }

            /* return our final match list */
            return matches;
        }

        /*
         *   Resolve ALL.  This is called on a separate pass after
         *   selectObjects(), because two-object verbs sometimes resolve ALL in
         *   one slot according to the selection in the other slot.
         */
        resolveAll(cmd)
        {
            /* if this is a simple ALL phrase, re-resolve it */
            if (determiner == All)
            {
                /*
                 *   If it's just ALL, re-match the vocabulary to pick up the
                 *   final ALL list.  Otherwise, take the subset of the ALL
                 *   list that matches the vocabulary.
                 */
                if (tokens == [])
                {
                    /* it's just ALL - start over with the final ALL list */
                    matchVocab(cmd);
                }
                else
                {
                    /*
                     *   it's ALL <somethings> - take the subset that's in the
                     *   final ALL list
                     */
                    local all = cmd.action.getAll(cmd, role);
                    local sub = matches.subset({ m: all.indexOf(m.obj) != nil });

                    /*
                     *   If we found any objects in the intersection, keep only
                     *   the subset, since this is the set that actually makes
                     *   sense for this command.  If the subset is empty,
                     *   though, ignore it and stick with the objects we've
                     *   already selected based on the vocabulary; these will
                     *   probably fail the command, but that'll make more sense
                     *   to the player than claiming there's nothing matching
                     *   the description they gave.
                     */
                    if (sub.length() != 0)
                        matches = sub;
                }
            }
        }

        /*
         *   Resolve reflexive pronouns.  Our Command calls this AFTER
         *   resolving all of the regular noun phrases, because reflexives
         *   refer back to other nouns in the same command.
         */
        resolveReflexives(cmd)
        {
            /* if we have a reflexive pronoun object in the list, resolve it */
            if (matches.length() == 1 && matches[1].obj.ofKind(Pronoun))
            {
                /*
                 *   We have a reflexive pronoun pending.  Ask the command for
                 *   the current meaning of the reflexive.
                 */
                matches = cmd.resolveReflexive(matches[1].obj).mapAll(
                    { x: new NPMatch(self, x, 0) });

                /* it's an error if that didn't yield anything */
                if (matches.length() == 0)
                    throw new NoAntecedentError(self, pronoun);
            }
            else
            {
                /*
                 *   This isn't a reflexive, so it's a candidate to be an
                 *   antecedent of a reflexive later in the phrase.  Pass it
                 *   along to the command to note for future use.  Since we
                 *   visit the noun phrases in their order of appearance in the
                 *   command, we'll naturally have the latest one before the
                 *   pronoun when we encounter a pronoun, which is exactly what
                 *   we want: a reflexive pronoun binds to the nearest
                 *   preceding noun that matches in gender, number, etc.
                 */
                matches.forEach({ match: cmd.saveReflexiveAnte(match.obj) });

                /* also save the entire list, for THEMSELVES */
                cmd.saveReflexiveAnte(matches.mapAll({ x: x.obj }));
            }
        }

        /* Build the 'objs' list from the match list */
        buildObjList()
        {
            objs = matches.mapAll({x: x.obj});
        }

        /*
         *   List of NPMatch objects.  This is populated during the matchName
         *   phase with the list of possible vocabulary matches, and then
         *   reduced during disambiguation to the final set.
         */
        matches = []

        /*
         *   List of resolved objects.  This is populated after disambiguation
         *   from the 'matches' set - it contains the same objects, but simply
         *   the objects rather than the NPMatch wrappers.
         */
        objs = []

        /* add a literal to this phrase */
        addLiteral(tok) { tokens += tok; }

        /* add a possessive qualifier, returning the new noun phrase */
        addPossessive(prod)
        {
            /* create, store, and return a new noun phrase for the possessor */
            return possQual = new NounPhrase(self, prod);
        }

        /* add a contents qualifier, returning the new noun phrase */
        addContents(prep, prod)
        {
            /* remember the contents preposition */
            contPrep = prep;

            /* create, store, and return a new noun phrase for the contents */
            return contQual = new NounPhrase(self, prod);
        }

        /* add a locational qualifier, returning the new noun phrase */
        addLocation(locType, prod)
        {
            /* create a new noun phrase for the location */
            locQual = new NounPhrase(self, prod);

            /* set its location type */
            locQual.locType = locType;

            /* return the new phrase */
            return locQual;
        }

        /* add a quantifier, given as an integer value */
        addQuantifier(num)
        {
            quantifier = num;
        }

        /* add an ordinal, given as an integer value */
        addOrdinal(num)
        {
            ordinal = num;
        }

        /* add an exclusion list item */
        addExclusionItem(prod)
        {
            /* if we don't already have an exclusion list, create one */
            if (exclusions == nil)
                exclusions = [];

            /* create a new NounPhrase */
            local np = new NounPhrase(self, prod);

            /* add it to the exclusion list */
            exclusions += np;

            /* return the new noun phrase */
            return np;
        }

        /*
         *   Does this noun phrase refer to multiple objects structurally?
         *   This is true if any the matches used plural words, or the
         *   determiner is All, or we have a quantifier greater than 1.
         */
        isMultiple()
        {
            return determiner == All
                || (quantifier != nil && quantifier > 1)
                || matches.indexWhich({ m: m.match & MatchPlural }) != nil;
        }

        /*
         *   the Command list we're a part of (&dobjNPs, &iobjNPs, etc: the
         *   Command overrides this to the actual list property for a primary
         *   noun phrase, and for qualifiers such as possessives, this
         *   inherited version looks it up via the parent)
         */
        role = (parent.role)

        /* the NounPhrase we qualify, if we're a possessive or locational */
        parent = nil

        /* the grammar production match object for this noun phrase */
        prod = nil

        /*
         *   the grammar match for the core noun phrase; this is the part that
         *   names a single object, stripped of all qualifiers (such as
         *   possessives, articles, quantifiers, and locational phrases)
         */
        coreProd = nil

        /* the literal tokens making up the noun phrase */
        tokens = []

        /* the pronoun, if any, as a Pronoun object */
        pronoun = nil

        /* the possessive qualifier, if any ("BOB'S box") */
        possQual = nil

        /* the locational qualifier phrase, if any ("the box ON THE SHELF") */
        locQual = nil

        /*
         *   The locational qualifier relationship, as a LocType object.  (This
         *   is stored on the locational qualifier noun phrase itself, not on
         *   the underlying noun phrase it qualifies.)
         */
        locType = nil

        /* the contents qualifier phrase, if any ("the bucket OF WATER") */
        contQual = nil

        /* the preposition of the contents qualifier */
        contPrep = nil

        /* the quantifier, if any, as a number: for "five books", this is 5 */
        quantifier = nil

        /*
         *   The ordinal value, if any, as a number: for "the third one", this
         *   is 3.  This is intended for use in disambiguation replies, to let
         *   the user pick out an item by its position in the offered list.
         */
        ordinal = nil

        /* the determiner, if any, as a Determiner object */
        determiner = nil

        /*
         *   the exclusion list, if any (this is the list following EXCEPT or
         *   BUT in a phrase like ALL EXCEPT THE RED ONES)
         */
        exclusions = nil

        /* the name list from the disambiguation query */
        disambigNameList = nil
    ;

    /*
     *   TopicPhrase is a special kind of NounPhrase for topics (ASK ABOUT,
     *   TELL ABOUT, TALK ABOUT, LOOK UP, etc).  These phrases aren't resolved
     *   to game-world objects the way ordinary noun phrases are, but instead
     *   are resolved to conversation topic objects.
     */
    class TopicPhrase: NounPhrase
         /*
         *   Get the list of objects matching the vocabulary words in our noun
         *   phrase.  Populates our 'matches' property with a vector of matching
         *   objects.  This doesn't look at any of our qualifiers, or attempt
         *   to disambiguate contextually; it simply finds everything in scope
         *   that the noun phrase could refer to.
         */
        matchVocab(cmd)
        {
            /* start with an empty vector */
            local v = new Vector(32);

            /* get the current scope list */
            //        local scope = World.scope;

            local scope = Q.topicScopeList;

            /* check what kind of phrase we have */
            if (pronoun != nil)
            {
                /* it's a pronoun - resolved based on the antecedent */
                addMatches(v, pronoun.resolve(), 0);

                /* if there are no antecedents, flag the error */
                if (v.length() == 0)
                    throw new NoAntecedentError(self, pronoun);

                /* filter for in-scope objects (or reflexive placeholders) */
                v = v.subset(
                    { m: m.obj.ofKind(Pronoun) || scope.find(m.obj) });

                /* if that leaves nothing, flag the error */
                if (v.length() == 0)
                    throw new AntecedentScopeError(cmd, self, pronoun);

            }

            else
            {
                /*
                 *   It's a named object.  Our 'tokens' property is a list of the
                 *   words in the noun phrase in the user input.  Match it against
                 *   the objects in physical scope.
                 */
                 v.appendAll(matchNameScope(cmd, scope));

                /*
                 *   Create a dummy object to represent the literal text; we may
                 *   need this even if there are other matches to ensure that a
                 *   regular expression is matched on a TopicEntry.
                 */
                local obj = new Topic(tokens.join(' ').trim());

                /* Wrap the dummy object in am NPMatch object */
                local lst = [obj];

                addMatches(v, lst, 1);

                matches = v;

                cmd.madeTopic = true;

            }

            /* save the match list so far */
            matches = v;

            /* if we have a possessive qualifier, apply it */
            if (possQual != nil)
            {
                /* match vocabulary for the possessive phrase */
                possQual.matchVocabPoss(cmd);

                /*
                 *   apply the qualifier, filtering out things not owned by the
                 *   object named in the qualifier
                 */
                possQual.applyPossessive();

                /* if that empties our list, flag it */
                if (matches.length() == 0)
                    throw new NoneInOwnerError(cmd, self, possQual);

                /* expand the error text to include the possessive qualifier */
                expandErrName(possQual);
            }

    //        if(matches.length == 0)
            {

            }

            local res = new ResolvedTopic(matches.mapAll({o: o.obj}).toList, tokens);

            res = new NPMatch(v[1].np, res, v[1].match);

            matches = new Vector([res]);

        }

        matchNameScope(cmd, scope)
        {
            /* set up a vector for the results */
            local v = new Vector(32);

            /*
             *   Run through the scope list and ask each object if it matches
             *   the noun phrase.  Keep the ones that match.
             */
            foreach (local obj in scope)
            {
                /* ask this object if it matches */
                local match = obj.matchName(tokens);

                /* if it matches, include it in the results */
                if (match)
                    v.append(new NPMatch(self, obj, match));
            }

            /* return the list */
            return v;
        }

        selectObjects(cmd)
        {
            filterResolveList(self, cmd, All);
        }
    ;

    class ResolvedTopic: object
        construct(lst, toks)
        {
            /*
             *   if our list of topics has more than one entry, sort it in ascending
             *   order of length of name. That's because the shorter the name, the
             *   closer it may be to what the player actually typed.
             */
            if(lst != nil && lst.length > 1)
                topicList = lst.sort(SortAsc, {a, b: a.name.length - b.name.length});
            else
                topicList = lst;
            tokens = toks;
        }

        topicList = nil
        tokens = nil

        getBestMatch = (topicList == nil ? nil : topicList[1])
        getTopicText = tokens.join(' ').trim()
        theName = (topicList != nil ? topicList[1].theName : getTopicText)
        aName = (topicList != nil ? topicList[1].aName : getTopicText)
        name = (topicList != nil ? topicList[1].name : getTopicText)
        person = 3
    ;

    /*
         *   LiteralPhrase is a special kind of NounPhrase for literals (TYPE,
         *   WRITE, SET TO, etc).  These phrases aren't resolved to game-world
         *   objects, but instead are just treated as literal text.
     */
    class LiteralPhrase: NounPhrase
        matchVocab(cmd)
        {
            local v = new Vector(2);

            /* Recreate the literal text */
            local litName = tokens.join(' ');

            /* Create a dummy object to represent the literal text */
            local obj = new LiteralObject(litName.trim());

            /* Wrap the dummy object in am NPMatch object */
            local lst = [obj];
            addMatches(v, lst, MatchNoApprox);

            matches = v;
        }

        selectObjects(cmd)
        {
            /* do nothing; there's only one object */
        }
    ;

    /* object to hold the result of a literal input */

    class LiteralObject: object
        construct(name_)
        {
            name = name_;
        }

        name = nil
        theName = (name)
        person = 3
    ;

    /*
     *   NumberPhrase is a special kind of NounPhrase for numeric literals
     *   (e.g., FOOTNOTE n).  These phrases aren't resolved to game-world
     *   objects, but are simply taken as numeric values.
     */
    class NumberPhrase: NounPhrase
         matchVocab(cmd)
        {
            local v = new Vector(2);

            /* Get the number just entered*/
            local val = prod.numval;

            /* Create a dummy object to represent the literal text */
            local obj = new NumericObject(tokens, val);

            /* Wrap the dummy object in am NPMatch object */
            local lst = [obj];
            addMatches(v, lst, MatchNoApprox);

            matches = v;
        }

        selectObjects(cmd)
        {
            /* do nothing; there's only one object */
        }
    ;

    /* An object to hold a numerical value. */
    class NumericObject: object
        construct(toks, val)
        {
            numToks = toks;
            numVal = val;
        }

        numToks = nil
        numVal = nil
        numStr = (numToks.join(' '))
    ;

    /* ------------------------------------------------------------------------ */
    /*
     *   NPMatch is an object that describes one object matching a noun phrase.
     */
    class NPMatch: object
        construct(np, obj, match)
        {
            /* save the NounPhrase, the object we matched, and the match flags */
            self.np = np;
            self.obj = obj;
            self.match = match;

            /*
             *   set the name initially to the object name; the Command will
             *   replace this before execution with a name from the
             *   Distinguishers that's unique relative to the other objects in
             *   the list
             */
            self.name = obj.name;

            /*
             *   Calculate the match strength for sorting purposes.
             *
             *   The strength tells us how well the vocabulary matched the
             *   object.  Matches without truncation are stronger than those
             *   that include truncated words; likewise character
             *   approximation.  Matches that consist of entirely adjectives
             *   are weaker than those that contain nouns or plurals (for
             *   example, if we have a TOY CAR and a TOY CAR REMOTE CONTROL in
             *   scope, we'd consider CAR to be an unambiguous match to the TOY
             *   CAR, since the match to the REMOTE is weak by virtue of being
             *   all adjectives).
             *
             *   The MatchXxx bit flags are arranged in arithmetic order of
             *   match strength, so the 'match' value basically equals the
             *   strength.  However, for the strength calculation, plurals and
             *   nouns are equivalent.  So the strength value is the match
             *   value with any plural flag replaced by the noun flag.
             */
            self.strength = (match & ~MatchPlural)
                | (match & MatchPlural ? MatchNoun : 0);
        }

        /* the NounPhrase we matched */
        np = nil

        /* the matching object */
        obj = nil

        /*
         *   the match flags - this is a combination of MatchXxx flags as
         *   returned from Mentionable.matchName()
         */
        match = 0

        /* the match strength, for sorting the match list */
        strength = 0

        /* the selection/disambiguation flags (SelXxx) */
        flags = 0

        /*
         *   Disambiguation score.  This is a number assigned by the action in
         *   scoreObjects().
         */
        score = 0

        /*
         *   The name, for announcement purposes.  This is filled in by the
         *   Command during execution.  The Command figures the name so that
         *   it's distinguished from all of the other objects in the same noun
         *   role in the command.
         */
        name = ''
    ;

    /* ------------------------------------------------------------------------ */
    /*
     *   Our root class for grammar productions.  (A "production" represents a
     *   match to a syntax rule, as defined with a 'grammar' template.)
     *
     *   The language module's grammar rules can define certain special
     *   properties on any production match object, and we'll find them in the
     *   course of building the command from the match tree:
     *
     *   endOfSentence=true - define this on a production for a sentence-ending
     *   verb conjunction.  In English (and most Western languages), this can
     *   be used with rules that match punctuation marks like periods,
     *   exclamation points, and question marks, since these marks typically
     *   end a sentence.  The parser distinguishes between the grammar rules
     *   for the first clause in a sentence vs subsequent clauses.  It starts a
     *   new input line with the first-in-sentence rule, then uses the
     *   additional clause rule for each subsequent clause.  When a clause ends
     *   with a sentence-ending mark, though, we'll treat the next clause as a
     *   sentence opener again.
     */
    class Production: object
        /* get the original text of the command for this match */
        getText()
        {
            /* if we have no token list, return an empty string */
            if (tokenList == nil)
                return '';

            /* build the string based on my original token list */
            return cmdTokenizer.buildOrigText(getTokens());
        }

        /* get my original token list, in canonical tokenizer format */
        getTokens()
        {
            /*
             *   return the subset of the full token list from my first token
             *   to my last token
             */
            return nilToList(tokenList).sublist(
                firstTokenIndex, lastTokenIndex - firstTokenIndex + 1);
        }

        /*
         *   Build the command for this production and its children.  By
         *   default, we'll simply traverse into our children.
         */
        build(cmd, np)
        {
            /* if this is a sentence-ending mark, note it */
            if (endOfSentence)
                noteEndOfSentence(cmd, self);

            /* run through our list of matches */
            local info = grammarInfoForBuild();
            for (local i = 2, local len = info.length() ; i <= len ; ++i)
            {
                /* get the current match */
                local cur = info[i];

                /* process it based on its type */
                switch (dataType(cur))
                {
                case TypeSString:
                    /* it's a literal token match item */
                    visitLiteral(cmd, np, cur);
                    break;

                case TypeObject:
                    /*
                     *   An object is a production sub-tree.  Set its parent
                     *   pointer to point back at us.
                     */
                    cur.parent = self;

                    /* visit the production */
                    visitProd(cmd, np, cur);
                    break;
                }
            }

            /*
             *   If there's a determiner, apply it the noun phrase.  Apply the
             *   determiner after building out the subtree, so that the parent
             *   determiner overrides any found in the subtree.
             */
            if (determiner != nil)
                np.determiner = determiner;
        }

        /*
         *   Get the grammar match list for build() purposes.  By default, this
         *   simply returns the grammarInfo() results, which are automatically
         *   generated by the compiler to return a list of the "->prop" values from
         *   the matched grammar rule.  Some rules might want to modify that default
         *   value list, so we provide this routine as an override hook.
         */
        grammarInfoForBuild()
        {
            return grammarInfo();
        }

        /*
         *   Add a new NounPhrase item to the list under construction.  Certain
         *   productions are associated with specific functional slots in the
         *   abstract command - direct object, indirect object, EXCEPT list,
         *   etc.  This routine is for such production subclasses to override,
         *   to direct new noun phrases into the appropriate slot lists.  In a
         *   grammar, the functional role is typically at a higher level in the
         *   tree, with ordinary noun phrases plugged in underneath.
         *
         *   Our default handling is to first check our nounPhraseRole
         *   property; if it's set, it tells us the role that this sub-tree
         *   plays in the predicate (direct object, indirect object,
         *   accessory).  We use that information to add the new NounPhrase to
         *   the Command list that we're building for our assigned role.
         *
         *   If nounPhraseRole is nil, then we simply pass the request up to
         *   our parent.  Eventually we should reach a node encoding the
         *   function slot.
         */
        addNounListItem(cmd, prod)
        {
            if (nounPhraseRole != nil)
                return cmd.addNounListItem(nounPhraseRole, prod);
            else
                return parent.addNounListItem(cmd, prod);
        }

        /*
         *   Note an end-of-sentence marker.  We'll simply notify our parent by
         *   default.
         */
        noteEndOfSentence(cmd, prod)
        {
            if (parent != nil)
                parent.noteEndOfSentence(cmd, prod);
        }

        /*
         *   The NounPhrase subclass to use for noun phrases within this
         *   sub-tree.  By default, we look to our parent; if we don't have a
         *   parent, we use the base NounPhrase class.
         *
         *   Special phrase types (topics, literals, and numbers) have their
         *   own NounPhrase subclasses.  This is important because the
         *   resolution rules for these phrase types differ from the regular
         *   object resolution rules.
         */
        npClass = (parent != nil ? parent.npClass : NounPhrase)

        /*
         *   My assigned noun phrase role, as a NounRole object.  This must be
         *   explicitly set for the top node in a noun slot (which can be a
         *   noun list production, a single noun production, a topic, etc).
         *
         *   In a positional language grammar, the predicate production will
         *   mark its immediate child in each noun phrase slot by setting this
         *   according to the role that the sub-tree plays in the predicate
         *   grammar.  Non-positional languages that use grammatical case or
         *   other ways of encoding the role information must set this some
         *   other way.
         */
        nounPhraseRole = nil

        /*
         *   Get our noun phrase role.  If we don't have a role defined
         *   directly, we'll inherit the role from our parent node.
         */
        getNounPhraseRole()
        {
            return nounPhraseRole != nil
                ? nounPhraseRole : parent.nounPhraseRole;
        }

        /*
         *   Visit a literal token child in our sub-tree.  This is called
         *   during the build process for each literal token in our child list.
         *   By default, we add the token to the command's current noun phrase.
         */
        visitLiteral(cmd, np, tok)
        {
            /* add the literal to the current noun phrase */
            if(np != nil)
               np.addLiteral(tok);
        }

        /*
         *   Visit a production object in our list.  This is called during the
         *   build process for each production object in our child list.  By
         *   default, we simply build the child production recursively.
         */
        visitProd(cmd, np, prod)
        {
            /* build out this production recursively */
            prod.build(cmd, np);
        }

        /*
         *   The determiner that this production applies to the noun phrase
         *   it's part of, as a Determiner object.  If this is non-nil, this
         *   Determiner will be set in the current NounPhrase when we visit
         *   this production in the build process.
         */
        determiner = nil

        /*
         *   My parent production.  The low-level GrammarProd mechanism doesn't
         *   set this up, so we set it up ourselves in the course of building
         *   out the tree.  In build(), just before we visit each
         *   sub-production, we set the sub-production's 'parent' property to
         *   point back to the parent production.  This property is therefore
         *   always set while we're traversing the child's tree, but won't
         *   necessarily be set yet if we're not currently working somewhere
         *   within the child's tree.  That means that you can always look at
         *   'parent' within your own build() routine or a child build()
         *   routine, but you can't necessarily look at it across the tree or
         *   within your own children.
         */
        parent = nil

        /*
         *   Find a parent matching a given test.  We'll scan up the parent
         *   tree, looking for the nearest parent p for which func(p) returns
         *   true, returning p.  If we can't find one, we return nil.
         */
        findParent(func)
        {
            /* find the nearest parent that passes the callback test */
            local par;
            for (par = parent ; par != nil && !func(par) ; par = par.parent) ;

            /* return what we found */
            return par;
        }

        /* Is this production a child of the given production? */
        isChildOf(prod)
        {
            /* look up my parent tree for the given parent */
            for (local par = parent ; par != nil ; par = par.parent)
            {
                /* if this is the one we're looking for, we're a child */
                if (par == prod)
                    return true;
            }

            /* didn't find it */
            return nil;
        }

        /*
         *   Find the action.  This finds the child of type VerbProduction,
         *   then retrieves the action from the verb production.
         */
        findAction()
        {
            /* find the VerbProduction among our children */
            local vp = findChild(VerbProduction);

            /* return the action from the VerbProduction, if we found it */
            return (vp != nil ? vp.action : nil);
        }

        /*
         *   Find a child of a given class.
         */
        findChild(cls)
        {
            /* if I'm of the desired class, we're done */
            if (ofKind(cls))
                return self;

            /* recursively scan my children */
            for (local gi = grammarInfo(), local i = 2, local len = gi.length() ;
                 i <= len ; ++i)
            {
                /* try this child */
                local chi = gi[i].findChild(cls);
                if (chi != nil)
                    return chi;
            }

            /* didn't find it */
            return nil;
        }
    ;

    /*
     *   CommandProduction is a special Production subclass for the top-level
     *   grammar rule for the overall command.
     *
     *   Each instance of this type of production must define the following
     *   '->' properties in its syntax template:
     *
     *   actor_ is the noun phrase giving the addressee of the command, if any.
     *   A command such as TELL ACTOR TO DO X or (using the long-standing IF
     *   convention) ACTOR, DO X addresses a command to an actor; i.e., it
     *   tells the actor to carry out the command, rather than the player's
     *   avatar.  A command that isn't addressed to an actor can leave actor_
     *   as nil.
     *
     *   cmd_ is the *first* predicate phrase (see below), in the desired order
     *   of execution.  For example, for "open the door and go north", cmd_
     *   should be set to the match tree for the "open the door" predicate.
     *
     *   conj_ is any conjunction or punctuation ending the first predicate
     *   phrase.  This might be a period at the end of the sentence, or a word
     *   like 'and' or 'then' that can separate multiple commands.  This can be
     *   nil if there's no conjunction at all (such as when the whole command
     *   is just the first predicate).  The reason we need conj_ is that it
     *   tells us where any subsequent command on the same command line starts.
     *   If cmd2_ is not nil, we'll ignore conj_ and use cmd2_ instead for this
     *   purpose.
     *
     *   cmd2_ is optional: it's the *second* predicate phrase.  If this is not
     *   nil, it tells the parser where to start parsing the next predicate on
     *   the same command line after finishing with the first one.  This is
     *   optional, even if the command line really does have more than one
     *   predicate, because the parser can use conj_ instead to infer where the
     *   second predicate must start.
     *
     *   (It's probably intuitively obvious what "first predicate" means, but
     *   for the sake of translators, here's a more thorough analysis.  Some
     *   command productions can match more than one predicate phrase, but this
     *   is only for the sake of determining where the first one ends,
     *   syntactically.  The execution engine actually only carries out the
     *   first predicate matched for a given parse tree - it simply ignores any
     *   others in the same tree.  After we finish executing the first
     *   predicate from the match, we go back and re-parse the remaining text
     *   from scratch, as raw text; at that point, the next predicate in the
     *   text becomes the first predicate in the new parse tree and gets
     *   executed.  We repeat this until we run out of text.  So we do
     *   eventually execute everything the player types in - but not on the
     *   first parse; we have to do one parse per predicate.  We have to repeat
     *   the parsing because carrying out the first action could change the
     *   game state in such a way that we'll find a different match to the next
     *   predicate than we would have if we'd parsed everything up front.  By
     *   "first predicate phrase", then, we mean the one that gets executed
     *   first.  The point is to carry out the user's wishes as expressed in
     *   the command, so we want the first predicate we execute to be the one
     *   that the player *intends* to be carried out first; so by "first" we
     *   really mean the one that a speaker of the natural language would
     *   expect to be performed first, given the structure of the sentence and
     *   the rules of the language.  In English, this is easy: X THEN Y or X,Y
     *   or X AND Y all mean "first do X, then do Y" - the reading order is the
     *   same as the execution order.)
     */
    class CommandProduction: Production
        /* -> property: the match tree for the addressee, if any */
        actor_ = nil

        /*
         *   The grammatical person of the actor to whom we're giving orders.
         *   This is 2 for second person and 3 for third person.  (It's not
         *   meaningful to give orders in the first person.)
         *
         *   In English (and probably most languages), commands of the form
         *   ACTOR, DO SOMETHING address ACTOR in the second person.  In
         *   contrast, TELL ACTOR TO DO SOMETHING gives orders to ACTOR, but in
         *   the third person.
         *
         *   In the second-person form of giving orders, second-person pronouns
         *   (YOU, YOURSELF) within the command will refer back to the actor
         *   being addressed: BOB, EXAMINE YOURSELF tells Bob to look at Bob.
         *   In the indirect form, YOU refers to the player character: TELL BOB
         *   TO EXAMINE YOU tells Bob to look at the PC.
         *
         *   The default is 2, since the long-standing IF convention is the
         *   ACTOR, DO SOMETHING format.  Override this (to 3) for TELL TO
         *   grammar rules.
         */
        actorPerson = 2

        /* build the tree */
        build(cmd, np)
        {
            /* if we're giving orders, tell the command which person they're in */
            if (actor_ != nil)
                cmd.actorPerson = actorPerson;

            /*
             *   if we have a second predicate or a conjunction, note where the
             *   second predicate starts
             */
            if (cmd2_ != nil)
            {
                /*
                 *   we have a second predicate production, so the second
                 *   predicate starts with the first token of that production
                 */
                cmd.nextTokens = tokenList.sublist(cmd2_.firstTokenIndex);
            }
            else if (conj_ != nil)
            {
                /*
                 *   we don't have an explicit second predicate production, but
                 *   we do have a conjunction, so the second predicate must
                 *   start at the next token after the conjunction
                 */
                cmd.nextTokens = tokenList.sublist(conj_.lastTokenIndex + 1);
            }

            /* do the normal work */
            inherited(cmd, np);
        }

        /* visit a production */
        visitProd(cmd, np, prod)
        {
            /* if this is the actor, create a NounPhrase for the actor role */
            if (prod == actor_)
                np = cmd.addNounListItem(ActorRole, prod);

            /*
             *   If this is the first predicate, actor, or conjunction, build
             *   it out as usual; otherwise ignore it.  We specifically don't
             *   want to build out any command processing for a second or
             *   subsequent predicate, because we only execute the first
             *   predicate in a parse tree.
             */
            if (prod is in (cmd_, actor_, conj_))
            {
                /* expand the token extent to include this phrase */
                if (prod.lastTokenIndex > cmd.tokenLen)
                    cmd.tokenLen = prod.lastTokenIndex;

                /* do the normal work */
                inherited(cmd, np, prod);
            }
        }

        /* note the end of the sentence */
        noteEndOfSentence(cmd, prod)
        {
            /*
             *   if the production is within the conjunction, the command ends
             *   the sentence
             */
            if (prod == conj_ || prod.isChildOf(conj_))
                cmd.endOfSentence = true;
        }
    ;

    /*
     *   A NounRole is a internal parser object that provides information on a
     *   given noun role in a predicate.
     *
     *   A noun role is one of the standard semantic roles that a noun phrase
     *   can play in a natural language predicate.  A predicate is a
     *   combination of an action and the objects that it applies to.  Any
     *   given verb has a set of assigned roles that need to be filled to make
     *   a complete thought.  (Sometimes the same verb word has multiple senses
     *   with different numbers of slots to fill, but you can think of the
     *   different senses as actually being different actions at some abstract
     *   level, which all happen to share the same verb word.)  For example,
     *   TAKE requires a noun phrase telling us which object is to be taken;
     *   this is called the direct object of the verb.  PUT X IN Y has a direct
     *   object (the thing to be put somewhere) and an indirect object (the
     *   place to put it).
     *
     *   Natural languages use a fairly small number of these noun roles.  Most
     *   predicates in most languages have just one role: TAKE, DROP, OPEN,
     *   CLOSE.  We call this first-and-only noun role the direct object.  A
     *   few predicates have two roles: PUT IN, GIVE TO, UNLOCK WITH.  We call
     *   the second role the indirect object.  A very few predicates have three
     *   roles: TRADE BOB AN APPLE FOR AN ORANGE, PUT PLUTONIUM IN REACTOR WITH
     *   TONGS.  We call the third role the "accessory" object (which is
     *   something we made up - there doesn't seem to be an agreed-upon word
     *   among linguists for this role).  And it appears that there's simply no
     *   such thing as a "tetratransitive" verb in any natural human language,
     *   so we don't bother defining a fourth slot.
     *
     *   (It would be easy for a game to add an object defining a fourth slot,
     *   analogous with these others, and use it to include a fourth noun
     *   phrase in the grammar for applicable verbs.  The rest of the parser
     *   will pick it up automatically if you do.  However, the practical
     *   utility of this seems minimal.  *Three*-noun verbs are incredibly rare
     *   in IF, in part because situations requiring them are rare, and in part
     *   because they're almost guaranteed to vex players and be panned as
     *   guess-the-syntax puzzles.  One can only imagine how a *four*-noun
     *   command would be received.)
     */
    class NounRole: object
        /*
         *   The -> property slot in the predicate grammar that's assigned to
         *   this role.  This is the property that predicate grammar rules
         *   assign for the match tree for a noun phrase taking this role.
         */
        matchProp = nil

        /* the NounPhrase list property in the Command object for this role */
        npListProp = nil

        /* the object match list property in the Command object for this role */
        objListProp = nil

        /* the property in the Command for the *current* item being executed */
        objProp = nil

        /* the property in the Command for the current item's NPMatch */
        objMatchProp = nil

        /*
         *   Is this a predicate noun phrase role?  This is true for roles that
         *   serve as objects of a verb: direct object, indirect object,
         *   accessory.  This is nil for non-predicate roles, such as the
         *   addressee actor.
         */
        isPredicate = true

        /*
         *   the predicate match object property that gives the grammar rule
         *   for parsing a reply to a missing noun question for this role
         */
        missingReplyProp = nil

        /*
         *   name - this is an ID string that we use internally for embedding
         *   the role in things like verb template strings
         */
        name = ''

        /*
         *   Internal sequence number.  This tells us the order in which this
         *   role appears in lists (including argument lists) when we store
         *   lists of roles.
         */
        order = 1000

        /* class property: master list of all roles */
        all = []

        /* class property: master list of all predicate roles */
        allPredicate = []

        /* on construction, populate the various maps */
        construct()
        {
            /* add it to our master list of roles */
            NounRole.all += self;

            /* add it to the master list of predicate roles, if applicable */
            if (isPredicate)
                NounRole.allPredicate += self;

            /* keep the lists in sorted order */
            NounRole.all = NounRole.all.sort(SortAsc, { a, b: a.order - b.order });
            NounRole.allPredicate = NounRole.allPredicate.sort(
                SortAsc, { a, b: a.order - b.order });
        }
    ;

    /*
     *   The DirectObject role is the role of the object being most directly
     *   acted upon in the command.  The is the only role in a verb that has
     *   only one object.  In a verb with two objects, this is the object most
     *   directly affected.  For example, UNLOCK DOOR WITH KEY directly acts
     *   upon the door, so the door is the direct object; the key isn't the
     *   direct object because it's merely a tool used to effect the change on
     *   the door.
     */
    DirectObject: NounRole
        matchProp = &dobjMatch
        npListProp = &dobjNPs
        objListProp = &dobjs
        objProp = &dobj
        objMatchProp = &dobjInfo
        missingReplyProp = &dobjReply
        curObjProp = &curDobj
        name = 'dobj'
        order = 1
    ;

    /*
     *   The IndirectObject role is the role of a secondary object that is used
     *   in the command, but isn't the primary object being acted upon.  This
     *   is usually a tool (UNLOCK dobj WITH iobj), a destination (PUT dobj IN
     *   iobj), or a topic (ASK dobj ABOUT iobj).
     */
    IndirectObject: NounRole
        matchProp = &iobjMatch
        npListProp = &iobjNPs
        objListProp = &iobjs
        objProp = &iobj
        objMatchProp = &iobjInfo
        missingReplyProp = &iobjReply
        curObjProp = &curIobj
        name = 'iobj'
        order = 2
    ;

    /*
     *   The AccessoryObject role is for a *third* object, beyond the direct
     *   and indirect objects, involved in the command.  This might be a peer
     *   to the indirect object in an exchange (TRADE dobj AN iobj FOR AN
     *   accessory), but the canonical IF use is as a tool in a two-object
     *   operation (PUT dobj IN iobj WITH accessory, WRITE dobj ON iobj WITH
     *   accessory).
     */
    AccessoryObject: NounRole
        matchProp = &accMatch
        npListProp = &accNPs
        objListProp = &accs
        objProp = &acc
        objMatchProp = &accInfo
        missingReplyProp = &accReply
        curObjProp = &curAobj
        name = 'acc'
        order = 3
    ;

    /*
     *   ActorRole is a special role for the addressee of a command (BOB, GO
     *   NORTH, or TELL BOB TO GO NORTH).  This doesn't appear as part of a
     *   predicate structure, so there's no matchProp, but it is used within
     *   the Command.
     */
    ActorRole: NounRole
        npListProp = &actorNPs
        objListProp = &actors
        objProp = &actor
        isPredicate = nil
    ;

    /*
     *   VerbProduction is a special Production subclass for verb (predicate)
     *   rules.  This production has special processing for building out the
     *   object phrases making up the verb.
     *
     *   Each instance should have an 'action' property giving the Action
     *   object associated with the verb rule.  This is the Action that will be
     *   performed when the parser matches the command input to the rule.
     *
     *   Some languages, such as English, have "positional" predicate grammars.
     *   This means that the position of a noun phrase in the sentence
     *   determines its role (direct object, indirect object, etc).  In the
     *   grammar for a positional language, each predicate rule simply needs to
     *   plug in a singleNoun or nounList production (as appropriate) in each
     *   noun phrase position, with its '->' property set to correspond to the
     *   role: ->dobjMatch for a direct object, ->iobjMatch for an indirect
     *   object, and ->accMatch for an accessory object.
     *
     *   Some languages, such as German and Latin, identify the role of a noun
     *   phrase using grammatical case.  This means that the articles change
     *   form in the different roles, or that the nouns themselves are
     *   inflected (they have different forms, such as added suffixes)
     *   according to role.  Case languages tend to have flexible predicate
     *   word order, because the case markers tell you the role of each noun
     *   even if the nouns are rearranged.  For this reason, it can be tedious
     *   to write a grammar for a case language the way we do for English,
     *   where the word ordering for a given verb is so rigid that we can
     *   easily just write out each possible phrasing manually.  For a case
     *   language, you'll probably instead want to write a set of generic verb
     *   rules that cover *all* verbs (i.e., you leave the verb word itself as
     *   a sub-production) in all of the different word orders, and use the
     *   case tagging in the language to determine the role of each noun
     *   phrase.  For this style of grammar, the grammar must set the property
     *   nounPhraseRole in the top-level rule for each noun phrase case; set
     *   this to DirectObject, IndirectObject, AccessoryObject, etc., according
     *   to the role denoted by the case.
     *
     *   Still other languages, such as Japanese, use particles (grammar
     *   function words) to denote the role of each noun phrase in the
     *   sentence.  This is similar to grammatical case, but the role
     *   information is encoded in separate words (the particles) rather than
     *   in noun affixes, so the nouns themselves aren't inflected.  You can
     *   handle this type of language roughly the same way you'd handle a case
     *   language.  Create generic rules that cover all verbs, then create a
     *   grammar rule for each particle-plus-noun structure.  In each
     *   particle-plus-noun phrase's top-level rule, set the nounPhraseRole
     *   property to the appropriate role object (DirectObject, etc).
     */
    class VerbProduction: Production
        /*
         *   The "priority" of this grammar rule.  This is a contributor to the
         *   Command priority - see Command.priority for an explanation of how
         *   that's used.
         *
         *   The predicate priority is a small number, 0-99.  The default is
         *   50, which should apply to most normal, complete verb phrases.  For
         *   incomplete phrases (with a missing object, which will force the
         *   parser to assume a default or ask the player for the missing
         *   information), use 25.  Other values are for fine-tuning as needed
         *   in the individual grammar rules.  A higher value means higher
         *   priority.
         */
        priority = 50

        /*
         *   Do we want to consider this production to be active; we may want some
         *   VerbRules to be active only under certain circumstanes.
         */
        isActive = true

        /* build the command */
        build(cmd, np)
        {
            /* set the action and the predicate phrase priority in the command */
            cmd.action = action;
            cmd.verbProd = self;
            cmd.predPriority = priority;
            cmd.predActive = isActive;;

            /* do the standard work */
            inherited(cmd, np);

            /* if we have a structurally empty slot, note it in the command */
            if (missingRole != nil)
                cmd.emptyNounRole(missingRole);
        }

        /*
         *   Visit a production during the build process.  If this is one of
         *   our noun phrase slots, we tell the command to add a new noun
         *   phrase of this type, and make it the current phrase; then we
         *   recursively build out this child to populate the new noun phrase.
         */
        visitProd(cmd, np, prod)
        {
            /*
             *   If this is a special phrase slot, mark the child with its
             *   role.  This is necessary for positional languages, where the
             *   role of a noun phrase is determined by its position in the
             *   predicate.  Grammars for these languages use generic rules
             *   that apply to any noun phrases, so the match objects don't
             *   know what role they have until they find out their position in
             *   the parent grammar.  We're the parent grammar, so when we see
             *   one of these special positional markers, we need to pass the
             *   information down to the sub-tree here.
             */
            local r;
            if ((r = NounRole.all.valWhich(
                {x: x.matchProp != nil && self.(x.matchProp) == prod})) != nil)
            {
                /* set the role in the sub-tree */
                prod.nounPhraseRole = r;

                /* start a new noun phrase for the role */
                np = prod.addNounListItem(cmd, prod);
            }

            /*
             *   build out the child, in the context of the noun phrase we
             *   decided upon
             */
            prod.build(cmd, np);
        }

        /*
         *   The parser calls answerMissing() when the player answers a query
         *   for a missing noun phrase in the last command.  There's nothing
         *   that needs to happen here, and by default we do nothing; this is
         *   purely advisory.  This routine gives the language module a chance
         *   to alter the command according to the reply, if necessary.
         */
        answerMissing(cmd, np) { }
    ;

    /*
     *   NounListProduction is a special Production subclass for lists
     *   including more than one noun.
     *
     *   Each instance should have two '->' properties: np1_ and np2_.  These
     *   should be set to the match sub-tree for the first and second elements
     *   of the noun list (respectively).  Note that we assume there are only
     *   two elements in each list grammar item - this isn't because we want to
     *   limit noun lists to two elements, but rather because we assume that
     *   the grammars for longer lists will be constructed recursively out of
     *   two-element nodes: A, B, C, D becomes something along the lines of
     *   List(a, List(b, List(c, List(d)))).
     */
    class NounListProduction: Production
        /*
         *   Visit a production during the build process.  When parsing the
         *   second element, we'll add a new NounPhrase to the current slot's
         *   list.
         */
        visitProd(cmd, np, prod)
        {
            /* if this is the second list item, add a new NounPhrase for it */
            if (prod == np2_)
                np = prod.addNounListItem(cmd, prod);

            /* for noun phrases, tell the noun phrase about the production */
            if (prod is in (np1_, np2_))
                np.prod = prod;

            /* do the normal work */
            inherited(cmd, np, prod);
        }
    ;

    /*
     *   A BadListProduction is a Production subclass for a noun list written
     *   in a slot intended for a single noun only.  This isn't really a
     *   grammatical error, so the language grammar will probably want to
     *   include a rule for this.  However, it *is* a semantic error; rules
     *   that are written for single objects are written that way because we
     *   can't make sense of a list there.  For example, PUT BOOK IN BOX AND
     *   BAG would be nonsensical to us, because we can't put something in two
     *   places at once.  This class can be used for a grammar rule that parses
     *   a list where a single noun is required; we'll flag it with an
     *   explanatory error message for the user.
     */
    class BadListProduction: Production
        build(cmd, np)
        {
            /* mark the command with the list-in-single-slot error */
            cmd.badMulti = getNounPhraseRole();

            /* do the normal work */
            inherited(cmd, np);
        }
    ;

    /*
     *   ExceptListProduction is a Production subclass for EXCEPT lists.  This
     *   is a slot in the grammar that holds a list of objects excepted from
     *   some set, as in ALL BUT THE RED BOOK or THE COINS EXCEPT THE PENNIES.
     */
    class ExceptListProduction: Production
        /*
         *   Build this phrase.  Our sub-tree is a noun list that's to be
         *   excluded from the current noun phrase under construction, 'np';
         *   this exclusion list is a type of qualifier.  So, we (a) start an
         *   exception qualifier for 'np', (b) make that list the current noun
         *   phrase within our sub-tree, then (c) do the normal work to build
         *   out our sub-tree, but using the new context.
         */
        build(cmd, np)
        {
            /*
             *   remember the noun phrase that we qualify - this is simply the
             *   parent noun phrase, np
             */
            qualifiedNP = np;

            /*
             *   start an exclusion list for the noun phrase; make the first
             *   element of the new list the active noun phrase for our
             *   sub-tree
             */
            np = np.addExclusionItem(self);

            /* do the normal work */
            inherited(cmd, np);
        }

        /*
         *   Add a noun list item.  List items within our sub-tree go into the
         *   exclusion list for the parent noun phrase that we qualify.
         */
        addNounListItem(cmd, prod)
        {
            /* add a new noun phrase to the qualified NP's exclusion list */
            return qualifiedNP.addExclusionItem(prod);
        }

        /* the noun phrase we qualify */
        qualifiedNP = nil
    ;

    /*
     *   CoreNounPhraseProduction is a Production subclass for the "core" noun
     *   phrase grammar for noun phrases with object vocabulary.  This is the
     *   part of the grammar that matches the basic name of an object, after
     *   all qualifiers (such as articles, possessives, and quantifiers) have
     *   already been dealt with.  This is the part of the phrase that contains
     *   the vocabulary words for game-world objects.
     *
     *   This class is only needed for noun phrases with object vocabulary
     *   words.  It captures the unqualified core of the phrase as entered by
     *   the user, mostly for reiteration in error messages from the parser.
     *   It's not necessary to define rules of this class for noun phrases that
     *   don't have object vocabulary words (e.g., pronouns, ALL).
     */
    class CoreNounPhraseProduction: Production
        build(cmd, np)
        {
            /* note in the NounPhrase that this is the core noun phrase */
            np.coreProd = self;

            /* do the normal work */
            inherited(cmd, np);
        }
    ;

    /*
     *   EmptyNounProduction is a Production subclass for a grammar rule that
     *   matches no tokens where a noun phrase would ordinarily go.
     */
    class EmptyNounProduction: Production
        build(cmd, np)
        {
            /* mark the noun phrase role as empty in the command */
            cmd.emptyNounRole(np.role);
        }
    ;

    /*
     *   NumberNounProduction is a Production subclass for a number that serves
     *   as a direct, indirect, or accessory object.
     */
    class NumberNounProduction: Production
        /* we use the NumberPhrase subclass for a noun phrase entries */
        npClass = NumberPhrase
    ;

    /*
     *   TopicNounProduction is a Production subclass for a topic that serves
     *   as a direct, indirect, or accessory object.
     */
    class TopicNounProduction: Production
        /* we use the TopicPhrase subclass for a topic phrase entry */
        npClass = TopicPhrase
    ;

    /*
     *   LiteralNounProduction is a Production subclass for a literal phrase
     *   that serves as a direct, indirect, or accessory object.
     */
    class LiteralNounProduction: Production
        /* we use the LiteralPhrase subclass for a noun phrase entries */
        npClass = LiteralPhrase
    ;

    /*
     *   PronounProduction is a Production subclass for pronoun phrases.
     *   Each instance should set the property 'pronoun' to a Pronoun object
     *   giving the pronoun role for the phrase.
     */
    class PronounProduction: Production
        /*
         *   Build the phrase.  We'll add our pronoun association to the
         *   current noun phrase.  (We'll also build out any sub-tree, although
         *   in nearly all cases a pronoun phrase is just a literal and won't
         *   have a sub-tree.)
         */
        build(cmd, np)
        {
            /* set the pronoun association in the noun phrase */
            np.pronoun = pronoun;

            /* do the normal work */
            inherited(cmd, np);
        }
    ;

    /*
     *   A PossessiveProduction is a production subclass for possessive
     *   qualifier phrases ("John's", "my").  When we build out this
     *   production's contribution to the command, we add a separate NounPhrase
     *   object for it, as a possessive qualifier to the current noun phrase.
     */
    class PossessiveProduction: Production
        /*
         *   Build the phrase.  We'll build out our sub-tree as normal, except
         *   that we'll assign its output to a new NounPhrase, which we attach
         *   as a possessive qualifier to the encompassing noun phrase under
         *   construction.
         */
        build(cmd, np)
        {
            /*
             *   create a new noun phrase to serve as a possessive qualifier to
             *   the current noun phrase
             */
            np = np.addPossessive(self);

            /* if I have a pronoun, set it in the noun phrase */
            np.pronoun = pronoun;

            /* do the normal work in the context of the possessive qualifier */
            inherited(cmd, np);
        }
    ;

    /*
     *   ContentsQualifierProduction is a subclass of Production for phrases
     *   that involve contents qualifiers, as in "the bucket of water".
     *
     *   Each grammar rule of this type needs to define two special '->'
     *   associations in its template:
     *
     *   cont_ is the contents qualifier.  This is also just an ordinary noun
     *   phrase.  This is the "water" part in "bucket of water".
     *
     *   prep_ is the preposition giving the relationship.
     */
    class ContentsQualifierProduction: Production
        /*
         *   Visit a production.  When we process the contents qualifier
         *   phrase, we'll build out the sub-tree in the context of a new
         *   NounPhrase, which we attach as a contents qualifier to the
         *   encompassing noun phrase under construction.
         */
        visitProd(cmd, np, prod)
        {
            /*
             *   if this sub-production is the contents qualifier phrase,
             *   create a new locational qualifier for it
             */
            if (prod == cont_)
                np = np.addContents(prep_.getText(), prod);

            /* do the normal work in the context of the noun phrase we set up */
            inherited(cmd, np, prod);
        }
    ;

    /*
     *   LocationalProduction is a subclass of Production for phrases that
     *   involve locational qualifiers, as in "the book on the table".
     *
     *   Each grammar rule of this type needs to define two special '->'
     *   associations in its template:
     *
     *   cont_ is the locational qualifier.  This is also just an ordinary noun
     *   phrase.  This is the "the table" part in "the book on the table".
     *
     *   prep_ is the preposition production.  This should be *or* contain a
     *   LocationTypeProduction match, which tells us the type of containment
     *   relationship specified by the grammar.  *Alternatively*, you can
     *   define locType directly on this production.  This specifies a LocType
     *   object giving the containment relationship.
     */
    class LocationalProduction: Production
        /*
         *   Visit a production.  When we process the locational qualifier
         *   phrase, we'll build out the sub-tree in the context of a new
         *   NounPhrase, which we attach as a locational qualifier to the
         *   encompassing noun phrase under construction.
         */
        visitProd(cmd, np, prod)
        {
            /*
             *   if this sub-production is the locational qualifier phrase,
             *   create a new locational qualifier for it
             */
            if (prod == cont_)
            {
                /* add the location to the noun phrase */
                np = np.addLocation(locType, prod);

                /*
                 *   explicitly build out the preposition sub-tree in the
                 *   context of the locational noun phrase - this ensures that
                 *   the locType gets set for the locational rather than the
                 *   base noun phrase
                 */
                if (prep_ != nil)
                    prep_.build(cmd, np);
            }

            /*
             *   we already built the prep_ subtree explicitly in build(), so
             *   we can ignore it if we're hitting it again here
             */
            if (prod == prep_)
                return;

            /* do the normal work in the context of the noun phrase we set up */
            inherited(cmd, np, prod);
        }

        /*
         *   Our location type.  This is a LocType object giving the location
         *   relationship specified by this locational phrase.  For languages
         *   that special locational phrases prepositionally, this will be set
         *   by the LocationPrepProduction in our sub-tree.  For languages that
         *   use case inflection to specify the type of relationship, this must
         *   be set by the noun phrase sub-tree instead.
         */
        locType = nil
    ;

    /*
     *   A LocationPrepProduction is a special Production type for phrases that
     *   encode the preposition of a locational phrase.  This is only needed in
     *   languages that use prepositional grammar to express location
     *   relationships.  For languages that use noun case inflection, the
     *   relationship will have to be inferred from the case grammar of the
     *   noun phrase (such as noun affixes or articles), and the noun phrase
     *   production will have to set the locType in the LocationalProduction.
     *
     *   Set the locType property to the LocType object corresponding to the
     *   location relationship of the preposition.
     */
    class LocationPrepProduction: Production
        /* our location relationship type, as a LocType object */
        locType = nil

        /*
         *   on building the production, set the locType in our
         *   LocationalProduction parent
         */
        build(cmd, np)
        {
            /* set the location type on the noun phrase */
            np.locType = locType;

            /* do the normal work */
            inherited(cmd, np);
        }
    ;

    /*
     *   QuantifierProduction is a subclass of Production for phrases that add
     *   a number qualifier, as in "five books".
     *
     *   Each grammar rule of this type needs to define a special '->quant_'
     *   association in its template, giving the quantity phrase production.
     *   This phrase must in turn provide a 'numval' property giving its
     *   numeric value.
     *
     *   Alternatively, this production can itself simply provide a 'numval'
     *   property with the correct number.  This is convenient for
     *   adjective-like qualifier phrases that imply a number without stating
     *   one directly, such as BOTH BOOKS.
     */
    class QuantifierProduction: Production
        /*
         *   Build out the subtree.  If we have a numval embedded in this
         *   production, we'll use it as the quantifier.  Otherwise, we'll
         *   expect to find a separate quant_ sub-production among our
         *   children, and that it provides the quantity.
         */
        build(cmd, np)
        {
            /* if we have our own numval value, apply it as the quantifier */
            if (numval != nil)
                np.addQuantifier(numval);

            /* do the normal work */
            inherited(cmd, np);
        }

        /*
         *   Visit a production.  When we visit the quantifier phrase, we'll
         *   handle it specially: we'll add the quantifier value to the main
         *   noun phrase, and then we *won't* parse into the subtree.  There's
         *   no need to parse the quantifier subtree, as its entire meaning is
         *   captured in its numeric value.  Parsing into it is undesirable
         *   because that would add the numeric tokens to the noun phrase -
         *   they don't belong there, since their qualification is captured in
         *   the quantifier and shouldn't also be added as adjectives.
         */
        visitProd(cmd, np, prod)
        {
            /* if this is the quantifier, handle it specially */
            if (prod == quant_)
            {
                /* add the quantifier to the noun phrase */
                np.addQuantifier(prod.numval);

                /* note that we explicitly DON'T parse into the subtree */
            }
            else
            {
                /* do the inherited work */
                inherited(cmd, np, prod);
            }
        }
    ;

    /*
     *   OrdinalProduction is a subclass of Production for ordinal phrases
     *   ("first", "second", etc).  The match object must define a method
     *   ordval() that returns the integer value of the ordinal (1 for "first",
     *   2 for "second", etc).
     */
    class OrdinalProduction: Production
        build(cmd, np)
        {
            /* apply the ordinal value to the noun phrase */
            np.addOrdinal(ordval);

            /*
             *   we don't want to build out the subtree, since we don't want to
             *   treat literals as vocabulary words for this type of phrase
             */
        }
    ;

    /*
     *   MiscWordListProduction is a subclass of Production for miscellaneous
     *   word list rules.  These are grammar rules of last resort, for matching
     *   text that's positionally where a noun phrase ought to be, but which
     *   doesn't match any of our other rules for constructing a valid noun
     *   phrase.  These rules let us still recognize the overall verb-phrase
     *   structure of a command, even though we can't make sense of what goes
     *   where the nouns ought to be.
     */
    class MiscWordListProduction: Production
        build(cmd, np)
        {
            /* tell the Command that it contains a misc word list */
            cmd.noteMiscWords(np);

            /* do the normal work */
            inherited(cmd, np);
        }
    ;

    /*
     *   An OopsProduction is a subclass for the word list part of an OOPS
     *   command.  This must have a ->toks_ property that holds the sub-tree
     *   for the literal token list of the correction.
     */
    class OopsProduction: Production
        /*
         *   Class method: apply the correction for an OOPS command to an
         *   original token list.
         */
        applyCorrection(prod, toks, typoIdx)
        {
            /* build the tree into an OopsCommand object */
            local cmd = new OopsCommand();
            prod.build(cmd, nil);

            /*
             *   splice the corrected tokens into the original token list,
             *   replacing the unknown word token, and return the result
             */
            return toks.splice(typoIdx, 1, cmd.tokens...);
        }

        /* build the command */
        build(cmd, np)
        {
            /* add the token list of the correction to the command */
            cmd.tokens += toks_.getTokens();
        }
    ;

    /*
     *   An OopsCommand is a fake Command object for building out an Oops tree.
     */
    class OopsCommand: object
        /* the token list: this is filled in when we build the Oops nodes */
        tokens = []
    ;

    /*
     *   DisambigProduction is a subclass of Production for the root of a
     *   disambiguation reply tree grammar.
     */
    class DisambigProduction: Production
        addNounListItem(cmd, prod)
        {
            /*
             *   add the new item to the disambig reply list for the original
             *   noun phrase
             */
            return cmd.addDisambigNP(prod);
        }
    ;

    /*
     *   Production class for Yes-or-No phrases
     */
    property yesOrNoAnswer;
    class YesOrNoProduction: Production
        build(cmd, np)
        {
            /* set the yes/no answer property in the Command */
            cmd.yesOrNoAnswer = answer;

            /* do the normal work */
            inherited(cmd, np);
        }
    ;

    /* ------------------------------------------------------------------------ */
    /*
     *   Base class for pronouns.  We represent each type of pronoun with an
     *   object, to abstract pronouns away from the vocabulary.
     *
     *   The base library defines a set of pronouns that are common to most
     *   languages: It, Him, Her, Them, You, Y'all, Me, and Us, plus reflexive
     *   forms of It, Him, Her, and Them.  Some languages might not employ all
     *   of these (French, for example, has no neuter gender, so there's no
     *   equivalent of It), and some might need additional pronouns (e.g.,
     *   French needs a feminine third-person plural).  If a pronoun we define
     *   here has no equivalent in a given language, the language module should
     *   simply omit any grammar mentioning it.  If the language has pronouns
     *   that aren't in the basic set, the language module can provide
     *   definitions for its own additional Pronoun objects, along with the
     *   corresponding grammar rules.
     *
     *   The library itself only directly references one pronoun object: You.
     *   The parser specifically references this pronoun because it binds to
     *   the addressee of a command, which has a special role in the parsing
     *   process.  Apart from You, though, the library's use of pronouns is
     *   directed by the grammar: if a given Pronoun doesn't appear in the
     *   grammar anywhere, the library will never use it.  (Other than in
     *   iterations over Pronoun instances, anyway; but these will be harmless
     *   because the parser is just trying to be inclusive.)  This means that
     *   language modules are free to ignore pronouns (other than You) from the
     *   standard set when they're not a good match for the language's needs.
     *   For example, if you need distinct Animate and Inanimate forms of Him
     *   and Her, you could simply define four new Pronoun objects for these
     *   forms, and use them in place of Him and Her throughout your grammar.
     *
     *   Note that these objects are NOT grammar rules or dictionary words.
     *   These are abstract objects representing the "binding" of the pronouns
     *   - basically the set of grammatical attributes (gender, number) that
     *   determine whether a given noun phrase is a valid antecedent for a
     *   given pronoun.  That's why we don't define separate Pronoun objects
     *   the different grammatical cases (nominative, accusative, dative, etc):
     *   case is a feature of the grammar, and we're one step removed from that
     *   here.
     */
    class Pronoun: object
        /*
         *   Resolve the pronoun during parsing.  The usual way of doing this
         *   is to return the list of antecedents we store as part of the
         *   pronoun object.  This lets each type of pronoun store an
         *   appropriate list of antecedents.
         *
         *   For a reflexive pronoun, return the Pronoun object for the
         *   ordinary form of the pronoun.  This tells the parser that it needs
         *   to find a match for the pronoun within the command itself, rather
         *   than looking for an external antecedent.  Second person is
         *   inherently reflexive, in that it refers to the addressee(s), so
         *   this should return 'self' for a second-person pronoun.
         */
        resolve() { return ante; }

        /*
         *   The grammatical person of the pronoun.  Pronouns come in three
         *   persons: first (me, us), second (you), and third (her, them).  We
         *   represent these as 1, 2, and 3.
         */
        person = 3

        /*
         *   Set the antecedent(s) for future pronoun usage based on the
         *   objects mentioned in the current command input or narrative
         *   output.  'obj' can be a single antecedent object, or it can be a
         *   list.  Even a singular pronoun can have a list of antecedents:
         *   some commands have more than one noun phrase, and there's no way
         *   of knowing which one the user might want to refer to with a
         *   pronoun in a future command.  We can't know until we see the
         *   context of the future pronoun use.  For example, UNLOCK DOOR WITH
         *   KEY could be followed by OPEN IT, in which case IT is probably the
         *   door; or by DROP IT, in which case IT is probably the key.  The
         *   best thing to do is to save both the door and the key as possible
         *   antecedents, so that we can choose the most suitable object when
         *   we actually see a pronoun in a subsequent command.
         */
        setAntecedents(obj){ ante = obj; }

        /*
         *   Does this pronoun match the given object or list of objects?  By
         *   default, we won't match lists, and we'll ask the object if it
         *   thinks we're a match.
         */
        matchObj(obj)
        {
            return !obj.ofKind(Collection) && obj.matchPronoun(self);
        }

        /* my antecedent or list of antecedents */
        ante = []

        /*
         *   the corresponding reflexive pronoun, if any - this is set up
         *   automatically during preinit
         */
        reflexive = nil

        /*
         *   Class property - list of all regular Pronoun objects.  (Note that
         *   this excludes the reflexive pronouns, because the ReflexivePronoun
         *   class has its own separate 'all' list for its instances.)
         */
        all = []

        /* on initialization, add me to the master list of pronoun objects */
        construct()
        {
            /* get the nearest class that has a master list */
            local cl = propDefined(&all, PropDefGetClass);

            /* add me to my class's master list */
            cl.all += self;
        }
    ;

    /* It - third-person neuter singular */
    It: Pronoun
    ;

    /* Her - third-person feminine singular */
    Her: Pronoun
    ;

    /* Him - third-person masculine singular */
    Him: Pronoun
    ;

    /* Them - third-person mixed-gender plural */
    Them: Pronoun
        /*
         *   Them is a plural, so it can match a list, as well as an individual
         *   object that matches Them
         */
        matchObj(obj)
        {
            return obj.ofKind(Collection) || obj.matchPronoun(self);
        }
    ;

    /*
     *   You - the second-person singular.  YOU always binds to the addressee
     *   of the command: either the player character, or the actor being given
     *   orders via a construct like ACTOR, DO THIS.
     *
     *   Binding to the PC is grammatically correct in a first-person
     *   narration, because the PC is the narrator's ME and therefore the
     *   player's YOU.  It's less so in a second-person game: the PC is the
     *   narrator's YOU, so the player's YOU ought to be the narrator.
     *   However, some players are literal-minded about second-person
     *   narration, so rather than reflecting the narrator's YOU into the
     *   player's ME, they simply say YOU too.  Fortunately, there's not any
     *   serious ambiguity here.  The narrator is typically not a game-world
     *   object, but is an entity that exists outside the game world, so it's
     *   off-limits for discussion in commands.  So YOU can't mean the
     *   narrator.  That means that if the player uses YOU at all, they must
     *   mean the PC.
     */
    You: Pronoun
        /*
         *   The second-person pronoun binds to information contained within
         *   the command itself, namely the addressee of the command, so we
         *   need to resolve it using the parser's "late binding" scheme.  That
         *   is, we return 'self' to tell the parser that it needs to go back
         *   and resolve this pronoun after resolving other phrases.
         */
        resolve()
        {
            /*
             *   But if no other actor has been specified, 'YOU' must mean 'ME',
             *   i.e. the player character
             */

            if(gCommand && gCommand.actorNPs == [] && gCommand.actorPerson == 2)
                return [gPlayerChar];

            return [self];
        }

        /* this is a second-person pronoun */
        person = 2
    ;

    /*
     *   Y'all - the second-person plural.  ("Y'all" isn't exactly standard
     *   English, but it's as close as English comes to having a distinct
     *   plural You, and we had to call this *something*.)
     *
     *   By default, we treat Y'all as a synonym for You, since there's rarely
     *   any reason in an IF context to distinguish them.  The main value in
     *   natural language is in group conversation, where it can be useful to
     *   clarify whether the speaker is addressing the whole group or just an
     *   individual.  In IF, though, this is never ambiguous: the addressee is
     *   either explicitly stated in the command, or it's the player character.
     *   The only thing we could do with a plural is check that the verb agrees
     *   in number, and chastise the player's sloppy grammar if not.  But that
     *   would be contrary to our general philosophy that we should be as lax
     *   as we can about the input grammar, to minimize the player's typing
     *   workload.  So our advice here is to implement a grammar rule for the
     *   various YOUs that treats all of the second-person pronoun forms as
     *   synonyms for the basic singular YOU.
     */
    Yall: Pronoun
        resolve() { return You.resolve(); }
        person = 2
    ;

    /*
     *   Me - the first-person singular.  ME always binds to the player
     *   character.
     *
     *   The discussion about the validity of binding YOU to the PC applies in
     *   mirror image here.  In a second-person game, the PC is the narrator's
     *   YOU and the player's ME; in a first-person game, she's the narrator's
     *   ME and the player's YOU.  But there is no game-world object for ME to
     *   bind to in commands in a first-person game - if anything, ME would be
     *   the player (not the player character, but the actual player), who is
     *   clearly not a game-world entity.  Since that's not meaningful, we can
     *   assume that a player talking about ME in a first-person game is being
     *   literal-minded and just using the same pronouns the narrator does, or
     *   that they're so accustomed to the second-person convention of most IF
     *   that they're saying ME out of habit.  In either case, the PC is the
     *   one they're talking about.
     */
    Me: Pronoun
        /*
         *   the first person always resolves to the player character,
         *   regardless of context
         */
        resolve() { return [libGlobal.playerChar]; }

        /* this is a first-person pronoun */
        person = 1
    ;

    /*
     *   Us - the first-person plural.  We throw this one in for relative
     *   completeness, but we simply treat it as a synonym for Me.  This could
     *   be useful in a game with a PC that represents a group of people (an
     *   adventuring party in a hack-n-slash game, say), or a royal personage.
     *
     *   A more sophisticated use would be to allow the player to refer
     *   collectively to the PC and a group of accompanying NPCs.  The base
     *   library doesn't implement this because it doesn't define a way to
     *   identify such a group, but a game could add that capability.  Once
     *   you've defined what US means, you could make the pronoun US bind to
     *   that group simply by modifying the resolve() method here.
     */
    Us: Pronoun
        resolve() { return Me.resolve(); }
    ;

    /*
     *   Base class for reflexive pronouns.  These are pronouns like "himself"
     *   that specifically refer to an antecedent in the same sentence, rather
     *   than to an earlier sentence: ASK BOB ABOUT HIMSELF is an inquiry about
     *   Bob, while ASK BOB ABOUT HIM refers to some male antecedent from an
     *   earlier statement.
     *
     *   Note that the first- and second-person reflexives are generally not
     *   needed in the parser.  (We define them here anyway, because they're
     *   useful for message generation.)  The third-person reflexive pronouns
     *   have distinct meanings in input from the corresponding ordinary
     *   pronouns, in that they refer to noun phrases within the same command
     *   rather than in earlier exchanges.  In contrast, the second-person
     *   pronouns have the same meaning in ordinary and reflexive forms, at
     *   least within the confines of the IF parser: EXAMINE ME and EXAMINE
     *   MYSELF mean the same thing in all typical IF command syntax.
     */
    class ReflexivePronoun: Pronoun
        /* during construction, set the regular pronoun to point back at me */
        construct()
        {
            inherited();
            pronoun.reflexive = self;
        }

        /*
         *   A reflexive pronoun binds to another noun phrase contained in the
         *   same command, so we resolve using the parser's "late binding"
         *   scheme.  We invoke this by returning the ordinary (non-reflexive)
         *   pronoun object representing the attributes that we match; upon
         *   seeing this, the parser will know to come back to this pronoun
         *   after it's finished resolving earlier phrases, and look for the
         *   appropriate pronoun binding within those other phrases.
         */
        resolve() { return pronoun; }

        /*
         *   Get the corresponding ordinary (non-reflexive) form of the
         *   pronoun.  For example, for HIMSELF we'd return HIM.
         */
        pronoun = nil

        /* my grammatical person is the same as my underlying pronoun's */
        person = (pronoun.person)

        /*
         *   Class property - list of all reflexive pronoun objects.  This
         *   keeps the reflexive pronouns in a separate list from the base
         *   Pronoun list.
         */
        all = []
    ;

    /* first-person singular reflexive */
    Myself: ReflexivePronoun
        pronoun = Me
    ;

    /* second-person singular reflexive */
    Yourself: ReflexivePronoun
        pronoun = You
    ;

    /* third-person singular neuter reflexive */
    Itself: ReflexivePronoun
        pronoun = It
    ;

    /* third-person singular feminine reflexive */
    Herself: ReflexivePronoun
        pronoun = Her
    ;

    /* third-person singular masculine reflexive */
    Himself: ReflexivePronoun
        pronoun = Him
    ;

    /* first-person plural reflexive */
    Ourselves: ReflexivePronoun
        pronoun = Us
    ;

    /* second-person plural reflexive */
    Yourselves: ReflexivePronoun
        pronoun = Yall
    ;

    /* third-person mixed-gender plural reflexive */
    Themselves: ReflexivePronoun
        pronoun = Them
    ;

    /* ------------------------------------------------------------------------ */
    /*
     *   Determiners.  A determiner qualifies a noun phrase with information on
     *   how it relates to the objects it describes.  For example, "a book"
     *   refers to any book that's in scope for the discussion (in IF terms,
     *   this is usually any book that's physically present), while "the book"
     *   refers to some specific single book.
     *
     *   Language modules can add determiners as needed.  For example, a
     *   language with grammatical gender would probably find gendered versions
     *   of Definite and Indefinite useful, to represent the use of gendered
     *   articles in input.
     */
    class Determiner: object;

    /* Unqualified mode ("book") */
    Unqualified: Determiner;

    /* Definite mode ("the book", "book", "both books", "the three books") */
    Definite: Determiner;

    /* Indefinite mode ("a book", "any book", "one of the books", three books") */
    Indefinite: Determiner;

    /* All ("the books", "all", "all of the books") */
    All: Determiner;

    /* ------------------------------------------------------------------------ */
    /*
     *   ParseError is an Exception subclass for parsing errors.
     */
    class ParseError: Exception
        /*
         *   Display the error message
         */
        display() { "Unknown parsing error."; }

        /*
         *   Rank a spelling correction candidate for input that triggered this
         *   error on parsing.
         *
         *   'toks' is the new token list, with the spelling correction
         *   applied; 'idx' is the index in the list of the corrected word.
         *   'dict' is the Dictionary used for parsing.
         *
         *   Returns an integer value giving the ranking.  The ranking is used
         *   for sorting, so the scale is arbitrary - we simply take the
         *   highest ranking item.  The value 0 is special, though: it means
         *   that we should filter out the candidate and not consider it at
         *   all.
         */
        rankCorrection(toks, idx, dict) { return 1; }

        /*
         *   Is this error allowed on a spelling correction candidate?  By
         *   default, this is nil, meaning that this error invalidates a
         *   correction candidate.  We mostly reject spelling "corrections"
         *   that result in errors because these are probably false positives:
         *   they probably replace a misspelled word with one that's in the
         *   dictionary but that's still wrong.  However, there are a few
         *   curable errors where it can make sense to keep a correction, such
         *   as an ambiguous noun phrase: that's so close to being a working
         *   command that we probably have a good correction.
         */
        allowOnRespell = nil

        /*
         *   Is this a "curable" error?  A curable error is one that the user
         *   can fix by answering a question, such as "which one do you mean?"
         *   or "what do you want to unlock it with?"
         *
         *   When we find more than one grammar match to an input string, the
         *   parser tries resolving each one, in order of the predicate match
         *   quality.  If one resolves without an error, the parser stops and
         *   uses that match.  But if *none* of the possible matches resolve
         *   without an error, the parser picks a match with a curable error
         *   over one with an incurable error.
         */
        curable = nil

        /*
         *   Try curing this error with the user's answer to the error message.
         *   The parser calls this when (a) the PREVIOUS command resulted in
         *   this error, (b) this error is curable, and (c) the user typed
         *   something on the CURRENT command that didn't parse as a valid new
         *   command.  Since the new input doesn't look like a valid command,
         *   the parser calls this to determine if the input was instead meant
         *   as an answer to the question posed by the last error.
         *
         *   If this new command is indeed a valid response to the error
         *   message, we return a CommandList with the "cured" version of the
         *   command.  This new command list should supplement the command with
         *   the new information provided by the reply.  If not, we simply
         *   return nil.
         */
        tryCuring(toks, dict) { return nil; }

        /*
         *   The parsing "stage" of this error.  We can distinguish three
         *   levels of intelligibility as we work through the parsing process:
         *   (1) completely unintelligible, (2) valid verb structure, and (3)
         *   resolved noun phrases.  This property tells us which stage we
         *   finish in when we encounter an error of this type.
         */
        errStage = 1
    ;

    /*
     *   The basic command-level parsing error.  This occurs when we can't find
     *   a grammar match to the overall command phrasing.
     */
    class NotUnderstoodError: ParseError
        display()
        {
            /*
             *   We couldn't parse a command.  This means that we were unable
             *   to find any grammar match for the input, so we basically have
             *   no idea what the player was trying to say.
             */
            DMsg(not understood, 'I don\'t understand that command.');
        }

        /*
         *   This is a general verb syntax error, so our best candidates will
         *   words that are used in verb phrases.  The next best is a corrected
         *   word that's used in any GrammarProd, since the problem might
         *   actually be in some other structural part of the command phrase
         *   above the verb phrase (a conjunction, for example).
         */
        rankCorrection(toks, idx, dict)
        {
            /* get the text of the token */
            local txt = getTokVal(toks[idx]);

            /* look up the word in the action vocabulary table */
            local w = actionDictionary.wordToAction[txt];
            if (w != nil)
            {
                /* get the highest spelling priority of the matching actions */
                local maxAct = w.maxVal({ a: a.spellingPriority });

                /*
                 *   Look for other words in the token list that are also in
                 *   this words associated word list.  (For example, if the
                 *   candidate is 'up', look for words like 'pick', 'go', or
                 *   'look' that occur in the same verb rules with 'up'.)
                 */
                local xlst = actionDictionary.xwords[txt] - txt;
                local xbonus = (toks.indexWhich(
                    { t: xlst.indexOf(getTokVal(t)) != nil }) != nil);

                /*
                 *   Give this a high rating, with the action priority and
                 *   associated word bonuses to break ties.
                 */
                return 200 + maxAct*2 + (xbonus ? 1 : 0);
            }

            /* okay, no predicate; how about any other GrammarProd word? */
            w = dict.findWord(txt);
            if (w.indexWhich(
                { x: dataType(x) == TypeObject && x.ofKind(GrammarProd) }) != nil)
                return 100;

            /*
             *   No luck on any of our preferences; give it our lowest rank.
             *   We still want to allow it to be considered, so give it a
             *   non-zero rank.
             */
            return 1;
        }
    ;

    /*
     *   An UnknownWordError points out a word that's not in the game's
     *   dictionary.
     */
    class UnknownWordError: ParseError
        construct(txt)
        {
            self.badWord = txt;
        }

        display()
        {
            /*
             *   The command contains a word that's not in the dictionary.
             *   This error is only used when the parser is set to admit to
             *   unknown words, and only when we fail to parse the command.
             *   (It's possible for a command to succeed even when it contains
             *   words that aren't in the dictionary, since objects and topics
             *   can sometimes match arbitrary input.)
             */
            DMsg(unknown word, 'I don\'t know the word "{1}".', badWord);

        }

        /* the text of the unknown word */
        badWord = nil
    ;

    /*
     *   OopsError is the base class for errors in an OOPS command.
     */
    class OopsError: ParseError
    ;

    /*
     *   A CantOopsError means that the player typed OOPS when we don't have a
     *   previous command typo we can correct.
     */
    class CantOopsError: OopsError
        display()
        {
            /*
             *   The player typed an OOPS command, but we don't have anything
             *   from a past command that we can correct.  This means that
             *   either the last command succeeded, or that it simply didn't
             *   contain any non-dictionary words.
             */
            DMsg(no oops now, 'Sorry, I\'m not sure what you\'re correcting.');
        }
    ;

    /*
     *   A CommandError is an error in parsing that occurs within the build
     *   process for a Command object.
     */
    class CommandError: ParseError
        construct(cmd)
        {
            /* remember the command */
            self.cmd = cmd;
        }

        /* the Command object where the error occurred */
        cmd = nil

        /*
         *   these errors occur once we have a valid predicate structure, so
         *   we're in stage 2 of the parsing when we encounter an error of this
         *   type
         */
        errStage = 2
    ;

    /*
     *   Rejected parsing structure.  There are certain structures that are
     *   hard to eliminate in the grammar, but which we don't want to accept
     *   semantically.  This error can be thrown when such a structure is
     *   encountered.  This effectively rules out a parse tree.  It's not a
     *   displayable error; the parser simply rules out these structures.
     */
    class RejectParseTreeError: CommandError
        display()
        {
            /*
             *   users should never see this error - it should be handled
             *   internally to the library
             */
            "\n(Internal: Parse tree rejected.)\n";
        }
    ;

    /*
     *   Empty noun slot error.  This occurs when there are no noun phrases in
     *   a functional slot in the predicate (e.g., when the player types "TAKE"
     *   without a direct object).
     */
    class EmptyNounError: CommandError
        construct(cmd, role)
        {
            inherited(cmd);
            self.role = role;
        }

        /* our message is a missing noun query (e.g., "What do want to open?") */
        display()
        {
            askMissingNoun(cmd, role);
        }

        /*
         *   Try curing the error.  After a missing noun query, the player can
         *   respond with a simple noun phrase answering the question.
         */
        tryCuring(toks, dict)
        {
            /* try parsing against the appropriate reply grammar */
            local lst = new CommandList(
                cmd.verbProd.missingRoleProd(role), toks, dict,
                new function(prod)
            {
                /* create a copy of the original command */
                local newCmd = cmd.clone();

                /* plug the new noun phrase tree into the empty role */
                newCmd.addNounProd(role, prod);

                /* the new command is the mapped list entry */
                return newCmd;
            });

            /* accept curable resolutions as replies */
            lst.acceptCurable();

            /* return the list */
            return lst;
        }

        /* we can cure by asking the player for the missing noun phrase */
        curable = true
    ;

    /*
     *   Noun phrase resolution error.  This is a special type of parsing error
     *   that indicates that the problem is with resolving a noun phrase to
     *   game-world objects.
     */
    class ResolutionError: ParseError
        construct(np)
        {
            /* do the normal work */
            inherited();

            /* save the noun phrase */
            self.np = np;

            /* note the error-display text of the noun phrase */
            self.txt = np.errName;
        }

        /* the NounPhrase object for the errant phrase, if available */
        np = nil

        /* the text of the errant phrase, if available */
        txt = nil

        /*
         *   For a noun resolution error, our best bet for a spelling
         *   correction would be a word associated with a game-world object.
         *   Only consider in-scope objects when making the correction, to
         *   avoid spurious corrections that give away information on objects
         *   the player has yet to encounter.  We'll also allow words that are
         *   used in non-predicate grammar productions, since we might have a
         *   structural noun phrase word (an article, pronoun, etc).
         */
        rankCorrection(toks, idx, dict)
        {
            /* make a list consisting of the single changed word */
            local disList = [getTokVal(toks[idx])];

            /* look for an in-scope object association for the word */
            local m = 0;
            foreach (local obj in World.scope())
                m |= obj.matchNameDisambig(disList);

            /*
             *   if we found any matches, give this the highest score; adjust
             *   slightly to prefer nouns, then adjectives, then plurals
             */
            if (m != 0)
            {
                return ((m & MatchNoun) != 0 ? 102 :
                        (m & MatchAdj) != 0 ? 101 : 100);
            }

            /* check for non-predicate grammar words */
            local w = dict.findWord(getTokVal(toks[idx]))
                .subset({ x: dataType(x) == TypeObject });

            if (w.indexWhich({ x: x.ofKind(GrammarProd) && !x.ofKind(predicate) })
                != nil)
                return 90;

            /*
             *   it's not an in-scope object word or a structural word, so
             *   don't allow it, in case it refers to a yet-unseen object
             */
            return 0;
        }
    ;

    /*
     *   ActorResolutionError - this is for resolution errors that are in the
     *   context of what the target actor of the command (the addressee) can
     *   see.  These require the Command in addition to the noun phrase, since
     *   that provides the target actor information.
     */
    class ActorResolutionError: ResolutionError
        construct(cmd, np)
        {
            inherited(np);
            self.cmd = cmd;
        }

        /* the command that we were attempting to resolve */
        cmd = nil
    ;

    /*
     *   No objects match the addressee of a command (BOB, GO NORTH or TELL BOB
     *   TO GO NORTH).
     */
    class UnmatchedActorError: ResolutionError
        display()
        {
            /*
             *   An actor phrase in a command (BOB, GO NORTH) didn't match any
             *   in-scope objects.  This doesn't necessarily mean that the
             *   phrase doesn't refer to any object anywhere in the game, just
             *   that it doesn't refer to anything in scope.  Since we didn't
             *   match anything, all we have is the text of the actor phrase
             *   from the player's input.
             */
            DMsg(unmatched actor, '{I} {see} no {1} {here}.', txt);
        }
    ;

    /*
     *   No objects match a noun phrase.
     */
    class UnmatchedNounError: ActorResolutionError
        display()
        {
            /*
             *   A noun phrase didn't match any in-scope objects.  This doesn't
             *   necessarily mean that the phrase doesn't refer to any object
             *   anywhere in the game, just that it doesn't refer to anything
             *   in scope.  Since we didn't find an object, all we have is the
             *   text of the noun phrase from the player's input.
             */
            DMsg(unmatched noun, '{I} {see} no {2} {here}.', cmd, stripArticle(txt));
        }
    ;

    /*
     *   Base class for resolution errors involving pronouns
     */
    class PronounError: ResolutionError
        construct(np, pro)
        {
            inherited(np);
            pronoun = pro;
        }

        /* the pronoun that caused the error, as a Pronoun object */
        pronoun = nil
    ;

    /*
     *   No pronouns match a noun phrase.
     */
    class NoAntecedentError: PronounError
        display()
        {
            /*
             *   The player used a pronoun for which there's currently no
             *   antecedent.
             */
            DMsg(no antecedent,
                 'I\'m not sure what you mean by "{1}".', np.prod.getText());
        }
    ;

    /*
     *   The antecedent of the pronoun is no longer in scope
     */
    class AntecedentScopeError: PronounError
        construct(cmd, np, pro)
        {
            inherited(np, pro);
            self.cmd = cmd;
        }

        cmd = nil

        display()
        {
            /*
             *   The player used a pronoun that refers to an object that's no
             *   longer in scope.
             */
            DMsg(antecedent out of scope,
                 '{I} no longer {see} that {here}.', cmd);
        }
    ;

    /*
     *   There aren't enough objects matching a noun phrase to satisfy a
     *   quantifier (e.g., TAKE FIVE COINS, but only three coins are present).
     */
    class InsufficientNounsError: ActorResolutionError
        display()
        {

            if(cmd.matchedAll)

                /*
                 *   The player used ALL when there's nothing suitable for all to
                 *   refer to.
                 */
                DMsg(nothing suitable for all, 'There{\'s} nothing suitable for
                    ALL to refer to. ');

            else

                /*
                 *   The player used a noun phrase that specifically calls for some
                 *   number of objects (such as FIVE COINS or BOTH BOOKS), but there
                 *   aren't enough of those objects present.
                 */
                DMsg(not enough nouns,
                     '{I} {don\'t see} that many {2} {here}.', cmd, txt);

        }
    ;

    /*
     *   The owner in a possessive phrase doesn't have any of the objects
     *   named.
     */
    class NoneInOwnerError: ActorResolutionError
        construct(cmd, np, poss)
        {
            inherited(cmd, np);
            possQual = poss;
        }

        /* the possessive qualifier */
        possQual = nil

        display()
        {
            /*
             *   if we have other than one possible owner, show the original
             *   text of the owner phrase, since we can't be sure which matched
             *   object was intended; otherwise show the name of the actual
             *   owner we matched
             */
            if (possQual.matches.length() != 1)
            {
                /*
                 *   The player used a possessive to qualify a noun phrase, and
                 *   we matched multiple objects for the possessive phrase, but
                 *   none of those owners actually owns anything in scope that
                 *   matches the main noun phrase.  For example, the player
                 *   entered THE GUARD'S SWORD, and there are two guards
                 *   present, but neither of them has a sword (not that's in
                 *   scope, anyway).
                 */
                DMsg(none in owners, 'No {2} {dummy}appear{s/ed} to have any {3}.',
                     cmd, possQual.prod.getText(), txt);
            }
            else
            {
                /*
                 *   The player used a possessive to qualify a noun phrase, and
                 *   we matched a single object for the possessive phrase, but
                 *   that owner doesn't actually possess anything in scope that
                 *   matches the main noun phrase.  For example, the player
                 *   entered BOB'S WALLET, and Bob is indeed in scope, but Bob
                 *   doesn't own a wallet (not one that's in scope, anyway).
                 */
                local obj = possQual.matches[1].obj;
                gMessageParams(obj);

                DMsg(none in owner, '{The subj obj} {doesn\'t appear[ed]} to have
                    any {2}.',  cmd,  txt);

            }
        }

    ;

    /*
     *   The location in a locational qualifier doesn't contain any of the
     *   objects named.
     */
    class NoneInLocationError: ActorResolutionError
        construct(cmd, np, loc)
        {
            inherited(cmd, np);
            locQual = loc;
        }

        /* the locational qualifier */
        locQual = nil

        display()
        {
            /*
             *   if we have other than one possible location, show the original
             *   text of the locational phrase, since we can't be sure which
             *   matched object was intended; otherwise show the name of the
             *   actual location we matched
             */
            if (locQual.matches.length() !=  1)
            {
                /*
                 *   We have a locational qualifier, and we have multiple
                 *   objects that match the location, but there's nothing in
                 *   scope that matches the main noun phrase that's in any of
                 *   those locations.  For example, the player typed THE BOX ON
                 *   THE TABLE, and we have two tables in scope, but there's no
                 *   box in scope that's on either of them.
                 */
                DMsg(none in locations,
                     '{I} {see} no {2} {3} any {4}.',
                     cmd, txt, locQual.locType.prep, locQual.prod.getText());
            }
            else
            {
                /*
                 *   We have a locational qualifier, and we have exactly one
                 *   object that matches the location, but there's nothing in
                 *   scope that matches the main noun phrase that's in that
                 *   location.  For example, the player typed THE BOX ON THE
                 *   TABLE, and we have a table in scope, but there's no box on
                 *   it.
                 */
                DMsg(none in location,
                     '{I} {see} no {2} {3} {the 4}.',
                     cmd, txt, locQual.locType.prep, locQual.matches[1].obj);
            }
        }
    ;

    /*
     *   There are no objects matching this noun phrase name that have the
     *   contents mentioned in the contents qualifier.
     */
    class NoneWithContentsError: ActorResolutionError
        construct(cmd, np, cont)
        {
            inherited(cmd, np);
            contQual = cont;
        }

        /* the contents qualifier */
        contQual = nil

        display()
        {
            /*
             *   if we have other than one possible contents object, show the
             *   original text of the contents phrase, since we can't be sure
             *   which matched object was intended; otherwise show the name of
             *   the object we matched
             */
            if (contQual.matches.length() != 1)
            {
                /*
                 *   We have a contents qualifier, and we have multiple objects
                 *   in scope that match the contents phrase, but there's
                 *   nothing in scope that matches the main noun phrase that
                 *   actually contains any of the contents objects.  For
                 *   example, the player typed THE BUCKET OF WATER, and we do
                 *   have multiple "water" objects present, but none of them
                 *   are inside buckets that are in scope.
                 */
                DMsg(none with contents in list,
                     '{I} {see} no {2} of {3}.',
                     cmd, txt, contQual.prod.getText());
            }
            else
            {
                /*
                 *   We have a contents qualifier, and we have exactly one
                 *   object in scope that matches the contents phrase, but
                 *   there's nothing in scope that matches the main noun phrase
                 *   that actually contains that object.  For example, the
                 *   player typed THE BUCKET OF WATER, and we do have a "water"
                 *   object present, but it's not inside anything called a
                 *   bucket (not one that's in scope, anyway).
                 */
                DMsg(none with contents,
                     '{I} {see} no {2} of {3}.',
                     cmd, txt, contQual.matches[1].obj);
            }
        }
    ;

    /*
     *   A noun phrase is ambiguous, so we'll have to ask for clarification.
     */
    class AmbiguousError: ResolutionError
        construct(cmd, np, names)
        {
            inherited(np);
            self.cmd = cmd;
            self.nameList = names;
        }

        display()
        {
            /* ask the language-specific ambiguous noun question */
            askAmbiguous(cmd, np.role, nameList.mapAll({ n: n[1] }));

        }

        /*
         *   Accept spelling corrections that trigger an ambiguous noun error.
         *   If we find an ambiguous noun it means that we have valid overall
         *   verb syntax *and* we have noun phrases that match in-scope objects
         *   - in fact, they match too many objects.  This is pretty good
         *   evidence that the respelling is valid.
         */
        allowOnRespell = true

        /*
         *   this is a curable error, since the player can fix the problem by
         *   answering the disambiguation question
         */
        curable = true

        /*
         *   Try curing the error.  After an ambiguous noun error, the player
         *   can type a partial noun phrase that clarifies which object was
         *   intended: a distinguishing adjective, a locational phrase, a
         *   possessive, etc.
         */
        tryCuring(toks, dict)
        {
            /* try parsing against the main disambiguation grammar */
            local lst = new CommandList(
                mainDisambigPhrase, toks, dict,
                new function(prod)
                {
                    /* create a new copy of the Command to apply the change to */
                    local newCmd = cmd.clone();

                    /* add the reply to the new command */
                    local dnp = newCmd.startDisambigReply(np, prod);

                    /* build the reply tree */
                    prod.build(newCmd, dnp);

                    /* the mapping is the new command */
                    return newCmd;
                });

            /* accept curable errors in the reply */
            lst.acceptCurable();

            /* return the list */
            return lst;
        }

        /* the original Command that we were trying to resolve */
        cmd = nil

        /*
         *   The list of object names, with distinguisher information.  This is
         *   the same information returned from Distinguisher.getNames().
         */
        nameList = []
    ;

    class AmbiguousMultiDefiniteError: UnmatchedNounError
        display()
        {
            DMsg(be more specific, 'I don\'t know which ones you mean.
                Can you be more specific?');
        }

        /*
         *   this is not really curable, but we need to say it is curable so that
         *   our custom message is displayed.  Would like to find a way to do this
         *   where curable=nil
         */
        curable = true
    ;

    /*
     *   Ordinal out of range.  This occurs when the player replies to a
     *   disambiguation query with an ordinal that's out of the bounds of the
     *   offered list.
     */
    class OrdinalRangeError: ResolutionError
        construct(np, ordinal)
        {
            inherited(np);
            self.ordinal = ordinal;
        }

        display()
        {
            /*
             *   An ordinal reply to a disambiguation question is out of range.
             *   For example, we asked "Which do you mean, the red book or the
             *   blue book?", and the player answered THE THIRD ONE.  There are
             *   only two options, so THIRD is out of range.
             */
            DMsg(ordinal out of range,
                 'Sorry, I don\'t see what you\'re referring to.');
        }

        /* the ordinal, as an integer value (1=first, 2=second, etc) */
        ordinal = nil
    ;

    class BadMultiError: ParseError
        display()
        {
            DMsg(multi not allowed, 'Sorry; multiple objects aren\'t allowed with
                that command.');
        }
    ;

    /* ------------------------------------------------------------------------ */
    /*
     *   A placeholder object for dictionary entries.  The Dictionary class
     *   stores a three-way association: word string, part-of-speech property,
     *   and object.  The object association is designed to allow the parser to
     *   come up with a list of objects that could match a given word, but the
     *   adv3L library doesn't use this feature.  We instead figure out the
     *   word-to-object association by directly asking the objects in scope if
     *   they're associated with a word.  We still need *something* to store as
     *   the object association for each word entry in the dictionary, though.
     *   That's where this object comes in: it's a dummy object that serves as
     *   the required object to associate with each word.
     *
     *   A language module can ignore this and use the word-object-property
     *   association feature of the dictionary, if desired.
     */
    dictionaryPlaceholder: object
    ;

    /* Exception thrown by exit macro */
    class ExitSignal: Exception
    ;

    /* Exception thrown by abortImplicit macro */
    class AbortImplicitSignal: Exception
    ;

    /* Exception thrown by abort macro */
    class AbortActionSignal: Exception
    ;

    /* Exception thrown by exitAction macro */
    class ExitActionSignal: Exception
    ;

    /* Exception thrown to terminate a command. */
    class TerminateCommandException: Exception
    ;

Adv3Lite Library Reference Manual
Generated on 01/03/2024 from adv3Lite version 1.6.2