Import v6.12.2 of the Inform 6 standard library
[informlib.git] / parser.h
1 ! ==============================================================================
2 !   PARSER:  Front end to parser.
3 !
4 !   Supplied for use with Inform 6 -- Release 6.12.2 -- Serial number 180520
5 !
6 !   Copyright Graham Nelson 1993-2004 and David Griffith 2012-2018
7 !
8 !   This file is free software: you can redistribute it and/or modify
9 !   it under the terms of the GNU Affero General Public License as
10 !   published by the Free Software Foundation, either version 3 of the
11 !   License, or (at your option) any later version.
12 !
13 !   This file is distributed in the hope that it will be useful, but
14 !   WITHOUT ANY WARRANTY; without even the implied warranty of
15 !   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 !   Affero General Public License for more details.
17 !
18 !   You should have received a copy of the GNU Affero General Public
19 !   License along with this program. If not, see
20 !   https://gnu.org/licenses/
21 !
22 !   In your game file, Include three library files in this order:
23 !       Include "parser";
24 !       Include "verblib";
25 !       Include "grammar";
26 !
27 ! ------------------------------------------------------------------------------
28 !   Inclusion of "linklpa" (which defines properties and attributes)
29 !   Global variables, constants and arrays
30 !       1: outside of the parser
31 !       2: used within the parser
32 !   Inclusion of natural language definition file
33 !       (which creates a compass and direction-objects)
34 !   Darkness and player objects
35 !   Definition of grammar token numbering system used by Inform
36 !
37 !   The InformParser object
38 !       keyboard reading
39 !       level 0: outer shell, conversation, errors
40 !             1: grammar lines
41 !             2: tokens
42 !             3: object lists
43 !             4: scope and ambiguity resolving
44 !             5: object comparisons
45 !             6: word comparisons
46 !             7: reading words and moving tables about
47 !       pronoun management
48 !
49 !   The InformLibrary object
50 !       main game loop
51 !       action processing
52 !       end of turn sequence
53 !       scope looping, before/after sequence, sending messages out
54 !       timers, daemons, time of day, score notification
55 !       light and darkness
56 !       changing player personality
57 !       tracing code (only present if DEBUG is set)
58 !
59 !   Status line printing, menu display
60 !   Printing object names with articles
61 !   Miscellaneous utility routines
62 !   Game banner, "version" verb, run-time errors
63 ! ==============================================================================
64
65 System_file;
66
67 #Ifndef LIBRARY_STAGE;  ! This file is the first one to define LIBRARY_STAGE.
68                 ! "This file already included" <=> "LIBRARY_STAGE exists"
69
70 ! ------------------------------------------------------------------------------
71
72 #Ifndef VN_1633;
73 Message fatalerror "*** Library 6.12.2 needs Inform v6.33 or later to work ***";
74 #Endif; ! VN_
75
76 Constant LibSerial       "180520";
77 Constant LibRelease      "6.12.2";
78 Constant LIBRARY_VERSION  612;
79 Constant Grammar__Version 2;
80
81 Constant BEFORE_PARSER   10;
82 Constant AFTER_PARSER    20;
83 Constant AFTER_VERBLIB   30;
84 Constant AFTER_GRAMMAR   40;
85
86 Constant LIBRARY_STAGE = BEFORE_PARSER;
87
88 Default COMMENT_CHARACTER '*';
89
90 #Ifdef INFIX;
91 Default DEBUG 0;
92 #Endif; ! INFIX
93
94 #Ifndef WORDSIZE;                   ! compiling with Z-code only compiler
95 Default TARGET_ZCODE 0;
96 Constant WORDSIZE 2;
97 #Endif; ! WORDSIZE
98
99 #Ifdef TARGET_ZCODE;                ! offsets into Z-machine header
100
101 Constant HDR_ZCODEVERSION  $00;     ! byte
102 Constant HDR_TERPFLAGS     $01;     ! byte
103 Constant HDR_GAMERELEASE   $02;     ! word
104 Constant HDR_HIGHMEMORY    $04;     ! word
105 Constant HDR_INITIALPC     $06;     ! word
106 Constant HDR_DICTIONARY    $08;     ! word
107 Constant HDR_OBJECTS       $0A;     ! word
108 Constant HDR_GLOBALS       $0C;     ! word
109 Constant HDR_STATICMEMORY  $0E;     ! word
110 Constant HDR_GAMEFLAGS     $10;     ! word
111 Constant HDR_GAMESERIAL    $12;     ! six ASCII characters
112 Constant HDR_ABBREVIATIONS $18;     ! word
113 Constant HDR_FILELENGTH    $1A;     ! word
114 Constant HDR_CHECKSUM      $1C;     ! word
115 Constant HDR_TERPNUMBER    $1E;     ! byte
116 Constant HDR_TERPVERSION   $1F;     ! byte
117 Constant HDR_SCREENHLINES  $20;     ! byte
118 Constant HDR_SCREENWCHARS  $21;     ! byte
119 Constant HDR_SCREENWUNITS  $22;     ! word
120 Constant HDR_SCREENHUNITS  $24;     ! word
121 Constant HDR_FONTWUNITS    $26;     ! byte
122 Constant HDR_FONTHUNITS    $27;     ! byte
123 Constant HDR_ROUTINEOFFSET $28;     ! word
124 Constant HDR_STRINGOFFSET  $2A;     ! word
125 Constant HDR_BGCOLOUR      $2C;     ! byte
126 Constant HDR_FGCOLOUR      $2D;     ! byte
127 Constant HDR_TERMCHARS     $2E;     ! word
128 Constant HDR_PIXELSTO3     $30;     ! word
129 Constant HDR_TERPSTANDARD  $32;     ! two bytes
130 Constant HDR_ALPHABET      $34;     ! word
131 Constant HDR_EXTENSION     $36;     ! word
132 Constant HDR_UNUSED        $38;     ! two words
133 Constant HDR_INFORMVERSION $3C;     ! four ASCII characters
134
135 #Ifnot; ! TARGET_GLULX              ! offsets into Glulx header and start of ROM
136
137 Constant HDR_MAGICNUMBER   $00;     ! long word
138 Constant HDR_GLULXVERSION  $04;     ! long word
139 Constant HDR_RAMSTART      $08;     ! long word
140 Constant HDR_EXTSTART      $0C;     ! long word
141 Constant HDR_ENDMEM        $10;     ! long word
142 Constant HDR_STACKSIZE     $14;     ! long word
143 Constant HDR_STARTFUNC     $18;     ! long word
144 Constant HDR_DECODINGTBL   $1C;     ! long word
145 Constant HDR_CHECKSUM      $20;     ! long word
146 Constant ROM_INFO          $24;     ! four ASCII characters
147 Constant ROM_MEMORYLAYOUT  $28;     ! long word
148 Constant ROM_INFORMVERSION $2C;     ! four ASCII characters
149 Constant ROM_COMPVERSION   $30;     ! four ASCII characters
150 Constant ROM_GAMERELEASE   $34;     ! short word
151 Constant ROM_GAMESERIAL    $36;     ! six ASCII characters
152
153 Include "infglk";
154
155 #Endif; ! TARGET_
156
157 Include "linklpa";
158
159 Fake_Action LetGo;
160 Fake_Action Receive;
161 Fake_Action ThrownAt;
162 Fake_Action Order;
163 Fake_Action TheSame;
164 Fake_Action PluralFound;
165 Fake_Action ListMiscellany;
166 Fake_Action Miscellany;
167 Fake_Action Prompt;
168 Fake_Action NotUnderstood;
169 Fake_Action Going;
170
171 #Ifdef NO_PLACES;
172 Fake_Action Places;
173 Fake_Action Objects;
174 #Endif; ! NO_PLACES
175
176 ! ------------------------------------------------------------------------------
177
178 [ Main; InformLibrary.play(); ];
179
180 ! ------------------------------------------------------------------------------
181
182 #Ifdef COLOR;
183 Constant COLOUR;
184 #Endif;
185
186 #Ifdef COLOUR;
187 Global clr_on = 1;
188 #Ifnot;
189 Global clr_on = 0;
190 #Endif;
191
192 ! ------------------------------------------------------------------------------
193 !   Global variables and their associated Constant and Array declarations
194 ! ------------------------------------------------------------------------------
195
196 Global location = InformLibrary;    ! Must be first global defined
197 Global sline1;                      ! Must be second
198 Global sline2;                      ! Must be third
199                                     ! (for status line display)
200
201 ! ------------------------------------------------------------------------------
202 !   Z-Machine and interpreter issues
203 ! ------------------------------------------------------------------------------
204
205 #Ifdef TARGET_ZCODE;
206 Global top_object;                  ! Largest valid number of any tree object
207 ! ### these globals are not meaningful... well, maybe standard_interpreter,
208 ! but I'll decide that later (AP).
209 Constant INDIV_PROP_START 64;       ! Equivalent of a Glulx constant
210
211 #Endif; ! TARGET_ZCODE
212
213 Global standard_interpreter;        ! The version number of the Z-Machine Standard which the
214                                     ! interpreter claims to support, in form (upper byte).(lower)
215
216 Global undo_flag;                   ! Can the interpreter provide "undo"?
217 Global just_undone;                 ! Can't have two successive UNDOs
218
219 Global transcript_mode;             ! true when game scripting is on
220
221 #Ifdef TARGET_ZCODE;
222 Global xcommsdir;                   ! true if command recording is on
223 #Endif; ! TARGET_ZCODE
224
225 #Ifdef TARGET_GLULX;
226 Constant GG_MAINWIN_ROCK     201;
227 Constant GG_STATUSWIN_ROCK   202;
228 Constant GG_QUOTEWIN_ROCK    203;
229 Constant GG_SAVESTR_ROCK     301;
230 Constant GG_SCRIPTSTR_ROCK   302;
231 Constant GG_COMMANDWSTR_ROCK 303;
232 Constant GG_COMMANDRSTR_ROCK 304;
233 Constant GG_SCRIPTFREF_ROCK  401;
234 Array gg_event --> 4;
235 #Ifdef VN_1630;
236 Array gg_arguments buffer 28;
237 #Ifnot;
238 Array gg_arguments --> 8;
239 #Endif; ! VN_
240 Global gg_mainwin = 0;
241 Global gg_statuswin = 0;
242 Global gg_quotewin = 0;
243 Global gg_scriptfref = 0;
244 Global gg_scriptstr = 0;
245 Global gg_savestr = 0;
246 Global gg_commandstr = 0;
247 Global gg_command_reading = 0;      ! true if gg_commandstr is being replayed
248 #Endif; ! TARGET_GLULX
249
250 Global gg_statuswin_cursize = 0;
251 Global gg_statuswin_size = 1;
252
253 ! ------------------------------------------------------------------------------
254 !   Time and score
255 !   (for linkage reasons, the task_* arrays are created not here but in verblib.h)
256 ! ------------------------------------------------------------------------------
257
258 #Ifndef sys_statusline_flag;
259 Global sys_statusline_flag = 0;     ! non-zero if status line displays time
260 #Endif;
261
262 #Ifndef START_MOVE;
263 Constant START_MOVE 0;               ! Traditionally 0 for Infocom, 1 for Inform
264 #Endif;
265
266 Global turns = START_MOVE;          ! Number of turns of play so far
267 Global the_time = NULL;             ! Current time (in minutes since midnight)
268 Global time_rate = 1;               ! How often time is updated
269 Global time_step;                   ! By how much
270
271 #Ifndef MAX_TIMERS;
272 Constant MAX_TIMERS  32;            ! Max number timers/daemons active at once
273 #Endif; ! MAX_TIMERS
274 Array  the_timers  --> MAX_TIMERS;
275 Global active_timers;               ! Number of timers/daemons actives
276
277 Global score;                       ! The current score
278 Global last_score;                  ! Score last turn (for testing for changes)
279 Global notify_mode = true;          ! Score notification
280 Global places_score;                ! Contribution to score made by visiting
281 Global things_score;                ! Contribution made by acquisition
282
283 ! ------------------------------------------------------------------------------
284 !   The player
285 ! ------------------------------------------------------------------------------
286
287 Global player;                      ! Which object the human is playing through
288 Global deadflag;                    ! Normally 0, or false; 1 for dead
289                                     ! 2 for victorious, and higher numbers
290                                     ! represent exotic forms of death
291
292 ! ------------------------------------------------------------------------------
293 !   Light and room descriptions
294 ! ------------------------------------------------------------------------------
295
296 Global lightflag = true;            ! Is there currently light to see by?
297 Global real_location;               ! When in darkness, location = thedark
298                                     ! and this holds the real location
299 Global prev_location;               ! The previous value of real_location
300 Global visibility_ceiling;          ! Highest object in tree visible from the
301                                     ! player's point of view (usually the room,
302                                     ! sometimes darkness, sometimes a closed
303                                     ! non-transparent container).
304
305 Global lookmode = 2;                ! 1=brief, 2=verbose, 3=superbrief
306                                     ! room descriptions
307 Global print_player_flag;           ! If set, print something like "(as Fred)"
308                                     ! in room descriptions, to reveal whom the
309                                     ! player is playing through
310 Global lastdesc;                    ! Value of location at time of most recent
311                                     ! room description printed out
312
313 ! ------------------------------------------------------------------------------
314 !   List writing  (style bits are defined as Constants in "verblibm.h")
315 ! ------------------------------------------------------------------------------
316
317 Global c_style;                     ! Current list-writer style
318 Global lt_value;                    ! Common value of list_together
319 Global listing_together;            ! Object number of one member of a group
320                                     ! being listed together
321 Global listing_size;                ! Size of such a group
322 Global wlf_indent;                  ! Current level of indentation printed by
323                                     ! WriteListFrom()
324
325 Global inventory_stage = 1;         ! 1 or 2 according to the context in which
326                                     ! "invent" routines of objects are called
327 Global inventory_style;             ! List-writer style currently used while
328                                     ! printing inventories
329 ! ------------------------------------------------------------------------------
330 !   Menus and printing
331 ! ------------------------------------------------------------------------------
332
333 Global pretty_flag = true;          ! Use character graphics, or plain text?
334 Global menu_nesting;                ! Level of nesting (0 = root menu)
335 Global menu_item;                   ! These are used in communicating
336 Global item_width = 8;              ! with the menu-creating routines
337 Global item_name = "---";
338
339 Global lm_n;                        ! Parameters used by LibraryMessages
340 Global lm_o;                        ! mechanism
341 Global lm_s;
342
343 #Ifdef DEBUG;
344 Constant DEBUG_MESSAGES $0001;
345 Constant DEBUG_ACTIONS  $0002;
346 Constant DEBUG_TIMERS   $0004;
347 Constant DEBUG_CHANGES  $0008;
348 Constant DEBUG_VERBOSE  $0080;
349 Global debug_flag;                  ! Bitmap of flags for tracing actions,
350                                     ! calls to object routines, etc.
351 Global x_scope_count;               ! Used in printing a list of everything
352 #Endif; ! DEBUG                     ! in scope
353
354 ! five for colour control
355 ! see http://www.inform-fiction.org/patches/L61007.html
356 ! To enable colour define a constant or Global: COLOR or COLOUR
357 !Global clr_on;                      ! has colour been enabled by the player?
358 #Ifdef COLOUR;
359 Global clr_fg = 1;                  ! foreground colour
360 Global clr_bg = 1;                  ! background colour
361 Global clr_fgstatus = 1;            ! foreground colour of statusline
362 Global clr_bgstatus = 1;            ! background colour of statusline
363 #Endif; ! COLOUR
364 Global statuswin_current;           ! if writing to top window
365
366 Constant CLR_CURRENT 0;
367 Constant CLR_DEFAULT 1;
368 Constant CLR_BLACK   2;
369 Constant CLR_RED     3;
370 Constant CLR_GREEN   4;
371 Constant CLR_YELLOW  5;
372 Constant CLR_BLUE    6;
373 Constant CLR_MAGENTA 7;
374 Constant CLR_CYAN    8;
375 Constant CLR_WHITE   9;
376 Constant CLR_PURPLE  7;
377 Constant CLR_AZURE   8;
378
379 Constant WIN_ALL     0;
380 Constant WIN_STATUS  1;
381 Constant WIN_MAIN    2;
382
383 ! ------------------------------------------------------------------------------
384 !   Action processing
385 ! ------------------------------------------------------------------------------
386
387 Global action;                      ! Action currently being asked to perform
388 Global inp1;                        ! 0 (nothing), 1 (number) or first noun
389 Global inp2;                        ! 0 (nothing), 1 (number) or second noun
390 Global noun;                        ! First noun or numerical value
391 Global second;                      ! Second noun or numerical value
392
393 Global keep_silent;                 ! If true, attempt to perform the action
394                                     ! silently (e.g. for implicit takes,
395                                     ! implicit opening of unlocked doors)
396
397 Global reason_code;                 ! Reason for calling a "life" rule
398                                     ! (an action or fake such as ##Kiss)
399
400 Global receive_action;              ! Either ##PutOn or ##Insert, whichever is
401                                     ! action being tried when an object's
402                                     ! "before" rule is checking "Receive"
403
404 Global no_implicit_actions;         ! Don't implicitly do things.
405
406 ! ==============================================================================
407 !   Parser variables: first, for communication to the parser
408 ! ------------------------------------------------------------------------------
409
410 Global parser_trace = 0;            ! Set this to 1 to make the parser trace
411                                     ! tokens and lines
412 Global parser_action;               ! For the use of the parser when calling
413 Global parser_one;                  ! user-supplied routines
414 Global parser_two;                  !
415 Array  inputobjs       --> 16;      ! For parser to write its results in
416 Global parser_inflection;           ! A property (usually "name") to find
417                                     ! object names in
418 Global parser_inflection_func;      ! Programmer sets this to true when
419                                     ! parser_infection is a function
420
421 ! ------------------------------------------------------------------------------
422 !   Parser output
423 ! ------------------------------------------------------------------------------
424
425 Global actor;                       ! Person asked to do something
426 Global actors_location;             ! Like location, but for the actor
427 Global meta;                        ! Verb is a meta-command (such as "save")
428
429 #Ifdef INFIX;
430 Global infix_verb;                  ! Verb is an Infix command
431 #Endif;
432
433 Array  multiple_object --> 64;      ! List of multiple parameters
434 Global multiflag;                   ! Multiple-object flag passed to actions
435                                     ! Also used to prevent misleading MULTI_PE
436 Global toomany_flag;                ! Flag for "multiple match too large"
437                                     ! (e.g. if "take all" took over 100 things)
438
439 Global special_word;                ! Dictionary address for "special" token
440 Global special_number;              ! Number typed for "special" token
441 Global parsed_number;               ! For user-supplied parsing routines
442 Global consult_from;                ! Word that a "consult" topic starts on
443 Global consult_words;               ! ...and number of words in topic
444 Global asking_player;               ! True during disambiguation question
445
446 ! ------------------------------------------------------------------------------
447 !   Implicit taking
448 ! ------------------------------------------------------------------------------
449
450 Global notheld_mode;                ! To do with implicit taking
451 Global onotheld_mode;               !     "old copy of notheld_mode", ditto
452 Global not_holding;                 ! Object to be automatically taken as an
453                                     ! implicit command
454 Array  kept_results --> 16;         ! Delayed command (while the take happens)
455
456 ! ------------------------------------------------------------------------------
457 !   Error numbers when parsing a grammar line
458 ! ------------------------------------------------------------------------------
459
460 Global etype;                       ! Error number on current line
461 Global best_etype;                  ! Preferred error number so far
462 Global nextbest_etype;              ! Preferred one, if ASKSCOPE_PE disallowed
463
464 Constant STUCK_PE     = 1;
465 Constant UPTO_PE      = 2;
466 Constant NUMBER_PE    = 3;
467 Constant CANTSEE_PE   = 4;
468 Constant TOOLIT_PE    = 5;
469 Constant NOTHELD_PE   = 6;
470 Constant MULTI_PE     = 7;
471 Constant MMULTI_PE    = 8;
472 Constant VAGUE_PE     = 9;
473 Constant EXCEPT_PE    = 10;
474 Constant ANIMA_PE     = 11;
475 Constant VERB_PE      = 12;
476 Constant SCENERY_PE   = 13;
477 Constant ITGONE_PE    = 14;
478 Constant JUNKAFTER_PE = 15;
479 Constant TOOFEW_PE    = 16;
480 Constant NOTHING_PE   = 17;
481 Constant ASKSCOPE_PE  = 18;
482
483 ! ------------------------------------------------------------------------------
484 !   Pattern-matching against a single grammar line
485 ! ------------------------------------------------------------------------------
486
487 Array pattern --> 32;               ! For the current pattern match
488 Global pcount;                      ! and a marker within it
489 Array pattern2 --> 32;              ! And another, which stores the best match
490 Global pcount2;                     ! so far
491 Constant PATTERN_NULL = $ffff;      ! Entry for a token producing no text
492
493 Array  line_ttype-->32;             ! For storing an analysed grammar line
494 Array  line_tdata-->32;
495 Array  line_token-->32;
496
497 Global parameters;                  ! Parameters (objects) entered so far
498 Global nsns;                        ! Number of special_numbers entered so far
499 Global special_number1;             ! First number, if one was typed
500 Global special_number2;             ! Second number, if two were typed
501
502 ! ------------------------------------------------------------------------------
503 !   Inferences and looking ahead
504 ! ------------------------------------------------------------------------------
505
506 Global params_wanted;               ! Number of parameters needed
507                                     ! (which may change in parsing)
508
509 Global inferfrom;                   ! The point from which the rest of the
510                                     ! command must be inferred
511 Global inferword;                   ! And the preposition inferred
512 Global dont_infer;                  ! Another dull flag
513 Global no_infer_message = false;    ! Use in ChooseObjects to suppress
514                                     ! an inference message.
515
516 Global action_to_be;                ! (If the current line were accepted.)
517 Global action_reversed;             ! (Parameters would be reversed in order.)
518 Global advance_warning;             ! What a later-named thing will be
519
520 ! ------------------------------------------------------------------------------
521 !   At the level of individual tokens now
522 ! ------------------------------------------------------------------------------
523
524 Global found_ttype;                 ! Used to break up tokens into type
525 Global found_tdata;                 ! and data (by AnalyseToken)
526 Global token_filter;                ! For noun filtering by user routines
527
528 Global length_of_noun;              ! Set by NounDomain to no of words in noun
529
530 #Ifdef TARGET_ZCODE;
531 Constant REPARSE_CODE = 10000;      ! Signals "reparse the text" as a reply
532                                     ! from NounDomain
533 #Ifnot; ! TARGET_GLULX
534 Constant REPARSE_CODE = $40000000;  ! The parser rather gunkily adds addresses
535                                     ! to REPARSE_CODE for some purposes and
536                                     ! expects the result to be greater than
537                                     ! REPARSE_CODE (signed comparison).
538                                     ! So Glulx Inform is limited to a single
539                                     ! gigabyte of storage, for the moment.
540 #Endif; ! TARGET_
541
542 Global lookahead;                   ! The token after the one now being matched
543
544 Global multi_mode;                  ! Multiple mode
545 Global multi_wanted;                ! Number of things needed in multitude
546 Global multi_had;                   ! Number of things actually found
547 Global multi_context;               ! What token the multi-obj was accepted for
548
549 Global indef_mode;                  ! "Indefinite" mode - ie, "take a brick"
550                                     ! is in this mode
551 Global indef_type;                  ! Bit-map holding types of specification
552 Global indef_wanted;                ! Number of items wanted (100 for all)
553 Global indef_guess_p;               ! Plural-guessing flag
554 Global indef_owner;                 ! Object which must hold these items
555 Global indef_cases;                 ! Possible gender and numbers of them
556 Global indef_possambig;             ! Has a possibly dangerous assumption
557                                     ! been made about meaning of a descriptor?
558 Global indef_nspec_at;              ! Word at which a number like "two" was
559                                     ! parsed (for backtracking)
560 Global allow_plurals;               ! Whether plurals presently allowed or not
561
562 Global take_all_rule;               ! Slightly different rules apply to
563                                     ! "take all" than other uses of multiple
564                                     ! objects, to make adjudication produce
565                                     ! more pragmatically useful results
566                                     ! (Not a flag: possible values 0, 1, 2)
567
568 Global dict_flags_of_noun;          ! Of the noun currently being parsed
569                                     ! (a bitmap in #dict_par1 format)
570 Constant DICT_VERB $01;
571 Constant DICT_META $02;
572 Constant DICT_PLUR $04;
573 Constant DICT_PREP $08;
574 Constant DICT_X654 $70;
575 Constant DICT_NOUN $80;
576
577 Global pronoun_word;                ! Records which pronoun ("it", "them", ...)
578                                     ! caused an error
579 Global pronoun_obj;                 ! And what obj it was thought to refer to
580 Global pronoun__word;               ! Saved value
581 Global pronoun__obj;                ! Saved value
582
583 ! ------------------------------------------------------------------------------
584 !   Searching through scope and parsing "scope=Routine" grammar tokens
585 ! ------------------------------------------------------------------------------
586
587 Constant PARSING_REASON       = 0;  ! Possible reasons for searching scope
588 Constant TALKING_REASON       = 1;
589 Constant EACH_TURN_REASON     = 2;
590 Constant REACT_BEFORE_REASON  = 3;
591 Constant REACT_AFTER_REASON   = 4;
592 Constant LOOPOVERSCOPE_REASON = 5;
593 Constant TESTSCOPE_REASON     = 6;
594
595 Global scope_reason = PARSING_REASON; ! Current reason for searching scope
596
597 Global scope_token;                 ! For "scope=Routine" grammar tokens
598 Global scope_error;
599 Global scope_stage;                 ! 1, 2 then 3
600
601 Global ats_flag = 0;                ! For AddToScope routines
602 Global ats_hls;                     !
603
604 Global placed_in_flag;              ! To do with PlaceInScope
605
606 ! ------------------------------------------------------------------------------
607 !   The match list of candidate objects for a given token
608 ! ------------------------------------------------------------------------------
609
610 Constant MATCH_LIST_SIZE = 64;
611 Array  match_list    --> MATCH_LIST_SIZE; ! An array of matched objects so far
612 Array  match_classes --> MATCH_LIST_SIZE; ! An array of equivalence classes for them
613 Array  match_scores --> MATCH_LIST_SIZE;  ! An array of match scores for them
614 Global number_matched;              ! How many items in it?  (0 means none)
615 Global number_of_classes;           ! How many equivalence classes?
616 Global match_length;                ! How many words long are these matches?
617 Global saved_ml;
618 Global match_from;                  ! At what word of the input do they begin?
619 Global bestguess_score;             ! What did the best-guess object score?
620
621 ! ------------------------------------------------------------------------------
622 !   Low level textual manipulation
623 ! ------------------------------------------------------------------------------
624
625 #Ifdef TARGET_ZCODE;
626
627 ! 'buffer' holds the input line as typed by the player
628 !
629 !       buffer->0                     INPUT_BUFFER_LEN - WORDSIZE
630 !       buffer->1                     Number of characters input by player
631 !       buffer->2 ... buffer->121     The actual characters
632 !       buffer->122                   Spare byte to allow for 'terp bugs
633 !
634 ! 'parse' holds the result of parsing that line into dictionary words
635 !
636 !       parse->0                      MAX_BUFFER_WORDS
637 !       parse->1                      Number of words input by player
638 !
639 !       parse-->1                     Dictionary addr of first input word
640 !       parse->4                      Number of characters in the word
641 !       parse->5                      Start position in 'buffer' of the word
642 !
643 !       parse-->3  parse->8,9         Same data for second input word
644 !       ...
645 !       parse-->29 parse->60,61       Same data for MAX_BUFFER_WORDS input word
646 !       parse->62,63,64               Spare bytes (not sure why)
647
648
649 Constant INPUT_BUFFER_LEN = WORDSIZE + 120;  ! 120 is limit on input chars
650 Constant MAX_BUFFER_WORDS = 15;              ! Limit on input words
651
652 Array  buffer  -> INPUT_BUFFER_LEN + 1;      ! For main line of input
653 Array  buffer2 -> INPUT_BUFFER_LEN + 1;      ! For supplementary questions
654 Array  buffer3 -> INPUT_BUFFER_LEN + 1;      ! Retaining input for "AGAIN"
655
656 #Ifdef VN_1630;
657 Array  parse   buffer (MAX_BUFFER_WORDS * 4) + 3;   ! Parsed data from 'buffer'
658 Array  parse2  buffer (MAX_BUFFER_WORDS * 4) + 3;   ! Parsed data from 'buffer2'
659 #Ifnot;
660 Array  parse   -> 2 + (MAX_BUFFER_WORDS * 4) + 3;
661 Array  parse2  -> 2 + (MAX_BUFFER_WORDS * 4) + 3;
662 #Endif; ! VN_
663
664 #Ifnot; ! TARGET_GLULX
665
666 ! 'buffer' holds the input line as typed by the player
667 !
668 !       buffer-->0                    Number of characters input by player
669 !       buffer->4 ... buffer->259     The actual characters
670 !
671 ! 'parse' holds the result of parsing that line into dictionary words
672 !
673 !       parse-->0                     Number of words input by player
674 !
675 !       parse-->1                     Dictionary addr of first input word
676 !       parse-->2                     Number of characters in the word
677 !       parse-->3                     Start position in 'buffer' of the word
678 !
679 !       parse-->4,5,6                 Same data for second input word
680 !       ...
681 !       parse-->58,59,60              Same data for MAX_BUFFER_WORDS input word
682
683 Constant INPUT_BUFFER_LEN = WORDSIZE + 256;    ! 256 is limit on input chars
684 Constant MAX_BUFFER_WORDS = 20;                ! Limit on input words
685
686 #Ifdef VN_1630;
687 Array  buffer  buffer (INPUT_BUFFER_LEN-WORDSIZE);  ! For main line of input
688 Array  buffer2 buffer (INPUT_BUFFER_LEN-WORDSIZE);  ! For supplementary questions
689 Array  buffer3 buffer (INPUT_BUFFER_LEN-WORDSIZE);  ! Retaining input for "AGAIN"
690 #Ifnot;
691 Array  buffer  -> INPUT_BUFFER_LEN;
692 Array  buffer2 -> INPUT_BUFFER_LEN;
693 Array  buffer3 -> INPUT_BUFFER_LEN;
694 #Endif; ! VN_
695 Array  parse   --> 1 + (MAX_BUFFER_WORDS * 3);      ! Parsed data from 'buffer'
696 Array  parse2  --> 1 + (MAX_BUFFER_WORDS * 3);      ! Parsed data from 'buffer2'
697
698 #Endif; ! TARGET_
699
700 Constant comma_word = 'comma,';     ! An "untypeable word" used to substitute
701                                     ! for commas in parse buffers
702
703 Global wn;                          ! Word number within "parse" (from 1)
704 Global num_words;                   ! Number of words typed
705 Global num_desc;                    ! Number of descriptors typed
706 Global verb_word;                   ! Verb word (eg, take in "take all" or
707                                     ! "dwarf, take all") - address in dict
708 Global verb_wordnum;                ! its number in typing order (eg, 1 or 3)
709 Global usual_grammar_after;         ! Point from which usual grammar is parsed (it may vary from the
710                                     ! above if user's routines match multi-word verbs)
711
712 Global oops_from;                   ! The "first mistake" word number
713 Global saved_oops;                  ! Used in working this out
714
715 Constant OOPS_WORKSPACE_LEN 64;     ! Used temporarily by "oops" routine
716 Array  oops_workspace -> OOPS_WORKSPACE_LEN;
717
718 Global held_back_mode;              ! Flag: is there some input from last time
719 Global hb_wn;                       ! left over?  (And a save value for wn.)
720                                     ! (Used for full stops and "then".)
721
722 Global caps_mode;                   ! Keep track of (The) with 'proper' caps
723 Global print_anything_result;       ! Return value from a PrintAny() routine
724 Global initial_lookmode;            ! Default, or set in Initialise()
725 Global before_first_turn;           ! True until after initial LOOK
726
727 ! ----------------------------------------------------------------------------
728
729 Array PowersOfTwo_TB                ! Used in converting case numbers to case
730   --> $$100000000000                ! bitmaps
731       $$010000000000
732       $$001000000000
733       $$000100000000
734       $$000010000000
735       $$000001000000
736       $$000000100000
737       $$000000010000
738       $$000000001000
739       $$000000000100
740       $$000000000010
741       $$000000000001;
742
743 ! ============================================================================
744 !  Constants, and one variable, needed for the language definition file
745 ! ----------------------------------------------------------------------------
746
747 Constant POSSESS_PK  = $100;
748 Constant DEFART_PK   = $101;
749 Constant INDEFART_PK = $102;
750 Global short_name_case;
751
752 Global dict_start;
753 Global dict_entry_size;
754 Global dict_end;
755
756 ! ----------------------------------------------------------------------------
757
758 Include "language__";               ! The natural language definition, whose filename is taken from
759                                     ! the ICL language_name variable
760
761 ! ----------------------------------------------------------------------------
762
763 #Ifndef LanguageCases;
764 Constant LanguageCases = 1;
765 #Endif; ! LanguageCases
766
767 ! ------------------------------------------------------------------------------
768 !   Pronouns support for the cruder (library 6/2 and earlier) version:
769 !   only needed in English
770 ! ------------------------------------------------------------------------------
771
772 #Ifdef EnglishNaturalLanguage;
773 Global itobj = NULL;                ! The object which is currently "it"
774 Global himobj = NULL;               ! The object which is currently "him"
775 Global herobj = NULL;               ! The object which is currently "her"
776
777 Global old_itobj = NULL;            ! The object which is currently "it"
778 Global old_himobj = NULL;           ! The object which is currently "him"
779 Global old_herobj = NULL;           ! The object which is currently "her"
780 #Endif; ! EnglishNaturalLanguage
781
782 ! ============================================================================
783 ! For present and past tenses
784 ! ----------------------------------------------------------------------------
785 Constant PRESENT_TENSE 0;
786 Constant PAST_TENSE    1;
787
788 ! ============================================================================
789 ! For InformLibrary.actor_act() to control what happens when it aborts.
790 ! ----------------------------------------------------------------------------
791 Constant ACTOR_ACT_OK 0;
792 Constant ACTOR_ACT_ABORT_NOTUNDERSTOOD 1;
793 Constant ACTOR_ACT_ABORT_ORDER 2;
794
795 ! ============================================================================
796 ! "Darkness" is not really a place: but it has to be an object so that the
797 !  location-name on the status line can be "Darkness".
798 ! ----------------------------------------------------------------------------
799
800 Object  thedark "(darkness object)"
801   with  initial 0,
802         short_name DARKNESS__TX,
803         description [;  return L__M(##Miscellany, 17); ];
804
805 ! If you want to use the third-person of the narrative voice, you will
806 ! need to replace this selfobj with your own.
807
808 Class  SelfClass
809   with name ',a' ',b' ',c' ',d' ',e',
810         short_name  YOURSELF__TX,
811         description [;  return L__M(##Miscellany, 19); ],
812         before NULL,
813         after NULL,
814         life NULL,
815         each_turn NULL,
816         time_out NULL,
817         describe NULL,
818         article "the",
819         add_to_scope 0,
820         capacity 100,
821         parse_name 0,
822         orders 0,
823         number 0,
824         narrative_voice 2,
825         narrative_tense PRESENT_TENSE,
826         nameless true,
827         posture 0,
828         before_implicit [;Take: return 2;],
829   has   concealed animate proper transparent;
830
831 SelfClass selfobj "(self object)";
832
833 ! ============================================================================
834 !  The definition of the token-numbering system used by Inform.
835 ! ----------------------------------------------------------------------------
836
837 Constant ILLEGAL_TT         = 0;    ! Types of grammar token: illegal
838 Constant ELEMENTARY_TT      = 1;    !     (one of those below)
839 Constant PREPOSITION_TT     = 2;    !     e.g. 'into'
840 Constant ROUTINE_FILTER_TT  = 3;    !     e.g. noun=CagedCreature
841 Constant ATTR_FILTER_TT     = 4;    !     e.g. edible
842 Constant SCOPE_TT           = 5;    !     e.g. scope=Spells
843 Constant GPR_TT             = 6;    !     a general parsing routine
844
845 Constant NOUN_TOKEN         = 0;    ! The elementary grammar tokens, and
846 Constant HELD_TOKEN         = 1;    ! the numbers compiled by Inform to
847 Constant MULTI_TOKEN        = 2;    ! encode them
848 Constant MULTIHELD_TOKEN    = 3;
849 Constant MULTIEXCEPT_TOKEN  = 4;
850 Constant MULTIINSIDE_TOKEN  = 5;
851 Constant CREATURE_TOKEN     = 6;
852 Constant SPECIAL_TOKEN      = 7;
853 Constant NUMBER_TOKEN       = 8;
854 Constant TOPIC_TOKEN        = 9;
855
856
857 Constant GPR_FAIL           = -1;   ! Return values from General Parsing
858 Constant GPR_PREPOSITION    = 0;    ! Routines
859 Constant GPR_NUMBER         = 1;
860 Constant GPR_MULTIPLE       = 2;
861 Constant GPR_REPARSE        = REPARSE_CODE;
862 Constant GPR_NOUN           = $ff00;
863 Constant GPR_HELD           = $ff01;
864 Constant GPR_MULTI          = $ff02;
865 Constant GPR_MULTIHELD      = $ff03;
866 Constant GPR_MULTIEXCEPT    = $ff04;
867 Constant GPR_MULTIINSIDE    = $ff05;
868 Constant GPR_CREATURE       = $ff06;
869
870 Constant ENDIT_TOKEN        = 15;   ! Value used to mean "end of grammar line"
871
872 #Iftrue (Grammar__Version == 1);
873
874 [ AnalyseToken token m;
875     found_tdata = token;
876     if (token < 0)   { found_ttype = ILLEGAL_TT; return; }
877     if (token <= 8)  { found_ttype = ELEMENTARY_TT; return; }
878     if (token < 15)  { found_ttype = ILLEGAL_TT; return; }
879     if (token == 15) { found_ttype = ELEMENTARY_TT; return; }
880     if (token < 48)  { found_ttype = ROUTINE_FILTER_TT;
881                        found_tdata = token - 16;
882                        return;
883     }
884     if (token < 80)  { found_ttype = GPR_TT;
885                        found_tdata = #preactions_table-->(token-48);
886                        return;
887     }
888     if (token < 128) { found_ttype = SCOPE_TT;
889                        found_tdata = #preactions_table-->(token-80);
890                        return;
891     }
892     if (token < 180) { found_ttype = ATTR_FILTER_TT;
893                        found_tdata = token - 128;
894                        return;
895     }
896
897     found_ttype = PREPOSITION_TT;
898     m = #adjectives_table;
899     for (::) {
900         if (token == m-->1) { found_tdata = m-->0; return; }
901         m = m+4;
902     }
903     m = #adjectives_table; RunTimeError(1);
904     found_tdata = m;
905 ];
906
907 [ UnpackGrammarLine line_address i m;
908     for (i=0 : i<32 : i++) {
909         line_token-->i = ENDIT_TOKEN;
910         line_ttype-->i = ELEMENTARY_TT;
911         line_tdata-->i = ENDIT_TOKEN;
912     }
913     for (i=0 : i<=5 : i++) {
914         line_token-->i = line_address->(i+1);
915         AnalyseToken(line_token-->i);
916         if ((found_ttype == ELEMENTARY_TT) && (found_tdata == NOUN_TOKEN)
917            && (m == line_address->0)) {
918             line_token-->i = ENDIT_TOKEN;
919             break;
920         }
921         line_ttype-->i = found_ttype;
922         line_tdata-->i = found_tdata;
923         if (found_ttype ~= PREPOSITION_TT) m++;
924     }
925     action_to_be = line_address->7;
926     action_reversed = false;
927     params_wanted = line_address->0;
928     return line_address + 8;
929 ];
930
931 #Ifnot; ! Grammar__Version == 2
932
933 [ AnalyseToken token;
934     if (token == ENDIT_TOKEN) {
935         found_ttype = ELEMENTARY_TT;
936         found_tdata = ENDIT_TOKEN;
937         return;
938     }
939     found_ttype = (token->0) & $$1111;
940     found_tdata = (token+1)-->0;
941 ];
942
943 #Ifdef TARGET_ZCODE;
944
945 [ UnpackGrammarLine line_address i;
946     for (i=0 : i<32 : i++) {
947         line_token-->i = ENDIT_TOKEN;
948         line_ttype-->i = ELEMENTARY_TT;
949         line_tdata-->i = ENDIT_TOKEN;
950     }
951     action_to_be = 256*(line_address->0) + line_address->1;
952     action_reversed = ((action_to_be & $400) ~= 0);
953     action_to_be = action_to_be & $3ff;
954     line_address--;
955     params_wanted = 0;
956     for (i=0 : : i++) {
957         line_address = line_address + 3;
958         if (line_address->0 == ENDIT_TOKEN) break;
959         line_token-->i = line_address;
960         AnalyseToken(line_address);
961         if (found_ttype ~= PREPOSITION_TT) params_wanted++;
962         line_ttype-->i = found_ttype;
963         line_tdata-->i = found_tdata;
964     }
965     return line_address + 1;
966 ];
967
968 #Ifnot; ! TARGET_GLULX
969
970 [ UnpackGrammarLine line_address i;
971     for (i=0 : i<32 : i++) {
972         line_token-->i = ENDIT_TOKEN;
973         line_ttype-->i = ELEMENTARY_TT;
974         line_tdata-->i = ENDIT_TOKEN;
975     }
976     @aloads line_address 0 action_to_be;
977     action_reversed = (((line_address->2) & 1) ~= 0);
978     line_address = line_address - 2;
979     params_wanted = 0;
980     for (i=0 : : i++) {
981         line_address = line_address + 5;
982         if (line_address->0 == ENDIT_TOKEN) break;
983         line_token-->i = line_address;
984         AnalyseToken(line_address);
985         if (found_ttype ~= PREPOSITION_TT) params_wanted++;
986         line_ttype-->i = found_ttype;
987         line_tdata-->i = found_tdata;
988     }
989     return line_address + 1;
990 ];
991
992 #Endif; ! TARGET_
993 #Endif; ! Grammar__Version
994
995 ! To protect against a bug in early versions of the "Zip" interpreter:
996 ! Of course, in Glulx, this routine actually performs work.
997
998 #Ifdef TARGET_ZCODE;
999
1000 [ Tokenise__ b p; b->(2 + b->1) = 0; @tokenise b p; ];
1001
1002 #Ifnot; ! TARGET_GLULX
1003
1004 Array gg_tokenbuf -> DICT_WORD_SIZE;
1005
1006 [ GGWordCompare str1 str2 ix jx;
1007     for (ix=0 : ix<DICT_WORD_SIZE : ix++) {
1008         jx = (str1->ix) - (str2->ix);
1009         if (jx ~= 0) return jx;
1010     }
1011     return 0;
1012 ];
1013
1014 [ Tokenise__ buf tab
1015     cx numwords len bx ix wx wpos wlen val res dictlen entrylen;
1016     len = buf-->0;
1017     buf = buf+WORDSIZE;
1018
1019     ! First, split the buffer up into words. We use the standard Infocom
1020     ! list of word separators (comma, period, double-quote).
1021
1022     cx = 0;
1023     numwords = 0;
1024     while (cx < len) {
1025         while (cx < len && buf->cx == ' ') cx++;
1026         if (cx >= len) break;
1027         bx = cx;
1028         if (buf->cx == '.' or ',' or '"') cx++;
1029         else {
1030             while (cx < len && buf->cx ~= ' ' or '.' or ',' or '"') cx++;
1031         }
1032         tab-->(numwords*3+2) = (cx-bx);
1033         tab-->(numwords*3+3) = WORDSIZE+bx;
1034         numwords++;
1035         if (numwords >= MAX_BUFFER_WORDS) break;
1036     }
1037     tab-->0 = numwords;
1038
1039     ! Now we look each word up in the dictionary.
1040
1041     dictlen = #dictionary_table-->0;
1042     entrylen = DICT_WORD_SIZE + 7;
1043
1044     for (wx=0 : wx<numwords : wx++) {
1045         wlen = tab-->(wx*3+2);
1046         wpos = tab-->(wx*3+3);
1047
1048         ! Copy the word into the gg_tokenbuf array, clipping to DICT_WORD_SIZE
1049         ! characters and lower case.
1050         if (wlen > DICT_WORD_SIZE) wlen = DICT_WORD_SIZE;
1051         cx = wpos - WORDSIZE;
1052         for (ix=0 : ix<wlen : ix++) gg_tokenbuf->ix = glk_char_to_lower(buf->(cx+ix));
1053         for (: ix<DICT_WORD_SIZE : ix++) gg_tokenbuf->ix = 0;
1054
1055         val = #dictionary_table + WORDSIZE;
1056         @binarysearch gg_tokenbuf DICT_WORD_SIZE val entrylen dictlen 1 1 res;
1057         tab-->(wx*3+1) = res;
1058     }
1059 ];
1060
1061 #Endif; ! TARGET_
1062
1063 ! ============================================================================
1064 !   The InformParser object abstracts the front end of the parser.
1065 !
1066 !   InformParser.parse_input(results)
1067 !   returns only when a sensible request has been made, and puts into the
1068 !   "results" buffer:
1069 !
1070 !   --> 0 = The action number
1071 !   --> 1 = Number of parameters
1072 !   --> 2, 3, ... = The parameters (object numbers), but
1073 !                   0 means "put the multiple object list here"
1074 !                   1 means "put one of the special numbers here"
1075 !
1076 ! ----------------------------------------------------------------------------
1077
1078 Object  InformParser "(Inform Parser)"
1079   with  parse_input [ results; Parser__parse(results); ],
1080   has   proper;
1081
1082 ! ----------------------------------------------------------------------------
1083 !   The Keyboard routine actually receives the player's words,
1084 !   putting the words in "a_buffer" and their dictionary addresses in
1085 !   "a_table".  It is assumed that the table is the same one on each
1086 !   (standard) call.
1087 !
1088 !   It can also be used by miscellaneous routines in the game to ask
1089 !   yes-no questions and the like, without invoking the rest of the parser.
1090 !
1091 !   Return the number of words typed
1092 ! ----------------------------------------------------------------------------
1093
1094 #Ifdef TARGET_ZCODE;
1095
1096 [ GetNthChar a_buffer n i;
1097     for (i = 0: a_buffer->(2+i) == ' ': i++) {
1098         if (i > a_buffer->(1)) return false;
1099     }
1100     return a_buffer->(2+i+n);
1101 ];
1102
1103 [ KeyboardPrimitive  a_buffer a_table;
1104     read a_buffer a_table;
1105
1106     #Iftrue (#version_number == 6);
1107     @output_stream -1;
1108     @loadb a_buffer 1 -> sp;
1109     @add a_buffer 2 -> sp;
1110     @print_table sp sp;
1111     new_line;
1112     @output_stream 1;
1113     #Endif;
1114 ];
1115
1116 [ KeyCharPrimitive win  key;
1117     if (win) @set_window win;
1118     @read_char 1 -> key;
1119     return key;
1120 ];
1121
1122 [ KeyTimerInterrupt;
1123     rtrue;
1124 ];
1125
1126 [ KeyDelay tenths  key;
1127     @read_char 1 tenths KeyTimerInterrupt -> key;
1128     return key;
1129 ];
1130
1131 #Ifnot; ! TARGET_GLULX
1132
1133 [ GetNthChar a_buffer n i;
1134     for (i = 0: a_buffer->(4+i) == ' ': i++) {
1135         if (i > a_buffer->(1)) return false;
1136     }
1137     return a_buffer->(4+i+n);
1138 ];
1139
1140 [ KeyCharPrimitive win nostat done res ix jx ch;
1141     jx = ch; ! squash compiler warnings
1142     if (win == 0) win = gg_mainwin;
1143     if (gg_commandstr ~= 0 && gg_command_reading ~= false) {
1144         ! get_line_stream
1145         done = glk_get_line_stream(gg_commandstr, gg_arguments, 31);
1146         if (done == 0) {
1147             glk_stream_close(gg_commandstr, 0);
1148             gg_commandstr = 0;
1149             gg_command_reading = false;
1150             ! fall through to normal user input.
1151         }
1152         else {
1153             ! Trim the trailing newline
1154             if (gg_arguments->(done-1) == 10) done = done-1;
1155             res = gg_arguments->0;
1156             if (res == '\') {
1157                 res = 0;
1158                 for (ix=1 : ix<done : ix++) {
1159                     ch = gg_arguments->ix;
1160                     if (ch >= '0' && ch <= '9') {
1161                         @shiftl res 4 res;
1162                         res = res + (ch-'0');
1163                     }
1164                     else if (ch >= 'a' && ch <= 'f') {
1165                         @shiftl res 4 res;
1166                         res = res + (ch+10-'a');
1167                     }
1168                     else if (ch >= 'A' && ch <= 'F') {
1169                         @shiftl res 4 res;
1170                         res = res + (ch+10-'A');
1171                     }
1172                 }
1173             }
1174         jump KCPContinue;
1175         }
1176     }
1177     done = false;
1178     glk_request_char_event(win);
1179     while (~~done) {
1180         glk_select(gg_event);
1181         switch (gg_event-->0) {
1182           5: ! evtype_Arrange
1183             if (nostat) {
1184                 glk_cancel_char_event(win);
1185                 res = $80000000;
1186                 done = true;
1187                 break;
1188             }
1189             DrawStatusLine();
1190           2: ! evtype_CharInput
1191             if (gg_event-->1 == win) {
1192                 res = gg_event-->2;
1193                 done = true;
1194                 }
1195         }
1196         ix = HandleGlkEvent(gg_event, 1, gg_arguments);
1197         if (ix == 0) ix = LibraryExtensions.RunWhile(ext_handleglkevent, 0, gg_event, 1, gg_arguments);
1198         if (ix == 2) {
1199             res = gg_arguments-->0;
1200             done = true;
1201         }
1202         else if (ix == -1) {
1203             done = false;
1204         }
1205     }
1206     if (gg_commandstr ~= 0 && gg_command_reading == false) {
1207         if (res < 32 || res >= 256 || (res == '\' or ' ')) {
1208             glk_put_char_stream(gg_commandstr, '\');
1209             done = 0;
1210             jx = res;
1211             for (ix=0 : ix<8 : ix++) {
1212                 @ushiftr jx 28 ch;
1213                 @shiftl jx 4 jx;
1214                 ch = ch & $0F;
1215                 if (ch ~= 0 || ix == 7) done = 1;
1216                 if (done) {
1217                     if (ch >= 0 && ch <= 9) ch = ch + '0';
1218                     else                    ch = (ch - 10) + 'A';
1219                     glk_put_char_stream(gg_commandstr, ch);
1220                 }
1221             }
1222         }
1223         else {
1224             glk_put_char_stream(gg_commandstr, res);
1225         }
1226         glk_put_char_stream(gg_commandstr, 10);
1227     }
1228   .KCPContinue;
1229     return res;
1230 ];
1231
1232 [ KeyDelay tenths  key done ix;
1233     glk_request_char_event(gg_mainwin);
1234     glk_request_timer_events(tenths*100);
1235     while (~~done) {
1236         glk_select(gg_event);
1237         ix = HandleGlkEvent(gg_event, 1, gg_arguments);
1238         if (ix == 0) ix = LibraryExtensions.RunWhile(ext_handleglkevent, 0, gg_event, 1, gg_arguments);
1239         if (ix == 2) {
1240             key = gg_arguments-->0;
1241             done = true;
1242         }
1243         else if (ix >= 0 && gg_event-->0 == 1 or 2) {
1244             key = gg_event-->2;
1245             done = true;
1246         }
1247     }
1248     glk_cancel_char_event(gg_mainwin);
1249     glk_request_timer_events(0);
1250     return key;
1251 ];
1252
1253 [ KeyboardPrimitive  a_buffer a_table done ix;
1254     if (gg_commandstr ~= 0 && gg_command_reading ~= false) {
1255         ! get_line_stream
1256         done = glk_get_line_stream(gg_commandstr, a_buffer+WORDSIZE, (INPUT_BUFFER_LEN-WORDSIZE)-1);
1257         if (done == 0) {
1258             glk_stream_close(gg_commandstr, 0);
1259             gg_commandstr = 0;
1260             gg_command_reading = false;
1261             ! L__M(##CommandsRead, 5); would come after prompt
1262             ! fall through to normal user input.
1263         }
1264         else {
1265             ! Trim the trailing newline
1266             if ((a_buffer+WORDSIZE)->(done-1) == 10) done = done-1;
1267             a_buffer-->0 = done;
1268             glk_set_style(style_Input);
1269             glk_put_buffer(a_buffer+WORDSIZE, done);
1270             glk_set_style(style_Normal);
1271             print "^";
1272             jump KPContinue;
1273         }
1274     }
1275     done = false;
1276     glk_request_line_event(gg_mainwin, a_buffer+WORDSIZE, INPUT_BUFFER_LEN-WORDSIZE, 0);
1277     while (~~done) {
1278         glk_select(gg_event);
1279         switch (gg_event-->0) {
1280           5: ! evtype_Arrange
1281             DrawStatusLine();
1282           3: ! evtype_LineInput
1283             if (gg_event-->1 == gg_mainwin) {
1284                 a_buffer-->0 = gg_event-->2;
1285                 done = true;            }
1286         }
1287         ix = HandleGlkEvent(gg_event, 0, a_buffer);
1288         if (ix == 0) ix = LibraryExtensions.RunWhile(ext_handleglkevent, 0, gg_event, 0, a_buffer);
1289         if (ix == 2) done = true;
1290         else if (ix == -1) done = false;
1291     }
1292     if (gg_commandstr ~= 0 && gg_command_reading == false) {
1293         ! put_buffer_stream
1294
1295         glk_put_buffer_stream(gg_commandstr, a_buffer+WORDSIZE, a_buffer-->0);
1296         glk_put_char_stream(gg_commandstr, 10);
1297     }
1298   .KPContinue;
1299     Tokenise__(a_buffer,a_table);
1300     ! It's time to close any quote window we've got going.
1301     if (gg_quotewin) {
1302         glk_window_close(gg_quotewin, 0);
1303         gg_quotewin = 0;
1304     }
1305 ];
1306
1307 #Endif; ! TARGET_
1308
1309 [ Keyboard  a_buffer a_table  nw i w w2 x1 x2;
1310     DisplayStatus();
1311
1312   .FreshInput;
1313
1314     ! Save the start of the buffer, in case "oops" needs to restore it
1315     ! to the previous time's buffer
1316
1317     for (i=0 : i<OOPS_WORKSPACE_LEN : i++) oops_workspace->i = a_buffer->i;
1318
1319     ! In case of an array entry corruption that shouldn't happen, but would be
1320     ! disastrous if it did:
1321
1322     #Ifdef TARGET_ZCODE;
1323     a_buffer->0 = INPUT_BUFFER_LEN - WORDSIZE;
1324     a_table->0  = MAX_BUFFER_WORDS; ! Allow to split input into this many words
1325     #Endif; ! TARGET_
1326
1327     ! Print the prompt, and read in the words and dictionary addresses
1328
1329     L__M(##Prompt);
1330     if (AfterPrompt() == 0) LibraryExtensions.RunAll(ext_afterprompt);
1331     #IfV5;
1332     DrawStatusLine();
1333     #Endif; ! V5
1334
1335     KeyboardPrimitive(a_buffer, a_table);
1336     nw = NumberWords(a_table);
1337
1338     ! If the line was blank, get a fresh line
1339     if (nw == 0) {
1340         L__M(##Miscellany, 10);
1341         jump FreshInput;
1342     }
1343
1344     ! Unless the opening word was "oops", return
1345     ! Conveniently, a_table-->1 is the first word in both ZCODE and GLULX.
1346
1347     w = a_table-->1;
1348     if (w == OOPS1__WD or OOPS2__WD or OOPS3__WD) jump DoOops;
1349
1350     if (a_buffer->WORDSIZE == COMMENT_CHARACTER) {
1351         #Ifdef TARGET_ZCODE;
1352         if ((HDR_GAMEFLAGS-->0) & $0001 || xcommsdir)
1353                                            L__M(##Miscellany, 54);
1354         else                               L__M(##Miscellany, 55);
1355         #Ifnot; ! TARGET_GLULX
1356         if (gg_scriptstr || gg_commandstr) L__M(##Miscellany, 54);
1357         else                               L__M(##Miscellany, 55);
1358         #Endif; ! TARGET_
1359
1360         jump FreshInput;
1361     }
1362
1363     #IfV5;
1364     ! Undo handling
1365
1366     if ((w == UNDO1__WD or UNDO2__WD or UNDO3__WD) && (nw==1)) {
1367         i = PerformUndo();
1368         if (i == 0) jump FreshInput;
1369     }
1370     #Ifdef TARGET_ZCODE;
1371     @save_undo i;
1372     #Ifnot; ! TARGET_GLULX
1373     @saveundo i;
1374     if (i == -1) {
1375         GGRecoverObjects();
1376         i = 2;
1377     }
1378     else  i = (~~i);
1379     #Endif; ! TARGET_
1380     just_undone = 0;
1381     undo_flag = 2;
1382     if (i == -1) undo_flag = 0;
1383     if (i == 0) undo_flag = 1;
1384     if (i == 2) {
1385         RestoreColours();
1386         #Ifdef TARGET_ZCODE;
1387         style bold;
1388         #Ifnot; ! TARGET_GLULX
1389         glk_set_style(style_Subheader);
1390         #Endif; ! TARGET_
1391         print (name) location, "^";
1392         #Ifdef TARGET_ZCODE;
1393         style roman;
1394         #Ifnot; ! TARGET_GLULX
1395         glk_set_style(style_Normal);
1396         #Endif; ! TARGET_
1397         L__M(##Miscellany, 13);
1398         just_undone = 1;
1399         jump FreshInput;
1400     }
1401     #Endif; ! V5
1402
1403     return nw;
1404
1405   .DoOops;
1406     if (oops_from == 0) {
1407         L__M(##Miscellany, 14);
1408         jump FreshInput;
1409     }
1410     if (nw == 1) {
1411         L__M(##Miscellany, 15);
1412         jump FreshInput;
1413     }
1414     if (nw > 2) {
1415         L__M(##Miscellany, 16);
1416         jump FreshInput;
1417     }
1418
1419     ! So now we know: there was a previous mistake, and the player has
1420     ! attempted to correct a single word of it.
1421
1422     for (i=0 : i<INPUT_BUFFER_LEN : i++) buffer2->i = a_buffer->i;
1423     #Ifdef TARGET_ZCODE;
1424     x1 = a_table->9;  ! Start of word following "oops"
1425     x2 = a_table->8;  ! Length of word following "oops"
1426     #Ifnot; ! TARGET_GLULX
1427     x1 = a_table-->6; ! Start of word following "oops"
1428     x2 = a_table-->5; ! Length of word following "oops"
1429     #Endif; ! TARGET_
1430
1431     ! Repair the buffer to the text that was in it before the "oops"
1432     ! was typed:
1433
1434     for (i=0 : i < OOPS_WORKSPACE_LEN : i++) a_buffer->i = oops_workspace->i;
1435     Tokenise__(a_buffer, a_table);
1436
1437     ! Work out the position in the buffer of the word to be corrected:
1438
1439     #Ifdef TARGET_ZCODE;
1440     w = a_table->(4*oops_from + 1); ! Start of word to go
1441     w2 = a_table->(4*oops_from);    ! Length of word to go
1442     #Ifnot; ! TARGET_GLULX
1443     w = a_table-->(3*oops_from);      ! Start of word to go
1444     w2 = a_table-->(3*oops_from - 1); ! Length of word to go
1445     #Endif; ! TARGET_
1446
1447 #IfDef OOPS_CHECK;
1448     print "[~";
1449     for (i=0 : i<w2 : i++) for (i=0 : i<w2 : i++) print (char)a_buffer->(i+w);
1450     print "~ --> ~";
1451 #Endif;
1452
1453     ! Write spaces over the word to be corrected:
1454
1455     for (i=0 : i<w2 : i++) a_buffer->(i+w) = ' ';
1456
1457     if (w2 < x2) {
1458         ! If the replacement is longer than the original, move up...
1459         for (i=INPUT_BUFFER_LEN-1 : i>=w+x2 : i--)
1460             a_buffer->i = a_buffer->(i-x2+w2);
1461
1462         ! ...increasing buffer size accordingly.
1463         SetKeyBufLength(GetKeyBufLength(a_buffer) + (x2-w2), a_buffer);
1464     }
1465
1466     ! Write the correction in:
1467
1468     for (i=0 : i<x2 : i++) {
1469         a_buffer->(i+w) = buffer2->(i+x1);
1470 #IfDef OOPS_CHECK;
1471         print (char) buffer2->(i+x1);
1472 #Endif;
1473     }
1474
1475 #IfDef OOPS_CHECK;
1476         print "~]^^";
1477 #Endif;
1478
1479     Tokenise__(a_buffer, a_table);
1480     nw=NumberWords(a_table);
1481
1482 !    saved_ml = 0;
1483     return nw;
1484 ]; ! end of Keyboard
1485
1486 [ PerformUndo i;
1487     if (turns == START_MOVE) { L__M(##Miscellany, 11); return 0; }
1488     if (undo_flag == 0) {      L__M(##Miscellany, 6); return 0; }
1489     if (undo_flag == 1) {      L__M(##Miscellany, 7); return 0; }
1490     #Ifdef TARGET_ZCODE;
1491     @restore_undo i;
1492     #Ifnot; ! TARGET_GLULX
1493     @restoreundo i;
1494     i = (~~i);
1495     #Endif; ! TARGET_
1496     if (i == 0) {    L__M(##Miscellany, 7); return 0; }
1497     L__M(##Miscellany, 1);
1498     return 1;
1499 ];
1500
1501 ! ==========================
1502 ! Taken from I7's Parser.i6t
1503 ! ==========================
1504
1505 [ DictionaryWordToVerbNum dword verbnum;
1506 #Ifdef TARGET_ZCODE;
1507     verbnum = $ff-(dword->#dict_par2);
1508 #Ifnot; ! GLULX
1509     dword = dword + #dict_par2 - 1;
1510     @aloads dword 0 verbnum;
1511     verbnum = $ffff-verbnum;
1512 #Endif;
1513     return verbnum;
1514 ];
1515
1516 ! ==========================
1517
1518
1519 ! ----------------------------------------------------------------------------
1520 !   To simplify the picture a little, a rough map of the main routine:
1521 !
1522 !   (A) Get the input, do "oops" and "again"
1523 !   (B) Is it a direction, and so an implicit "go"?  If so go to (K)
1524 !   (C) Is anyone being addressed?
1525 !   (D) Get the verb: try all the syntax lines for that verb
1526 !   (E) Break down a syntax line into analysed tokens
1527 !   (F) Look ahead for advance warning for multiexcept/multiinside
1528 !   (G) Parse each token in turn (calling ParseToken to do most of the work)
1529 !   (H) Cheaply parse otherwise unrecognised conversation and return
1530 !   (I) Print best possible error message
1531 !   (J) Retry the whole lot
1532 !   (K) Last thing: check for "then" and further instructions(s), return.
1533 !
1534 !   The strategic points (A) to (K) are marked in the commentary.
1535 !
1536 !   Note that there are three different places where a return can happen.
1537 ! ----------------------------------------------------------------------------
1538
1539 [ Parser__parse  results   syntax line num_lines line_address i j k
1540                            token l m line_etype vw;
1541
1542     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
1543     !
1544     ! A: Get the input, do "oops" and "again"
1545     !
1546     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
1547
1548     ! Firstly, in "not held" mode, we still have a command left over from last
1549     ! time (eg, the user typed "eat biscuit", which was parsed as "take biscuit"
1550     ! last time, with "eat biscuit" tucked away until now).  So we return that.
1551
1552     if (notheld_mode == 1) {
1553         for (i=0 : i<8 : i++) results-->i = kept_results-->i;
1554         notheld_mode = 0;
1555         rtrue;
1556     }
1557
1558     if (held_back_mode ~= 0) {
1559         held_back_mode = 0;
1560         Tokenise__(buffer, parse);
1561         jump ReParse;
1562     }
1563
1564   .ReType;
1565
1566     Keyboard(buffer, parse);
1567
1568 #Ifdef INFIX;
1569     ! An Infix verb is a special kind of meta verb.  We mark them here.
1570     if (GetNthChar(buffer, 0) == ';')
1571         infix_verb = true;
1572     else
1573         infix_verb = false;
1574 #Endif;
1575
1576   .ReParse;
1577
1578     parser_inflection = name;
1579     parser_inflection_func = false;
1580
1581     ! Initially assume the command is aimed at the player, and the verb
1582     ! is the first word
1583
1584     num_words = NumberWords();
1585     wn = 1;
1586
1587     #Ifdef LanguageToInformese;
1588     LanguageToInformese();
1589     #IfV5;
1590     ! Re-tokenise:
1591     Tokenise__(buffer,parse);
1592     #Endif; ! V5
1593     #Endif; ! LanguageToInformese
1594
1595     if (BeforeParsing() == false) {
1596         LibraryExtensions.ext_number_1 = wn;    ! Set "between calls" functionality to restore wn each pass
1597         LibraryExtensions.BetweenCalls = LibraryExtensions.RestoreWN;
1598         LibraryExtensions.RunWhile(ext_beforeparsing, false);
1599         LibraryExtensions.BetweenCalls = 0;     ! Turn off "between calls" functionality
1600      }
1601     num_words = NumberWords();
1602
1603     k=0;
1604     #Ifdef DEBUG;
1605     if (parser_trace >= 2) {
1606         print "[ ";
1607         for (i=0 : i<num_words : i++) {
1608
1609             j = WordValue(i+1);
1610             k = WordAddress(i+1);
1611             l = WordLength(i+1);
1612             print "~"; for (m=0 : m<l : m++) print (char) k->m; print "~ ";
1613
1614             if (j == 0) print "?";
1615             else {
1616                 #Ifdef TARGET_ZCODE;
1617                 if (UnsignedCompare(j, HDR_DICTIONARY-->0) >= 0 &&
1618                     UnsignedCompare(j, HDR_HIGHMEMORY-->0) < 0)
1619                      print (address) j;
1620                 else print j;
1621                 #Ifnot; ! TARGET_GLULX
1622                 if (j->0 == $60) print (address) j;
1623                 else print j;
1624                 #Endif; ! TARGET_
1625             }
1626             if (i ~= num_words-1) print " / ";
1627         }
1628         print " ]^";
1629     }
1630     #Endif; ! DEBUG
1631     verb_wordnum = 1;
1632     actor = player;
1633     actors_location = ScopeCeiling(player);
1634     usual_grammar_after = 0;
1635
1636   .AlmostReParse;
1637
1638     scope_token = 0;
1639     action_to_be = NULL;
1640
1641     ! Begin from what we currently think is the verb word
1642
1643   .BeginCommand;
1644
1645     wn = verb_wordnum;
1646     verb_word = NextWordStopped();
1647
1648     ! If there's no input here, we must have something like "person,".
1649
1650     if (verb_word == -1) {
1651         best_etype = STUCK_PE;
1652         jump GiveError;
1653     }
1654
1655     ! Now try for "again" or "g", which are special cases: don't allow "again" if nothing
1656     ! has previously been typed; simply copy the previous text across
1657
1658     if (verb_word == AGAIN2__WD or AGAIN3__WD) verb_word = AGAIN1__WD;
1659     if (verb_word == AGAIN1__WD) {
1660         if (actor ~= player) {
1661             L__M(##Miscellany, 20);
1662             jump ReType;
1663         }
1664         if (GetKeyBufLength(buffer3) == 0) {
1665             L__M(##Miscellany, 21);
1666             jump ReType;
1667         }
1668
1669         if (WordAddress(verb_wordnum) == buffer + WORDSIZE) { ! not held back
1670             ! splice rest of buffer onto end of buffer3
1671             i = GetKeyBufLength(buffer3);
1672             while (buffer3 -> (i + WORDSIZE - 1) == ' ' or '.')
1673                 i--;
1674             j = i - WordLength(verb_wordnum);  ! amount to move buffer up by
1675             if (j > 0) {
1676                 for (m=INPUT_BUFFER_LEN-1 : m>=WORDSIZE+j : m--)
1677                     buffer->m = buffer->(m-j);
1678                 SetKeyBufLength(GetKeyBufLength()+j);
1679                 }
1680             for (m=WORDSIZE : m<WORDSIZE+i : m++) buffer->m = buffer3->m;
1681             if (j < 0) for (:m<WORDSIZE+i-j : m++) buffer->m = ' ';
1682          }
1683         else
1684             for (i=0 : i<INPUT_BUFFER_LEN : i++) buffer->i = buffer3->i;
1685         jump ReParse;
1686     }
1687
1688     ! Save the present input in case of an "again" next time
1689
1690     if (verb_word ~= AGAIN1__WD)
1691         for (i=0 : i<INPUT_BUFFER_LEN : i++) buffer3->i = buffer->i;
1692
1693     if (usual_grammar_after == 0) {
1694         j = verb_wordnum;
1695         i = RunRoutines(actor, grammar);
1696         #Ifdef DEBUG;
1697         if (parser_trace >= 2 && actor.grammar ~= 0 or NULL)
1698             print " [Grammar property returned ", i, "]^";
1699         #Endif; ! DEBUG
1700
1701         #Ifdef TARGET_ZCODE;
1702         if ((i ~= 0 or 1) &&
1703             (UnsignedCompare(i, dict_start) < 0 ||
1704              UnsignedCompare(i, dict_end) >= 0 ||
1705              (i - dict_start) % dict_entry_size ~= 0)) {
1706             usual_grammar_after = j;
1707             i=-i;
1708         }
1709
1710         #Ifnot; ! TARGET_GLULX
1711         if (i < 0) { usual_grammar_after = j; i=-i; }
1712         #Endif;
1713
1714         if (i == 1) {
1715             results-->0 = action;
1716             results-->1 = 0;            ! Number of parameters
1717             results-->2 = noun;
1718             results-->3 = second;
1719             if (noun) results-->1 = 1;
1720             if (second) results-->1 = 2;
1721             rtrue;
1722         }
1723         if (i ~= 0) { verb_word = i; wn--; verb_wordnum--; }
1724         else { wn = verb_wordnum; verb_word = NextWord(); }
1725     }
1726     else usual_grammar_after = 0;
1727
1728     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
1729     !
1730     ! B: Is it a direction, and so an implicit "go"?  If so go to (K)
1731     !
1732     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
1733
1734     #Ifdef LanguageIsVerb;
1735     if (verb_word == 0) {
1736         i = wn; verb_word = LanguageIsVerb(buffer, parse, verb_wordnum);
1737         wn = i;
1738     }
1739     #Endif; ! LanguageIsVerb
1740
1741     ! If the first word is not listed as a verb, it must be a direction
1742     ! or the name of someone to talk to
1743
1744     if (verb_word == 0 || ((verb_word->#dict_par1) & DICT_VERB) == 0) {
1745
1746         ! So is the first word an object contained in the special object "compass"
1747         ! (i.e., a direction)?  This needs use of NounDomain, a routine which
1748         ! does the object matching, returning the object number, or 0 if none found,
1749         ! or REPARSE_CODE if it has restructured the parse table so the whole parse
1750         ! must be begun again...
1751
1752         wn = verb_wordnum; indef_mode = false; token_filter = 0;
1753         l = NounDomain(compass, 0, NOUN_TOKEN);
1754         if (l == REPARSE_CODE) jump ReParse;
1755
1756         ! If it is a direction, send back the results:
1757         ! action=GoSub, no of arguments=1, argument 1=the direction.
1758
1759         if (l ~= 0) {
1760             results-->0 = ##Go;
1761             action_to_be = ##Go;
1762             results-->1 = 1;
1763             results-->2 = l;
1764             jump LookForMore;
1765         }
1766
1767     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
1768     !
1769     ! C: Is anyone being addressed?
1770     !
1771     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
1772
1773         ! Only check for a comma (a "someone, do something" command) if we are
1774         ! not already in the middle of one.  (This simplification stops us from
1775         ! worrying about "robot, wizard, you are an idiot", telling the robot to
1776         ! tell the wizard that she is an idiot.)
1777
1778         if (actor == player) {
1779             for (j=2 : j<=num_words : j++) {
1780                 i=NextWord();
1781                 if (i == comma_word) jump Conversation;
1782             }
1783         }
1784         vw = verb_word;
1785         verb_word = UnknownVerb(vw);
1786         if (verb_word == false) verb_word = LibraryExtensions.RunWhile(ext_unknownverb, false, vw);
1787         if (verb_word) jump VerbAccepted;
1788         best_etype = VERB_PE;
1789         jump GiveError;
1790
1791         ! NextWord nudges the word number wn on by one each time, so we've now
1792         ! advanced past a comma.  (A comma is a word all on its own in the table.)
1793
1794       .Conversation;
1795
1796         j = wn - 1;
1797         if (j == 1) {
1798             L__M(##Miscellany, 22);
1799             jump ReType;
1800         }
1801
1802         ! Use NounDomain (in the context of "animate creature") to see if the
1803         ! words make sense as the name of someone held or nearby
1804
1805         wn = 1; lookahead = HELD_TOKEN;
1806         scope_reason = TALKING_REASON;
1807         l = NounDomain(player,actors_location,CREATURE_TOKEN);
1808         scope_reason = PARSING_REASON;
1809         if (l == REPARSE_CODE) jump ReParse;
1810         if (l == 0) {
1811             L__M(##Miscellany, 23);
1812             jump ReType;
1813         }
1814
1815       .Conversation2;
1816
1817         ! The object addressed must at least be "talkable" if not actually "animate"
1818         ! (the distinction allows, for instance, a microphone to be spoken to,
1819         ! without the parser thinking that the microphone is human).
1820
1821         if (l hasnt animate && l hasnt talkable) {
1822             L__M(##Miscellany, 24, l);
1823             jump ReType;
1824         }
1825
1826         ! Check that there aren't any mystery words between the end of the person's
1827         ! name and the comma (eg, throw out "dwarf sdfgsdgs, go north").
1828
1829         if (wn ~= j) {
1830             L__M(##Miscellany, 25);
1831             jump ReType;
1832         }
1833
1834         ! The player has now successfully named someone.  Adjust "him", "her", "it":
1835
1836         PronounNotice(l);
1837
1838         ! Set the global variable "actor", adjust the number of the first word,
1839         ! and begin parsing again from there.
1840
1841         verb_wordnum = j + 1;
1842
1843         ! Stop things like "me, again":
1844
1845         if (l == player) {
1846             wn = verb_wordnum;
1847             if (NextWordStopped() == AGAIN1__WD or AGAIN2__WD or AGAIN3__WD) {
1848                 L__M(##Miscellany, 20);
1849                 jump ReType;
1850             }
1851         }
1852
1853         actor = l;
1854         actors_location = ScopeCeiling(l);
1855         #Ifdef DEBUG;
1856         if (parser_trace >= 1)
1857             print "[Actor is ", (the) actor, " in ", (name) actors_location, "]^";
1858         #Endif; ! DEBUG
1859         jump BeginCommand;
1860
1861     } ! end of first-word-not-a-verb
1862
1863     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
1864     !
1865     ! D: Get the verb: try all the syntax lines for that verb
1866     !
1867     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
1868
1869   .VerbAccepted;
1870
1871     ! We now definitely have a verb, not a direction, whether we got here by the
1872     ! "take ..." or "person, take ..." method.  Get the meta flag for this verb:
1873
1874     meta = (verb_word->#dict_par1) & DICT_META;
1875
1876     ! You can't order other people to "full score" for you, and so on...
1877
1878     if (meta && actor ~= player) {
1879         best_etype = VERB_PE;
1880         meta = false;
1881         jump GiveError;
1882     }
1883
1884     ! Now let i be the corresponding verb number, stored in the dictionary entry
1885     ! (in a peculiar 255-n fashion for traditional Infocom reasons)...
1886
1887     i = DictionaryWordToVerbNum(verb_word);
1888
1889     ! ...then look up the i-th entry in the verb table, whose address is at word
1890     ! 7 in the Z-machine (in the header), so as to get the address of the syntax
1891     ! table for the given verb...
1892
1893     #Ifdef TARGET_ZCODE;
1894     syntax = (HDR_STATICMEMORY-->0)-->i;
1895     #Ifnot; ! TARGET_GLULX
1896     syntax = (#grammar_table)-->(i+1);
1897     #Endif; ! TARGET_
1898
1899     ! ...and then see how many lines (ie, different patterns corresponding to the
1900     ! same verb) are stored in the parse table...
1901
1902     num_lines = (syntax->0) - 1;
1903
1904     ! ...and now go through them all, one by one.
1905     ! To prevent pronoun_word 0 being misunderstood,
1906
1907     pronoun_word = NULL; pronoun_obj = NULL;
1908
1909     #Ifdef DEBUG;
1910     if (parser_trace >= 1) print "[Parsing for the verb '", (address) verb_word, "' (", num_lines+1, " lines)]^";
1911     #Endif; ! DEBUG
1912
1913     best_etype = STUCK_PE; nextbest_etype = STUCK_PE;
1914     multiflag = false; saved_oops = 0;
1915
1916     ! "best_etype" is the current failure-to-match error - it is by default
1917     ! the least informative one, "don't understand that sentence".
1918     ! "nextbest_etype" remembers the best alternative to having to ask a
1919     ! scope token for an error message (i.e., the best not counting ASKSCOPE_PE).
1920     ! multiflag is used here to prevent inappropriate MULTI_PE errors
1921     ! in addition to its unrelated duties passing information to action routines
1922
1923     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
1924     !
1925     ! E: Break down a syntax line into analysed tokens
1926     !
1927     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
1928
1929     line_address = syntax + 1;
1930
1931     for (line=0 : line<=num_lines : line++) {
1932
1933         for (i=0 : i<32 : i++) {
1934             line_token-->i = ENDIT_TOKEN;
1935             line_ttype-->i = ELEMENTARY_TT;
1936             line_tdata-->i = ENDIT_TOKEN;
1937         }
1938
1939         ! Unpack the syntax line from Inform format into three arrays; ensure that
1940         ! the sequence of tokens ends in an ENDIT_TOKEN.
1941
1942         line_address = UnpackGrammarLine(line_address);
1943
1944         #Ifdef DEBUG;
1945         if (parser_trace >= 1) {
1946             if (parser_trace >= 2) new_line;
1947             print "[line ", line; DebugGrammarLine();
1948             print "]^";
1949         }
1950         #Endif; ! DEBUG
1951
1952         ! We aren't in "not holding" or inferring modes, and haven't entered
1953         ! any parameters on the line yet, or any special numbers; the multiple
1954         ! object is still empty.
1955
1956         token_filter = 0;
1957         not_holding = 0;
1958         inferfrom = 0;
1959         parameters = 0;
1960         nsns = 0; special_word = 0; special_number = 0;
1961         multiple_object-->0 = 0;
1962         multi_context = 0;
1963         etype = STUCK_PE; line_etype = 100;
1964
1965         ! Put the word marker back to just after the verb
1966
1967         wn = verb_wordnum+1;
1968
1969     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
1970     !
1971     ! F: Look ahead for advance warning for multiexcept/multiinside
1972     !
1973     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
1974
1975         ! There are two special cases where parsing a token now has to be
1976         ! affected by the result of parsing another token later, and these
1977         ! two cases (multiexcept and multiinside tokens) are helped by a quick
1978         ! look ahead, to work out the future token now.  We can only carry this
1979         ! out in the simple (but by far the most common) case:
1980         !
1981         !     multiexcept <one or more prepositions> noun
1982         !
1983         ! and similarly for multiinside.
1984
1985         advance_warning = NULL; indef_mode = false;
1986         for (i=0,m=false,pcount=0 : line_token-->pcount ~= ENDIT_TOKEN : pcount++) {
1987             scope_token = 0;
1988
1989             if (line_ttype-->pcount ~= PREPOSITION_TT) i++;
1990
1991             if (line_ttype-->pcount == ELEMENTARY_TT) {
1992                 if (line_tdata-->pcount == MULTI_TOKEN) m = true;
1993                 if (line_tdata-->pcount == MULTIEXCEPT_TOKEN or MULTIINSIDE_TOKEN  && i == 1) {
1994                     ! First non-preposition is "multiexcept" or
1995                     ! "multiinside", so look ahead.
1996
1997                     #Ifdef DEBUG;
1998                     if (parser_trace >= 2) print " [Trying look-ahead]^";
1999                     #Endif; ! DEBUG
2000
2001                     ! We need this to be followed by 1 or more prepositions.
2002
2003                     pcount++;
2004                     if (line_ttype-->pcount == PREPOSITION_TT) {
2005                         ! skip ahead to a preposition word in the input
2006                         do {
2007                             l = NextWord();
2008                         } until ((wn > num_words) ||
2009                                  (l && (l->#dict_par1) & DICT_PREP ~= 0));
2010
2011                         if (wn > num_words) {
2012                             #Ifdef DEBUG;
2013                             if (parser_trace >= 2)
2014                                 print " [Look-ahead aborted: prepositions missing]^";
2015                             #Endif;
2016                             jump EmptyLine;
2017                         }
2018
2019                         do {
2020                             if (PrepositionChain(l, pcount) ~= -1) {
2021                                 ! advance past the chain
2022                                 if ((line_token-->pcount)->0 & $20 ~= 0) {
2023                                     pcount++;
2024                                     while ((line_token-->pcount ~= ENDIT_TOKEN) &&
2025                                            ((line_token-->pcount)->0 & $10 ~= 0))
2026                                         pcount++;
2027                                 } else {
2028                                     pcount++;
2029                                 }
2030                             } else {
2031                                 ! try to find another preposition word
2032                                 do {
2033                                     l = NextWord();
2034                                 } until ((wn >= num_words) ||
2035                                          (l && (l->#dict_par1) & 8 ~= 0));
2036
2037                                 if (l && (l->#dict_par1) & 8) continue;
2038
2039                                 ! lookahead failed
2040                                 #Ifdef DEBUG;
2041                                 if (parser_trace >= 2)
2042                                     print " [Look-ahead aborted: prepositions don't match]^";
2043                                 #Endif;
2044                                 jump LineFailed;
2045                             }
2046                             l = NextWord();
2047                         } until (line_ttype-->pcount ~= PREPOSITION_TT);
2048
2049                         .EmptyLine;
2050                         ! put back the non-preposition we just read
2051                         wn--;
2052
2053                         if ((line_ttype-->pcount == ELEMENTARY_TT) && (line_tdata-->pcount == NOUN_TOKEN)) {
2054                             l = Descriptors();  ! skip past THE etc
2055                             if (l~=0) etype=l;  ! don't allow multiple objects
2056                             l = NounDomain(actors_location, actor, NOUN_TOKEN);
2057
2058                             #Ifdef DEBUG;
2059                             if (parser_trace >= 2) {
2060                                 print " [Advanced to ~noun~ token: ";
2061                                 if (l == REPARSE_CODE) print "re-parse request]^";
2062                                 if (l == 1) print "but multiple found]^";
2063                                 if (l == 0) print "error ", etype, "]^";
2064                                 if (l >= 2) print (the) l, "]^";
2065                             }
2066                             #Endif; ! DEBUG
2067                             if (l == REPARSE_CODE) jump ReParse;
2068                             if (l >= 2) advance_warning = l;
2069                         }
2070                     }
2071                     break;
2072                 }
2073             }
2074         }
2075
2076         ! Slightly different line-parsing rules will apply to "take multi", to
2077         ! prevent "take all" behaving correctly but misleadingly when there's
2078         ! nothing to take.
2079
2080         take_all_rule = 0;
2081         if (m && params_wanted == 1 && action_to_be == ##Take)
2082             take_all_rule = 1;
2083
2084         ! And now start again, properly, forearmed or not as the case may be.
2085         ! As a precaution, we clear all the variables again (they may have been
2086         ! disturbed by the call to NounDomain, which may have called outside
2087         ! code, which may have done anything!).
2088
2089         not_holding = 0;
2090         inferfrom = 0;
2091         inferword = 0;
2092         parameters = 0;
2093         nsns = 0; special_word = 0; special_number = 0;
2094         multiple_object-->0 = 0;
2095         etype = STUCK_PE; line_etype = 100;
2096         wn = verb_wordnum+1;
2097
2098     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2099     !
2100     ! G: Parse each token in turn (calling ParseToken to do most of the work)
2101     !
2102     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2103
2104         ! "Pattern" gradually accumulates what has been recognised so far,
2105         ! so that it may be reprinted by the parser later on
2106
2107         for (pcount=1 : : pcount++) {
2108             pattern-->pcount = PATTERN_NULL; scope_token = 0;
2109
2110             token = line_token-->(pcount-1);
2111             lookahead = line_token-->pcount;
2112
2113             #Ifdef DEBUG;
2114             if (parser_trace >= 2)
2115                 print " [line ", line, " token ", pcount, " word ", wn, " : ", (DebugToken) token,
2116                   "]^";
2117             #Endif; ! DEBUG
2118
2119             if (token ~= ENDIT_TOKEN) {
2120                 scope_reason = PARSING_REASON;
2121                 parser_inflection = name;
2122                 parser_inflection_func = false;
2123                 AnalyseToken(token);
2124
2125                 if (action_to_be == ##AskTo && found_ttype == ELEMENTARY_TT &&
2126                     found_tdata == TOPIC_TOKEN && line_etype == 100) {
2127                     if (actor ~= player) {
2128                         best_etype = VERB_PE; jump GiveError;
2129                     }
2130                     l = inputobjs-->2;
2131                     wn--;
2132                     j = wn;
2133                     jump Conversation2;
2134                 }
2135
2136                 l = ParseToken__(found_ttype, found_tdata, pcount-1, token);
2137                 while (l<-200) l = ParseToken__(ELEMENTARY_TT, l + 256);
2138                 scope_reason = PARSING_REASON;
2139
2140                 if (l == GPR_PREPOSITION) {
2141                     if (found_ttype~=PREPOSITION_TT && (found_ttype~=ELEMENTARY_TT ||
2142                         found_tdata~=TOPIC_TOKEN)) params_wanted--;
2143                     l = true;
2144                 }
2145                 else
2146                     if (l < 0) l = false;
2147                     else
2148                         if (l ~= GPR_REPARSE) {
2149                             if (l == GPR_NUMBER) {
2150                                 if (nsns == 0) special_number1 = parsed_number;
2151                                 else special_number2 = parsed_number;
2152                                 nsns++; l = 1;
2153                             }
2154                             if (l == GPR_MULTIPLE) l = 0;
2155                             results-->(parameters+2) = l;
2156                             parameters++;
2157                             pattern-->pcount = l;
2158                             l = true;
2159                         }
2160
2161                 #Ifdef DEBUG;
2162                 if (parser_trace >= 3) {
2163                     print "  [token resulted in ";
2164                     if (l == REPARSE_CODE) print "re-parse request]^";
2165                     if (l == 0) print "failure with error type ", etype, "]^";
2166                     if (l == 1) print "success]^";
2167                 }
2168                 #Endif; ! DEBUG
2169
2170                 if (l == REPARSE_CODE) jump ReParse;
2171                 if (l == false) {
2172                     if (etype < line_etype) line_etype = etype;
2173                     if (etype == STUCK_PE || wn >= num_words) break;
2174                 }
2175             }
2176             else {
2177
2178                 ! If the player has entered enough already but there's still
2179                 ! text to wade through: store the pattern away so as to be able to produce
2180                 ! a decent error message if this turns out to be the best we ever manage,
2181                 ! and in the mean time give up on this line
2182
2183                 ! However, if the superfluous text begins with a comma or "then" then
2184                 ! take that to be the start of another instruction
2185
2186                 if (line_etype < 100) break;
2187                 if (wn <= num_words) {
2188                     l = NextWord();
2189                     if (l == THEN1__WD or THEN2__WD or THEN3__WD or comma_word or AND1__WD) {
2190                         held_back_mode = 1; hb_wn = wn-1;
2191                     }
2192                     else {
2193                         for (m=0 : m<32 : m++) pattern2-->m = pattern-->m;
2194                         pcount2 = pcount;
2195                         etype = UPTO_PE;
2196                         break;
2197                     }
2198                 }
2199
2200                 ! Now, we may need to revise the multiple object because of the single one
2201                 ! we now know (but didn't when the list was drawn up).
2202
2203                 if (parameters >= 1 && results-->2 == 0) {
2204                     l = ReviseMulti(results-->3);
2205                     if (l ~= 0) { etype = l; results-->0 = action_to_be; break; }
2206                 }
2207                 if (parameters >= 2 && results-->3 == 0) {
2208                     l = ReviseMulti(results-->2);
2209                     if (l ~= 0) { etype = l; break; }
2210                 }
2211
2212                 ! To trap the case of "take all" inferring only "yourself" when absolutely
2213                 ! nothing else is in the vicinity...
2214
2215                 if (take_all_rule == 2 && results-->2 == actor) {
2216                     best_etype = NOTHING_PE;
2217                     jump GiveError;
2218                 }
2219
2220                 #Ifdef DEBUG;
2221                 if (parser_trace >= 1) print "[Line successfully parsed]^";
2222                 #Endif; ! DEBUG
2223
2224                 ! The line has successfully matched the text.  Declare the input error-free...
2225
2226                 oops_from = 0;
2227
2228                 ! ...explain any inferences made (using the pattern)...
2229
2230                 if (inferfrom ~= 0 && no_infer_message == false) {
2231                     print "("; PrintCommand(inferfrom); print ")^";
2232                 }
2233                 no_infer_message = false;
2234
2235                 ! ...copy the action number, and the number of parameters...
2236
2237                 results-->0 = action_to_be;
2238                 results-->1 = parameters;
2239
2240                 ! ...reverse first and second parameters if need be...
2241
2242                 if (action_reversed && parameters == 2) {
2243                     i = results-->2; results-->2 = results-->3;
2244                     results-->3 = i;
2245                     if (nsns == 2) {
2246                         i = special_number1; special_number1 = special_number2;
2247                         special_number2 = i;
2248                     }
2249                 }
2250
2251                 ! ...and to reset "it"-style objects to the first of these parameters, if
2252                 ! there is one (and it really is an object)...
2253
2254                 if (parameters > 0 && results-->2 >= 2)
2255                     PronounNotice(results-->2);
2256
2257                 ! ...and worry about the case where an object was allowed as a parameter
2258                 ! even though the player wasn't holding it and should have been: in this
2259                 ! event, keep the results for next time round, go into "not holding" mode,
2260                 ! and for now tell the player what's happening and return a "take" request
2261                 ! instead...
2262
2263                 if (not_holding ~= 0 && actor == player) {
2264                     action = ##Take;
2265                     i = RunRoutines(not_holding, before_implicit);
2266                     ! i = 0: Take the object, tell the player (default)
2267                     ! i = 1: Take the object, don't tell the player
2268                     ! i = 2: don't Take the object, continue
2269                     ! i = 3: don't Take the object, don't continue
2270                     if (i > 2 || no_implicit_actions) { best_etype = NOTHELD_PE; jump GiveError; }
2271                     ! perform the implicit Take
2272                     if (i < 2) {
2273                         if (i ~= 1)     ! and tell the player
2274                             L__M(##Miscellany, 26, not_holding);
2275                         notheld_mode = 1;
2276                         for (i=0 : i<8 : i++) kept_results-->i = results-->i;
2277                         results-->0 = ##Take;
2278                         results-->1 = 1;
2279                         results-->2 = not_holding;
2280                     }
2281                 }
2282
2283                 ! (Notice that implicit takes are only generated for the player, and not
2284                 ! for other actors.  This avoids entirely logical, but misleading, text
2285                 ! being printed.)
2286
2287                 ! ...and return from the parser altogether, having successfully matched
2288                 ! a line.
2289
2290                 if (held_back_mode == 1) {
2291                     wn=hb_wn;
2292                     jump LookForMore;
2293                 }
2294                 rtrue;
2295
2296             } ! end of if(token ~= ENDIT_TOKEN) else
2297         } ! end of for(pcount++)
2298
2299         .LineFailed;
2300         ! The line has failed to match.
2301         ! We continue the outer "for" loop, trying the next line in the grammar.
2302
2303         if (line_etype < 100) etype = line_etype;
2304         if (etype > best_etype) best_etype = etype;
2305         if (etype ~= ASKSCOPE_PE && etype > nextbest_etype) nextbest_etype = etype;
2306
2307         ! ...unless the line was something like "take all" which failed because
2308         ! nothing matched the "all", in which case we stop and give an error now.
2309
2310         if (take_all_rule == 2 && etype==NOTHING_PE) break;
2311
2312     } ! end of for(line++)
2313
2314     ! The grammar is exhausted: every line has failed to match.
2315
2316     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2317     !
2318     ! H: Cheaply parse otherwise unrecognised conversation and return
2319     !
2320     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2321
2322   .GiveError;
2323
2324     etype = best_etype;
2325
2326     ! Errors are handled differently depending on who was talking.
2327     ! If the command was addressed to somebody else (eg, "dwarf, sfgh") then
2328     ! it is taken as conversation which the parser has no business in disallowing.
2329
2330     if (actor ~= player) {
2331         if (usual_grammar_after ~= 0) {
2332             verb_wordnum = usual_grammar_after;
2333             jump AlmostReParse;
2334         }
2335         wn = verb_wordnum;
2336         special_word = NextWord();
2337         if (special_word == comma_word) {
2338             special_word = NextWord();
2339             verb_wordnum++;
2340         }
2341         special_number = TryNumber(verb_wordnum);
2342         results-->0 = ##NotUnderstood;
2343         results-->1 = 2;
2344         results-->2 = 1; special_number1 = special_word;
2345         results-->3 = actor;
2346         consult_from = verb_wordnum; consult_words = num_words-consult_from+1;
2347         rtrue;
2348     }
2349
2350     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2351     !
2352     ! I: Print best possible error message
2353     !
2354     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2355
2356     ! If the player was the actor (eg, in "take dfghh") the error must be
2357     ! printed, and fresh input called for.  In four cases the oops word
2358     ! must be jiggled (where oops_from is set to something).
2359
2360     if (ParserError(etype)) jump ReType;
2361     if (LibraryExtensions.RunWhile(ext_parsererror, false, etype)) jump ReType;
2362     pronoun_word = pronoun__word; pronoun_obj = pronoun__obj;
2363
2364     if (etype == STUCK_PE) {    L__M(##Miscellany, 27); oops_from = 1; }
2365     if (etype == UPTO_PE) {     L__M(##Miscellany, 28);
2366         for (m=0 : m<32 : m++) pattern-->m = pattern2-->m;
2367         pcount = pcount2; PrintCommand(0); L__M(##Miscellany, 56);
2368         oops_from = wn-1;
2369     }
2370     if (etype == NUMBER_PE)     L__M(##Miscellany, 29);
2371     if (etype == CANTSEE_PE) {  L__M(##Miscellany, 30); oops_from=saved_oops;}
2372     if (etype == TOOLIT_PE)     L__M(##Miscellany, 31);
2373     if (etype == NOTHELD_PE) {  L__M(##Miscellany, 32, not_holding); oops_from=saved_oops; }
2374     if (etype == MULTI_PE)      L__M(##Miscellany, 33);
2375     if (etype == MMULTI_PE)     L__M(##Miscellany, 34);
2376     if (etype == VAGUE_PE)      L__M(##Miscellany, 35, pronoun_word);
2377     if (etype == EXCEPT_PE)     L__M(##Miscellany, 36);
2378     if (etype == ANIMA_PE)      L__M(##Miscellany, 37);
2379     if (etype == VERB_PE)       L__M(##Miscellany, 38);
2380     if (etype == SCENERY_PE)    L__M(##Miscellany, 39);
2381     if (etype == ITGONE_PE) {
2382         if (pronoun_obj == NULL)
2383                                 L__M(##Miscellany, 35, pronoun_word);
2384         else                    L__M(##Miscellany, 40, pronoun_word, pronoun_obj);
2385     }
2386     if (etype == JUNKAFTER_PE)  L__M(##Miscellany, 41);
2387     if (etype == TOOFEW_PE)     L__M(##Miscellany, 42, multi_had);
2388     if (etype == NOTHING_PE) {
2389         if (results-->0 == ##Remove && results-->3 ofclass Object) {
2390             noun = results-->3; ! ensure valid for messages
2391             if (noun has animate) L__M(##Miscellany, 44, verb_word);
2392             else if (noun hasnt container or supporter) L__M(##Insert, 2, noun);
2393             else if (noun has container && noun hasnt open) L__M(##Take, 9, noun);
2394             else if (children(noun)==0) L__M(##Search, 6, noun);
2395             else results-->0 = 0;
2396         }
2397         if (results-->0 ~= ##Remove) {
2398             if (multi_wanted == 100)    L__M(##Miscellany, 43);
2399             else {
2400                 #Ifdef NO_TAKE_ALL;
2401                 if (take_all_rule == 2) L__M(##Miscellany, 59);
2402                 else                    L__M(##Miscellany, 44, verb_word);
2403                 #Ifnot;
2404                 L__M(##Miscellany, 44, verb_word);
2405                 #Endif; ! NO_TAKE_ALL
2406             }
2407         }
2408     }
2409     if (etype == ASKSCOPE_PE) {
2410         scope_stage = 3;
2411         if (scope_error() == -1) {
2412             best_etype = nextbest_etype;
2413             jump GiveError;
2414         }
2415     }
2416
2417     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2418     !
2419     ! J: Retry the whole lot
2420     !
2421     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2422
2423     ! And go (almost) right back to square one...
2424
2425     jump ReType;
2426
2427     ! ...being careful not to go all the way back, to avoid infinite repetition
2428     ! of a deferred command causing an error.
2429
2430
2431     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2432     !
2433     ! K: Last thing: check for "then" and further instructions(s), return.
2434     !
2435     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2436
2437     ! At this point, the return value is all prepared, and we are only looking
2438     ! to see if there is a "then" followed by subsequent instruction(s).
2439
2440   .LookForMore;
2441
2442     if (wn > num_words) rtrue;
2443
2444     i = NextWord();
2445     if (i == THEN1__WD or THEN2__WD or THEN3__WD or comma_word or AND1__WD) {
2446         if (wn > num_words) {
2447            held_back_mode = false;
2448            return;
2449         }
2450         i = WordAddress(verb_wordnum);
2451         j = WordAddress(wn);
2452         for (: i<j : i++) i->0 = ' ';
2453         i = NextWord();
2454         if (i == AGAIN1__WD or AGAIN2__WD or AGAIN3__WD) {
2455             ! Delete the words "then again" from the again buffer,
2456             ! in which we have just realised that it must occur:
2457             ! prevents an infinite loop on "i. again"
2458
2459             i = WordAddress(wn-2)-buffer;
2460             if (wn > num_words) j = INPUT_BUFFER_LEN-1;
2461             else j = WordAddress(wn)-buffer;
2462             for (: i<j : i++) buffer3->i = ' ';
2463         }
2464         Tokenise__(buffer,parse);
2465         held_back_mode = true;
2466         return;
2467     }
2468     best_etype = UPTO_PE;
2469     jump GiveError;
2470
2471 ]; ! end of Parser__parse
2472
2473 [ ScopeCeiling person act;
2474   act = parent(person);
2475   if (act == 0) return person;
2476   if (person == player && location == thedark) return thedark;
2477   while (parent(act)~=0 && (act has transparent || act has supporter ||
2478                            (act has container && act has open)))
2479       act = parent(act);
2480   return act;
2481 ];
2482
2483 ! ----------------------------------------------------------------------------
2484 !  Descriptors()
2485 !
2486 !  Handles descriptive words like "my", "his", "another" and so on.
2487 !  Skips "the", and leaves wn pointing to the first misunderstood word.
2488 !
2489 !  Allowed to set up for a plural only if allow_p is set
2490 !
2491 !  Returns error number, or 0 if no error occurred
2492 ! ----------------------------------------------------------------------------
2493
2494 Constant OTHER_BIT  =   1;     !  These will be used in Adjudicate()
2495 Constant MY_BIT     =   2;     !  to disambiguate choices
2496 Constant THAT_BIT   =   4;
2497 Constant PLURAL_BIT =   8;
2498 Constant LIT_BIT    =  16;
2499 Constant UNLIT_BIT  =  32;
2500
2501 [ ResetDescriptors;
2502     indef_mode = 0; indef_type = 0; indef_wanted = 0; indef_guess_p = 0;
2503     indef_possambig = false;
2504     indef_owner = nothing;
2505     indef_cases = $$111111111111;
2506     indef_nspec_at = 0;
2507 ];
2508
2509 [ Descriptors  allows_multiple o x flag cto type m n;
2510     ResetDescriptors();
2511     if (wn > num_words) return 0;
2512     m = wn;
2513     for (flag=true : flag :) {
2514         o = NextWordStopped(); flag = false;
2515        for (x=1 : x<=LanguageDescriptors-->0 : x=x+4)
2516             if (o == LanguageDescriptors-->x) {
2517                 flag = true;
2518                 type = LanguageDescriptors-->(x+2);
2519                 if (type ~= DEFART_PK) indef_mode = true;
2520                 indef_possambig = true;
2521                 indef_cases = indef_cases & (LanguageDescriptors-->(x+1));
2522                 if (type == POSSESS_PK) {
2523                     cto = LanguageDescriptors-->(x+3);
2524                     switch (cto) {
2525                       0: indef_type = indef_type | MY_BIT;
2526                       1: indef_type = indef_type | THAT_BIT;
2527                       default:
2528                         indef_owner = PronounValue(cto);
2529                         if (indef_owner == NULL) indef_owner = InformParser;
2530                     }
2531                 }
2532                 if (type == light)  indef_type = indef_type | LIT_BIT;
2533                 if (type == -light) indef_type = indef_type | UNLIT_BIT;
2534             }
2535         if (o == OTHER1__WD or OTHER2__WD or OTHER3__WD) {
2536             indef_mode = 1; flag = 1;
2537             indef_type = indef_type | OTHER_BIT;
2538         }
2539         if (o == ALL1__WD or ALL2__WD or ALL3__WD or ALL4__WD or ALL5__WD) {
2540             indef_mode = 1; flag = 1; indef_wanted = 100;
2541             if (take_all_rule == 1) take_all_rule = 2;
2542             indef_type = indef_type | PLURAL_BIT;
2543         }
2544         if (allow_plurals && allows_multiple) {
2545             n = TryNumber(wn-1);
2546             if (n == 1) { indef_mode = 1; flag = 1; indef_wanted = 1; }
2547             if (n > 1) {
2548                 indef_guess_p = 1;
2549                 indef_mode = 1; flag = 1; indef_wanted = n;
2550                 indef_nspec_at = wn-1;
2551                 indef_type = indef_type | PLURAL_BIT;
2552             }
2553         }
2554         if (flag == 1 && NextWordStopped() ~= OF1__WD or OF2__WD or OF3__WD or OF4__WD)
2555             wn--;  ! Skip 'of' after these
2556     }
2557     wn--;
2558     num_desc = wn - m;
2559     return 0;
2560 ];
2561
2562 ! ----------------------------------------------------------------------------
2563 !  CreatureTest: Will this person do for a "creature" token?
2564 ! ----------------------------------------------------------------------------
2565
2566 [ CreatureTest obj;
2567     if (actor ~= player) rtrue;
2568     if (obj has animate) rtrue;
2569     if (obj hasnt talkable) rfalse;
2570     if (action_to_be == ##Ask or ##Answer or ##Tell or ##AskFor) rtrue;
2571     rfalse;
2572 ];
2573
2574 [ PrepositionChain wd index;
2575     if (line_tdata-->index == wd) return wd;
2576     if ((line_token-->index)->0 & $20 == 0) return -1;
2577     do {
2578         if (line_tdata-->index == wd) return wd;
2579         index++;
2580     } until ((line_token-->index == ENDIT_TOKEN) || (((line_token-->index)->0 & $10) == 0));
2581     return -1;
2582 ];
2583
2584 ! ----------------------------------------------------------------------------
2585 !  ParseToken(type, data):
2586 !      Parses the given token, from the current word number wn, with exactly
2587 !      the specification of a general parsing routine.
2588 !      (Except that for "topic" tokens and prepositions, you need to supply
2589 !      a position in a valid grammar line as third argument.)
2590 !
2591 !  Returns:
2592 !    GPR_REPARSE  for "reconstructed input, please re-parse from scratch"
2593 !    GPR_PREPOSITION  for "token accepted with no result"
2594 !    $ff00 + x    for "please parse ParseToken(ELEMENTARY_TT, x) instead"
2595 !    0            for "token accepted, result is the multiple object list"
2596 !    1            for "token accepted, result is the number in parsed_number"
2597 !    object num   for "token accepted with this object as result"
2598 !    -1           for "token rejected"
2599 !
2600 !  (A)            Analyse the token; handle all tokens not involving
2601 !                 object lists and break down others into elementary tokens
2602 !  (B)            Begin parsing an object list
2603 !  (C)            Parse descriptors (articles, pronouns, etc.) in the list
2604 !  (D)            Parse an object name
2605 !  (E)            Parse connectives ("and", "but", etc.) and go back to (C)
2606 !  (F)            Return the conclusion of parsing an object list
2607 ! ----------------------------------------------------------------------------
2608
2609 [ ParseToken given_ttype given_tdata token_n x y;
2610     x = lookahead; lookahead = NOUN_TOKEN;
2611     y = ParseToken__(given_ttype,given_tdata,token_n);
2612     if (y == GPR_REPARSE) Tokenise__(buffer,parse);
2613     lookahead = x; return y;
2614 ];
2615
2616 [ ParseToken__ given_ttype given_tdata token_n
2617              token l o i j k and_parity single_object desc_wn many_flag
2618              token_allows_multiple prev_indef_wanted;
2619
2620     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2621     !
2622     ! A: Analyse token; handle all not involving object lists, break down others
2623     !
2624     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2625
2626     token_filter = 0;
2627
2628     switch (given_ttype) {
2629       ELEMENTARY_TT:
2630         switch (given_tdata) {
2631           SPECIAL_TOKEN:
2632             l = TryNumber(wn);
2633             special_word = NextWord();
2634             #Ifdef DEBUG;
2635             if (l ~= -1000)
2636                 if (parser_trace >= 3) print "  [Read special as the number ", l, "]^";
2637             #Endif; ! DEBUG
2638             if (l == -1000) {
2639                 #Ifdef DEBUG;
2640                 if (parser_trace >= 3) print "  [Read special word at word number ", wn, "]^";
2641                 #Endif; ! DEBUG
2642                 l = special_word;
2643             }
2644             parsed_number = l; return GPR_NUMBER;
2645
2646           NUMBER_TOKEN:
2647             l=TryNumber(wn++);
2648             if (l == -1000) { etype = NUMBER_PE; return GPR_FAIL; }
2649             #Ifdef DEBUG;
2650             if (parser_trace>=3) print "  [Read number as ", l, "]^";
2651             #Endif; ! DEBUG
2652             parsed_number = l; return GPR_NUMBER;
2653
2654           CREATURE_TOKEN:
2655             if (action_to_be == ##Answer or ##Ask or ##AskFor or ##Tell)
2656                 scope_reason = TALKING_REASON;
2657
2658           TOPIC_TOKEN:
2659             consult_from = wn;
2660             if ((line_ttype-->(token_n+1) ~= PREPOSITION_TT) &&
2661                (line_token-->(token_n+1) ~= ENDIT_TOKEN))
2662                 RunTimeError(13);
2663             do o = NextWordStopped();
2664             until (o == -1 || PrepositionChain(o, token_n+1) ~= -1);
2665             wn--;
2666             consult_words = wn-consult_from;
2667             if (consult_words == 0) return GPR_FAIL;
2668             if (action_to_be == ##Ask or ##Answer or ##Tell) {
2669                 o = wn; wn = consult_from; parsed_number = NextWord();
2670                 #Ifdef EnglishNaturalLanguage;
2671                 if (parsed_number == 'the' && consult_words > 1) parsed_number=NextWord();
2672                 #Endif; ! EnglishNaturalLanguage
2673                 wn = o; return 1;
2674             }
2675             if (o==-1 && (line_ttype-->(token_n+1) == PREPOSITION_TT))
2676                 return GPR_FAIL;    ! don't infer if required preposition is absent
2677             return GPR_PREPOSITION;
2678         }
2679
2680       PREPOSITION_TT:
2681         #Iffalse (Grammar__Version == 1);
2682         ! Is it an unnecessary alternative preposition, when a previous choice
2683         ! has already been matched?
2684         if ((token->0) & $10) return GPR_PREPOSITION;
2685         #Endif; ! Grammar__Version
2686
2687         ! If we've run out of the player's input, but still have parameters to
2688         ! specify, we go into "infer" mode, remembering where we are and the
2689         ! preposition we are inferring...
2690
2691         if (wn > num_words) {
2692             if (inferfrom==0 && parameters<params_wanted) {
2693                 inferfrom = pcount; inferword = token;
2694                 pattern-->pcount = REPARSE_CODE + Dword__No(given_tdata);
2695             }
2696
2697             ! If we are not inferring, then the line is wrong...
2698
2699             if (inferfrom == 0) return -1;
2700
2701             ! If not, then the line is right but we mark in the preposition...
2702
2703             pattern-->pcount = REPARSE_CODE + Dword__No(given_tdata);
2704             return GPR_PREPOSITION;
2705         }
2706
2707         o = NextWord();
2708
2709         pattern-->pcount = REPARSE_CODE + Dword__No(o);
2710
2711         ! Whereas, if the player has typed something here, see if it is the
2712         ! required preposition... if it's wrong, the line must be wrong,
2713         ! but if it's right, the token is passed (jump to finish this token).
2714
2715         if (o == given_tdata) return GPR_PREPOSITION;
2716         #Iffalse (Grammar__Version == 1);
2717         if (PrepositionChain(o, token_n) ~= -1) return GPR_PREPOSITION;
2718         #Endif; ! Grammar__Version
2719         return -1;
2720
2721       GPR_TT:
2722         l = given_tdata();
2723         #Ifdef DEBUG;
2724         if (parser_trace >= 3) print "  [Outside parsing routine returned ", l, "]^";
2725         #Endif; ! DEBUG
2726         return l;
2727
2728       SCOPE_TT:
2729         scope_token = given_tdata;
2730         scope_stage = 1;
2731         l = scope_token();
2732         #Ifdef DEBUG;
2733         if (parser_trace >= 3) print "  [Scope routine returned multiple-flag of ", l, "]^";
2734         #Endif; ! DEBUG
2735         if (l == 1) given_tdata = MULTI_TOKEN; else given_tdata = NOUN_TOKEN;
2736
2737       ATTR_FILTER_TT:
2738         token_filter = 1 + given_tdata;
2739         given_tdata = NOUN_TOKEN;
2740
2741       ROUTINE_FILTER_TT:
2742         token_filter = given_tdata;
2743         given_tdata = NOUN_TOKEN;
2744
2745     } ! end of switch(given_ttype)
2746
2747     token = given_tdata;
2748
2749     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2750     !
2751     ! B: Begin parsing an object list
2752     !
2753     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2754
2755     ! There are now three possible ways we can be here:
2756     !     parsing an elementary token other than "special" or "number";
2757     !     parsing a scope token;
2758     !     parsing a noun-filter token (either by routine or attribute).
2759     !
2760     ! In each case, token holds the type of elementary parse to
2761     ! perform in matching one or more objects, and
2762     ! token_filter is 0 (default), an attribute + 1 for an attribute filter
2763     ! or a routine address for a routine filter.
2764
2765     token_allows_multiple = false;
2766     if (token == MULTI_TOKEN or MULTIHELD_TOKEN or MULTIEXCEPT_TOKEN or MULTIINSIDE_TOKEN)
2767         token_allows_multiple = true;
2768
2769     many_flag = false; and_parity = true; dont_infer = false;
2770
2771     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2772     !
2773     ! C: Parse descriptors (articles, pronouns, etc.) in the list
2774     !
2775     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2776
2777     ! We expect to find a list of objects next in what the player's typed.
2778
2779   .ObjectList;
2780
2781     #Ifdef DEBUG;
2782     if (parser_trace >= 3) print "  [Object list from word ", wn, "]^";
2783     #Endif; ! DEBUG
2784
2785     ! Take an advance look at the next word: if it's "it" or "them", and these
2786     ! are unset, set the appropriate error number and give up on the line
2787     ! (if not, these are still parsed in the usual way - it is not assumed
2788     ! that they still refer to something in scope)
2789
2790     o = NextWord(); wn--;
2791
2792     pronoun_word = NULL; pronoun_obj = NULL;
2793     l = PronounValue(o);
2794     if (l ~= 0) {
2795         pronoun_word = o; pronoun_obj = l;
2796         if (l == NULL) {
2797             ! Don't assume this is a use of an unset pronoun until the
2798             ! descriptors have been checked, because it might be an
2799             ! article (or some such) instead
2800
2801             for (l=1 : l<=LanguageDescriptors-->0 : l=l+4)
2802                 if (o == LanguageDescriptors-->l) jump AssumeDescriptor;
2803             pronoun__word = pronoun_word; pronoun__obj = pronoun_obj;
2804             etype = VAGUE_PE; return GPR_FAIL;
2805         }
2806     }
2807
2808   .AssumeDescriptor;
2809
2810     if (o == ME1__WD or ME2__WD or ME3__WD) { pronoun_word = o; pronoun_obj = player; }
2811
2812     allow_plurals = true;
2813     desc_wn = wn;
2814
2815   .TryAgain;
2816
2817     ! First, we parse any descriptive words (like "the", "five" or "every"):
2818     l = Descriptors(token_allows_multiple);
2819     if (l ~= 0) { etype = l; return GPR_FAIL; }
2820
2821   .TryAgain2;
2822
2823     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2824     !
2825     ! D: Parse an object name
2826     !
2827     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2828
2829     ! This is an actual specified object, and is therefore where a typing error
2830     ! is most likely to occur, so we set:
2831
2832     oops_from = wn;
2833
2834     ! So, two cases.  Case 1: token not equal to "held"
2835     ! but we may well be dealing with multiple objects
2836
2837     ! In either case below we use NounDomain, giving it the token number as
2838     ! context, and two places to look: among the actor's possessions, and in the
2839     ! present location.  (Note that the order depends on which is likeliest.)
2840     if (token ~= HELD_TOKEN) {
2841         i = multiple_object-->0;
2842         #Ifdef DEBUG;
2843         if (parser_trace >= 3) print "  [Calling NounDomain on location and actor]^";
2844         #Endif; ! DEBUG
2845         l = NounDomain(actors_location, actor, token);
2846         if (l == REPARSE_CODE) return l;                  ! Reparse after Q&A
2847         if (l ~= nothing && l ~= 1 && l notin actor && token == MULTIHELD_TOKEN or MULTIEXCEPT_TOKEN) {
2848             if (ImplicitTake(l)) {
2849                 etype = NOTHELD_PE;
2850                 jump FailToken;
2851             }
2852         }
2853
2854         if (indef_wanted == 100 && l == 0 && number_matched == 0)
2855             l = 1;  ! ReviseMulti if TAKE ALL FROM empty container
2856
2857         if (token_allows_multiple && ~~multiflag) {
2858             if (best_etype==MULTI_PE) best_etype=STUCK_PE;
2859             multiflag = true;
2860         }
2861         if (l == 0) {
2862             if (indef_possambig) {
2863                 saved_ml = match_length;
2864                 ResetDescriptors();
2865                 wn = desc_wn;
2866                 jump TryAgain2;
2867             }
2868             if (etype ~=TOOFEW_PE && (multiflag || etype ~= MULTI_PE))
2869                 etype = CantSee();
2870             jump FailToken;
2871         } ! Choose best error
2872
2873         #Ifdef DEBUG;
2874         if (parser_trace >= 3) {
2875             if (l > 1) print "  [NounDomain returned ", (the) l, "]^";
2876             else {
2877                 print "  [NounDomain appended to the multiple object list:^";
2878                 k = multiple_object-->0;
2879                 for (j=i+1 : j<=k : j++)
2880                     print "  Entry ", j, ": ", (The) multiple_object-->j,
2881                           " (", multiple_object-->j, ")^";
2882                 print "  List now has size ", k, "]^";
2883             }
2884         }
2885         #Endif; ! DEBUG
2886
2887         if (l == 1) {
2888             if (~~many_flag) many_flag = true;
2889             else {                                ! Merge with earlier ones
2890                 k = multiple_object-->0;            ! (with either parity)
2891                 multiple_object-->0 = i;
2892                 for (j=i+1 : j<=k : j++) {
2893                     if (and_parity) MultiAdd(multiple_object-->j);
2894                     else            MultiSub(multiple_object-->j);
2895                 }
2896                 #Ifdef DEBUG;
2897                 if (parser_trace >= 3) print "  [Merging ", k-i, " new objects to the ", i, " old ones]^";
2898                 #Endif; ! DEBUG
2899             }
2900         }
2901         else {
2902             ! A single object was indeed found
2903
2904             if (match_length == 0 && indef_possambig) {
2905                 ! So the answer had to be inferred from no textual data,
2906                 ! and we know that there was an ambiguity in the descriptor
2907                 ! stage (such as a word which could be a pronoun being
2908                 ! parsed as an article or possessive).  It's worth having
2909                 ! another go.
2910
2911                 ResetDescriptors();
2912                 wn = desc_wn;
2913                 jump TryAgain2;
2914             }
2915
2916             if (token == CREATURE_TOKEN && CreatureTest(l) == 0) {
2917                 etype = ANIMA_PE;
2918                 jump FailToken;
2919             } !  Animation is required
2920
2921             if (~~many_flag) single_object = l;
2922             else {
2923                 if (and_parity) MultiAdd(l); else MultiSub(l);
2924                 #Ifdef DEBUG;
2925                 if (parser_trace >= 3) print "  [Combining ", (the) l, " with list]^";
2926                 #Endif; ! DEBUG
2927             }
2928         }
2929
2930     } else {
2931     ! Case 2: token is "held" (which fortunately can't take multiple objects)
2932     ! and may generate an implicit take
2933         l = NounDomain(actor,actors_location,token);       ! Same as above...
2934         if (l == REPARSE_CODE) return GPR_REPARSE;
2935         if (l == 0) {
2936             if (indef_possambig) {
2937                 ResetDescriptors();
2938                 wn = desc_wn;
2939                 jump TryAgain2;
2940             }
2941             etype = CantSee(); jump FailToken;            ! Choose best error
2942         }
2943
2944         ! ...until it produces something not held by the actor.  Then an implicit
2945         ! take must be tried.  If this is already happening anyway, things are too
2946         ! confused and we have to give up (but saving the oops marker so as to get
2947         ! it on the right word afterwards).
2948         ! The point of this last rule is that a sequence like
2949         !
2950         !     > read newspaper
2951         !     (taking the newspaper first)
2952         !     The dwarf unexpectedly prevents you from taking the newspaper!
2953         !
2954         ! should not be allowed to go into an infinite repeat - read becomes
2955         ! take then read, but take has no effect, so read becomes take then read...
2956         ! Anyway for now all we do is record the number of the object to take.
2957
2958         o = parent(l);
2959
2960         if (o ~= actor) {
2961             if (notheld_mode == 1) {
2962                 saved_oops = oops_from;
2963                 etype = NOTHELD_PE;
2964                 jump FailToken;
2965             }
2966             not_holding = l;
2967             #Ifdef DEBUG;
2968             if (parser_trace >= 3) print "  [Allowing object ", (the) l, " for now]^";
2969             #Endif; ! DEBUG
2970         }
2971         single_object = l;
2972     } ! end of if (token ~= HELD_TOKEN) else
2973
2974     ! The following moves the word marker to just past the named object...
2975
2976     wn = oops_from + match_length;
2977
2978     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2979     !
2980     ! E: Parse connectives ("and", "but", etc.) and go back to (C)
2981     !
2982     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2983
2984     ! Object(s) specified now: is that the end of the list, or have we reached
2985     ! "and", "but" and so on?  If so, create a multiple-object list if we
2986     ! haven't already (and are allowed to).
2987
2988   .NextInList;
2989
2990     o = NextWord();
2991
2992     if (o == AND1__WD or AND2__WD or AND3__WD or BUT1__WD or BUT2__WD or BUT3__WD or comma_word) {
2993
2994         #Ifdef DEBUG;
2995         if (parser_trace >= 3) print "  [Read connective '", (address) o, "']^";
2996         #Endif; ! DEBUG
2997
2998         k = NextWord();
2999         if (k ~= AND1__WD) wn--;  ! allow Serial commas in input
3000         if (k > 0 && (k->#dict_par1) & (DICT_NOUN+DICT_VERB) == DICT_VERB) {
3001             wn--; ! player meant 'THEN'
3002             jump PassToken;
3003         }
3004         if (~~token_allows_multiple) {
3005             if (multiflag) jump PassToken; ! give UPTO_PE error
3006             etype=MULTI_PE;
3007             jump FailToken;
3008         }
3009
3010         if (o == BUT1__WD or BUT2__WD or BUT3__WD) and_parity = 1-and_parity;
3011
3012         if (~~many_flag) {
3013             multiple_object-->0 = 1;
3014             multiple_object-->1 = single_object;
3015             many_flag = true;
3016             #Ifdef DEBUG;
3017             if (parser_trace >= 3) print "  [Making new list from ", (the) single_object, "]^";
3018             #Endif; ! DEBUG
3019         }
3020         dont_infer = true; inferfrom=0;           ! Don't print (inferences)
3021         jump ObjectList;                          ! And back around
3022     }
3023
3024     wn--;   ! Word marker back to first not-understood word
3025
3026     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3027     !
3028     ! F: Return the conclusion of parsing an object list
3029     !
3030     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3031
3032     ! Happy or unhappy endings:
3033
3034   .PassToken;
3035
3036     if (many_flag) {
3037         single_object = GPR_MULTIPLE;
3038         multi_context = token;
3039     }
3040     else {
3041         if (indef_mode == 1 && indef_type & PLURAL_BIT ~= 0) {
3042             if (indef_wanted < 100 && indef_wanted > 1) {
3043                 multi_had = 1; multi_wanted = indef_wanted;
3044                 etype = TOOFEW_PE;
3045                 jump FailToken;
3046             }
3047         }
3048     }
3049     return single_object;
3050
3051   .FailToken;
3052
3053     ! If we were only guessing about it being a plural, try again but only
3054     ! allowing singulars (so that words like "six" are not swallowed up as
3055     ! Descriptors)
3056
3057     if (allow_plurals && indef_guess_p == 1) {
3058         #Ifdef DEBUG;
3059         if (parser_trace >= 4) print "   [Retrying singulars after failure ", etype, "]^";
3060         #Endif;
3061         prev_indef_wanted = indef_wanted;
3062         allow_plurals = false;
3063         wn = desc_wn;
3064         jump TryAgain;
3065     }
3066
3067     if ((indef_wanted > 0 || prev_indef_wanted > 0) && (~~multiflag)) etype = MULTI_PE;
3068
3069     return GPR_FAIL;
3070
3071 ]; ! end of ParseToken__
3072
3073 ! ----------------------------------------------------------------------------
3074 !  NounDomain does the most substantial part of parsing an object name.
3075 !
3076 !  It is given two "domains" - usually a location and then the actor who is
3077 !  looking - and a context (i.e. token type), and returns:
3078 !
3079 !   0    if no match at all could be made,
3080 !   1    if a multiple object was made,
3081 !   k    if object k was the one decided upon,
3082 !   REPARSE_CODE if it asked a question of the player and consequently rewrote
3083 !        the player's input, so that the whole parser should start again
3084 !        on the rewritten input.
3085 !
3086 !   In the case when it returns 1<k<REPARSE_CODE, it also sets the variable
3087 !   length_of_noun to the number of words in the input text matched to the
3088 !   noun.
3089 !   In the case k=1, the multiple objects are added to multiple_object by
3090 !   hand (not by MultiAdd, because we want to allow duplicates).
3091 ! ----------------------------------------------------------------------------
3092
3093 [ NounDomain domain1 domain2 context    first_word i j k l
3094                                         answer_words;
3095     #Ifdef DEBUG;
3096     if (parser_trace >= 4) {
3097         print "   [NounDomain called at word ", wn, "]^";
3098         print "   ";
3099         if (indef_mode) {
3100             print "seeking indefinite object: ";
3101             if (indef_type & OTHER_BIT)  print "other ";
3102             if (indef_type & MY_BIT)     print "my ";
3103             if (indef_type & THAT_BIT)   print "that ";
3104             if (indef_type & PLURAL_BIT) print "plural ";
3105             if (indef_type & LIT_BIT)    print "lit ";
3106             if (indef_type & UNLIT_BIT)  print "unlit ";
3107             if (indef_owner ~= 0) print "owner:", (name) indef_owner;
3108             new_line;
3109             print "   number wanted: ";
3110             if (indef_wanted == 100) print "all"; else print indef_wanted;
3111             new_line;
3112             print "   most likely GNAs of names: ", indef_cases, "^";
3113         }
3114         else print "seeking definite object^";
3115     }
3116     #Endif; ! DEBUG
3117
3118     match_length = 0; number_matched = 0; match_from = wn; placed_in_flag = 0;
3119
3120     SearchScope(domain1, domain2, context);
3121
3122     #Ifdef DEBUG;
3123     if (parser_trace >= 4) print "   [NounDomain made ", number_matched, " matches]^";
3124     #Endif; ! DEBUG
3125
3126     wn = match_from+match_length;
3127
3128     ! If nothing worked at all, leave with the word marker skipped past the
3129     ! first unmatched word...
3130
3131     if (number_matched == 0) { wn++; rfalse; }
3132
3133     ! Suppose that there really were some words being parsed (i.e., we did
3134     ! not just infer).  If so, and if there was only one match, it must be
3135     ! right and we return it...
3136     if (match_from <= num_words) {
3137         if (number_matched == 1) {
3138             i=match_list-->0;
3139             if (indef_mode) {
3140                 if ((indef_type & LIT_BIT) && i hasnt light) rfalse;
3141                 if ((indef_type & UNLIT_BIT) && i has light) rfalse;
3142             }
3143             return i;
3144         }
3145
3146         ! ...now suppose that there was more typing to come, i.e. suppose that
3147         ! the user entered something beyond this noun.  If nothing ought to follow,
3148         ! then there must be a mistake, (unless what does follow is just a full
3149         ! stop, and or comma)
3150
3151         if (wn <= num_words) {
3152             i = NextWord(); wn--;
3153             if (i ~=  AND1__WD or AND2__WD or AND3__WD or comma_word
3154                    or THEN1__WD or THEN2__WD or THEN3__WD
3155                    or BUT1__WD or BUT2__WD or BUT3__WD) {
3156                 if (lookahead == ENDIT_TOKEN) rfalse;
3157             }
3158         }
3159     }
3160
3161     ! Now look for a good choice, if there's more than one choice...
3162
3163     number_of_classes = 0;
3164
3165     if (match_length == 0 && indef_mode && indef_wanted ~= 100)
3166         number_matched = 0;  ! ask question for 'take three'
3167     if (number_matched == 1) i = match_list-->0;
3168     if (number_matched > 1) {
3169         i = Adjudicate(context);
3170         if (i == -1) rfalse;
3171         if (i == 1) rtrue;       !  Adjudicate has made a multiple
3172                                  !  object, and we pass it on
3173     }
3174
3175     ! If i is non-zero here, one of two things is happening: either
3176     ! (a) an inference has been successfully made that object i is
3177     !     the intended one from the user's specification, or
3178     ! (b) the user finished typing some time ago, but we've decided
3179     !     on i because it's the only possible choice.
3180     ! In either case we have to keep the pattern up to date,
3181     ! note that an inference has been made and return.
3182     ! (Except, we don't note which of a pile of identical objects.)
3183
3184     if (i ~= 0) {
3185         if (dont_infer) return i;
3186         if (inferfrom == 0) inferfrom=pcount;
3187         pattern-->pcount = i;
3188         return i;
3189     }
3190
3191     ! If we get here, there was no obvious choice of object to make.  If in
3192     ! fact we've already gone past the end of the player's typing (which
3193     ! means the match list must contain every object in scope, regardless
3194     ! of its name), then it's foolish to give an enormous list to choose
3195     ! from - instead we go and ask a more suitable question...
3196
3197     if (match_from > num_words) jump Incomplete;
3198     return AskPlayer(context);
3199
3200     ! Now we come to the question asked when the input has run out
3201     ! and can't easily be guessed (eg, the player typed "take" and there
3202     ! were plenty of things which might have been meant).
3203
3204   .Incomplete;
3205
3206     if (best_etype == NOTHING_PE && pattern-->1 == 0) rfalse; ! for DROP when empty-handed
3207     if (context == CREATURE_TOKEN) L__M(##Miscellany, 48, actor);
3208     else                           L__M(##Miscellany, 49, actor);
3209
3210     #Ifdef TARGET_ZCODE;
3211     for (i=2 : i<INPUT_BUFFER_LEN : i++) buffer2->i = ' ';
3212     #Endif; ! TARGET_ZCODE
3213     answer_words = Keyboard(buffer2, parse2);
3214
3215     first_word = WordValue(1, parse2);
3216     #Ifdef LanguageIsVerb;
3217     if (first_word == 0) {
3218         j = wn; first_word = LanguageIsVerb(buffer2, parse2, 1); wn = j;
3219     }
3220     #Endif; ! LanguageIsVerb
3221
3222     ! Once again, if the reply looks like a command, give it to the
3223     ! parser to get on with and forget about the question...
3224
3225     ! Once again, if the reply looks like a command
3226     ! (that is, VERB ... or XXX,VERB ...), give it to the parser to get
3227     ! on with and forget about the question...
3228
3229     if (first_word) {
3230         if ((first_word->#dict_par1) & DICT_VERB) {
3231             CopyBuffer(buffer, buffer2);
3232             return REPARSE_CODE;
3233         }
3234         if (NumberWords(parse2) > 2) {
3235             j = WordValue(2, parse2);
3236             k = WordValue(3, parse2);
3237             if (j == ',//' && k && (k->#dict_par1) & DICT_VERB) {
3238                 CopyBuffer(buffer, buffer2);
3239                 return REPARSE_CODE;
3240             }
3241         }
3242     }
3243
3244     ! ...but if we have a genuine answer, then:
3245     !
3246     ! (1) we must glue in text suitable for anything that's been inferred.
3247
3248     if (inferfrom ~= 0) {
3249         for (j=inferfrom : j<pcount : j++) {
3250             if (pattern-->j == PATTERN_NULL) continue;
3251             i = WORDSIZE + GetKeyBufLength();
3252             SetKeyBufLength(i-WORDSIZE + 1);
3253             buffer->(i++) = ' ';
3254
3255             #Ifdef DEBUG;
3256             if (parser_trace >= 5) print "[Gluing in inference with pattern code ", pattern-->j, "]^";
3257             #Endif; ! DEBUG
3258
3259             ! Conveniently, parse2-->1 is the first word in both ZCODE and GLULX.
3260
3261             parse2-->1 = 0;
3262
3263             ! An inferred object.  Best we can do is glue in a pronoun.
3264             ! (This is imperfect, but it's very seldom needed anyway.)
3265
3266             if (pattern-->j >= 2 && pattern-->j < REPARSE_CODE) {
3267                 ! was the inference made from some noun words?
3268                 ! In which case, we can infer again.
3269                 if ((WordValue(NumberWords())->#dict_par1) & DICT_NOUN) continue;
3270                 PronounNotice(pattern-->j);
3271                 for (k=1 : k<=LanguagePronouns-->0 : k=k+3)
3272                     if (pattern-->j == LanguagePronouns-->(k+2)) {
3273                         parse2-->1 = LanguagePronouns-->k;
3274                         #Ifdef DEBUG;
3275                         if (parser_trace >= 5) print "[Using pronoun '", (address) parse2-->1, "']^";
3276                         #Endif; ! DEBUG
3277                         break;
3278                     }
3279             }
3280             else {
3281                 ! An inferred preposition.
3282                 parse2-->1 = No__Dword(pattern-->j - REPARSE_CODE);
3283                 #Ifdef DEBUG;
3284                 if (parser_trace >= 5) print "[Using preposition '", (address) parse2-->1, "']^";
3285                 #Endif; ! DEBUG
3286             }
3287
3288             ! parse2-->1 now holds the dictionary address of the word to glue in.
3289
3290             if (parse2-->1 ~= 0) {
3291                 k = buffer + i;
3292                 #Ifdef TARGET_ZCODE;
3293                 @output_stream 3 k;
3294                 print (address) parse2-->1;
3295                 @output_stream -3;
3296                 k = k-->0;
3297                 for (l=i : l<i+k : l++) buffer->l = buffer->(l+2);
3298                 #Ifnot; ! TARGET_GLULX
3299                 k = PrintAnyToArray(buffer+i, INPUT_BUFFER_LEN-i, parse2-->1);
3300                 l=l; ! suppress compiler warning
3301                 #Endif; ! TARGET_
3302                 i = i + k; SetKeyBufLength(i-WORDSIZE);
3303             }
3304         }
3305     }
3306
3307     ! (2) we must glue the newly-typed text onto the end.
3308
3309     i = WORDSIZE + GetKeyBufLength();
3310     buffer->(i++) = ' ';
3311     SetKeyBufLength(GetKeyBufLength()+1);
3312     for (j=0 : j<GetKeyBufLength(buffer2) : i++,j++) {
3313         buffer->i = buffer2->(j+WORDSIZE);
3314         SetKeyBufLength(GetKeyBufLength()+1);
3315         if (i-WORDSIZE == INPUT_BUFFER_LEN-1) break;
3316     }
3317
3318     ! (3) we fill up the buffer with spaces, which is unnecessary, but may
3319     !     help incorrectly-written interpreters to cope.
3320
3321     #Ifdef TARGET_ZCODE;
3322     for (: i<INPUT_BUFFER_LEN : i++) buffer->i = ' ';
3323     #Endif; ! TARGET_ZCODE
3324
3325     return REPARSE_CODE;
3326
3327 ]; ! end of NounDomain
3328
3329
3330 [ AskPlayer context  i j k l first_word answer_words marker;
3331     ! Now we print up the question, using the equivalence classes as worked
3332     ! out by Adjudicate() so as not to repeat ourselves on plural objects...
3333
3334     asking_player = true;
3335     if (context == CREATURE_TOKEN) L__M(##Miscellany, 45);
3336     else                           L__M(##Miscellany, 46);
3337
3338     j = number_of_classes; marker = 0;
3339     for (i=1 : i<=number_of_classes : i++) {
3340         while (((match_classes-->marker) ~= i) && ((match_classes-->marker) ~= -i)) marker++;
3341         k = match_list-->marker;
3342
3343         if (match_classes-->marker > 0) print (the) k; else print (a) k;
3344
3345         if (i < j-1)  print (string) COMMA__TX;
3346         if (i == j-1) print (SerialComma) j, (string) OR__TX;
3347     }
3348     L__M(##Miscellany, 57);
3349
3350     ! ...and get an answer:
3351
3352   .WhichOne;
3353     #Ifdef TARGET_ZCODE;
3354     for (i=WORDSIZE : i<INPUT_BUFFER_LEN : i++) buffer2->i = ' ';
3355     #Endif; ! TARGET_ZCODE
3356     answer_words = Keyboard(buffer2, parse2);
3357
3358     first_word = WordValue(1, parse2);
3359     asking_player = false;
3360
3361     ! Take care of "all", because that does something too clever here to do
3362     ! later on:
3363
3364     if (first_word == ALL1__WD or ALL2__WD or ALL3__WD or ALL4__WD or ALL5__WD) {
3365         if (context == MULTI_TOKEN or MULTIHELD_TOKEN or MULTIEXCEPT_TOKEN or MULTIINSIDE_TOKEN) {
3366             l = multiple_object-->0;
3367             for (i=0 : i<number_matched && l+i<63 : i++) {
3368                 k = match_list-->i;
3369                 multiple_object-->(i+1+l) = k;
3370             }
3371             multiple_object-->0 = i+l;
3372             rtrue;
3373         }
3374         L__M(##Miscellany, 47);
3375         jump WhichOne;
3376     }
3377
3378     ! If the first word of the reply can be interpreted as a verb, then
3379     ! assume that the player has ignored the question and given a new
3380     ! command altogether.
3381     ! (This is one time when it's convenient that the directions are
3382     ! not themselves verbs - thus, "north" as a reply to "Which, the north
3383     ! or south door" is not treated as a fresh command but as an answer.)
3384
3385     #Ifdef LanguageIsVerb;
3386     if (first_word == 0) {
3387         j = wn; first_word = LanguageIsVerb(buffer2, parse2, 1); wn = j;
3388     }
3389     #Endif; ! LanguageIsVerb
3390     if (first_word) {
3391         if (((first_word->#dict_par1) & DICT_VERB) && ~~LanguageVerbMayBeName(first_word)) {
3392             CopyBuffer(buffer, buffer2);
3393             return REPARSE_CODE;
3394         }
3395         if (NumberWords(parse2) > 2) {
3396             j = WordValue(2, parse2);
3397             k = WordValue(3, parse2);
3398             if (j == ',//' && k && (k->#dict_par1) & DICT_VERB) {
3399                 CopyBuffer(buffer, buffer2);
3400                 return REPARSE_CODE;
3401             }
3402         }
3403     }
3404
3405     ! Now we insert the answer into the original typed command, as
3406     ! words additionally describing the same object
3407     ! (eg, > take red button
3408     !      Which one, ...
3409     !      > music
3410     ! becomes "take music red button".  The parser will thus have three
3411     ! words to work from next time, not two.)
3412
3413     k = WordAddress(match_from) - buffer;
3414     l = GetKeyBufLength(buffer2) +1;
3415     for (j=buffer + INPUT_BUFFER_LEN - 1 : j>=buffer+k+l : j--) j->0 = j->(-l);
3416     for (i=0 : i<l : i++) buffer->(k+i) = buffer2->(WORDSIZE+i);
3417     buffer->(k+l-1) = ' ';
3418     SetKeyBufLength(GetKeyBufLength() + l);
3419
3420     ! Having reconstructed the input, we warn the parser accordingly
3421     ! and get out.
3422
3423     return REPARSE_CODE;
3424 ];
3425
3426
3427 ! ----------------------------------------------------------------------------
3428 !  The Adjudicate routine tries to see if there is an obvious choice, when
3429 !  faced with a list of objects (the match_list) each of which matches the
3430 !  player's specification equally well.
3431 !
3432 !  To do this it makes use of the context (the token type being worked on).
3433 !  It counts up the number of obvious choices for the given context
3434 !  (all to do with where a candidate is, except for 6 (animate) which is to
3435 !  do with whether it is animate or not);
3436 !
3437 !  if only one obvious choice is found, that is returned;
3438 !
3439 !  if we are in indefinite mode (don't care which) one of the obvious choices
3440 !    is returned, or if there is no obvious choice then an unobvious one is
3441 !    made;
3442 !
3443 !  at this stage, we work out whether the objects are distinguishable from
3444 !    each other or not: if they are all indistinguishable from each other,
3445 !    then choose one, it doesn't matter which;
3446 !
3447 !  otherwise, 0 (meaning, unable to decide) is returned (but remember that
3448 !    the equivalence classes we've just worked out will be needed by other
3449 !    routines to clear up this mess, so we can't economise on working them
3450 !    out).
3451 !
3452 !  Returns -1 if an error occurred
3453 ! ----------------------------------------------------------------------------
3454
3455 Constant SCORE__CHOOSEOBJ   = 1000;
3456 Constant SCORE__IFGOOD      = 500;
3457 Constant SCORE__UNCONCEALED = 100;
3458 Constant SCORE__BESTLOC     = 60;
3459 Constant SCORE__NEXTBESTLOC = 40;
3460 Constant SCORE__NOTCOMPASS  = 20;
3461 Constant SCORE__NOTSCENERY  = 10;
3462 Constant SCORE__NOTACTOR    = 5;
3463 Constant SCORE__GNA         = 1;
3464 Constant SCORE__DIVISOR     = 20;
3465
3466 [ Adjudicate context i j k good_flag good_ones last n flag offset sovert;
3467     #Ifdef DEBUG;
3468     if (parser_trace >= 4) {
3469         print "   [Adjudicating match list of size ", number_matched, " in context ", context, "]^";
3470         print "   ";
3471         if (indef_mode) {
3472             print "indefinite type: ";
3473             if (indef_type & OTHER_BIT)  print "other ";
3474             if (indef_type & MY_BIT)     print "my ";
3475             if (indef_type & THAT_BIT)   print "that ";
3476             if (indef_type & PLURAL_BIT) print "plural ";
3477             if (indef_type & LIT_BIT)    print "lit ";
3478             if (indef_type & UNLIT_BIT)  print "unlit ";
3479             if (indef_owner ~= 0) print "owner:", (name) indef_owner;
3480             new_line;
3481             print "   number wanted: ";
3482             if (indef_wanted == 100) print "all"; else print indef_wanted;
3483             new_line;
3484             print "   most likely GNAs of names: ", indef_cases, "^";
3485         }
3486         else print "definite object^";
3487     }
3488     #Endif; ! DEBUG
3489
3490     j = number_matched-1; good_ones = 0; last = match_list-->0;
3491     for (i=0 : i<=j : i++) {
3492         n = match_list-->i;
3493         match_scores-->i = 0;
3494
3495         good_flag = false;
3496
3497         switch (context) {
3498           HELD_TOKEN, MULTIHELD_TOKEN:
3499             if (parent(n) == actor) good_flag = true;
3500           MULTIEXCEPT_TOKEN:
3501             if (advance_warning == -1) {
3502                 good_flag = true;
3503             }
3504             else {
3505                 if (n ~= advance_warning) good_flag = true;
3506             }
3507           MULTIINSIDE_TOKEN:
3508             if (advance_warning == -1) {
3509                 if (parent(n) ~= actor) good_flag = true;
3510             }
3511             else {
3512                 if (n in advance_warning) good_flag = true;
3513             }
3514           CREATURE_TOKEN:
3515             if (CreatureTest(n) == 1) good_flag = true;
3516           default:
3517             good_flag = true;
3518         }
3519
3520         if (good_flag) {
3521             match_scores-->i = SCORE__IFGOOD;
3522             good_ones++; last = n;
3523         }
3524     }
3525     if (good_ones == 1) return last;
3526
3527     ! If there is ambiguity about what was typed, but it definitely wasn't
3528     ! animate as required, then return anything; higher up in the parser
3529     ! a suitable error will be given.  (This prevents a question being asked.)
3530
3531     if (context == CREATURE_TOKEN && good_ones == 0) return match_list-->0;
3532
3533     if (indef_mode == 0) indef_type=0;
3534
3535     ScoreMatchL(context);
3536     if (number_matched == 0) return -1;
3537
3538     if (indef_mode == 1 && indef_type & PLURAL_BIT ~= 0) {
3539         if (context ~= MULTI_TOKEN or MULTIHELD_TOKEN or MULTIEXCEPT_TOKEN
3540                      or MULTIINSIDE_TOKEN) {
3541   &