#define MAX_OBJECTS	400
#define MAX_WORDS	20
#define STACK_SIZE	10
#define VERSION		3
#define RELEASE         0
#define DEFAULT_CONFIG	"\\games\\jacl\\config"

/*#define POWERC*/

#include <stdio.h>
#include <stdlib.h>

#ifdef POWERC

#include <conio.h>
#include <bios.h>

#endif

#ifdef __STDC__

int scope(int index, char *expected);
long value_of(int index);
long attribute_resolve(int wordno);
struct function_type *function_resolve(char *name);
struct variable_type *variable_resolve(int wordno);

#else

int scope();
long value_of();
long attribute_resolve();
struct function_type *function_resolve();
struct variable_type *variable_resolve();

#endif

#define HELD CURRENT_PLAYER->value+MAX_OBJECTS
#define HERE object[CURRENT_PLAYER->value]->location

#define LIMBO	32765
#define SCENERY	100
#define HEAVY	99

#define CURRENT_PLAYER		variable[0]
#define TOTAL_MOVES		variable[1]
#define TURN_WORKED		variable[2]
#define CURRENT_SCORE		variable[3]
#define INTERNAL_VERSION	variable[4]
#define DISPLAY_MODE		variable[5]

#define FALSE	0
#define TRUE	1

#define SEEK_SET	0
#define SEEK_CURRENT	1
#define SEEK_END	2

char current_function[81];
char function_name[81];
char default_function[81];
char before_function[81];
char after_function[81];
char override[81];
char text_buffer[161];
char write_buffer[240];
char last_command[81];
char current_command[81] = "\0";
char *word[MAX_WORDS + 2];
char punctuation[MAX_WORDS + 2];

int wp;
int destination = 1;
int locations, objects;
int it;
int them;
int her;
int him;
int parent;
int stack = 0;
int current_level;
int execution_level;
int custom_error;
int row = 0;
int column = 0;
int noun[4];
int screen_width = 79;
int screen_depth = 25;
int significance = 8;
int variable_contents;
int oec, location_element_contents;
int *object_element_address, *location_element_address;
int *object_backup_address, *location_backup_address;

short int restarting = FALSE;
short int spaced = FALSE;
short int notify = FALSE;
short int object_expected = FALSE;

FILE *file = NULL;

struct stack_type {
    int execution_level;
    int current_level;
    long address;
    char name[81];
};

struct stack_type backup[STACK_SIZE];

struct object_type {
    char label[21];
    char article[11];
    struct name_type *first_name;
    char inventory[41];
    char described[81];
    char described_backup[81];
    char initial[81];
    int location;
    int location_backup;
    long attributes;
    long attributes_backup;
    int info;
    int info_backup;
    int mass;
    int mass_backup;
};

struct object_type *object[MAX_OBJECTS];

struct location_type {
    char label[21];
    long no_go;
    int north;
    int north_backup;
    long go_north;
    long no_north;
    int northeast;
    int northeast_backup;
    long go_northeast;
    long no_northeast;
    int northwest;
    int northwest_backup;
    long go_northwest;
    long no_northwest;
    int south;
    int south_backup;
    long go_south;
    long no_south;
    int southeast;
    int southeast_backup;
    long go_southeast;
    long no_southeast;
    int southwest;
    int southwest_backup;
    long go_southwest;
    long no_southwest;
    int east;
    int east_backup;
    long go_east;
    long no_east;
    int west;
    int west_backup;
    long go_west;
    long no_west;
    int up;
    int up_backup;
    long go_up;
    long no_up;
    int down;
    int down_backup;
    long go_down;
    long no_down;
    int in;
    int in_backup;
    long go_in;
    long no_in;
    int out;
    int out_backup;
    long go_out;
    long no_out;
    long attributes;
    long attributes_backup;
};

struct location_type *location[MAX_OBJECTS];

struct variable_type {
    char name[21];
    int value;
    int value_backup;
    struct variable_type *next_variable;
};

struct variable_type *variable_table = NULL;
struct variable_type *variable[6];

struct function_type {
    char name[81];
    long position;
    struct function_type *next_function;
};

struct function_type *function_table = NULL;

struct word_type {
    char word[21];
    struct word_type *first_child;
    struct word_type *next_sibling;
};

struct word_type *grammar_table = NULL;

struct synonym_type {
    char original[21];
    char standard[21];
    struct synonym_type *next_synonym;
};

struct synonym_type *synonym_table = NULL;

struct name_type {
    char name[21];
    struct name_type *next_name;
};

struct filter_type {
    char word[21];
    struct filter_type *next_filter;
};

struct filter_type *filter_table = NULL;

main(argc, argv)
int argc;
char *argv[];
{
    int index;

    override[0] = 0;
    if ((file = fopen("config", "r")) != NULL)
	read_config_file();
    else if ((file = fopen(DEFAULT_CONFIG, "r")) != NULL)
	read_config_file();

    if (screen_width < 30)
	screen_width = 30;
    if (screen_depth < 10)
	screen_depth = 10;

    if (argc == 1) {
	clrscrn();
	version_info();
	write_text("you are welcome to redistribute it under certain ");
	write_text("conditions, type ~info~ for details.^^");
	printf("ENTER NAME OF GAME FILE: ");
	fgets(text_buffer, 80, stdin);
	strcat(override, text_buffer);
	row = 0;
    } else
	strcat(override, argv[1]);

    if (text_buffer[0] == 10) {
	write_text("ERROR: No data file specified, can't continue.^");
	terminate(1);
    }
    for (index = 0; index < strlen(override); index++) {
	if (override[index] == 10)
	    override[index] = 0;
    }

    if ((file = fopen(override, "r")) == NULL) {
	write_text("ERROR: Unable to open data file ~");
	write_text(override);
	write_text("~, can't continue.^");
	terminate(1);
    }
    read_gamefile();

    if (location[1] == NULL) {
	write_text("ERROR: No locations defined, can't continue.^");
	terminate(1);
    }
    strcpy(function_name, "{global_intro");
    execute(function_name);

    if (object[CURRENT_PLAYER->value] == NULL) {
	write_text("ERROR: Variable CURRENT_PLAYER does not point to an ");
	write_text("object, can't continue.^");
	terminate(1);
    }
    strcpy(function_name, "{global_eachturn");
    execute(function_name);

    do {
	if (TURN_WORKED->value) {
	    TOTAL_MOVES->value++;
	    strcpy(function_name, "{global_eachturn");
	    execute(function_name);
	    if (!check_light(HERE)) {
		strcpy(function_name, "{global_grued");
		if (execute(function_name) == FALSE) {
		    unkfunrun("{global_grued");
		    terminate(0);
		}
	    }
	}
	TURN_WORKED->value = TRUE;
	custom_error = FALSE;
	row = 0;

	newline();
	printf(">");

	strcpy(last_command, current_command);
	fgets(text_buffer, 80, stdin);

	if (feof(stdin)) {
	    write_text("END OF FILE^");
	    terminate(0);
	}
	for (index = 0; index < 80; index++)
	    text_buffer[index] = tolower(text_buffer[index]);

	strcpy(current_command, text_buffer);
	encapsulate();
	truncate();
	if (word[0] != NULL) {
	    if (strcmp(word[0], "undo"))
		save_game_state();
	    word_check();
	} else {
	    write_text("A fiendishly clever move.^");
	    TURN_WORKED->value = FALSE;
	}
    }
    while (TRUE);
}

word_check()
{
    if (!strncmp(word[wp], "quit", significance) || !strncmp(word[wp], "q", significance)) {
	TURN_WORKED->value = FALSE;
	printf("\nAre you sure you want to quit? >");
	fgets(text_buffer, 4, stdin);
	if (text_buffer[0] == 121 || text_buffer[0] == 89) {
	    newline();
	    strcpy(function_name, "{global_score");
	    execute(function_name);
	    terminate(0);
	} else
	    write_text("Returning to game.^");
    } else if (!strncmp(word[wp], "restart", significance)) {
	TURN_WORKED->value = FALSE;
	printf("\nAre you sure you want to restart? >");
	fgets(text_buffer, 4, stdin);
	if (text_buffer[0] == 121 || text_buffer[0] == 89) {
	    write_text("^Restarting...^");
	    restart_game();
	} else
	    write_text("Returning to game.^");
    } else if (!strncmp(word[wp], "again", significance) || !strncmp(word[wp], "g", significance)) {
	if (last_command[0] == 0) {
	    write_text("But you haven't done anything yet!^");
	    TURN_WORKED->value = FALSE;
	} else if (last_command[0] == 10) {
	    write_text("It wasn't so clever as to be worth repeating.^");
	    current_command[0] = 10;
	    TURN_WORKED->value = FALSE;
	} else {
	    strcpy(text_buffer, last_command);
	    strcpy(current_command, last_command);
	    encapsulate();
	    truncate();
	    word_check();
	}
    } else if (!strncmp(word[wp], "save", significance))
	save_game();
    else if (!strncmp(word[wp], "restore", significance))
	restore_game();
    else if (!strncmp(word[wp], "undo", significance)) {
	if (TOTAL_MOVES->value && strncmp(last_command, "undo", 4))
	    restore_game_state();
	else {
	    write_text("Nothing to undo.^");
	    TURN_WORKED->value = FALSE;
	}
    } else if (!strncmp(word[wp], "info", significance)) {
	version_info();
	write_text("you can redistribute it and/or modify it under the ");
	write_text("terms of the GNU General Public License as published by ");
	write_text("the Free Software Foundation; either version 2 of the ");
	write_text("License, or any later version.^^");
	write_text("This program is distributed in the hope that it will be ");
	write_text("useful, but WITHOUT ANY WARRANTY; without even the ");
	write_text("implied warranty of MERCHANTABILITY or FITNESS FOR A ");
	write_text("PARTICULAR PURPOSE. See the GNU General Public License ");
	write_text("for more details.^^");
	write_text("You should have received a copy of the GNU General ");
	write_text("Public License along with this program; if not, write ");
	write_text("to the Free Software Foundation, Inc., 675 Mass Ave, ");
	write_text("Cambridge, MA 02139, USA.^^");
	printf("OBJECTS DEFINED:   %d", objects);
	newline();
	printf("LOCATIONS DEFINED: %d", locations);
	newline();
	TURN_WORKED->value = FALSE;
    } else
	parser();
}

read_config_file()
{
    fgets(text_buffer, 80, file);
    while (!feof(file)) {
	encapsulate();
	if (word[0] == NULL);
	else if (!strcmp(word[0], "columns")) {
	    if (word[1] != NULL)
		screen_width = atoi(word[1]);
	} else if (!strcmp(word[0], "lines")) {
	    if (word[1] != NULL)
		screen_depth = atoi(word[1]);
	} else if (!strcmp(word[0], "spaced")) {
	    spaced = TRUE;
	} else if (!strcmp(word[0], "notify")) {
	    notify = TRUE;
	} else if (!strcmp(word[0], "significance")) {
	    if (word[1] != NULL)
		significance = atoi(word[1]);
	} else if (!strcmp(word[0], "path")) {
	    if (word[1] != NULL)
		strcpy(override, word[1]);
	}
	fgets(text_buffer, 80, file);
    }
    fclose(file);
    file = NULL;
}

version_info()
{
    printf("JACL Engine v%d / r%d ", VERSION, RELEASE);
    printf("/ %d object.", MAX_OBJECTS);
    write_text("^Copyright (C) 1990-1997 Stuart Allen.^^");
    write_text("This program is free software; ");
}

encapsulate()
{
    int index, length;
    int position = 0;
    int new_word = TRUE;

    length = strlen(text_buffer);
    text_buffer[--length] = 0;
    index = 0;

    for (index = 0; index < length; index++) {
	switch (text_buffer[index]) {
	case ',':
	    punctuation[position - 1] = text_buffer[index];
	    text_buffer[index] = 0;
	    new_word = TRUE;
	    break;
	case ':':
	case '\t':
	case ' ':
	    text_buffer[index] = 0;
	    new_word = TRUE;
	    break;
	case ';':
	    text_buffer[index] = 0;
	    index = length;
	    break;
	case '"':
	    index++;
	    if (new_word) {
		word[position] = &text_buffer[index];
		new_word = FALSE;
		if (position < MAX_WORDS) {
		    position++;
		    punctuation[position] = 0;
		}
	    }
	    for (; index < length; index++) {
		if (text_buffer[index] == 34) {
		    text_buffer[index] = 0;
		    new_word = TRUE;
		    break;
		}
	    }
	    break;
	default:
	    if (new_word) {
		word[position] = &text_buffer[index];
		new_word = FALSE;
		if (position < MAX_WORDS) {
		    position++;
		    punctuation[position] = 0;
		}
	    }
	    break;
	}

    }
    word[position] = NULL;
    wp = 0;
}

truncate()
{
    int index, counter, match;
    int position = 0;

    struct synonym_type *synonym;
    struct filter_type *filter = filter_table;

    if (filter != NULL) {
	while (word[position] != NULL) {
	    match = FALSE;
	    do {
		if (!strncmp(word[position], filter->word, significance)) {
		    for (index = position; word[index + 1] != NULL; index++) {
			word[index] = word[index + 1];
			punctuation[index] = punctuation[index + 1];
		    }
		    word[index] = NULL;
		    punctuation[index] = 0;
		    match = TRUE;
		}
		filter = filter->next_filter;
	    }
	    while (filter != NULL && !match);
	    filter = filter_table;
	    if (!match)
		position++;
	};
    }
    if (synonym_table != NULL) {
	for (counter = 0; word[counter] != NULL; counter++) {
	    synonym = synonym_table;
	    do {
		if (!strncmp(word[counter], synonym->original, significance)) {
		    word[counter] = synonym->standard;
		    break;
		}
		if (synonym->next_synonym != NULL)
		    synonym = synonym->next_synonym;
		else
		    break;
	    }
	    while (TRUE);
	}
    }
}

parser()
{
    struct word_type *pointer;

    int index;
    int current_noun = -1;

    noun[0] = FALSE;
    noun[1] = FALSE;

    if (grammar_table != NULL) {
	pointer = grammar_table;
	while (word[wp] != NULL) {
	    object_expected = FALSE;
	    do {
		if (!strncmp(word[wp], pointer->word, significance)) {
		    if (pointer->first_child == NULL) {
			write_text("ERROR: Incomplete grammar statement.^");
			return;
		    } else {
			pointer = pointer->first_child;
			wp++;
			break;
		    }
		} else if (pointer->word[0] == '*' && (index = noun_resolve(pointer))) {
		    noun[++current_noun] = index;
		    if (position(noun[current_noun], pointer->word)) {
			if (pointer->first_child == NULL) {
			    write_text("ERROR: Incomplete grammar statement.^");
			    return;
			} else {
			    pointer = pointer->first_child;
			    wp++;
			    break;
			}
		    } else {
			TURN_WORKED->value = FALSE;
			return;
		    }
		} else {
		    if (custom_error == TRUE) {
			TURN_WORKED->value = FALSE;
			return;
		    } else if (pointer->next_sibling != NULL)
			pointer = pointer->next_sibling;
		    else {
			diagnose();
			return;
		    }
		}
	    }
	    while (TRUE);
	};

	do {
	    if (!strncmp(pointer->word, "->", 2)) {
		strcpy(function_name, "{");
		strcat(function_name, pointer->word + 2);
		strcat(function_name, "_");
		strcpy(override, function_name);
		strcpy(before_function, "{global_before_");
		strcat(before_function, pointer->word + 2);
		strcpy(after_function, "{global_after_");
		strcat(after_function, pointer->word + 2);
		strcpy(default_function, "{global_default_");
		strcat(default_function, pointer->word + 2);
		if (execute(before_function) != FALSE)
		    return;
		if (noun[0] == FALSE) {
		    strcat(function_name, location[HERE]->label);
		    if (execute(function_name) == FALSE) {
			strcat(override, "override_");
			strcat(override, location[HERE]->label);
			strcpy(function_name, "{global_");
			strcat(function_name, pointer->word + 2);
			if (execute(function_name) == FALSE)
			    unkfunrun(function_name);
		    }
		} else if (noun[1] == FALSE) {
		    strcat(function_name, object[noun[0]]->label);
		    if (execute(function_name) == FALSE) {
			strcat(override, "override_");
			strcat(override, object[noun[0]]->label);
			strcpy(function_name, "{global_");
			strcat(function_name, pointer->word + 2);
			if (execute(function_name) == FALSE)
			    unkfunrun(function_name);
		    }
		} else {
		    strcat(function_name, object[noun[1]]->label);
		    strcat(function_name, "_");
		    strcat(function_name, object[noun[0]]->label);
		    if (execute(function_name) == FALSE) {
			strcat(override, object[noun[1]]->label);
			strcat(override, "_override_");
			strcat(override, object[noun[0]]->label);
			strcpy(function_name, "{global_");
			strcat(function_name, pointer->word + 2);
			if (execute(function_name) == FALSE)
			    unkfunrun(function_name);
		    }
		}
		execute(after_function);
		return;
	    } else {
		if (pointer->next_sibling == NULL)
		    break;
		else
		    pointer = pointer->next_sibling;
	    }
	}
	while (TRUE);
	diagnose();
	return;
    }
    diagnose();
}

diagnose()
{
    if (custom_error) {
	TURN_WORKED->value = FALSE;
	return;
    }
    if (word[wp] == NULL) {
	write_text("The sentence you typed was incomplete.^");
    } else if (object_expected && wp != 0) {
	write_text("You can't see any such thing.^");
    } else {
	strcpy(write_buffer, "You can't use the word ~");
	strcat(write_buffer, word[wp]);
	strcat(write_buffer, "~ in that context.^");
	write_text(write_buffer);
    }
    TURN_WORKED->value = FALSE;
}

position(index, expected)
int index;
char expected[];
{
    if (!strcmp(expected, "*held")) {
	if (object[index]->location == HELD)
	    return (TRUE);
	else {
	    strcpy(write_buffer, "You are not holding ");
	    sentence_output(index, 0);
	    strcat(write_buffer, ".^");
	    write_text(write_buffer);
	    return (FALSE);
	}
    } else if (!strcmp(expected, "*here")) {
	if (object[index]->location == HERE)
	    return (TRUE);
	else if (object[index]->location == HELD) {
	    strcpy(write_buffer, "That will be a bit hard while you're holding ");
	    sentence_output(index, 0);
	    strcat(write_buffer, ".^");
	    write_text(write_buffer);
	    return (FALSE);
	} else if (find_parent(index)) {
	    if (object[parent]->attributes & 32) {
		strcpy(write_buffer, "You don't see ");
		sentence_output(index, 0);
		strcat(write_buffer, " here.^");
		write_text(write_buffer);
		return (FALSE);
	    } else if (object[parent]->attributes & 2097152) {
		write_buffer[0] = 0;
		sentence_output(parent, 1);
		strcat(write_buffer, " currently has ");
		sentence_output(index, 0);
		strcat(write_buffer, ".^");
		write_text(write_buffer);
		return (FALSE);
	    } else
		return (TRUE);
	} else {
	    strcpy(write_buffer, "You don't see ");
	    sentence_output(index, 0);
	    strcat(write_buffer, " here.^");
	    write_text(write_buffer);
	    return (FALSE);
	}
    } else if (!strcmp(expected, "*anywhere"))
	return (TRUE);
    else {
	if (object[index]->location == HERE || object[index]->location == HELD)
	    return (TRUE);
	else if (find_parent(index)) {
	    if (object[parent]->attributes & 32) {
		strcpy(write_buffer, "You don't see ");
		sentence_output(index, 0);
		strcat(write_buffer, " here.^");
		write_text(write_buffer);
		return (FALSE);
	    } else if (object[parent]->attributes & 2097152 && !strcmp(expected, "*present")) {
		write_buffer[0] = 0;
		sentence_output(parent, 1);
		strcat(write_buffer, " currently has ");
		sentence_output(index, 0);
		strcat(write_buffer, ".^");
		write_text(write_buffer);
		return (FALSE);
	    } else
		return (TRUE);
	} else {
	    strcpy(write_buffer, "You don't see ");
	    sentence_output(index, 0);
	    strcat(write_buffer, " here.^");
	    write_text(write_buffer);
	    return (FALSE);
	}
    }
}

scope(index, expected)
int index;
char *expected;
{
    if (!strcmp(expected, "*held")) {
	if (object[index]->location == HELD)
	    return (TRUE);
	else
	    return (FALSE);
    } else if (!strcmp(expected, "*here")) {
	if (object[index]->location == HERE)
	    return (TRUE);
	else if (object[index]->location == HELD)
	    return (FALSE);
	else if (find_parent(index)) {
	    if (object[parent]->attributes & 32)
		return (FALSE);
	    return (TRUE);
	} else
	    return (FALSE);
    } else if (!strcmp(expected, "*anywhere"))
	return (TRUE);
    else {
	if (object[index]->location == HERE || object[index]->location == HELD)
	    return (TRUE);
	else if (find_parent(index)) {
	    if (object[parent]->attributes & 32)
		return (FALSE);
	    return (TRUE);
	} else
	    return (FALSE);
    }
}

save_game()
{
    struct variable_type *current_variable = variable_table;
    FILE *bookmark;
    int index;
    char text_buffer[81];

    if (word[++wp] == NULL)
	strcpy(text_buffer, "bookmark");
    else
	strncpy(text_buffer, word[wp], 80);

    if ((bookmark = fopen(text_buffer, "w")) == NULL) {
	write_text("Error opening save file ~");
	write_text(text_buffer);
	write_text("~.^");
	return;
    }
    do {
	fprintf(bookmark, "%d/", current_variable->value);
	current_variable = current_variable->next_variable;
    }
    while (current_variable != NULL);

    for (index = 1; index <= objects; index++) {
	fprintf(bookmark, "%d/%ld/%d/%d/", object[index]->info, object[index]->attributes, object[index]->location, object[index]->mass);
    }
    for (index = 1; index <= locations; index++) {
	fprintf(bookmark, "%d/%d/%d/%d/%d/", location[index]->in, location[index]->out, location[index]->north, location[index]->south, location[index]->east);
	fprintf(bookmark, "%d/%d/%d/%d/", location[index]->northeast, location[index]->northwest, location[index]->southeast, location[index]->southwest);
	fprintf(bookmark, "%d/%d/%d/%ld/", location[index]->west, location[index]->up, location[index]->down, location[index]->attributes);
    }

    fprintf(bookmark, "\n");

    for (index = 1; index <= objects; index++) {
	strcpy(text_buffer, object[index]->described);
	strcat(text_buffer, "\n");
	fputs(text_buffer, bookmark);
    }

    fclose(bookmark);
    write_text("Game saved.^");
    TURN_WORKED->value = FALSE;
}

save_game_state()
{
    int index;
    struct variable_type *current_variable = variable_table;

    do {
	current_variable->value_backup = current_variable->value;
	current_variable = current_variable->next_variable;
    }
    while (current_variable != NULL);

    for (index = 1; index <= objects; index++) {
	object[index]->info_backup = object[index]->info;
	object[index]->location_backup = object[index]->location;
	object[index]->attributes_backup = object[index]->attributes;
	strcpy(object[index]->described_backup, object[index]->described);
    }
    for (index = 1; index <= locations; index++) {
	location[index]->north_backup = location[index]->north;
	location[index]->northeast_backup = location[index]->northeast;
	location[index]->east_backup = location[index]->east;
	location[index]->southeast_backup = location[index]->southeast;
	location[index]->south_backup = location[index]->south;
	location[index]->southwest_backup = location[index]->southwest;
	location[index]->west_backup = location[index]->west;
	location[index]->northwest_backup = location[index]->northwest;
	location[index]->in_backup = location[index]->in;
	location[index]->out_backup = location[index]->out;
	location[index]->up_backup = location[index]->up;
	location[index]->down_backup = location[index]->down;
	location[index]->attributes_backup = location[index]->attributes;
    }
}

restore_game()
{
    struct variable_type *current_variable = variable_table;
    FILE *bookmark;
    int index, counter;
    char text_buffer[81];

    if (word[++wp] == NULL)
	strcpy(text_buffer, "bookmark");
    else
	strncpy(text_buffer, word[wp], 80);

    if ((bookmark = fopen(text_buffer, "r")) == NULL) {
	write_text("Error opening save file ~");
	write_text(text_buffer);
	write_text("~.^");
	return;
    }
    do {
	fscanf(bookmark, "%d/", &current_variable->value);
	current_variable = current_variable->next_variable;
    }
    while (current_variable != NULL);

    for (index = 1; index <= objects; index++) {
	fscanf(bookmark, "%d/%ld/%d/%d/", &object[index]->info, &object[index]->attributes, &object[index]->location, &object[index]->mass);
    }

    for (index = 1; index <= locations; index++) {
	fscanf(bookmark, "%d/%d/%d/%d/%d/", &location[index]->in, &location[index]->out, &location[index]->north, &location[index]->south, &location[index]->east);
	fscanf(bookmark, "%d/%d/%d/%d/", &location[index]->northeast, &location[index]->northwest, &location[index]->southeast, &location[index]->southwest);
	fscanf(bookmark, "%d/%d/%d/%ld/", &location[index]->west, &location[index]->up, &location[index]->down, &location[index]->attributes);
    }

    fscanf(bookmark, "\n");

    for (index = 1; index <= objects; index++) {
	fgets(object[index]->described, 80, bookmark);
	for (counter = 0; counter < strlen(object[index]->described); counter++) {
	    if (object[index]->described[counter] == 10) {
		object[index]->described[counter] = 0;
		break;
	    }
	}
    }

    fclose(bookmark);
    write_text("Game restored.^^");
    location[HERE]->attributes &= ~1L;
    display();
    TURN_WORKED->value = FALSE;
}

restore_game_state()
{
    int index;
    struct variable_type *current_variable = variable_table;

    do {
	current_variable->value = current_variable->value_backup;
	current_variable = current_variable->next_variable;
    }
    while (current_variable != NULL);

    for (index = 1; index <= objects; index++) {
	object[index]->info = object[index]->info_backup;
	object[index]->location = object[index]->location_backup;
	object[index]->attributes = object[index]->attributes_backup;
	strcpy(object[index]->described, object[index]->described_backup);
    }

    for (index = 1; index <= locations; index++) {
	location[index]->north = location[index]->north_backup;
	location[index]->northeast = location[index]->northeast_backup;
	location[index]->east = location[index]->east_backup;
	location[index]->southeast = location[index]->southeast_backup;
	location[index]->south = location[index]->south_backup;
	location[index]->southwest = location[index]->southwest_backup;
	location[index]->west = location[index]->west_backup;
	location[index]->northwest = location[index]->northwest_backup;
	location[index]->in = location[index]->in_backup;
	location[index]->out = location[index]->out_backup;
	location[index]->up = location[index]->up_backup;
	location[index]->down = location[index]->down_backup;
	location[index]->attributes = location[index]->attributes_backup;
    }
    write_text("Previous move undone.^^");
    location[HERE]->attributes &= ~1L;
    display();
    TURN_WORKED->value = FALSE;
}

display()
{
    int index;

    strcpy(function_name, "{global_title");
    execute(function_name);

    if (DISPLAY_MODE->value)
        location[HERE]->attributes &= ~1L;
    
    strcpy(function_name, "{look_");
    strcat(function_name, location[HERE]->label);
    execute(function_name);
    location[HERE]->attributes = location[HERE]->attributes | 1;

    for (index = 1; index <= objects; index++) {
	if (object[index]->location == HERE && object[index]->mass < SCENERY) {
	    if (object[index]->attributes & 8388608 || object[index]->initial[0] == 0) {

		if (spaced)
		    newline();
		write_text(object[index]->described);
	    } else {
		if (spaced)
		    newline();
		write_text(object[index]->initial);
	    }
	    newline();
	}
    }
}

check_light(where)
int where;
{
    int index;

    if ((location[where]->attributes & 2) == FALSE)
	return (TRUE);
    else {
	for (index = 1; index <= objects; index++) {
	    if ((object[index]->attributes & 64) && scope(index, "*present"))
		return (TRUE);
	}
    }
    return (FALSE);
}

move_player(go_pointer, no_pointer)
long go_pointer;
long no_pointer;
{
    strcpy(function_name, "{global_movement");
    if (execute(function_name) == TRUE) {
	TURN_WORKED->value = FALSE;
	return (FALSE);
    }
    if (destination) {
	if (check_light(destination)) {
	    if (go_pointer != 0) {
		fseek(file, go_pointer, SEEK_SET);
		fgets(text_buffer, 160, file);
		encapsulate();
		if (word[1] != NULL) {
		    write_text(word[1]);
		    newline();
		    newline();
		}
	    }
	    HERE = destination;
	    display();
	} else {
	    write_text("It's dark ");
	    if (location[HERE]->attributes & 32)
		write_text("out");
	    else
		write_text("in");
	    write_text(" there, you'll need a light.^");
	    TURN_WORKED->value = FALSE;
	}
    } else {
	TURN_WORKED->value = FALSE;
	if (no_pointer != 0) {
	    fseek(file, no_pointer, SEEK_SET);
	    fgets(text_buffer, 160, file);
	    encapsulate();
	    if (word[1] != NULL) {
		write_text(word[1]);
		newline();
	    } else
		write_text("You can't go that way.^");
	} else if (location[HERE]->no_go != 0) {
	    fseek(file, location[HERE]->no_go, SEEK_SET);
	    fgets(text_buffer, 160, file);
	    encapsulate();
	    if (word[1] != NULL) {
		write_text(word[1]);
		newline();
	    } else
		write_text("You can't go that way.^");
	} else
	    write_text("You can't go that way.^");
    }
}

find_parent(index)
int index;
{
    if ((object[index]->location > MAX_OBJECTS) && (object[index]->location < (MAX_OBJECTS * 2))) {
	parent = object[index]->location - MAX_OBJECTS;
	if (object[parent]->location == HELD || object[parent]->location == HERE) {
	    if (object[parent]->attributes & 1)
		return (FALSE);
	    else
		return (TRUE);
	} else {
	    if (object[parent]->attributes & 1)
		return (FALSE);
	    else
		return (find_parent(parent));
	}
    } else
	return (FALSE);
}

sentence_output(index, capital)
int index;
int capital;
{
    char text_buffer[52];

    if (!strcmp(object[index]->article, "name")) {
	strcpy(text_buffer, object[index]->inventory);
    } else {
	strcpy(text_buffer, "the");
	strcat(text_buffer, " ");
	strcat(text_buffer, object[index]->inventory);
    }

    if (capital)
	text_buffer[0] = toupper(text_buffer[0]);
    strcat(write_buffer, text_buffer);
}

isnt_output(index)
int index;
{
    if (object[index]->attributes & 16384)
	strcat(write_buffer, " aren't");
    else
	strcat(write_buffer, " isn't");
}

is_output(index)
int index;
{
    if (object[index]->attributes & 16384)
	strcat(write_buffer, " are");
    else
	strcat(write_buffer, " is");
}

doesnt_output(index)
int index;
{
    if (object[index]->attributes & 16384)
	strcat(write_buffer, " don't ");
    else
	strcat(write_buffer, " doesn't ");
}

does_output(index)
int index;
{
    if (object[index]->attributes & 16384)
	strcat(write_buffer, " do ");
    else
	strcat(write_buffer, " does ");
}

list_output(index, capital)
int index;
int capital;
{
    char text_buffer[52];

    if (!strcmp(object[index]->article, "name")) {
	strcpy(text_buffer, object[index]->inventory);
    } else {
	strcpy(text_buffer, object[index]->article);
	strcat(text_buffer, " ");
	strcat(text_buffer, object[index]->inventory);
    }

    if (capital)
	text_buffer[0] = toupper(text_buffer[0]);
    strcat(write_buffer, text_buffer);
}

terminate(code)
int code;
{
    write_text("^---JACL ENGINE TERMINATED---^^^");
    more();
    if (file != NULL)
	fclose(file);
    exit(code);
}

execute(funcname)
char *funcname;
{
    char subfunc[81];

    int index, to, from;
    int counter = 0;
    int *container;
    int contents;

    long top_of_loop = FALSE;
    long go_pointer;
    long no_pointer;

    long bit_mask;

    struct function_type *resolved_function;
    struct variable_type *resolved_variable;
    struct name_type *current_name;

    char temporary_buffer[161];
    char variable_buffer[16];

    resolved_function = function_resolve(funcname);

    if (resolved_function == NULL)
	return (FALSE);

    execution_level = 0;
    current_level = 0;
    strcpy(current_function, funcname);

    fseek(file, resolved_function->position, SEEK_SET);
    fgets(text_buffer, 160, file);

    while (text_buffer[0] != 125) {
	encapsulate();
	if (word[0] == NULL);
	else if (!strcmp(word[0], "endif")) {
	    current_level--;
	    if (current_level < execution_level)
		execution_level = current_level;
	} else if (!strcmp(word[0], "endall")) {
	    current_level = 0;
	    execution_level = 0;
	} else if (!strcmp(word[0], "else")) {
	    if (current_level == execution_level)
		execution_level--;
	    else if (current_level == execution_level + 1) 
		execution_level++;
	} else if (current_level == execution_level) {
	    if (!strcmp(word[0], "more"))
		more();
	    else if (!strcmp(word[0], "look")) {
		push_stack(ftell(file));
		location[HERE]->attributes &= ~1L;
		display();
		pop_stack();
	    } else if (!strcmp(word[0], "endgame")) {
		while (TRUE) {
		    write_text("^Please type S to start again, Q to quit ");
		    write_text("or U to undo >");
		    row = 0;
		    fgets(text_buffer, 4, stdin);
		    if (text_buffer[0] == 'U' || text_buffer[0] == 'u') {
			restore_game_state();
			return (TRUE);
		    } else if (text_buffer[0] == 'Q' || text_buffer[0] == 'q')
			terminate(0);
		    else if (text_buffer[0] == 'S' || text_buffer[0] == 's') {
			write_text("^Restarting...^");
			restart_game();
			return (TRUE);
		    }
		};
	    } else if (!strcmp(word[0], "loop")) {
		top_of_loop = ftell(file);
		noun[2] = 1;
	    } else if (!strcmp(word[0], "endloop")) {
		if (top_of_loop == FALSE)
		    printf("ERROR: In function \"%s\", endloop command without loop command.", funcname);
		else {
		    noun[2]++;
		    if (noun[2] > objects) {
			top_of_loop = FALSE;
			noun[2] = FALSE;
		    } else
			fseek(file, top_of_loop, SEEK_SET);
		}
	    } else if (!strcmp(word[0], "proxy")) {
		push_stack(ftell(file));
		temporary_buffer[0] = 0;
		for (counter = 1; word[counter] != NULL; counter++) {
		    if (!strcmp(word[counter], "noun1")) {
			current_name = object[noun[0]]->first_name;
			while (current_name != NULL) {
			    strcat(temporary_buffer, " ");
			    strcat(temporary_buffer, current_name->name);
			    current_name = current_name->next_name;
			}
		    } else if (!strcmp(word[counter], "noun2")) {
			current_name = object[noun[1]]->first_name;
			while (current_name != NULL) {
			    strcat(temporary_buffer, " ");
			    strcat(temporary_buffer, current_name->name);
			    current_name = current_name->next_name;
			}
		    } else if (!strcmp(word[counter], "noun3")) {
			current_name = object[noun[2]]->first_name;
			while (current_name != NULL) {
			    strcat(temporary_buffer, " ");
			    strcat(temporary_buffer, current_name->name);
			    current_name = current_name->next_name;
			}
		    } else if (!strcmp(word[counter], "noun4")) {
			current_name = object[noun[3]]->first_name;
			while (current_name != NULL) {
			    strcat(temporary_buffer, " ");
			    strcat(temporary_buffer, current_name->name);
			    current_name = current_name->next_name;
			}
		    } else
			strcat(temporary_buffer, word[counter]);
		}
		strcat(temporary_buffer, "\n");
		strcpy(text_buffer, temporary_buffer);
		encapsulate();
		truncate();
		word_check();
		pop_stack();
	    } else if (!strcmp(word[0], "override")) {
		push_stack(ftell(file));
		if (execute(override) == TRUE) {
		    pop_stack();
		    return (TRUE);
		} else {
		    if (execute(default_function) == TRUE) {
			pop_stack();
			return (TRUE);
		    } else {
			pop_stack();
		    }
		}
	    } else if (!strcmp(word[0], "execute")) {
		if (word[1] == NULL)
		    noproprun();
		else {
		    strcpy(subfunc, "{");
		    strcat(subfunc, word[1]);
		    push_stack(ftell(file));
		    if (execute(subfunc) == FALSE) {
			printf("ERROR: In function \"%s\", attempt to execute undefined function \"%s\".\n", funcname, subfunc);
		    }
		    pop_stack();
		}
	    } else if (!strcmp(word[0], "terminate"))
		terminate(0);
	    else if (!strcmp(word[0], "points")) {
		if (word[1] != NULL) {
		    CURRENT_SCORE->value = CURRENT_SCORE->value + atoi(word[1]);
		    if (notify) {
			strcpy(write_buffer, "^[YOUR SCORE JUST WENT UP BY ");
			strcat(write_buffer, word[1]);
			if (atoi(word[1]) == 1)
			    strcat(write_buffer, " POINT]^");
			else
			    strcat(write_buffer, " POINTS]^");
			write_text(write_buffer);
		    }
		} else
		    noproprun();
	    } else if (!strcmp(word[0], "right")) {
		if (word[1] != NULL) {
		    write_right(word[1]);
		    newline();
		} else
		    noproprun();
	    } else if (!strcmp(word[0], "centre")) {
		if (word[1] != NULL) {
		    write_centred(word[1]);
		    newline();
		} else
		    noproprun();
	    } else if (!strcmp(word[0], "write")) {
		write_buffer[0] = 0;
		for (counter = 1; word[counter] != NULL; counter++) {
		    if (!strcmp(word[counter], "noun1")) {
			if (noun[0] != 0)
			    sentence_output(noun[0], 0);
		    } else if (!strcmp(word[counter], "noun1(inventory)")) {
			if (noun[0] != 0)
			    list_output(noun[0], 0);
		    } else if (!strcmp(word[counter], "noun1(does)")) {
			if (noun[0] != 0)
			    does_output(noun[0]);
		    } else if (!strcmp(word[counter], "noun1(doesnt)")) {
			if (noun[0] != 0)
			    doesnt_output(noun[0]);
		    } else if (!strcmp(word[counter], "noun1(s)")) {
			if (noun[0] != 0) {
			    if (!(object[noun[0]]->attributes & 16384))
				strcat(write_buffer, "s");
			}
		    } else if (!strcmp(word[counter], "noun1(is)")) {
			if (noun[0] != 0)
			    is_output(noun[0]);
		    } else if (!strcmp(word[counter], "noun1(isnt)")) {
			if (noun[0] != 0)
			    isnt_output(noun[0]);
		    } else if (!strcmp(word[counter], "Noun1(inventory)")) {
			if (noun[0] != 0)
			    list_output(noun[0], 1);
		    } else if (!strcmp(word[counter], "Noun1")) {
			if (noun[0] != 0)
			    sentence_output(noun[0], 1);
		    } else if (!strcmp(word[counter], "noun2")) {
			if (noun[1] != 0)
			    sentence_output(noun[1], 0);
		    } else if (!strcmp(word[counter], "noun2(inventory)")) {
			if (noun[1] != 0)
			    list_output(noun[1], 0);
		    } else if (!strcmp(word[counter], "noun2(does)")) {
			if (noun[1] != 0)
			    does_output(noun[1]);
		    } else if (!strcmp(word[counter], "noun2(doesnt)")) {
			if (noun[1] != 0)
			    doesnt_output(noun[1]);
		    } else if (!strcmp(word[counter], "noun2(s)")) {
			if (noun[1] != 0) {
			    if (!(object[noun[1]]->attributes & 16384))
				strcat(write_buffer, "s");
			}
		    } else if (!strcmp(word[counter], "noun2(is)")) {
			if (noun[1] != 0)
			    is_output(noun[1]);
		    } else if (!strcmp(word[counter], "noun2(isnt)")) {
			if (noun[1] != 0)
			    isnt_output(noun[1]);
		    } else if (!strcmp(word[counter], "Noun2(inventory)")) {
			if (noun[1] != 0)
			    list_output(noun[1], 1);
		    } else if (!strcmp(word[counter], "Noun2")) {
			if (noun[1] != 0)
			    sentence_output(noun[1], 1);
		    } else if (!strcmp(word[counter], "noun3")) {
			if (noun[2] != 0)
			    sentence_output(noun[2], 0);
		    } else if (!strcmp(word[counter], "noun3(inventory)")) {
			if (noun[2] != 0)
			    list_output(noun[2], 0);
		    } else if (!strcmp(word[counter], "noun3(does)")) {
			if (noun[2] != 0)
			    does_output(noun[2]);
		    } else if (!strcmp(word[counter], "noun3(doesnt)")) {
			if (noun[2] != 0)
			    doesnt_output(noun[2]);
		    } else if (!strcmp(word[counter], "noun3(s)")) {
			if (noun[2] != 0) {
			    if (!(object[noun[2]]->attributes & 16384))
				strcat(write_buffer, "s");
			}
		    } else if (!strcmp(word[counter], "noun3(is)")) {
			if (noun[2] != 0)
			    is_output(noun[2]);
		    } else if (!strcmp(word[counter], "noun3(isnt)")) {
			if (noun[2] != 0)
			    isnt_output(noun[2]);
		    } else if (!strcmp(word[counter], "Noun3(inventory)")) {
			if (noun[2] != 0)
			    list_output(noun[2], 1);
		    } else if (!strcmp(word[counter], "Noun3")) {
			if (noun[2] != 0)
			    sentence_output(noun[2], 1);
		    } else if (!strcmp(word[counter], "noun4")) {
			if (noun[3] != 0)
			    sentence_output(noun[3], 0);
		    } else if (!strcmp(word[counter], "noun4(inventory)")) {
			if (noun[3] != 0)
			    list_output(noun[3], 0);
		    } else if (!strcmp(word[counter], "noun4(does)")) {
			if (noun[3] != 0)
			    does_output(noun[3]);
		    } else if (!strcmp(word[counter], "noun4(doesnt)")) {
			if (noun[3] != 0)
			    doesnt_output(noun[3]);
		    } else if (!strcmp(word[counter], "noun4(s)")) {
			if (noun[3] != 0) {
			    if (!(object[noun[3]]->attributes & 16384))
				strcat(write_buffer, "s");
			}
		    } else if (!strcmp(word[counter], "noun4(is)")) {
			if (noun[3] != 0)
			    is_output(noun[3]);
		    } else if (!strcmp(word[counter], "noun4(isnt)")) {
			if (noun[3] != 0)
			    isnt_output(noun[3]);
		    } else if (!strcmp(word[counter], "Noun4(inventory)")) {
			if (noun[3] != 0)
			    list_output(noun[3], 1);
		    } else if (!strcmp(word[counter], "Noun4")) {
			if (noun[3] != 0)
			    sentence_output(noun[3], 1);
		    } else if ((resolved_variable = variable_resolve(counter)) != NULL) {
			variable_buffer[0] = 0;
			sprintf(variable_buffer, "%d", resolved_variable->value);
			strcat(write_buffer, variable_buffer);
		    } else
			strcat(write_buffer, word[counter]);
		}
		write_text(write_buffer);
	    } else if (!strcmp(word[0], "break")) {
		if (word[1] == NULL)
		    return (TRUE);
		else if (!strcmp(word[1], "false"))
		    return (FALSE);
		else
		    return (TRUE);
	    } else if (!strcmp(word[0], "clear"))
		clrscrn();
	    else if (!strcmp(word[0], "describe")) {
		if (word[1] == NULL)
		    noproprun();
		else if (index = object_resolve(1)) {
		    if (word[3] == NULL)
			noproprun();
		    else {
			strncpy(object[index]->described, word[3], 80);
			object[index]->described[80] = 0;
		    }
		} else
		    unkobjrun(1);
	    } else if (!strcmp(word[0], "set")) {
		if (word[3] == NULL)
		    noproprun();
		else if ((resolved_variable = variable_resolve(1)) != NULL)
		    container = &resolved_variable->value;
		else if (location_element_resolve(1))
		    container = location_element_address;
		else if (object_element_resolve(1))
		    container = object_element_address;
		else if (!strcmp(word[1], "noun1"))
		    container = &noun[0];
		else if (!strcmp(word[1], "noun2"))
		    container = &noun[1];
		else if (!strcmp(word[1], "noun3"))
		    container = &noun[2];
		else if (!strcmp(word[1], "noun4"))
		    container = &noun[3];
		else
		    unkvarrun(1);
		contents = value_of(3);
		if (!strcmp(word[2], "+"))
		    *container += contents;
		else if (!strcmp(word[2], "-"))
		    *container -= contents;
		else if (!strcmp(word[2], "*"))
		    *container = *container * contents;
		else if (!strcmp(word[2], "/"))
		    *container = *container / contents;
		else if (!strcmp(word[2], "="))
		    *container = contents;
		else if (!strcmp(word[2], "parentof")) {
		    if (object[contents]->location > MAX_OBJECTS)
			*container = object[contents]->location - MAX_OBJECTS;
		    else
			*container = 0;
		} else
		    printf("ERROR: Illegal operator \"%s\".", word[2]);
	    } else if (!strcmp(word[0], "ensure")) {
		if (word[3] == NULL)
		    noproprun();
		else {
		    if (bit_mask = attribute_resolve(3)) {
			if (index = object_resolve(1)) {
			    if (!strcmp(word[2], "has")) {
				object[index]->attributes = object[index]->attributes | bit_mask;
			    } else if (!strcmp(word[2], "hasnt")) {
				bit_mask = ~bit_mask;
				object[index]->attributes = object[index]->attributes & bit_mask;
			    }
			} else if (index = location_resolve(1)) {
			    if (!strcmp(word[2], "has")) {
				location[index]->attributes = location[index]->attributes | bit_mask;
			    } else if (!strcmp(word[2], "hasnt")) {
				bit_mask = ~bit_mask;
				location[index]->attributes = location[index]->attributes & bit_mask;
			    }
			}
		    } else {
			printf("ERROR: Unknown attribute \"%s\".\n", word[3]);
		    }
		}
	    } else if (!strcmp(word[0], "move")) {
		if (word[3] == NULL)
		    noproprun();
		else if (!strcmp(word[1], "player")) {
		    push_stack(ftell(file), funcname);
		    if (!strcmp(word[3], "north")) {
			destination = location[HERE]->north;
			go_pointer = location[HERE]->go_north;
			no_pointer = location[HERE]->no_north;
			move_player(go_pointer, no_pointer);
		    } else if (!strcmp(word[3], "northeast")) {
			destination = location[HERE]->northeast;
			go_pointer = location[HERE]->go_northeast;
			no_pointer = location[HERE]->no_northeast;
			move_player(go_pointer, no_pointer);
		    } else if (!strcmp(word[3], "northwest")) {
			destination = location[HERE]->northwest;
			go_pointer = location[HERE]->go_northwest;
			no_pointer = location[HERE]->no_northwest;
			move_player(go_pointer, no_pointer);
		    } else if (!strcmp(word[3], "south")) {
			destination = location[HERE]->south;
			go_pointer = location[HERE]->go_south;
			no_pointer = location[HERE]->no_south;
			move_player(go_pointer, no_pointer);
		    } else if (!strcmp(word[3], "southeast")) {
			destination = location[HERE]->southeast;
			go_pointer = location[HERE]->go_southeast;
			no_pointer = location[HERE]->no_southeast;
			move_player(go_pointer, no_pointer);
		    } else if (!strcmp(word[3], "southwest")) {
			destination = location[HERE]->southwest;
			go_pointer = location[HERE]->go_southwest;
			no_pointer = location[HERE]->no_southwest;
			move_player(go_pointer, no_pointer);
		    } else if (!strcmp(word[3], "east")) {
			destination = location[HERE]->east;
			go_pointer = location[HERE]->go_east;
			no_pointer = location[HERE]->no_east;
			move_player(go_pointer, no_pointer);
		    } else if (!strcmp(word[3], "west")) {
			destination = location[HERE]->west;
			go_pointer = location[HERE]->go_west;
			no_pointer = location[HERE]->no_west;
			move_player(go_pointer, no_pointer);
		    } else if (!strcmp(word[3], "up")) {
			destination = location[HERE]->up;
			go_pointer = location[HERE]->go_up;
			no_pointer = location[HERE]->no_up;
			move_player(go_pointer, no_pointer);
		    } else if (!strcmp(word[3], "down")) {
			destination = location[HERE]->down;
			go_pointer = location[HERE]->go_down;
			no_pointer = location[HERE]->no_down;
			move_player(go_pointer, no_pointer);
		    } else if (!strcmp(word[3], "in")) {
			destination = location[HERE]->in;
			go_pointer = location[HERE]->go_in;
			no_pointer = location[HERE]->no_in;
			move_player(go_pointer, no_pointer);
		    } else if (!strcmp(word[3], "out")) {
			destination = location[HERE]->out;
			go_pointer = location[HERE]->go_out;
			no_pointer = location[HERE]->no_out;
			move_player(go_pointer, no_pointer);
		    } else {
			unklocrun(3);
		    }
		    pop_stack();
		} else if (index = object_resolve(1)) {
		    from = object[index]->location;
		    if (from > MAX_OBJECTS && from != LIMBO) {
			object[from - MAX_OBJECTS]->info += object[index]->mass;
		    }
		    if (to = location_resolve(3))
			object[index]->location = to;
		    else if (location_element_resolve(3))
			object[index]->location = location_element_contents;
		    else if (to = object_resolve(3)) {
			object[index]->location = to + MAX_OBJECTS;
			object[to]->info -= object[index]->mass;
		    } else if (!strcmp(word[3], "limbo"))
			object[index]->location = LIMBO;
		    else
			unklocrun(3);
		} else
		    unkobjrun(1);
	    } else if (!strcmp(word[0], "if")) {
		current_level++;
		if (word[3] == NULL)
		    noproprun(0);
		else if (condition())
		    execution_level++;
	    } else
		printf("ERROR: In function \"%s\", unknown command \"%s\".\n", funcname, word[0]);
	} else if (!strcmp(word[wp], "if"))
	    current_level++;
	fgets(text_buffer, 160, file);
    };
    return (TRUE);
}

pop_stack()
{
    stack--;
    strcpy(current_function, backup[stack].name);
    current_level = backup[stack].current_level;
    execution_level = backup[stack].execution_level;
    fseek(file, backup[stack].address, SEEK_SET);
}

push_stack(file_pointer)
long file_pointer;
{

    if (stack == STACK_SIZE) {
	puts("ERROR: Stack overflow.");
	terminate(1);
    } else {
	strcpy(backup[stack].name, current_function);
	backup[stack].address = file_pointer;
	backup[stack].current_level = current_level;
	backup[stack].execution_level = execution_level;
    }
    stack++;
}

newline()
{
    printf("\n");
    scroll();
}

write_right(string)
char string[];
{
    int index;

    if (strlen(string) > screen_width)
	puts(string);
    else {
	index = (screen_width - strlen(string));
	index -= column;
	if (index < 0)
	    index = 0;
	for (; index != 0; index--)
	    printf(" ");
	printf("%s", string);
    }
}

write_centred(string)
char string[];
{
    int index;

    if (strlen(string) > screen_width)
	puts(string);
    else {
	index = ((screen_width - strlen(string)) / 2);
	for (; index != 0; index--)
	    printf(" ");
	printf("%s", string);
    }
}

write_text(tout_buffer)
char tout_buffer[];
{
    char chunk_buffer[512];
    int counter = 0;
    int index;

    for (index = 0; index < strlen(tout_buffer); index++) {
	if (tout_buffer[index] != '^') {
	    chunk_buffer[counter] = tout_buffer[index];
	    counter++;
	} else {
	    chunk_buffer[counter] = 0;
	    if (chunk_buffer[0] != 0)
		output_text(chunk_buffer);
	    newline();
	    counter = 0;
	}
    }
    chunk_buffer[counter] = 0;
    output_text(chunk_buffer);
}

output_text(string)
char string[];
{
    int index;
    int done = FALSE;
    char text_buffer[512];
    char temporary_buffer[512];
    char *pointer;
    strcpy(text_buffer, string);

    if (strlen(text_buffer) + column < screen_width) {
	if (text_buffer[0] == 32 && column == 0) {
	    pointer = &text_buffer[1];
	    printj(pointer);
	} else
	    printj(text_buffer);
    } else {
	for (index = screen_width - column; index > 0; index--) {
	    if (text_buffer[index] == 32) {
		done = TRUE;
		text_buffer[index] = 0;
		if (text_buffer[0] == 32 && column == 0) {
		    pointer = &text_buffer[1];
		    printj(pointer);
		} else
		    printj(text_buffer);
		newline();
		index++;
		pointer = &text_buffer[index];
		write_text(pointer);
		break;
	    }
	}
	if (done == FALSE) {
	    if (column == 0) {
		strncpy(temporary_buffer, text_buffer, screen_width);
		printj(temporary_buffer);
		newline();
		pointer = &text_buffer[screen_width];
		write_text(pointer);
	    } else {
		newline();
		write_text(text_buffer);
	    }
	}
    }
}

printj(output_string)
char output_string[];
{
    int index;

    for (index = 0; output_string[index] != 0; index++) {
	if (output_string[index] == '~') {
	    printf("\"");
	    column++;
	} else {
	    printf("%c", output_string[index]);
	    column++;
	}
    }
}

scroll()
{
    column = 0;
    row++;

    if (row == screen_depth - 2)
	more();
}

condition()
{
    long compare = 0;
    long index = 0;
    int type = 0;

    struct variable_type *resolved_variable;

    if (word[3] == NULL) {
	noproprun();
	return (FALSE);
    } else
	compare = value_of(3);

    if (index = object_resolve(1))
	type = 1;
    else if (index = location_resolve(1))
	type = 2;
    else if ((resolved_variable = variable_resolve(1)) != NULL)
	index = resolved_variable->value;
    else if (object_element_resolve(1))
	index = oec;
    else if (location_element_resolve(1))
	index = location_element_contents;

    if (!strcmp(word[2], "=")) {
	if (index == compare)
	    return (TRUE);
	else
	    return (FALSE);
    } else if (!strcmp(word[2], ">")) {
	if (index > compare)
	    return (TRUE);
	else
	    return (FALSE);
    } else if (!strcmp(word[2], "<")) {
	if (index < compare)
	    return (TRUE);
	else
	    return (FALSE);
    } else if (!strcmp(word[2], "is")) {
	return (scope(index, word[3]));
    } else if (!strcmp(word[2], "isnt")) {
	return (!scope(index, word[3]));
    } else if (!strcmp(word[2], "has")) {
	if (type == 1)
	    index = object[index]->attributes;
	else if (type == 2)
	    index = location[index]->attributes;
	if (index & compare)
	    return (TRUE);
	else
	    return (FALSE);
    } else if (!strcmp(word[2], "hasnt")) {
	if (type == 1)
	    index = object[index]->attributes;
	else if (type == 2)
	    index = location[index]->attributes;
	if (index & compare)
	    return (FALSE);
	else
	    return (TRUE);
    } else if (!strcmp(word[2], "!=")) {
	if (index != compare)
	    return (TRUE);
	else
	    return (FALSE);
    } else if (!strcmp(word[2], ">=") || !strcmp(word[2], "=>")) {
	if (index >= compare)
	    return (TRUE);
	else
	    return (FALSE);
    } else if (!strcmp(word[2], "<=") || !strcmp(word[2], "=<")) {
	if (index <= compare)
	    return (TRUE);
	else
	    return (FALSE);
    } else if (!strcmp(word[2], "childof")) {
	if (object[index]->location == compare + MAX_OBJECTS)
	    return (TRUE);
	else
	    return (FALSE);
    } else if (!strcmp(word[2], "!childof")) {
	if (object[index]->location != compare + MAX_OBJECTS)
	    return (TRUE);
	else
	    return (FALSE);
    } else if (!strcmp(word[2], "grandof")) {
	find_parent(compare);
	if (parent == index)
	    return (TRUE);
	else
	    return (FALSE);
    } else if (!strcmp(word[2], "!grandof")) {
	find_parent(compare);
	if (parent != index)
	    return (TRUE);
	else
	    return (FALSE);
    } else if (!strcmp(word[2], "parentof")) {
	if (object[index]->location == compare - MAX_OBJECTS)
	    return (TRUE);
	else
	    return (FALSE);
    } else if (!strcmp(word[2], "!parentof")) {
	if (object[index]->location != compare - MAX_OBJECTS)
	    return (TRUE);
	else
	    return (FALSE);
    } else {
	printf("ERROR: In function \"%s\", illegal operand \"%s\".\n", function_name, word[2]);
	return (FALSE);
    }
}

long value_of(index)
int index;
{
    long compare = 0;

    struct variable_type *resolved_variable;

    if (!strcmp(word[index], "objects"))
	return (MAX_OBJECTS);
    else if (!strcmp(word[index], "limbo"))
	return (LIMBO);
    else if (!strcmp(word[index], "scenery"))
	return (SCENERY);
    else if (!strcmp(word[index], "heavy"))
	return (HEAVY);
    else if (!strcmp(word[index], "true"))
	return (TRUE);
    else if (!strcmp(word[index], "false"))
	return (FALSE);
    else if (!strcmp(word[index], "nowhere"))
	return (FALSE);
    else if ((resolved_variable = variable_resolve(index)) != NULL)
	return (resolved_variable->value);
    else if (object_element_resolve(index))
	return (oec);
    else if (location_element_resolve(index))
	return (location_element_contents);
    else if (compare = attribute_resolve(index))
	return (compare);
    else if (compare = object_resolve(index))
	return (compare);
    else if (compare = location_resolve(index))
	return (compare);
    else
	return (atoi(word[index]));
}

struct variable_type *
 variable_resolve(wordno)
int wordno;
{
    struct variable_type *pointer = variable_table;

    do {
	if (!strcmp(word[wordno], pointer->name))
	    return (pointer);
	else
	    pointer = pointer->next_variable;
    }
    while (pointer != NULL);

    return (NULL);
}

struct function_type *
 function_resolve(name)
char *name;
{
    struct function_type *pointer = function_table;

    if (function_table == NULL)
	return (NULL);

    do {
	if (!strcmp(name, pointer->name))
	    return (pointer);
	else
	    pointer = pointer->next_function;
    }
    while (pointer != NULL);

    return (NULL);
}

object_element_resolve(wordno)
int wordno;
{
    int index;
    int delimiter = 0;
    int match = 0;

    char wordtemp[161];
    strcpy(wordtemp, word[wordno]);

    if (!strncmp(wordtemp, "noun1(", 6)) {
	if (noun[0] != FALSE) {
	    index = noun[0];
	    delimiter = 5;
	    match = TRUE;
	}
    } else if (!strncmp(wordtemp, "noun2(", 6)) {
	index = noun[1];
	delimiter = 5;
	match = TRUE;
    } else if (!strncmp(wordtemp, "noun3(", 6)) {
	index = noun[2];
	delimiter = 5;
	match = TRUE;
    } else if (!strncmp(wordtemp, "noun4(", 6)) {
	index = noun[3];
	delimiter = 5;
	match = TRUE;
    } else if (!strncmp(wordtemp, "player(", 7)) {
	index = CURRENT_PLAYER->value;
	delimiter = 6;
	match = TRUE;
    } else {
	for (index = 0; index < strlen(wordtemp); index++) {
	    if (wordtemp[index] == 40) {
		delimiter = index;
		wordtemp[index] = 0;
		break;
	    }
	}

	if (delimiter) {
	    for (index = 1; index <= objects; index++) {
		if (!strcmp(wordtemp, object[index]->label)) {
		    match = TRUE;
		    break;
		}
	    }
	}
    }

    if (match) {
	delimiter++;
	if (!strcmp(&wordtemp[delimiter], "mass)")) {
	    oec = object[index]->mass;
	    object_element_address = &object[index]->mass;
	    return (TRUE);
	} else if (!strcmp(&wordtemp[delimiter], "info)")) {
	    oec = object[index]->info;
	    object_element_address = &object[index]->info;
	    return (TRUE);
	} else if (!strcmp(&wordtemp[delimiter], "location)")) {
	    object_element_address = &object[index]->location;
	    oec = object[index]->location;
	    return (TRUE);
	}
    }
    return (FALSE);
}

location_element_resolve(wordno)
int wordno;
{
    int index;
    int delimiter = 0;
    int match = 0;

    char wordtemp[161];
    strcpy(wordtemp, word[wordno]);

    if (!strncmp(wordtemp, "here(", 5)) {
	index = HERE;
	delimiter = 4;
	match = TRUE;
    } else {
	for (index = 0; index < strlen(wordtemp); index++) {
	    if (wordtemp[index] == 40) {
		delimiter = index;
		wordtemp[index] = 0;
		break;
	    }
	}

	if (delimiter) {
	    for (index = 1; index <= locations; index++) {
		if (!strcmp(wordtemp, location[index]->label)) {
		    match = TRUE;
		    break;
		}
	    }
	}
    }

    if (match) {
	delimiter++;
	if (!strcmp(&wordtemp[delimiter], "north)")) {
	    location_element_contents = location[index]->north;
	    location_element_address = &location[index]->north;
	    return (TRUE);
	} else if (!strcmp(&wordtemp[delimiter], "northeast)")) {
	    location_element_contents = location[index]->northeast;
	    location_element_address = &location[index]->northeast;
	    return (TRUE);
	} else if (!strcmp(&wordtemp[delimiter], "northwest)")) {
	    location_element_contents = location[index]->northwest;
	    location_element_address = &location[index]->northwest;
	    return (TRUE);
	} else if (!strcmp(&wordtemp[delimiter], "south)")) {
	    location_element_contents = location[index]->south;
	    location_element_address = &location[index]->south;
	    return (TRUE);
	} else if (!strcmp(&wordtemp[delimiter], "southeast)")) {
	    location_element_contents = location[index]->southeast;
	    location_element_address = &location[index]->southeast;
	    return (TRUE);
	} else if (!strcmp(&wordtemp[delimiter], "southwest)")) {
	    location_element_contents = location[index]->southwest;
	    location_element_address = &location[index]->southwest;
	    return (TRUE);
	} else if (!strcmp(&wordtemp[delimiter], "east)")) {
	    location_element_contents = location[index]->east;
	    location_element_address = &location[index]->east;
	    return (TRUE);
	} else if (!strcmp(&wordtemp[delimiter], "west)")) {
	    location_element_contents = location[index]->west;
	    location_element_address = &location[index]->west;
	    return (TRUE);
	} else if (!strcmp(&wordtemp[delimiter], "up)")) {
	    location_element_contents = location[index]->up;
	    location_element_address = &location[index]->up;
	    return (TRUE);
	} else if (!strcmp(&wordtemp[delimiter], "down)")) {
	    location_element_contents = location[index]->down;
	    location_element_address = &location[index]->down;
	    return (TRUE);
	} else if (!strcmp(&wordtemp[delimiter], "in)")) {
	    location_element_contents = location[index]->in;
	    location_element_address = &location[index]->in;
	    return (TRUE);
	} else if (!strcmp(&wordtemp[delimiter], "out)")) {
	    location_element_contents = location[index]->out;
	    location_element_address = &location[index]->out;
	    return (TRUE);
	}
    }
    return (FALSE);
}

object_resolve(wordno)
int wordno;
{
    int index;

    if (!strcmp(word[wordno], "noun1"))
	return (noun[0]);
    else if (!strcmp(word[wordno], "noun2"))
	return (noun[1]);
    else if (!strcmp(word[wordno], "noun3"))
	return (noun[2]);
    else if (!strcmp(word[wordno], "noun4"))
	return (noun[3]);
    else if (!strcmp(word[wordno], "player"))
	return (CURRENT_PLAYER->value);
    else {
	for (index = 1; index <= objects; index++) {
	    if (!strcmp(word[wordno], object[index]->label))
		return (index);
	}
    }

    return (FALSE);
}

location_resolve(wordno)
int wordno;
{
    int index;

    if (!strcmp(word[wordno], "here"))
	return (HERE);

    if (!strcmp(word[wordno], "destination"))
	return (destination);

    for (index = 1; index <= locations; index++) {
	if (!strcmp(word[wordno], location[index]->label))
	    return (index);
    }

    return (FALSE);
}

restart_game()
{
    int index;

    struct variable_type *current_variable;
    struct variable_type *previous_variable;
    struct name_type *current_name;
    struct name_type *next_name;

    restarting = TRUE;

    for (index = 1; index <= objects; index++) {
	current_name = object[index]->first_name;
	while (current_name->next_name != NULL) {
	    next_name = current_name->next_name;
	    free(current_name);
	    current_name = next_name;
	}
	free(current_name);
	free(object[index]);
    }
    for (index = 1; index <= locations; index++)
	free(location[index]);

    do {
	current_variable = variable_table;
	previous_variable = variable_table;
	while (current_variable->next_variable != NULL) {
	    previous_variable = current_variable;
	    current_variable = current_variable->next_variable;
	}
	free(current_variable);
	previous_variable->next_variable = NULL;
    }
    while (previous_variable != variable_table);

    free(variable_table);
    variable_table = NULL;

    read_gamefile();

    row = 0;

    strcpy(function_name, "{global_intro");
    execute(function_name);
}

read_gamefile()
{
    int index, reference, errors;
    int object_count, location_count;
    int last = 0;
    int line = 0;

    long start_of_file = 0;
    long current_file_position = 0;
    long bit_mask;

    struct filter_type *current_filter;
    struct filter_type *new_filter;
    struct synonym_type *current_synonym;
    struct synonym_type *new_synonym;
    struct function_type *current_function;
    struct variable_type *current_variable;
    struct name_type *current_name;

    char function_name[81];

    if ((variable_table = (struct variable_type *) malloc(sizeof(struct variable_type))) == NULL)
	outofmem();
    CURRENT_PLAYER = variable_table;

    for (index = 1; index < 6; index++) {
	if ((variable[index] = (struct variable_type *) malloc(sizeof(struct variable_type))) == NULL)
	    outofmem();
	variable[index - 1]->next_variable = variable[index];
    }

    current_variable = DISPLAY_MODE;
    errors = FALSE;
    objects = 0;
    locations = 0;
    fseek(file, start_of_file, SEEK_SET);

    fgets(text_buffer, 160, file);
    line++;

    while (!feof(file)) {
	encapsulate();
	if (word[0] == NULL);
	else if (text_buffer[0] == 123 && restarting == FALSE) {
	    while (word[wp] != NULL) {
		if (!strncmp(text_buffer, "{global_", 8)) {
		    strncpy(function_name, word[wp], 80);
		    function_name[80] = 0;
		} else if (last == 0) {
		    printf("ERROR: In line %d, non-global function before object or location.\n", line);
		    errors++;
		} else if (last == 1) {
		    if (word[wp][0] == 123)
			function_name[0] = 0;
		    else
			strcpy(function_name, "{");
		    strncat(function_name, word[wp], 39);
		    strcat(function_name, "_");
		    strcat(function_name, location[locations]->label);
		} else if (last == 2) {
		    if (word[wp][0] == 123)
			function_name[0] = 0;
		    else
			strcpy(function_name, "{");
		    strncat(function_name, word[wp], 59);
		    strcat(function_name, "_");
		    strcat(function_name, object[objects]->label);
		}
		if (function_table == NULL) {
		    if ((function_table = (struct function_type *) malloc(sizeof(struct function_type))) == NULL)
			outofmem();
		    else {
			current_function = function_table;
			strcpy(current_function->name, function_name);
			current_function->position = ftell(file);
			current_function->next_function = NULL;
		    }
		} else {
		    if ((current_function->next_function = (struct function_type *) malloc(sizeof(struct function_type))) == NULL)
			outofmem();
		    else {
			current_function = current_function->next_function;
			strcpy(current_function->name, function_name);
			current_function->position = ftell(file);
			current_function->next_function = NULL;
		    }
		}
		wp++;
	    }
	    while (!feof(file)) {
		fgets(text_buffer, 160, file);
		line++;
		if (text_buffer[0] == 125)
		    break;
	    }
	} else {
	    if (!strcmp(word[0], "grammar") && restarting == FALSE) {
		if (word[++wp] == NULL) {
		    noproperr(line);
		    errors++;
		} else {
		    if (grammar_table == NULL) {
			if ((grammar_table = (struct word_type *) malloc(sizeof(struct word_type))) == NULL)
			    outofmem();
			else {
			    strncpy(grammar_table->word, word[wp], 20);
			    grammar_table->word[20] = 0;
			    grammar_table->next_sibling = NULL;
			    grammar_table->first_child = NULL;
			    build_grammar_table(grammar_table);
			}
		    } else
			build_grammar_table(grammar_table);
		}
	    } else if (!strcmp(word[0], "location")) {
		if (word[1] == NULL) {
		    noproperr(line);
		    errors++;
		} else {
		    locations++;
		    if (locations == MAX_OBJECTS) {
			printf("ERROR: Maximum number of locations exceeded, can't continue.\n");
		    } else {
			if ((location[locations] = (struct location_type *) malloc(sizeof(struct location_type))) == NULL)
			    outofmem();
			strncpy(location[locations]->label, word[1], 20);
			location[locations]->label[20] = 0;
			last = 1;
		    }
		}
	    } else if (!strcmp(word[0], "object")) {
		if (word[2] == NULL) {
		    noproperr(line);
		    terminate(1);
		} else {
		    objects++;
		    if (objects == MAX_OBJECTS) {
			printf("ERROR: Maximum number of objects exceeded, can't continue.\n");
			terminate(1);
		    } else {
			if ((object[objects] = (struct object_type *) malloc(sizeof(struct object_type))) == NULL)
			    outofmem();
			strncpy(object[objects]->label, word[1], 20);
			object[objects]->label[20] = 0;
			if (locations == 0)
			    object[objects]->location = 1;
			else
			    object[objects]->location = locations;
			last = 2;
		    }
		}
	    } else if (!strcmp(word[0], "synonym") && restarting == FALSE) {
		if (word[++wp] == NULL) {
		    noproperr(line);
		    errors++;
		} else {
		    if ((new_synonym = (struct synonym_type *) malloc(sizeof(struct synonym_type))) == NULL)
			outofmem();
		    else {
			if (synonym_table == NULL) {
			    synonym_table = new_synonym;
			} else {
			    current_synonym->next_synonym = new_synonym;
			}
		    }
		    current_synonym = new_synonym;
		    strncpy(current_synonym->original, word[wp], 20);
		    current_synonym->original[20] = 0;
		    if (word[++wp] == NULL) {
			noproperr(line);
			errors++;
		    } else {
			strncpy(current_synonym->standard, word[wp], 20);
			current_synonym->standard[20] = 0;
		    }
		    current_synonym->next_synonym = NULL;
		}
	    } else if (!strcmp(word[0], "filter") && restarting == FALSE) {
		if (word[++wp] == NULL) {
		    noproperr(line);
		    errors++;
		} else {
		    if ((new_filter = (struct filter_type *) malloc(sizeof(struct filter_type))) == NULL)
			outofmem();
		    else {
			if (filter_table == NULL) {
			    filter_table = new_filter;
			} else {
			    current_filter->next_filter = new_filter;
			}
			current_filter = new_filter;
			strncpy(current_filter->word, word[wp], 20);
			current_filter->word[20] = 0;
			current_filter->next_filter = NULL;

		    }
		}
	    } else if (!strcmp(word[0], "variable")) {
		if (word[1] == NULL) {
		    noproperr(line);
		    errors++;
		} else {
		    if ((current_variable->next_variable = (struct variable_type *) malloc(sizeof(struct variable_type))) == NULL)
			outofmem();
		    else {
			current_variable = current_variable->next_variable;
			strncpy(current_variable->name, word[1], 20);
			current_variable->name[20] = 0;
			current_variable->next_variable = NULL;
		    }
		    if (word[2] != NULL) {
			if (!strcmp(word[2], "true"))
			    current_variable->value = TRUE;
			else if (!strcmp(word[2], "false"))
			    current_variable->value = FALSE;
			else
			    current_variable->value = atoi(word[2]);
		    } else
			current_variable->value = FALSE;
		}
	    }
	}
	fgets(text_buffer, 160, file);
	line++;
    }

    setdefaults();

    fseek(file, start_of_file, SEEK_SET);

    object_count = 0;
    location_count = 0;
    line = 0;

    fgets(text_buffer, 160, file);
    line++;

    while (!feof(file)) {
	if (text_buffer[0] == 123) {
	    while (!feof(file)) {
		fgets(text_buffer, 160, file);
		line++;
		if (text_buffer[0] == 125)
		    break;
	    }
	} else {
	    encapsulate();
	    if (word[0] == NULL);
	    else if (!strcmp(word[0], "variable"));
	    else if (!strcmp(word[0], "synonym"));
	    else if (!strcmp(word[0], "grammar"));
	    else if (!strcmp(word[0], "filter"));
	    else if (!strcmp(word[0], "has")) {
		if (word[1] == NULL) {
		    noproperr(line);
		    errors++;
		} else {
		    for (index = 1; word[index] != NULL; index++) {
			if (bit_mask = attribute_resolve(index)) {
			    if (last == 0);
			    else if (last == 1)
				location[location_count]->attributes += bit_mask;
			    else if (last == 2)
				object[object_count]->attributes += bit_mask;
			} else {
			    unkkeyerr(line, index);
			    errors++;
			}
		    }
		}
	    } else if (!strcmp(word[0], "location")) {
		location_count++;
		last = 1;
	    } else if (!strcmp(word[0], "object")) {
		object_count++;
		last = 2;
		if ((object[object_count]->first_name = (struct name_type *) malloc(sizeof(struct name_type))) == NULL)
		    outofmem();
		else {
		    current_name = object[object_count]->first_name;
		    strncpy(current_name->name, word[2], 20);
		    current_name->name[20] = 0;
		    current_name->next_name = NULL;
		}
		wp = 3;
		while (word[wp] != NULL) {
		    if ((current_name->next_name = (struct name_type *) malloc(sizeof(struct name_type))) == NULL)
			outofmem();
		    else {
			current_name = current_name->next_name;
			strncpy(current_name->name, word[wp], 20);
			current_name->name[20] = 0;
			current_name->next_name = NULL;
		    }
		    wp++;
		}
	    } else if (!strcmp(word[0], "no_go")) {
		location[location_count]->no_go = current_file_position;
	    } else if (!strcmp(word[0], "northeast")) {
		if (word[1] == NULL) {
		    noproperr(line);
		    errors++;
		} else if (!strcmp(word[1], "nowhere"));
		else {
		    if (reference = location_resolve(1)) {
			location[location_count]->northeast = reference;
		    } else {
			unklocerr(line, 1);
			errors++;
		    }
		}
	    } else if (!strcmp(word[0], "no_northeast")) {
		location[location_count]->no_northeast = current_file_position;
	    } else if (!strcmp(word[0], "go_northeast")) {
		location[location_count]->go_northeast = current_file_position;
	    } else if (!strcmp(word[0], "northwest")) {
		if (word[1] == NULL) {
		    noproperr(line);
		    errors++;
		} else if (!strcmp(word[1], "nowhere"));
		else {
		    if (reference = location_resolve(1)) {
			location[location_count]->northwest = reference;
		    } else {
			unklocerr(line, 1);
			errors++;
		    }
		}
	    } else if (!strcmp(word[0], "no_northwest")) {
		location[location_count]->no_northwest = current_file_position;
	    } else if (!strcmp(word[0], "go_northwest")) {
		location[location_count]->go_northwest = current_file_position;
	    } else if (!strcmp(word[0], "southeast")) {
		if (word[1] == NULL) {
		    noproperr(line);
		    errors++;
		} else if (!strcmp(word[1], "nowhere"));
		else {
		    if (reference = location_resolve(1)) {
			location[location_count]->southeast = reference;
		    } else {
			unklocerr(line, 1);
			errors++;
		    }
		}
	    } else if (!strcmp(word[0], "no_southeast")) {
		location[location_count]->no_southeast = current_file_position;
	    } else if (!strcmp(word[0], "go_southeast")) {
		location[location_count]->go_southeast = current_file_position;
	    } else if (!strcmp(word[0], "southwest")) {
		if (word[1] == NULL) {
		    noproperr(line);
		    errors++;
		} else if (!strcmp(word[1], "nowhere"));
		else {
		    if (reference = location_resolve(1)) {
			location[location_count]->southwest = reference;
		    } else {
			unklocerr(line, 1);
			errors++;
		    }
		}
	    } else if (!strcmp(word[0], "no_southwest")) {
		location[location_count]->no_southwest = current_file_position;
	    } else if (!strcmp(word[0], "go_southwest")) {
		location[location_count]->go_southwest = current_file_position;
	    } else if (!strcmp(word[0], "in")) {
		if (word[1] == NULL) {
		    noproperr(line);
		    errors++;
		} else if (!strcmp(word[1], "nowhere"));
		else {
		    if (reference = location_resolve(1)) {
			location[location_count]->in = reference;
		    } else {
			unklocerr(line, 1);
			errors++;
		    }
		}
	    } else if (!strcmp(word[0], "no_in")) {
		location[location_count]->no_in = current_file_position;
	    } else if (!strcmp(word[0], "go_in")) {
		location[location_count]->go_in = current_file_position;
	    } else if (!strcmp(word[0], "out")) {
		if (word[1] == NULL) {
		    noproperr(line);
		    errors++;
		} else if (!strcmp(word[1], "nowhere"));
		else {
		    if (reference = location_resolve(1)) {
			location[location_count]->out = reference;
		    } else {
			unklocerr(line, 1);
			errors++;
		    }
		}
	    } else if (!strcmp(word[0], "no_out")) {
		location[location_count]->no_out = current_file_position;
	    } else if (!strcmp(word[0], "go_out")) {
		location[location_count]->go_out = current_file_position;
	    } else if (!strcmp(word[0], "up")) {
		if (word[1] == NULL) {
		    noproperr(line);
		    errors++;
		} else if (!strcmp(word[1], "nowhere"));
		else {
		    if (reference = location_resolve(1)) {
			location[location_count]->up = reference;
		    } else {
			unklocerr(line, 1);
			errors++;
		    }
		}
	    } else if (!strcmp(word[0], "no_up")) {
		location[location_count]->no_up = current_file_position;
	    } else if (!strcmp(word[0], "go_up")) {
		location[location_count]->go_up = current_file_position;
	    } else if (!strcmp(word[0], "down")) {
		if (word[1] == NULL) {
		    noproperr(line);
		    errors++;
		} else if (!strcmp(word[1], "nowhere"));
		else {
		    if (reference = location_resolve(1)) {
			location[location_count]->down = reference;
		    } else {
			unklocerr(line, 1);
			errors++;
		    }
		}
	    } else if (!strcmp(word[0], "no_down")) {
		location[location_count]->no_down = current_file_position;
	    } else if (!strcmp(word[0], "go_down")) {
		location[location_count]->go_down = current_file_position;
	    } else if (!strcmp(word[0], "north")) {
		if (word[1] == NULL) {
		    noproperr(line);
		    errors++;
		} else if (!strcmp(word[1], "nowhere"));
		else {
		    if (reference = location_resolve(1)) {
			location[location_count]->north = reference;
		    } else {
			unklocerr(line, 1);
			errors++;
		    }
		}
	    } else if (!strcmp(word[0], "no_north")) {
		location[location_count]->no_north = current_file_position;
	    } else if (!strcmp(word[0], "go_north")) {
		location[location_count]->go_north = current_file_position;
	    } else if (!strcmp(word[0], "south")) {
		if (word[1] == NULL) {
		    noproperr(line);
		    errors++;
		} else if (!strcmp(word[1], "nowhere"));
		else {
		    if (reference = location_resolve(1)) {
			location[location_count]->south = reference;
		    } else {
			unklocerr(line, 1);
			errors++;
		    }
		}
	    } else if (!strcmp(word[0], "no_south")) {
		location[location_count]->no_south = current_file_position;
	    } else if (!strcmp(word[0], "go_south")) {
		location[location_count]->go_south = current_file_position;
	    } else if (!strcmp(word[0], "east")) {
		if (word[1] == NULL) {
		    noproperr(line);
		    errors++;
		} else if (!strcmp(word[1], "nowhere"));
		else {
		    if (reference = location_resolve(1)) {
			location[location_count]->east = reference;
		    } else {
			unklocerr(line, 1);
			errors++;
		    }
		}
	    } else if (!strcmp(word[0], "no_east")) {
		location[location_count]->no_east = current_file_position;
	    } else if (!strcmp(word[0], "go_east")) {
		location[location_count]->go_east = current_file_position;
	    } else if (!strcmp(word[0], "west")) {
		if (word[1] == NULL) {
		    noproperr(line);
		    errors++;
		} else if (!strcmp(word[1], "nowhere"));
		else {
		    if (reference = location_resolve(1)) {
			location[location_count]->west = reference;
		    } else {
			unklocerr(line, 1);
			errors++;
		    }
		}
	    } else if (!strcmp(word[0], "no_west")) {
		location[location_count]->no_west = current_file_position;
	    } else if (!strcmp(word[0], "go_west")) {
		location[location_count]->go_west = current_file_position;
	    } else if (!strcmp(word[0], "inventory")) {
		if (word[2] == NULL) {
		    noproperr(line);
		    errors++;
		} else {
		    strncpy(object[object_count]->article, word[1], 10);
		    object[object_count]->article[10] = 0;
		    strncpy(object[object_count]->inventory, word[2], 40);
		    object[object_count]->inventory[40] = 0;
		}
	    } else if (!strcmp(word[0], "described")) {
		strncpy(object[object_count]->described, word[1], 80);
		object[object_count]->described[80] = 0;
	    } else if (!strcmp(word[0], "initial")) {
		strncpy(object[object_count]->initial, word[1], 80);
		object[object_count]->initial[80] = 0;
	    } else if (!strcmp(word[0], "starts")) {
		if (word[1] == NULL) {
		    noproperr(line);
		    errors++;
		} else if (!strcmp(word[1], "childof")) {
		    if (word[2] == NULL) {
			noproperr(line);
			errors++;
		    } else if (reference = object_resolve(2)) {
			object[object_count]->location = reference + MAX_OBJECTS;
		    } else {
			unkobjerr(line, 2);
			errors++;
		    }
		} else {
		    if (!strcmp(word[1], "limbo"))
			object[object_count]->location = LIMBO;
		    else if (!strcmp(word[1], "here"))
			object[object_count]->location = location_count;
		    else {
			if (reference = location_resolve(1)) {
			    object[object_count]->location = reference;
			} else {
			    unklocerr(line, 1);
			    errors++;
			}
		    }
		}
	    } else if (!strcmp(word[0], "quantity")) {
		if (word[1] == NULL) {
		    noproperr(line);
		    errors++;
		} else
		    object[object_count]->info = atoi(word[1]);
	    } else if (!strcmp(word[0], "mass")) {
		if (word[1] == NULL) {
		    noproperr(line);
		    errors++;
		} else if (!strcmp(word[1], "scenery"))
		    object[object_count]->mass = SCENERY;
		else if (!strcmp(word[1], "heavy"))
		    object[object_count]->mass = HEAVY;
		else
		    object[object_count]->mass = atoi(word[1]);
	    } else {
		unkkeyerr(line, 0);
		errors++;
	    }
	}
	current_file_position = ftell(file);
	fgets(text_buffer, 160, file);
	line++;
    }

    if (errors) {
	newline();
	if (errors == 1)
	    printf("1 error detected.\n");
	else
	    printf("%d errors detected.\n", errors);
	terminate(1);
    }
}

build_grammar_table(pointer)
struct word_type *pointer;
{
    do {
	if (!strcmp(word[wp], pointer->word)) {
	    if (pointer->first_child == NULL && word[wp + 1] != NULL) {
		if ((pointer->first_child = (struct word_type *) malloc(sizeof(struct word_type))) == NULL)
		    outofmem();
		else {
		    pointer = pointer->first_child;
		    strncpy(pointer->word, word[++wp], 20);
		    pointer->word[20] = 0;
		    pointer->next_sibling = NULL;
		    pointer->first_child = NULL;
		}
	    } else {
		pointer = pointer->first_child;
		wp++;
	    }
	} else {
	    if (pointer->next_sibling == NULL) {
		if ((pointer->next_sibling = (struct word_type *) malloc(sizeof(struct word_type))) == NULL)
		    outofmem();
		else {
		    pointer = pointer->next_sibling;
		    strncpy(pointer->word, word[wp], 20);
		    pointer->word[20] = 0;
		    pointer->next_sibling = NULL;
		    pointer->first_child = NULL;
		}
	    } else
		pointer = pointer->next_sibling;
	}
    }
    while (word[wp] != NULL);
}

unkfunrun(name)
char *name;
{
    printf("ERROR: Attempt to execute unknown function \"%s\".\n", name);
}

unkkeyerr(line, wordno)
int line;
int wordno;
{
    printf("ERROR: In line %d, unknown keyword \"%s\".\n", line, word[wordno]);
}

noproprun()
{
    printf("ERROR: In function \"%s\", \"%s\" command with insufficient arguments.\n", current_function, word[0]);
}

noproperr(line)
int line;
{
    printf("ERROR: In line %d, \"%s\" keyword with insufficient arguments.\n", line, word[0]);
}

unklocerr(line, wordno)
int line;
int wordno;
{
    printf("ERROR: In line %d, reference to undefined location \"%s\".\n", line, word[wordno]);
}

unklocrun(wordno)
int wordno;
{
    printf("ERROR: In function \"%s\", reference to undefined location \"%s\".\n", current_function, word[wordno]);
}

unkobjerr(line, wordno)
int line;
int wordno;
{
    printf("ERROR: In line %d, reference to undefined object \"%s\".\n", line, word[wordno]);
}

unkobjrun(wordno)
int wordno;
{
    printf("ERROR: In function \"%s\", reference to undefined object \"%s\".\n", current_function, word[wordno]);
}

unkvarrun(wordno)
int wordno;
{
    printf("ERROR: In function \"%s\", reference to undefined variable \"%s\".\n", current_function, word[wordno]);
}

outofmem()
{
    printf("ERROR: Out of memory, can't continue.\n");
    terminate(1);
}

long attribute_resolve(wordno)
int wordno;
{
    if (!strcmp(word[wordno], "VISITED"))
	return (1);
    else if (!strcmp(word[wordno], "DARK"))
	return (2);
    else if (!strcmp(word[wordno], "ON_WATER"))
	return (4);
    else if (!strcmp(word[wordno], "UNDER_WATER"))
	return (8);
    else if (!strcmp(word[wordno], "WITHOUT_AIR"))
	return (16);
    else if (!strcmp(word[wordno], "OUTDOORS"))
	return (32);
    else if (!strcmp(word[wordno], "MID_AIR"))
	return (64);
    else if (!strcmp(word[wordno], "TIGHT_ROPE"))
	return (128);
    else if (!strcmp(word[wordno], "POLLUTED"))
	return (256);
    else if (!strcmp(word[wordno], "SOLVED"))
	return (512);
    else if (!strcmp(word[wordno], "MID_WATER"))
	return (1024);
    else if (!strcmp(word[wordno], "CLOSED"))
	return (1);
    else if (!strcmp(word[wordno], "LOCKED"))
	return (2);
    else if (!strcmp(word[wordno], "DEAD"))
	return (4);
    else if (!strcmp(word[wordno], "EDIBLE"))
	return (8);
    else if (!strcmp(word[wordno], "WORN"))
	return (16);
    else if (!strcmp(word[wordno], "CONCEALING"))
	return (32);
    else if (!strcmp(word[wordno], "LUMINOUS"))
	return (64);
    else if (!strcmp(word[wordno], "WEARABLE"))
	return (128);
    else if (!strcmp(word[wordno], "CLOSABLE"))
	return (256);
    else if (!strcmp(word[wordno], "LOCKABLE"))
	return (512);
    else if (!strcmp(word[wordno], "ANIMATE"))
	return (1024);
    else if (!strcmp(word[wordno], "LIQUID"))
	return (2048);
    else if (!strcmp(word[wordno], "CONTAINER"))
	return (4096);
    else if (!strcmp(word[wordno], "SURFACE"))
	return (8192);
    else if (!strcmp(word[wordno], "PLURAL"))
	return (16384);
    else if (!strcmp(word[wordno], "FLAMMABLE"))
	return (32768);
    else if (!strcmp(word[wordno], "BURNING"))
	return (65536);
    else if (!strcmp(word[wordno], "SWITCHABLE"))
	return (131072);
    else if (!strcmp(word[wordno], "ON"))
	return (262144);
    else if (!strcmp(word[wordno], "DAMAGED"))
	return (524288);
    else if (!strcmp(word[wordno], "FEMALE"))
	return (1048576);
    else if (!strcmp(word[wordno], "POSSESSIVE"))
	return (2097152);
    else if (!strcmp(word[wordno], "OUT_OF_REACH"))
	return (4194304);
    else if (!strcmp(word[wordno], "TOUCHED"))
	return (8388608);
    else if (!strcmp(word[wordno], "SCORED"))
	return (16777216);
    else if (!strcmp(word[wordno], "SITTING"))
	return (33554432);
    else if (!strcmp(word[wordno], "CUSTOM1"))
	return (67108864);
    else if (!strcmp(word[wordno], "CUSTOM2"))
	return (134217728);
    else if (!strcmp(word[wordno], "CUSTOM3"))
	return (268435456);
    else if (!strcmp(word[wordno], "CUSTOM4"))
	return (536870912);
    else if (!strcmp(word[wordno], "CUSTOM5"))
	return (1073741824);
    else
	return (0);
}

setdefaults()
{
    int index;

    strcpy(CURRENT_PLAYER->name, "CURRENT_PLAYER");
    CURRENT_PLAYER->value = 0;
    strcpy(TOTAL_MOVES->name, "TOTAL_MOVES");
    TOTAL_MOVES->value = 0;
    strcpy(TURN_WORKED->name, "TURN_WORKED");
    TURN_WORKED->value = FALSE;
    strcpy(CURRENT_SCORE->name, "CURRENT_SCORE");
    CURRENT_SCORE->value = 0;
    strcpy(DISPLAY_MODE->name, "DISPLAY_MODE");
    DISPLAY_MODE->value = 0;
    strcpy(INTERNAL_VERSION->name, "INTERNAL_VERSION");
    INTERNAL_VERSION->value = VERSION;

    for (index = 1; index <= objects; index++) {
	strcpy(object[index]->described, object[index]->label);
	object[index]->initial[0] = 0;
	strcpy(object[index]->inventory, object[index]->label);
	object[index]->attributes = FALSE;
	object[index]->info = 0;
	object[index]->mass = SCENERY;
    }

    for (index = 1; index <= locations; index++) {
	location[index]->in = FALSE;
	location[index]->out = FALSE;
	location[index]->north = FALSE;
	location[index]->northeast = FALSE;
	location[index]->northwest = FALSE;
	location[index]->south = FALSE;
	location[index]->southeast = FALSE;
	location[index]->southwest = FALSE;
	location[index]->east = FALSE;
	location[index]->west = FALSE;
	location[index]->up = FALSE;
	location[index]->down = FALSE;
	location[index]->go_north = FALSE;
	location[index]->go_northeast = FALSE;
	location[index]->go_northwest = FALSE;
	location[index]->go_south = FALSE;
	location[index]->go_southeast = FALSE;
	location[index]->go_southwest = FALSE;
	location[index]->go_east = FALSE;
	location[index]->go_west = FALSE;
	location[index]->go_up = FALSE;
	location[index]->go_down = FALSE;
	location[index]->go_in = FALSE;
	location[index]->go_out = FALSE;
	location[index]->no_north = FALSE;
	location[index]->no_northeast = FALSE;
	location[index]->no_northwest = FALSE;
	location[index]->no_south = FALSE;
	location[index]->no_southeast = FALSE;
	location[index]->no_southwest = FALSE;
	location[index]->no_east = FALSE;
	location[index]->no_west = FALSE;
	location[index]->no_up = FALSE;
	location[index]->no_down = FALSE;
	location[index]->no_in = FALSE;
	location[index]->no_out = FALSE;
	location[index]->no_go = FALSE;
	location[index]->attributes = FALSE;
    }
}

no_it()
{
    char buffer[200];

    strcpy(buffer, "You must have referred to an appropriate noun previously to use the word \"");
    strcat(buffer, word[wp]);
    strcat(buffer, "\".");
    write_text(buffer);
    newline();
    custom_error = TRUE;
}

noun_resolve(pointer)
struct word_type *pointer;
{
    int word_found, index, counter;
    int matches = 0;
    int confidence[MAX_OBJECTS];
    int highest_confidence = 0;
    int prime_suspect = 0;
    int name_found = FALSE;
    int done = FALSE;
    int backup_pointer = wp;
    short int last_word = FALSE;

    struct word_type *options = pointer;
    struct word_type *terminator = options->first_child;
    struct name_type *current_name;

    char buffer[200];

    if (!strncmp("it", word[wp], significance)) {
	if (it)
	    return (it);
	else {
	    no_it();
	    return (FALSE);
	}
    } else if (!strncmp("them", word[wp], significance)) {
	if (them)
	    return (them);
	else {
	    no_it();
	    return (FALSE);
	}
    } else if (!strncmp("him", word[wp], significance)) {
	if (him)
	    return (him);
	else {
	    no_it();
	    return (FALSE);
	}
    } else if (!strncmp("her", word[wp], significance)) {
	if (her)
	    return (her);
	else {
	    no_it();
	    return (FALSE);
	}
    }
    if (!strncmp("itself", word[wp], significance) || !strncmp("themselves", word[wp], significance) || !strncmp("himself", word[wp], significance) || !strncmp("herself", word[wp], significance) || !strncmp("yourself", word[wp], significance)) {
	if (noun[0] == FALSE) {
	    strcpy(buffer, "You must have referred to a noun previously in the same sentence to use the word \"");
	    strcat(buffer, word[wp]);
	    strcat(buffer, "\".");
	    write_text(buffer);
	    newline();
	    custom_error = TRUE;
	    return (FALSE);
	} else
	    return (noun[0]);
    }
    for (index = 1; index <= objects; index++)
	confidence[index] = 1;

    while (word[wp] != NULL && last_word != TRUE) {
	if (punctuation[wp] != 0) {
	    last_word = TRUE;
	} else if (options != NULL) {
	    do {
		if (!strncmp(word[wp], options->word, significance)) {
		    if (!matches)
			return (FALSE);
		    else {
			done = TRUE;
			break;
		    }
		}
	    }
	    while ((options = options->next_sibling) != NULL);
	}
	if (done == TRUE) {
	    break;
	}
	for (index = 1; index <= objects; index++) {
	    if (!confidence[index])
		continue;
	    word_found = FALSE;
	    current_name = object[index]->first_name;
	    while (current_name != NULL) {
		if (!strncmp(word[wp], current_name->name, significance)) {
		    word_found = TRUE;
		    name_found = TRUE;
		    options = terminator;
		    break;
		}
		current_name = current_name->next_name;
	    }
	    if (word_found) {
		if (confidence[index] == 1)
		    matches++;
		if (confidence[index] != FALSE)
		    confidence[index]++;
	    } else {
		if (confidence[index] > 1)
		    matches--;
		confidence[index] = FALSE;
	    }
	}
	if (!name_found && !matches)
	    break;
	wp++;
	name_found = FALSE;
    }

    wp--;

    if (matches == 0) {
	object_expected = TRUE;
	wp = backup_pointer;
	return (FALSE);
    }
    for (index = 1; index <= objects; index++) {
	if (confidence[index] != FALSE && strcmp(pointer->word, "*anywhere")) {
	    if (scope(index, "*present") == FALSE) {
		matches--;
		confidence[index] = FALSE;
	    }
	}
	if (confidence[index] != FALSE) {
	    current_name = object[index]->first_name;
	    counter = 0;
	    while (current_name != NULL) {
		counter++;
		current_name = current_name->next_name;
	    }
	    confidence[index] = ((confidence[index] - 1) * 100) / counter;
	    if (confidence[index] > highest_confidence)
		highest_confidence = confidence[index];
	}
    }
    if (matches > 1) {
	for (index = 1; index <= objects; index++) {
	    if (confidence[index] != FALSE) {
		if (confidence[index] < highest_confidence) {
		    confidence[index] = FALSE;
		    matches--;
		}
	    }
	}
    }
    for (index = 1; index <= objects; index++) {
	if (confidence[index] != FALSE) {
	    if (scope(index, "*present") != FALSE)
		prime_suspect = index;
	    if (scope(index, pointer->word) == FALSE) {
		matches--;
		confidence[index] = FALSE;
	    }
	}
    }
    if (matches == 0) {
	if (prime_suspect != FALSE) {
	    if (!(object[prime_suspect]->attributes & 1024))
		it = prime_suspect;
	    if (object[prime_suspect]->attributes & 16384)
		them = prime_suspect;
	    if (object[prime_suspect]->attributes & 1024 && object[prime_suspect]->attributes & 1048576)
		her = prime_suspect;
	    if (object[prime_suspect]->attributes & 1024 && !(object[prime_suspect]->attributes & 1048576))
		him = prime_suspect;
	    return (prime_suspect);
	} else {
	    object_expected = TRUE;
	    wp = backup_pointer;
	    return (FALSE);
	}
    }
    if (matches == 1) {
	for (index = 1; index <= objects; index++) {
	    if (confidence[index] != FALSE) {
		if (!(object[index]->attributes & 1024))
		    it = index;
		if (object[index]->attributes & 16384)
		    them = index;
		if (object[index]->attributes & 1024 && object[index]->attributes & 1048576)
		    her = index;
		if (object[index]->attributes & 1024 && !(object[index]->attributes & 1048576))
		    him = index;
		return (index);
	    }
	}
    }
    strcpy(write_buffer, "Are you referring to ");
    for (index = 1; index <= objects; index++) {
	if (confidence[index] != FALSE) {
	    sentence_output(index, 0);
	    matches--;
	    if (matches == 1)
		strcat(write_buffer, " or ");
	    else if (matches > 1)
		strcat(write_buffer, ", ");
	}
    }
    strcat(write_buffer, "?^");
    write_text(write_buffer);
    custom_error = TRUE;
    return (FALSE);
}


#ifndef POWERC

clrscrn()
{
    int y = screen_depth;

    for (; y >= 0; y--)
	printf("\n");
}

more()
{
    write_centred("---[PRESS ENTER]---");

    getchar();

    row = 0;
}

#else

more()
{
    int index;
    int y;

    y = cursrow();

    write_centred("---[MORE]---");

    kbhit();
    getch();

    poscurs(y, 0);
    for (index = 0; index < screen_width; index++)
	printf(" ");
    poscurs(y, 0);

    row = 0;
}

#endif