+++ /dev/null
-/* ------------------------------------------------------------------------- */
-/* "verbs" : Manages actions and grammar tables; parses the directives */
-/* Verb and Extend. */
-/* */
-/* Copyright (c) Graham Nelson 1993 - 2018 */
-/* */
-/* This file is part of Inform. */
-/* */
-/* Inform is free software: you can redistribute it and/or modify */
-/* it under the terms of the GNU General Public License as published by */
-/* the Free Software Foundation, either version 3 of the License, or */
-/* (at your option) any later version. */
-/* */
-/* Inform is distributed in the hope that it will be useful, */
-/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
-/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
-/* GNU General Public License for more details. */
-/* */
-/* You should have received a copy of the GNU General Public License */
-/* along with Inform. If not, see https://gnu.org/licenses/ */
-/* */
-/* ------------------------------------------------------------------------- */
-
-#include "header.h"
-
-int grammar_version_number; /* 1 for pre-Inform 6.06 table format */
-int32 grammar_version_symbol; /* Index of "Grammar__Version"
- within symbols table */
-
-/* ------------------------------------------------------------------------- */
-/* Actions. */
-/* ------------------------------------------------------------------------- */
-/* Array defined below: */
-/* */
-/* int32 action_byte_offset[n] The (byte) offset in the Z-machine */
-/* code area of the ...Sub routine */
-/* for action n. (NB: This is left */
-/* blank until the end of the */
-/* compilation pass.) */
-/* int32 action_symbol[n] The symbol table index of the n-th */
-/* action's name. */
-/* ------------------------------------------------------------------------- */
-
-int no_actions, /* Number of actions made so far */
- no_fake_actions; /* Number of fake actions made so far */
-
-/* ------------------------------------------------------------------------- */
-/* Adjectives. (The term "adjective" is traditional; they are mainly */
-/* prepositions, such as "onto".) */
-/* ------------------------------------------------------------------------- */
-/* Arrays defined below: */
-/* */
-/* int32 adjectives[n] Byte address of dictionary entry */
-/* for the nth adjective */
-/* dict_word adjective_sort_code[n] Dictionary sort code of nth adj */
-/* ------------------------------------------------------------------------- */
-
-int no_adjectives; /* Number of adjectives made so far */
-
-/* ------------------------------------------------------------------------- */
-/* Verbs. Note that Inform-verbs are not quite the same as English verbs: */
-/* for example the English verbs "take" and "drop" both normally */
-/* correspond in a game's dictionary to the same Inform verb. An */
-/* Inform verb is essentially a list of grammar lines. */
-/* ------------------------------------------------------------------------- */
-/* Arrays defined below: */
-/* */
-/* verbt Inform_verbs[n] The n-th grammar line sequence: */
-/* see "header.h" for the definition */
-/* of the typedef struct verbt */
-/* int32 grammar_token_routine[n] The byte offset from start of code */
-/* area of the n-th one */
-/* ------------------------------------------------------------------------- */
-
-int no_Inform_verbs, /* Number of Inform-verbs made so far */
- no_grammar_token_routines; /* Number of routines given in tokens */
-
-/* ------------------------------------------------------------------------- */
-/* We keep a list of English verb-words known (e.g. "take" or "eat") and */
-/* which Inform-verbs they correspond to. (This list is needed for some */
-/* of the grammar extension operations.) */
-/* The format of this list is a sequence of variable-length records: */
-/* */
-/* Byte offset to start of next record (1 byte) */
-/* Inform verb number this word corresponds to (1 byte) */
-/* The English verb-word (reduced to lower case), null-terminated */
-/* ------------------------------------------------------------------------- */
-
-static char *English_verb_list, /* First byte of first record */
- *English_verb_list_top; /* Next byte free for new record */
-
-static int English_verb_list_size; /* Size of the list in bytes
- (redundant but convenient) */
-
-/* ------------------------------------------------------------------------- */
-/* Arrays used by this file */
-/* ------------------------------------------------------------------------- */
-
- verbt *Inform_verbs;
- uchar *grammar_lines;
- int32 grammar_lines_top;
- int no_grammar_lines, no_grammar_tokens;
-
- int32 *action_byte_offset,
- *action_symbol,
- *grammar_token_routine,
- *adjectives;
- static uchar *adjective_sort_code;
-
-/* ------------------------------------------------------------------------- */
-/* Tracing for compiler maintenance */
-/* ------------------------------------------------------------------------- */
-
-extern void list_verb_table(void)
-{ int i;
- for (i=0; i<no_Inform_verbs; i++)
- printf("Verb %2d has %d lines\n", i, Inform_verbs[i].lines);
-}
-
-/* ------------------------------------------------------------------------- */
-/* Actions. */
-/* ------------------------------------------------------------------------- */
-
-static void new_action(char *b, int c)
-{
- /* Called whenever a new action (or fake action) is created (either
- by using make_action above, or the Fake_Action directive, or by
- the linker). At present just a hook for some tracing code. */
-
- if (printprops_switch)
- printf("Action '%s' is numbered %d\n",b,c);
-}
-
-/* Note that fake actions are numbered from a high base point upwards;
- real actions are numbered from 0 upward in GV2. */
-
-extern void make_fake_action(void)
-{ int i;
- char action_sub[MAX_IDENTIFIER_LENGTH+4];
- debug_location_beginning beginning_debug_location =
- get_token_location_beginning();
-
- get_next_token();
- if (token_type != SYMBOL_TT)
- { discard_token_location(beginning_debug_location);
- ebf_error("new fake action name", token_text);
- panic_mode_error_recovery(); return;
- }
-
- snprintf(action_sub, MAX_IDENTIFIER_LENGTH+4, "%s__A", token_text);
- i = symbol_index(action_sub, -1);
-
- if (!(sflags[i] & UNKNOWN_SFLAG))
- { discard_token_location(beginning_debug_location);
- ebf_error("new fake action name", token_text);
- panic_mode_error_recovery(); return;
- }
-
- assign_symbol(i, ((grammar_version_number==1)?256:4096)+no_fake_actions++,
- FAKE_ACTION_T);
-
- new_action(token_text, i);
-
- if (debugfile_switch)
- { debug_file_printf("<fake-action>");
- debug_file_printf("<identifier>##%s</identifier>", token_text);
- debug_file_printf("<value>%d</value>", svals[i]);
- get_next_token();
- write_debug_locations
- (get_token_location_end(beginning_debug_location));
- put_token_back();
- debug_file_printf("</fake-action>");
- }
-
- return;
-}
-
-extern assembly_operand action_of_name(char *name)
-{
- /* Returns the action number of the given name, creating it as a new
- action name if it isn't already known as such. */
-
- char action_sub[MAX_IDENTIFIER_LENGTH+4];
- int j;
- assembly_operand AO;
-
- snprintf(action_sub, MAX_IDENTIFIER_LENGTH+4, "%s__A", name);
- j = symbol_index(action_sub, -1);
-
- if (stypes[j] == FAKE_ACTION_T)
- { INITAO(&AO);
- AO.value = svals[j];
- if (!glulx_mode)
- AO.type = LONG_CONSTANT_OT;
- else
- set_constant_ot(&AO);
- sflags[j] |= USED_SFLAG;
- return AO;
- }
-
- if (sflags[j] & UNKNOWN_SFLAG)
- {
- if (no_actions>=MAX_ACTIONS) memoryerror("MAX_ACTIONS",MAX_ACTIONS);
- new_action(name, no_actions);
- action_symbol[no_actions] = j;
- assign_symbol(j, no_actions++, CONSTANT_T);
- sflags[j] |= ACTION_SFLAG;
- }
- sflags[j] |= USED_SFLAG;
-
- INITAO(&AO);
- AO.value = svals[j];
- AO.marker = ACTION_MV;
- if (!glulx_mode) {
- AO.type = (module_switch)?LONG_CONSTANT_OT:SHORT_CONSTANT_OT;
- if (svals[j] >= 256) AO.type = LONG_CONSTANT_OT;
- }
- else {
- AO.type = CONSTANT_OT;
- }
- return AO;
-}
-
-extern void find_the_actions(void)
-{ int i; int32 j;
- char action_name[MAX_IDENTIFIER_LENGTH+4];
- char action_sub[MAX_IDENTIFIER_LENGTH+4];
-
- if (module_switch)
- for (i=0; i<no_actions; i++) action_byte_offset[i] = 0;
- else
- for (i=0; i<no_actions; i++)
- { strcpy(action_name, (char *) symbs[action_symbol[i]]);
- action_name[strlen(action_name) - 3] = '\0'; /* remove "__A" */
- strcpy(action_sub, action_name);
- strcat(action_sub, "Sub");
- j = symbol_index(action_sub, -1);
- if (sflags[j] & UNKNOWN_SFLAG)
- {
- error_named_at("No ...Sub action routine found for action:", action_name, slines[action_symbol[i]]);
- }
- else
- if (stypes[j] != ROUTINE_T)
- {
- error_named_at("No ...Sub action routine found for action:", action_name, slines[action_symbol[i]]);
- error_named_at("-- ...Sub symbol found, but not a routine:", action_sub, slines[j]);
- }
- else
- { action_byte_offset[i] = svals[j];
- sflags[j] |= USED_SFLAG;
- }
- }
-}
-
-/* ------------------------------------------------------------------------- */
-/* Adjectives. */
-/* ------------------------------------------------------------------------- */
-
-static int make_adjective(char *English_word)
-{
- /* Returns adjective number of the English word supplied, creating
- a new adjective number if need be.
-
- Note that (partly for historical reasons) adjectives are numbered
- from 0xff downwards. (And partly to make them stand out as tokens.)
-
- This routine is used only in grammar version 1: the corresponding
- table is left empty in GV2. */
-
- int i;
- uchar new_sort_code[MAX_DICT_WORD_BYTES];
-
- if (no_adjectives >= MAX_ADJECTIVES)
- memoryerror("MAX_ADJECTIVES", MAX_ADJECTIVES);
-
- dictionary_prepare(English_word, new_sort_code);
- for (i=0; i<no_adjectives; i++)
- if (compare_sorts(new_sort_code,
- adjective_sort_code+i*DICT_WORD_BYTES) == 0)
- return(0xff-i);
- adjectives[no_adjectives]
- = dictionary_add(English_word,8,0,0xff-no_adjectives);
- copy_sorts(adjective_sort_code+no_adjectives*DICT_WORD_BYTES,
- new_sort_code);
- return(0xff-no_adjectives++);
-}
-
-/* ------------------------------------------------------------------------- */
-/* Parsing routines. */
-/* ------------------------------------------------------------------------- */
-
-static int make_parsing_routine(int32 routine_address)
-{
- /* This routine is used only in grammar version 1: the corresponding
- table is left empty in GV2. */
-
- int l;
- for (l=0; l<no_grammar_token_routines; l++)
- if (grammar_token_routine[l] == routine_address)
- return l;
-
- grammar_token_routine[l] = routine_address;
- return(no_grammar_token_routines++);
-}
-
-/* ------------------------------------------------------------------------- */
-/* The English-verb list. */
-/* ------------------------------------------------------------------------- */
-
-static int find_or_renumber_verb(char *English_verb, int *new_number)
-{
- /* If new_number is null, returns the Inform-verb number which the
- * given English verb causes, or -1 if the given verb is not in the
- * dictionary */
-
- /* If new_number is non-null, renumbers the Inform-verb number which
- * English_verb matches in English_verb_list to account for the case
- * when we are extending a verb. Returns 0 if successful, or -1 if
- * the given verb is not in the dictionary (which shouldn't happen as
- * get_verb has already run) */
-
- char *p;
- p=English_verb_list;
- while (p < English_verb_list_top)
- { if (strcmp(English_verb, p+3) == 0)
- { if (new_number)
- { p[1] = (*new_number)/256;
- p[2] = (*new_number)%256;
- return 0;
- }
- return(256*((uchar)p[1]))+((uchar)p[2]);
- }
- p=p+(uchar)p[0];
- }
- return(-1);
-}
-
-static void register_verb(char *English_verb, int number)
-{
- /* Registers a new English verb as referring to the given Inform-verb
- number. (See comments above for format of the list.) */
- int entrysize;
-
- if (find_or_renumber_verb(English_verb, NULL) != -1)
- { error_named("Two different verb definitions refer to", English_verb);
- return;
- }
-
- /* We set a hard limit of MAX_VERB_WORD_SIZE=120 because the
- English_verb_list table stores length in a leading byte. (We could
- raise that to 250, really, but there's little point when
- MAX_DICT_WORD_SIZE is 40.) */
- entrysize = strlen(English_verb)+4;
- if (entrysize > MAX_VERB_WORD_SIZE+4)
- error_numbered("Verb word is too long -- max length is", MAX_VERB_WORD_SIZE);
- English_verb_list_size += entrysize;
- if (English_verb_list_size >= MAX_VERBSPACE)
- memoryerror("MAX_VERBSPACE", MAX_VERBSPACE);
-
- English_verb_list_top[0] = entrysize;
- English_verb_list_top[1] = number/256;
- English_verb_list_top[2] = number%256;
- strcpy(English_verb_list_top+3, English_verb);
- English_verb_list_top += entrysize;
-}
-
-static int get_verb(void)
-{
- /* Look at the last-read token: if it's the name of an English verb
- understood by Inform, in double-quotes, then return the Inform-verb
- that word refers to: otherwise give an error and return -1. */
-
- int j;
-
- if ((token_type == DQ_TT) || (token_type == SQ_TT))
- { j = find_or_renumber_verb(token_text, NULL);
- if (j==-1)
- error_named("There is no previous grammar for the verb",
- token_text);
- return j;
- }
-
- ebf_error("an English verb in quotes", token_text);
-
- return -1;
-}
-
-/* ------------------------------------------------------------------------- */
-/* Grammar lines for Verb/Extend directives. */
-/* ------------------------------------------------------------------------- */
-
-static int grammar_line(int verbnum, int line)
-{
- /* Parse a grammar line, to be written into grammar_lines[mark] onward.
-
- Syntax: * <token1> ... <token-n> -> <action>
-
- is compiled to a table in the form:
-
- <action number : word>
- <token 1> ... <token n> <ENDIT>
-
- where <ENDIT> is the byte 15, and each <token> is 3 bytes long.
-
- If grammar_version_number is 1, the token holds
-
- <bytecode> 00 00
-
- and otherwise a GV2 token.
-
- Return TRUE if grammar continues after the line, FALSE if the
- directive comes to an end. */
-
- int j, bytecode, mark; int32 wordcode;
- int grammar_token, slash_mode, last_was_slash;
- int reverse_action, TOKEN_SIZE;
- debug_location_beginning beginning_debug_location =
- get_token_location_beginning();
-
- get_next_token();
- if ((token_type == SEP_TT) && (token_value == SEMICOLON_SEP))
- { discard_token_location(beginning_debug_location);
- return FALSE;
- }
- if (!((token_type == SEP_TT) && (token_value == TIMES_SEP)))
- { discard_token_location(beginning_debug_location);
- ebf_error("'*' divider", token_text);
- panic_mode_error_recovery();
- return FALSE;
- }
-
- /* Have we run out of lines or token space? */
-
- if (line >= MAX_LINES_PER_VERB)
- { discard_token_location(beginning_debug_location);
- error("Too many lines of grammar for verb. This maximum is built \
-into Inform, so suggest rewriting grammar using general parsing routines");
- return(FALSE);
- }
-
- /* Internally, a line can be up to 3*32 + 1 + 2 = 99 bytes long */
- /* In Glulx, that's 5*32 + 4 = 164 bytes */
-
- mark = grammar_lines_top;
- if (!glulx_mode) {
- if (mark + 100 >= MAX_LINESPACE)
- { discard_token_location(beginning_debug_location);
- memoryerror("MAX_LINESPACE", MAX_LINESPACE);
- }
- }
- else {
- if (mark + 165 >= MAX_LINESPACE)
- { discard_token_location(beginning_debug_location);
- memoryerror("MAX_LINESPACE", MAX_LINESPACE);
- }
- }
-
- Inform_verbs[verbnum].l[line] = mark;
-
- if (!glulx_mode) {
- mark = mark + 2;
- TOKEN_SIZE = 3;
- }
- else {
- mark = mark + 3;
- TOKEN_SIZE = 5;
- }
-
- grammar_token = 0; last_was_slash = TRUE; slash_mode = FALSE;
- no_grammar_lines++;
-
- do
- { get_next_token();
- bytecode = 0; wordcode = 0;
- if ((token_type == SEP_TT) && (token_value == SEMICOLON_SEP))
- { discard_token_location(beginning_debug_location);
- ebf_error("'->' clause", token_text);
- return FALSE;
- }
- if ((token_type == SEP_TT) && (token_value == ARROW_SEP))
- { if (last_was_slash && (grammar_token>0))
- ebf_error("grammar token", token_text);
- break;
- }
-
- if (!last_was_slash) slash_mode = FALSE;
- if ((token_type == SEP_TT) && (token_value == DIVIDE_SEP))
- { if (grammar_version_number == 1)
- error("'/' can only be used with Library 6/3 or later");
- if (last_was_slash)
- ebf_error("grammar token or '->'", token_text);
- else
- { last_was_slash = TRUE;
- slash_mode = TRUE;
- if (((grammar_lines[mark-TOKEN_SIZE]) & 0x0f) != 2)
- error("'/' can only be applied to prepositions");
- grammar_lines[mark-TOKEN_SIZE] |= 0x20;
- continue;
- }
- }
- else last_was_slash = FALSE;
-
- if ((token_type == DQ_TT) || (token_type == SQ_TT))
- { if (grammar_version_number == 1)
- bytecode = make_adjective(token_text);
- else
- { bytecode = 0x42;
- wordcode = dictionary_add(token_text, 8, 0, 0);
- }
- }
- else if ((token_type==DIR_KEYWORD_TT)&&(token_value==NOUN_DK))
- { get_next_token();
- if ((token_type == SEP_TT) && (token_value == SETEQUALS_SEP))
- {
- /* noun = <routine> */
-
- get_next_token();
- if ((token_type != SYMBOL_TT)
- || (stypes[token_value] != ROUTINE_T))
- { discard_token_location(beginning_debug_location);
- ebf_error("routine name after 'noun='", token_text);
- panic_mode_error_recovery();
- return FALSE;
- }
- if (grammar_version_number == 1)
- bytecode
- = 16 + make_parsing_routine(svals[token_value]);
- else
- { bytecode = 0x83;
- wordcode = svals[token_value];
- }
- sflags[token_value] |= USED_SFLAG;
- }
- else
- { put_token_back();
- if (grammar_version_number == 1) bytecode=0;
- else { bytecode = 1; wordcode = 0; }
- }
- }
- else if ((token_type==DIR_KEYWORD_TT)&&(token_value==HELD_DK))
- { if (grammar_version_number==1) bytecode=1;
- else { bytecode=1; wordcode=1; } }
- else if ((token_type==DIR_KEYWORD_TT)&&(token_value==MULTI_DK))
- { if (grammar_version_number==1) bytecode=2;
- else { bytecode=1; wordcode=2; } }
- else if ((token_type==DIR_KEYWORD_TT)&&(token_value==MULTIHELD_DK))
- { if (grammar_version_number==1) bytecode=3;
- else { bytecode=1; wordcode=3; } }
- else if ((token_type==DIR_KEYWORD_TT)&&(token_value==MULTIEXCEPT_DK))
- { if (grammar_version_number==1) bytecode=4;
- else { bytecode=1; wordcode=4; } }
- else if ((token_type==DIR_KEYWORD_TT)&&(token_value==MULTIINSIDE_DK))
- { if (grammar_version_number==1) bytecode=5;
- else { bytecode=1; wordcode=5; } }
- else if ((token_type==DIR_KEYWORD_TT)&&(token_value==CREATURE_DK))
- { if (grammar_version_number==1) bytecode=6;
- else { bytecode=1; wordcode=6; } }
- else if ((token_type==DIR_KEYWORD_TT)&&(token_value==SPECIAL_DK))
- { if (grammar_version_number==1) bytecode=7;
- else { bytecode=1; wordcode=7; } }
- else if ((token_type==DIR_KEYWORD_TT)&&(token_value==NUMBER_DK))
- { if (grammar_version_number==1) bytecode=8;
- else { bytecode=1; wordcode=8; } }
- else if ((token_type==DIR_KEYWORD_TT)&&(token_value==TOPIC_DK))
- { if (grammar_version_number==1)
- error("The 'topic' token is only available if you \
-are using Library 6/3 or later");
- else { bytecode=1; wordcode=9; } }
- else if ((token_type==DIR_KEYWORD_TT)&&(token_value==SCOPE_DK))
- {
- /* scope = <routine> */
-
- get_next_token();
- if (!((token_type==SEP_TT)&&(token_value==SETEQUALS_SEP)))
- { discard_token_location(beginning_debug_location);
- ebf_error("'=' after 'scope'", token_text);
- panic_mode_error_recovery();
- return FALSE;
- }
-
- get_next_token();
- if ((token_type != SYMBOL_TT)
- || (stypes[token_value] != ROUTINE_T))
- { discard_token_location(beginning_debug_location);
- ebf_error("routine name after 'scope='", token_text);
- panic_mode_error_recovery();
- return FALSE;
- }
-
- if (grammar_version_number == 1)
- bytecode = 80 +
- make_parsing_routine(svals[token_value]);
- else { bytecode = 0x85; wordcode = svals[token_value]; }
- sflags[token_value] |= USED_SFLAG;
- }
- else if ((token_type == SEP_TT) && (token_value == SETEQUALS_SEP))
- { discard_token_location(beginning_debug_location);
- error("'=' is only legal here as 'noun=Routine'");
- panic_mode_error_recovery();
- return FALSE;
- }
- else { /* <attribute> or <general-parsing-routine> tokens */
-
- if ((token_type != SYMBOL_TT)
- || ((stypes[token_value] != ATTRIBUTE_T)
- && (stypes[token_value] != ROUTINE_T)))
- { discard_token_location(beginning_debug_location);
- error_named("No such grammar token as", token_text);
- panic_mode_error_recovery();
- return FALSE;
- }
- if (stypes[token_value]==ATTRIBUTE_T)
- { if (grammar_version_number == 1)
- bytecode = 128 + svals[token_value];
- else { bytecode = 4; wordcode = svals[token_value]; }
- }
- else
- { if (grammar_version_number == 1)
- bytecode = 48 +
- make_parsing_routine(svals[token_value]);
- else { bytecode = 0x86; wordcode = svals[token_value]; }
- }
- sflags[token_value] |= USED_SFLAG;
- }
-
- grammar_token++; no_grammar_tokens++;
- if ((grammar_version_number == 1) && (grammar_token > 6))
- { if (grammar_token == 7)
- warning("Grammar line cut short: you can only have up to 6 \
-tokens in any line (unless you're compiling with library 6/3 or later)");
- }
- else
- { if (slash_mode)
- { if (bytecode != 0x42)
- error("'/' can only be applied to prepositions");
- bytecode |= 0x10;
- }
- grammar_lines[mark++] = bytecode;
- if (!glulx_mode) {
- grammar_lines[mark++] = wordcode/256;
- grammar_lines[mark++] = wordcode%256;
- }
- else {
- grammar_lines[mark++] = ((wordcode >> 24) & 0xFF);
- grammar_lines[mark++] = ((wordcode >> 16) & 0xFF);
- grammar_lines[mark++] = ((wordcode >> 8) & 0xFF);
- grammar_lines[mark++] = ((wordcode) & 0xFF);
- }
- }
-
- } while (TRUE);
-
- grammar_lines[mark++] = 15;
- grammar_lines_top = mark;
-
- dont_enter_into_symbol_table = TRUE;
- get_next_token();
- dont_enter_into_symbol_table = FALSE;
-
- if (token_type != DQ_TT)
- { discard_token_location(beginning_debug_location);
- ebf_error("name of new or existing action", token_text);
- panic_mode_error_recovery();
- return FALSE;
- }
-
- { assembly_operand AO = action_of_name(token_text);
- j = AO.value;
- if (j >= ((grammar_version_number==1)?256:4096))
- error_named("This is a fake action, not a real one:", token_text);
- }
-
- reverse_action = FALSE;
- get_next_token();
- if ((token_type == DIR_KEYWORD_TT) && (token_value == REVERSE_DK))
- { if (grammar_version_number == 1)
- error("'reverse' actions can only be used with \
-Library 6/3 or later");
- reverse_action = TRUE;
- }
- else put_token_back();
-
- mark = Inform_verbs[verbnum].l[line];
-
- if (debugfile_switch)
- { debug_file_printf("<table-entry>");
- debug_file_printf("<type>grammar line</type>");
- debug_file_printf("<address>");
- write_debug_grammar_backpatch(mark);
- debug_file_printf("</address>");
- debug_file_printf("<end-address>");
- write_debug_grammar_backpatch(grammar_lines_top);
- debug_file_printf("</end-address>");
- write_debug_locations
- (get_token_location_end(beginning_debug_location));
- debug_file_printf("</table-entry>");
- }
-
- if (!glulx_mode) {
- if (reverse_action)
- j = j + 0x400;
- grammar_lines[mark++] = j/256;
- grammar_lines[mark++] = j%256;
- }
- else {
- grammar_lines[mark++] = ((j >> 8) & 0xFF);
- grammar_lines[mark++] = ((j) & 0xFF);
- grammar_lines[mark++] = (reverse_action ? 1 : 0);
- }
-
- return TRUE;
-}
-
-/* ------------------------------------------------------------------------- */
-/* The Verb directive: */
-/* */
-/* Verb [meta] "word-1" ... "word-n" | = "existing-English-verb" */
-/* | <grammar-line-1> ... <g-line-n> */
-/* */
-/* ------------------------------------------------------------------------- */
-
-extern void make_verb(void)
-{
- /* Parse an entire Verb ... directive. */
-
- int Inform_verb, meta_verb_flag=FALSE, verb_equals_form=FALSE;
-
- char *English_verbs_given[32]; int no_given = 0, i;
-
- directive_keywords.enabled = TRUE;
-
- get_next_token();
-
- if ((token_type == DIR_KEYWORD_TT) && (token_value == META_DK))
- { meta_verb_flag = TRUE;
- get_next_token();
- }
-
- while ((token_type == DQ_TT) || (token_type == SQ_TT))
- { English_verbs_given[no_given++] = token_text;
- get_next_token();
- }
-
- if (no_given == 0)
- { ebf_error("English verb in quotes", token_text);
- panic_mode_error_recovery(); return;
- }
-
- if ((token_type == SEP_TT) && (token_value == SETEQUALS_SEP))
- { verb_equals_form = TRUE;
- get_next_token();
- Inform_verb = get_verb();
- if (Inform_verb == -1) return;
- get_next_token();
- if (!((token_type == SEP_TT) && (token_value == SEMICOLON_SEP)))
- ebf_error("';' after English verb", token_text);
- }
- else
- { Inform_verb = no_Inform_verbs;
- if (no_Inform_verbs == MAX_VERBS)
- memoryerror("MAX_VERBS",MAX_VERBS);
- }
-
- for (i=0; i<no_given; i++)
- { dictionary_add(English_verbs_given[i],
- 0x41 + ((meta_verb_flag)?0x02:0x00),
- (glulx_mode)?(0xffff-Inform_verb):(0xff-Inform_verb), 0);
- register_verb(English_verbs_given[i], Inform_verb);
- }
-
- if (!verb_equals_form)
- { int lines = 0;
- put_token_back();
- while (grammar_line(no_Inform_verbs, lines++)) ;
- Inform_verbs[no_Inform_verbs++].lines = --lines;
- }
-
- directive_keywords.enabled = FALSE;
-}
-
-/* ------------------------------------------------------------------------- */
-/* The Extend directive: */
-/* */
-/* Extend | only "verb-1" ... "verb-n" | <grammar-lines> */
-/* | "verb" | "replace" */
-/* | "first" */
-/* | "last" */
-/* */
-/* ------------------------------------------------------------------------- */
-
-#define EXTEND_REPLACE 1
-#define EXTEND_FIRST 2
-#define EXTEND_LAST 3
-
-extern void extend_verb(void)
-{
- /* Parse an entire Extend ... directive. */
-
- int Inform_verb = -1, k, l, lines, extend_mode;
-
- directive_keywords.enabled = TRUE;
- directives.enabled = FALSE;
-
- get_next_token();
- if ((token_type == DIR_KEYWORD_TT) && (token_value == ONLY_DK))
- { l = -1;
- if (no_Inform_verbs == MAX_VERBS)
- memoryerror("MAX_VERBS", MAX_VERBS);
- while (get_next_token(),
- ((token_type == DQ_TT) || (token_type == SQ_TT)))
- { Inform_verb = get_verb();
- if (Inform_verb == -1) return;
- if ((l!=-1) && (Inform_verb!=l))
- warning_named("Verb disagrees with previous verbs:", token_text);
- l = Inform_verb;
- dictionary_set_verb_number(token_text,
- (glulx_mode)?(0xffff-no_Inform_verbs):(0xff-no_Inform_verbs));
- /* make call to renumber verb in English_verb_list too */
- if (find_or_renumber_verb(token_text, &no_Inform_verbs) == -1)
- warning_named("Verb to extend not found in English_verb_list:",
- token_text);
- }
-
- /* Copy the old Inform-verb into a new one which the list of
- English-verbs given have had their dictionary entries modified
- to point to */
-
- Inform_verbs[no_Inform_verbs] = Inform_verbs[Inform_verb];
- Inform_verb = no_Inform_verbs++;
- }
- else
- { Inform_verb = get_verb();
- if (Inform_verb == -1) return;
- get_next_token();
- }
-
- /* Inform_verb now contains the number of the Inform-verb to extend... */
-
- extend_mode = EXTEND_LAST;
- if ((token_type == SEP_TT) && (token_value == TIMES_SEP))
- put_token_back();
- else
- { extend_mode = 0;
- if ((token_type == DIR_KEYWORD_TT) && (token_value == REPLACE_DK))
- extend_mode = EXTEND_REPLACE;
- if ((token_type == DIR_KEYWORD_TT) && (token_value == FIRST_DK))
- extend_mode = EXTEND_FIRST;
- if ((token_type == DIR_KEYWORD_TT) && (token_value == LAST_DK))
- extend_mode = EXTEND_LAST;
-
- if (extend_mode==0)
- { ebf_error("'replace', 'last', 'first' or '*'", token_text);
- extend_mode = EXTEND_LAST;
- }
- }
-
- l = Inform_verbs[Inform_verb].lines;
- lines = 0;
- if (extend_mode == EXTEND_LAST) lines=l;
- do
- { if (extend_mode == EXTEND_FIRST)
- for (k=l; k>0; k--)
- Inform_verbs[Inform_verb].l[k+lines]
- = Inform_verbs[Inform_verb].l[k-1+lines];
- } while (grammar_line(Inform_verb, lines++));
-
- if (extend_mode == EXTEND_FIRST)
- { Inform_verbs[Inform_verb].lines = l+lines-1;
- for (k=0; k<l; k++)
- Inform_verbs[Inform_verb].l[k+lines-1]
- = Inform_verbs[Inform_verb].l[k+lines];
- }
- else Inform_verbs[Inform_verb].lines = --lines;
-
- directive_keywords.enabled = FALSE;
- directives.enabled = TRUE;
-}
-
-/* ========================================================================= */
-/* Data structure management routines */
-/* ------------------------------------------------------------------------- */
-
-extern void init_verbs_vars(void)
-{
- no_fake_actions = 0;
- no_actions = 0;
- no_grammar_lines = 0;
- no_grammar_tokens = 0;
- English_verb_list_size = 0;
-
- Inform_verbs = NULL;
- action_byte_offset = NULL;
- grammar_token_routine = NULL;
- adjectives = NULL;
- adjective_sort_code = NULL;
- English_verb_list = NULL;
-
- if (!glulx_mode)
- grammar_version_number = 1;
- else
- grammar_version_number = 2;
-}
-
-extern void verbs_begin_pass(void)
-{
- no_Inform_verbs=0; no_adjectives=0;
- no_grammar_token_routines=0;
- no_actions=0;
-
- no_fake_actions=0;
- grammar_lines_top = 0;
-}
-
-extern void verbs_allocate_arrays(void)
-{
- Inform_verbs = my_calloc(sizeof(verbt), MAX_VERBS, "verbs");
- grammar_lines = my_malloc(MAX_LINESPACE, "grammar lines");
- action_byte_offset = my_calloc(sizeof(int32), MAX_ACTIONS, "actions");
- action_symbol = my_calloc(sizeof(int32), MAX_ACTIONS,
- "action symbols");
- grammar_token_routine = my_calloc(sizeof(int32), MAX_ACTIONS,
- "grammar token routines");
- adjectives = my_calloc(sizeof(int32), MAX_ADJECTIVES,
- "adjectives");
- adjective_sort_code = my_calloc(DICT_WORD_BYTES, MAX_ADJECTIVES,
- "adjective sort codes");
-
- English_verb_list = my_malloc(MAX_VERBSPACE, "register of verbs");
- English_verb_list_top = English_verb_list;
-}
-
-extern void verbs_free_arrays(void)
-{
- my_free(&Inform_verbs, "verbs");
- my_free(&grammar_lines, "grammar lines");
- my_free(&action_byte_offset, "actions");
- my_free(&action_symbol, "action symbols");
- my_free(&grammar_token_routine, "grammar token routines");
- my_free(&adjectives, "adjectives");
- my_free(&adjective_sort_code, "adjective sort codes");
- my_free(&English_verb_list, "register of verbs");
-}
-
-/* ========================================================================= */
projects / inform.git / blobdiff