madcow/scummvm-cursorfix
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity
Files
main
scummvm-cursorfix/engines/glk/jacl/loader.cpp
Leon Krieg 5b11698731 Initial commit
2026-02-02 04:50:13 +01:00

1675 lines
51 KiB
C++
Raw Permalink Blame History

/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#include "glk/jacl/jacl.h"
#include "glk/jacl/language.h"
#include "glk/jacl/types.h"
#include "glk/jacl/prototypes.h"
#include "glk/jacl/version.h"
namespace Glk {
namespace JACL {
/* INDICATES THAT THE CURRENT '.j2' FILE BEING WORKED
* WITH IS ENCRYPTED */
int encrypted = FALSE;
extern char text_buffer[];
extern char temp_buffer[];
extern char prefix[];
extern char error_buffer[];
extern const char *word[];
extern int quoted[];
extern int punctuated[];
extern int wp;
extern schanid_t sound_channel[];
extern struct object_type *object[];
extern struct integer_type *integer_table;
extern struct integer_type *integer[];
extern struct cinteger_type *cinteger_table;
extern struct string_type *string_table;
extern struct string_type *cstring_table;
extern struct attribute_type *attribute_table;
extern struct function_type *function_table;
extern struct function_type *executing_function;
extern struct command_type *completion_list;
extern struct word_type *grammar_table;
extern struct synonym_type *synonym_table;
extern struct filter_type *filter_table;
struct string_type *current_string = nullptr;
struct integer_type *current_integer = nullptr;
struct integer_type *last_system_integer = nullptr;
extern struct string_type *current_cstring;
extern struct cinteger_type *current_cinteger;
extern strid_t game_stream;
extern int objects;
extern int integers;
extern int functions;
extern int strings;
extern int player;
extern int it;
extern int them[];
extern int her;
extern int him;
extern int parent;
extern int noun[];
int value_resolved;
void read_gamefile() {
int index,
counter,
errors;
int result;
int location_count = 0;
int object_count = 0;
int line = 0;
int self_parent = 0;
long start_of_file = 0;
long bit_mask;
filter_type *current_filter = nullptr;
filter_type *new_filter = nullptr;
attribute_type *current_attribute = nullptr;
attribute_type *new_attribute = nullptr;
cinteger_type *resolved_cinteger = nullptr;
synonym_type *current_synonym = nullptr;
synonym_type *new_synonym = nullptr;
function_type *current_function = nullptr;
name_type *current_name = nullptr;
char function_name[81];
// CREATE SOME SYSTEM VARIABLES
// THIS IS USED BY JACL FUNCTIONS TO PASS STRING VALUES BACK
// TO THE INTERPRETER AS JACL FUNCTION CAN ONLY RETURN
// AN INTEGER
create_string("return_value", "");
create_cstring("function_name", "JACL*Internal");
// THESE ARE THE FIELDS FOR THE CSV PARSER
create_cstring("field", "field0");
create_cstring("field", "field1");
create_cstring("field", "field2");
create_cstring("field", "field3");
create_cstring("field", "field4");
create_cstring("field", "field5");
create_cstring("field", "field6");
create_cstring("field", "field7");
create_cstring("field", "field8");
create_cstring("field", "field9");
create_cstring("field", "field10");
create_cstring("field", "field11");
create_cstring("field", "field12");
create_cstring("field", "field13");
create_cstring("field", "field14");
create_cstring("field", "field15");
create_cstring("field", "field16");
create_cstring("field", "field17");
create_cstring("field", "field18");
create_cstring("field", "field19");
create_cinteger("field_count", 0);
create_integer("compass", 0);
// START AT -1 AS TIME PASSES BEFORE THE FIRST PROMPT
create_integer("total_moves", -1);
create_integer("time", TRUE);
create_integer("score", 0);
create_integer("display_mode", 0);
create_integer("internal_version", J_VERSION);
create_integer("max_rand", 100);
create_integer("destination", 0);
create_integer("interrupted", 0);
create_integer("debug", 0);
create_integer("graphics_enabled", 0);
create_integer("sound_enabled", 0);
create_integer("timer_enabled", 0);
create_integer("multi_prefix", 0);
create_integer("notify", 1);
create_integer("debug", 0);
create_integer("linebreaks", 1);
/* STORE THIS SO THE SECOND PASS KNOWS WHERE TO START
* SETTING VALUES FROM (EVERYTHING BEFORE THIS IN THE
* VARIABLE TABLE IS A SYSTEM VARIABLE */
last_system_integer = current_integer;
/* CREATE SOME SYSTEM CONSTANTS */
create_cinteger("graphics_supported", 0);
create_cinteger("sound_supported", 0);
create_cinteger("timer_supported", 0);
create_cinteger("GLK", 0);
create_cinteger("CGI", 1);
create_cinteger("NDS", 2);
create_cinteger("interpreter", 0);
/* TEST FOR AVAILABLE FUNCTIONALITY BEFORE EXECUTING ANY JACL CODE */
GRAPHICS_SUPPORTED->value = (int)g_vm->glk_gestalt(gestalt_Graphics, 0);
GRAPHICS_ENABLED->value = (int)g_vm->glk_gestalt(gestalt_Graphics, 0);
SOUND_SUPPORTED->value = (int)g_vm->glk_gestalt(gestalt_Sound, 0);
SOUND_ENABLED->value = (int)g_vm->glk_gestalt(gestalt_Sound, 0);
TIMER_SUPPORTED->value = (int)g_vm->glk_gestalt(gestalt_Timer, 0);
TIMER_ENABLED->value = (int)g_vm->glk_gestalt(gestalt_Timer, 0);
create_cinteger("true", 1);
create_cinteger("false", 0);
create_cinteger("null", 0);
create_cinteger("nowhere", 0);
create_cinteger("heavy", HEAVY);
create_cinteger("scenery", SCENERY);
create_cinteger("north", NORTH_DIR);
create_cinteger("south", SOUTH_DIR);
create_cinteger("east", EAST_DIR);
create_cinteger("west", WEST_DIR);
create_cinteger("northeast", NORTHEAST_DIR);
create_cinteger("northwest", NORTHWEST_DIR);
create_cinteger("southeast", SOUTHEAST_DIR);
create_cinteger("southwest", SOUTHWEST_DIR);
create_cinteger("up", UP_DIR);
create_cinteger("down", DOWN_DIR);
create_cinteger("in", IN_DIR);
create_cinteger("out", OUT_DIR);
create_cinteger("parent", 0);
create_cinteger("quantity", 1);
create_cinteger("capacity", 1);
create_cinteger("mass", 2);
create_cinteger("bearing", 3);
create_cinteger("velocity", 4);
create_cinteger("next", 5);
create_cinteger("previous", 6);
create_cinteger("child", 7);
create_cinteger("index", 8);
create_cinteger("status", 9);
create_cinteger("state", 10);
create_cinteger("counter", 11);
create_cinteger("points", 12);
create_cinteger("class", 13);
create_cinteger("x", 14);
create_cinteger("y", 15);
create_cinteger("volume", 100);
create_cinteger("volume", 100);
create_cinteger("volume", 100);
create_cinteger("volume", 100);
create_cinteger("volume", 100);
create_cinteger("volume", 100);
create_cinteger("volume", 100);
create_cinteger("volume", 100);
create_cinteger("timer", 500);
set_defaults();
/* CREATE A DUMMY FUNCTION TO BE USED WHEN AN ERROR MESSAGE
IS PRINTED AS A RESULT OF CODE CALLED BY THE INTERPRETER */
if ((function_table = (struct function_type *)
malloc(sizeof(struct function_type))) == nullptr)
outofmem();
else {
current_function = function_table;
Common::strcpy_s(current_function->name, "JACL*Internal");
current_function->position = 0;
current_function->self = 0;
current_function->call_count = 0;
current_function->call_count_backup = 0;
current_function->next_function = nullptr;
}
executing_function = function_table;
errors = 0;
objects = 0;
integers = 0;
functions = 0;
strings = 0;
g_vm->glk_stream_set_position(game_stream, start_of_file, seekmode_Start);
result = glk_get_bin_line_stream(game_stream, text_buffer, (glui32) 1024);
line++;
if (!encrypted && strstr(text_buffer, "#encrypted")) {
encrypted = TRUE;
result = glk_get_bin_line_stream(game_stream, text_buffer, (glui32) 1024);
line++;
}
if (encrypted) jacl_decrypt(text_buffer);
while (result) {
encapsulate();
if (word[0] == nullptr);
else if (text_buffer[0] == '{') {
while (result) {
result = glk_get_bin_line_stream(game_stream, text_buffer, (glui32) 1024);
line++;
if (!encrypted && strstr(text_buffer, "#encrypted")) {
encrypted = TRUE;
result = glk_get_bin_line_stream(game_stream, text_buffer, (glui32) 1024);
line++;
}
if (encrypted) jacl_decrypt(text_buffer);
if (text_buffer[0] == '}')
break;
}
} else {
if (!strcmp(word[0], "grammar")) {
if (word[++wp] == nullptr) {
noproperr(line);
errors++;
} else {
if (grammar_table == nullptr) {
if ((grammar_table = (struct word_type *)
malloc(sizeof(struct word_type))) == nullptr)
outofmem();
else {
strncpy(grammar_table->word, word[wp], 40);
grammar_table->word[40] = 0;
grammar_table->next_sibling = nullptr;
grammar_table->first_child = nullptr;
build_grammar_table(grammar_table);
}
} else
build_grammar_table(grammar_table);
}
} else if (!strcmp(word[0], "object")
|| !strcmp(word[0], "location")) {
if (word[1] == nullptr) {
noproperr(line);
errors++;
} else if (legal_label_check(word[1], line, OBJ_TYPE)) {
errors++;
} else {
objects++;
if (objects == MAX_OBJECTS) {
log_error(MAXIMUM_EXCEEDED, PLUS_STDERR);
terminate(47);
return;
} else {
if ((object[objects] = (struct object_type *)
malloc(sizeof(struct object_type))) == nullptr)
outofmem();
strncpy(object[objects]->label, word[1], 40);
object[objects]->label[40] = 0;
object[objects]->first_plural = nullptr;
Common::strcpy_s(object[objects]->described, object[objects]->label);
Common::strcpy_s(object[objects]->inventory, object[objects]->label);
Common::strcpy_s(object[objects]->article, "the");
Common::strcpy_s(object[objects]->definite, "the");
object[objects]->attributes = FALSE;
object[objects]->user_attributes = FALSE;
for (counter = 0; counter < 16; counter++)
object[objects]->integer[counter] = 0;
}
object[objects]->nosave = FALSE;
}
} else if (!strcmp(word[0], "synonym")) {
if (word[++wp] == nullptr) {
noproperr(line);
errors++;
} else {
if ((new_synonym = (struct synonym_type *)
malloc(sizeof(struct synonym_type))) == nullptr)
outofmem();
else {
if (synonym_table == nullptr) {
synonym_table = new_synonym;
} else {
current_synonym->next_synonym = new_synonym;
}
}
current_synonym = new_synonym;
strncpy(current_synonym->original, word[wp], 40);
current_synonym->original[40] = 0;
if (word[++wp] == nullptr) {
noproperr(line);
errors++;
} else {
strncpy(current_synonym->standard, word[wp], 40);
current_synonym->standard[40] = 0;
}
current_synonym->next_synonym = nullptr;
}
} else if (!strcmp(word[0], "parameter")) {
#ifdef UNUSED
if (word[2] == NULL) {
noproperr(line);
errors++;
} else {
if ((new_parameter = (struct parameter_type *)
malloc(sizeof(struct parameter_type))) == NULL)
outofmem();
else {
if (parameter_table == NULL) {
parameter_table = new_parameter;
} else {
current_parameter->next_parameter =
new_parameter;
}
current_parameter = new_parameter;
strncpy(current_parameter->name, word[1], 40);
current_parameter->name[40] = 0;
strncpy(current_parameter->container, word[2], 40);
current_parameter->container[40] = 0;
current_parameter->next_parameter = NULL;
}
if (word[4] != NULL) {
if (validate(word[3]))
current_parameter->low = atoi(word[3]);
else
current_parameter->low = -65535;
if (validate(word[4]))
current_parameter->high = atoi(word[4]);
else
current_parameter->high = 65535;
} else {
current_parameter->low = -65535;
current_parameter->high = 65535;
}
}
#else
warning("parameter");
#endif
} else if (!strcmp(word[0], "constant")) {
if (word[2] == nullptr) {
noproperr(line);
errors++;
} else {
/* CHECK IF MORE THAN ONE VALUE IS SUPPLIED AND CREATE
ADDITIONAL CONSTANTS IF REQUIRED */
index = 2;
while (word[index] != nullptr && index < MAX_WORDS) {
if (quoted[index] == TRUE || !validate(word[index])) {
if (legal_label_check(word[1], line, CSTR_TYPE)) {
errors++;
} else {
create_cstring(word[1], word[index]);
}
} else {
if (legal_label_check(word[1], line, CINT_TYPE)) {
errors++;
} else {
create_cinteger(word[1], value_of(word[index])/*, FALSE */);
if (!value_resolved) {
unkvalerr(line, index);
errors++;
}
}
}
index++;
}
}
} else if (!strcmp(word[0], "attribute")) {
if (word[1] == nullptr) {
noproperr(line);
errors++;
} else if (legal_label_check(word[1], line, ATT_TYPE)) {
errors++;
} else if (current_attribute != nullptr && current_attribute->value == 1073741824) {
maxatterr(line, 1);
errors++;
} else {
if ((new_attribute = (struct attribute_type *)
malloc(sizeof(struct attribute_type))) == nullptr)
outofmem();
else {
if (attribute_table == nullptr) {
attribute_table = new_attribute;
new_attribute->value = 1;
} else {
current_attribute->next_attribute = new_attribute;
new_attribute->value = current_attribute->value * 2;
}
current_attribute = new_attribute;
strncpy(current_attribute->name, word[1], 40);
current_attribute->name[40] = 0;
current_attribute->next_attribute = nullptr;
}
/* CHECK IF MORE THAN ONE VALUE IS SUPPLIED AND CREATE
ADDITIONAL CONSTANTS IF REQUIRED */
index = 2;
while (word[index] != nullptr && index < MAX_WORDS) {
if (legal_label_check(word[index], line, ATT_TYPE)) {
errors++;
} else if (current_attribute != nullptr && current_attribute->value == 1073741824) {
maxatterr(line, index);
errors++;
} else {
if ((new_attribute = (struct attribute_type *)
malloc(sizeof(struct attribute_type))) == nullptr)
outofmem();
else {
current_attribute->next_attribute = new_attribute;
new_attribute->value = current_attribute->value * 2;
current_attribute = new_attribute;
strncpy(current_attribute->name, word[index], 40);
current_attribute->name[40] = 0;
current_attribute->next_attribute = nullptr;
}
}
index++;
}
}
} else if (!strcmp(word[0], "string")) {
if (word[1] == nullptr) {
noproperr(line);
errors++;
} else if (legal_label_check(word[1], line, STR_TYPE)) {
errors++;
} else {
if (word[2] == nullptr) {
create_string(word[1], "");
} else {
create_string(word[1], word[2]);
index = 3;
while (word[index] != nullptr && index < MAX_WORDS) {
create_string(word[1], word[index]);
index++;
}
}
}
} else if (!strcmp(word[0], "filter")) {
if (word[++wp] == nullptr) {
noproperr(line);
errors++;
} else {
if ((new_filter = (struct filter_type *)
malloc(sizeof(struct filter_type))) == nullptr)
outofmem();
else {
if (filter_table == nullptr) {
filter_table = new_filter;
} else {
current_filter->next_filter = new_filter;
}
current_filter = new_filter;
strncpy(current_filter->word, word[wp], 40);
current_filter->word[40] = 0;
current_filter->next_filter = nullptr;
}
}
} else if (!strcmp(word[0], "string_array")) {
if (word[2] == nullptr) {
noproperr(line);
errors++;
} else if (legal_label_check(word[1], line, STR_TYPE)) {
errors++;
} else {
int x;
index = value_of(word[2], FALSE);
if (!value_resolved) {
unkvalerr(line, 2);
errors++;
}
for (x = 0; x < index; x++) {
create_string(word[1], word[3]);
}
}
} else if (!strcmp(word[0], "integer_array")) {
if (word[2] == nullptr) {
noproperr(line);
errors++;
} else if (legal_label_check(word[1], line, INT_TYPE)) {
errors++;
} else {
int default_value, x;
if (word[3] != nullptr) {
default_value = value_of(word[3], FALSE);
if (!value_resolved) {
unkvalerr(line, 3);
errors++;
}
} else {
default_value = 0;
}
/* THIS IS THE NUMBER OF ARRAY ELEMENTS TO MAKE */
index = value_of(word[2], FALSE);
if (!value_resolved) {
unkvalerr(line, 2);
errors++;
}
for (x = 0; x < index; x++) {
create_integer(word[1], default_value);
}
}
} else if (!strcmp(word[0], "integer")) {
if (word[1] == nullptr) {
noproperr(line);
errors++;
} else if (legal_label_check(word[1], line, INT_TYPE)) {
errors++;
} else {
create_integer(word[1], 0);
/* CHECK IF MORE THAN ONE VALUE IS SUPPLIED AND CREATE
ADDITIONAL VARIABLES IF REQUIRED */
index = 3;
while (word[index] != nullptr && index < MAX_WORDS) {
create_integer(word[1], 0);
index++;
}
}
}
}
result = glk_get_bin_line_stream(game_stream, text_buffer, (glui32) 1024);
line++;
if (!encrypted && strstr(text_buffer, "#encrypted")) {
encrypted = TRUE;
result = glk_get_bin_line_stream(game_stream, text_buffer, (glui32) 1024);
line++;
}
if (encrypted) jacl_decrypt(text_buffer);
}
if (errors) {
totalerrs(errors);
terminate(48);
return;
}
/*************************************************************************
* START OF SECOND PASS *
*************************************************************************/
/* IF NO SIZE IS SPECIFIED FOR THE STATUS WINDOW, SET IT TO 1 */
if (integer_resolve("status_window") == nullptr) {
create_integer("status_window", 1);
}
/* IF NO STRING IS SPECIFIED FOR THE COMMAND PROMPT, SET IT TO "^> " */
if (string_resolve("command_prompt") == nullptr) {
create_string("command_prompt", "^> ");
}
/* IF NO STRING IS SPECIFIED FOR THE GAME_TITLE, SET IT TO THE FILENAME */
if (cstring_resolve("game_title") == nullptr) {
create_cstring("game_title", prefix);
}
create_language_constants();
/* MUST RE-DETERMINE THE POINT IN THE GAME FILE THAT ENCRYPTION STARTS */
encrypted = FALSE;
/* SET CURRENT VARIABLE TO POINT TO THE FIRST USER VARIABLE THAT WAS
* CREATED AFTER THE SYSTEM VARIABLES */
current_integer = last_system_integer;
line = 0;
g_vm->glk_stream_set_position(game_stream, start_of_file, seekmode_Start);
result = glk_get_bin_line_stream(game_stream, text_buffer, (glui32) 1024);
line++;
if (!encrypted && strstr(text_buffer, "#encrypted")) {
encrypted = TRUE;
result = glk_get_bin_line_stream(game_stream, text_buffer, (glui32) 1024);
line++;
}
if (encrypted) jacl_decrypt(text_buffer);
while (result) {
encapsulate();
if (word[0] == nullptr);
else if (text_buffer[0] == '{') {
word[wp]++; /* MOVE THE START OF THE FIRST WORD ONLY
* TO PAST THE '{'. */
if (word[wp][0] == 0) {
nofnamerr(line);
errors++;
} else {
while (word[wp] != nullptr && wp < MAX_WORDS) {
if (word[wp][0] == '+') {
strncpy(function_name, word[wp], 80);
function_name[80] = 0;
self_parent = 0;
} else if (word[wp][0] == '*') {
const char *last_underscore = (char *)nullptr;
/* ALLOW MANUAL NAMING OF ASSOCIATED FUNCTIONS */
/* TO GIVE CLASS-LIKE BEHAVIOR */
strncpy(function_name, word[wp] + 1, 80);
function_name[80] = 0;
/* LOOK FOR THE FINAL UNDERSCORE AND SEE IF */
/* IT IS FOLLOWED BY AN OBJECT LABEL */
last_underscore = strrchr(word[wp], '_');
if (last_underscore != nullptr) {
self_parent = object_resolve(last_underscore + 1);
} else {
self_parent = 0;
}
} else if (object_count == 0) {
nongloberr(line);
errors++;
} else {
strncpy(function_name, word[wp], 59);
function_name[60] = '\0';
Common::strcat_s(function_name, "_");
Common::strcat_s(function_name, object[object_count]->label);
self_parent = object_count;
}
if (function_table == nullptr) {
if ((function_table = (struct function_type *)
malloc(sizeof(struct function_type))) == nullptr)
outofmem();
else {
// STORE THE NUMBER OF FUNCTION DEFINED TO
// HELP VALIDATE SAVED GAME FILES
functions++;
current_function = function_table;
Common::strcpy_s(current_function->name, function_name);
current_function->position = g_vm->glk_stream_get_position(game_stream);
current_function->call_count = 0;
current_function->call_count_backup = 0;
current_function->self = self_parent;
current_function->next_function = nullptr;
}
} else {
if ((current_function->next_function =
(struct function_type *)
malloc(sizeof(struct function_type))) == nullptr)
outofmem();
else {
// STORE THE NUMBER OF FUNCTION DEFINED TO
// HELP VALIDATE SAVED GAME FILES
functions++;
current_function = current_function->next_function;
Common::strcpy_s(current_function->name, function_name);
current_function->position = g_vm->glk_stream_get_position(game_stream);
current_function->call_count = 0;
current_function->call_count_backup = 0;
current_function->self = self_parent;
current_function->next_function = nullptr;
}
}
wp++;
}
}
while (result) {
result = glk_get_bin_line_stream(game_stream, text_buffer, (glui32) 1024);
line++;
if (!encrypted && strstr(text_buffer, "#encrypted")) {
encrypted = TRUE;
result = glk_get_bin_line_stream(game_stream, text_buffer, (glui32) 1024);
line++;
}
if (encrypted) jacl_decrypt(text_buffer);
if (text_buffer[0] == '}')
break;
}
}
else if (!strcmp(word[0], "string_array")) {
} else if (!strcmp(word[0], "integer_array")) {
if (word[2] == nullptr) {
noproperr(line);
errors++;
} else {
int x;
/* THIS IS THE NUMBER OF ARRAY ELEMENTS TO MAKE */
index = value_of(word[2], FALSE);
if (!value_resolved) {
unkvalerr(line, 2);
errors++;
}
for (x = 0; x < index; x++) {
current_integer = current_integer->next_integer;
}
}
} else if (!strcmp(word[0], "integer")) {
if (word[2] != nullptr) {
current_integer = current_integer->next_integer;
current_integer->value = value_of(word[2], FALSE);
if (!value_resolved) {
unkvalerr(line, 2);
errors++;
}
index = 3;
while (word[index] != nullptr && index < MAX_WORDS) {
current_integer = current_integer->next_integer;
current_integer->value = value_of(word[index], FALSE);
if (!value_resolved) {
unkvalerr(line, index);
errors++;
}
index++;
}
} else {
current_integer = current_integer->next_integer;
current_integer->value = FALSE;
}
/* CONSUME ALL THESE KEYWORDS TO AVOID AN UNKNOWN KEYWORD */
/* ERROR DURING THE SECOND PASS (ALL WORK DONE IN FIRST PASS) */
} else if (!strcmp(word[0], "constant"));
else if (!strcmp(word[0], "string"));
else if (!strcmp(word[0], "attribute"));
else if (!strcmp(word[0], "parameter"));
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] == nullptr) {
noproperr(line);
errors++;
} else if (object_count == 0) {
noobjerr(line);
errors++;
} else {
for (index = 1; word[index] != nullptr && index < MAX_WORDS; index++) {
if ((bit_mask = attribute_resolve(word[index]))) {
object[object_count]->attributes = object[object_count]->attributes | bit_mask;
} else if ((bit_mask = user_attribute_resolve(word[index]))) {
object[object_count]->user_attributes = object[object_count]->user_attributes | bit_mask;
} else {
unkatterr(line, index);
errors++;
}
}
}
} else if (!strcmp(word[0], "object")
|| !strcmp(word[0], "location")) {
object_count++;
if (!strcmp(word[0], "object")) {
object[object_count]->MASS = SCENERY;
if (location_count == 0)
object[object_count]->PARENT = 0;
else
object[object_count]->PARENT = location_count;
} else {
location_count = object_count;
object[object_count]->PARENT = 0;
object[object_count]->attributes =
object[object_count]->attributes | LOCATION;
}
if ((object[object_count]->first_name =
(struct name_type *) malloc(sizeof(struct name_type)))
== nullptr)
outofmem();
else {
current_name = object[object_count]->first_name;
if (word[2] != nullptr) {
strncpy(current_name->name, word[2], 40);
} else {
strncpy(current_name->name, object[object_count]->label, 40);
}
current_name->name[40] = 0;
current_name->next_name = nullptr;
}
wp = 3;
while (word[wp] != nullptr && wp < MAX_WORDS) {
if ((current_name->next_name = (struct name_type *)
malloc(sizeof(struct name_type))) == nullptr)
outofmem();
else {
current_name = current_name->next_name;
strncpy(current_name->name, word[wp], 40);
current_name->name[40] = 0;
current_name->next_name = nullptr;
}
wp++;
}
} else if (!strcmp(word[0], "plural")) {
if (word[1] == nullptr) {
noproperr(line);
errors++;
} else {
if ((object[object_count]->first_plural =
(struct name_type *) malloc(sizeof(struct name_type)))
== nullptr)
outofmem();
else {
current_name = object[object_count]->first_plural;
strncpy(current_name->name, word[1], 40);
current_name->name[40] = 0;
current_name->next_name = nullptr;
}
wp = 2;
while (word[wp] != nullptr && wp < MAX_WORDS) {
if ((current_name->next_name = (struct name_type *)
malloc(sizeof(struct name_type))) == nullptr)
outofmem();
else {
current_name = current_name->next_name;
strncpy(current_name->name, word[wp], 40);
current_name->name[40] = 0;
current_name->next_name = nullptr;
}
wp++;
}
}
} else if (!strcmp(word[0], "static")) {
if (object_count == 0) {
noobjerr(line);
errors++;
} else
object[object_count]->nosave = TRUE;
} else if (!strcmp(word[0], "player")) {
if (object_count == 0) {
noobjerr(line);
errors++;
} else
player = object_count;
} else if (!strcmp(word[0], "short")) {
if (word[2] == nullptr) {
noproperr(line);
errors++;
} else if (object_count == 0) {
noobjerr(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], "definite")) {
if (word[1] == nullptr) {
noproperr(line);
errors++;
} else if (object_count == 0) {
noobjerr(line);
errors++;
} else {
strncpy(object[object_count]->definite, word[1], 10);
object[object_count]->definite[10] = 0;
}
} else if (!strcmp(word[0], "long")) {
if (word[1] == nullptr) {
noproperr(line);
errors++;
} else if (object_count == 0) {
noobjerr(line);
errors++;
} else {
strncpy(object[object_count]->described, word[1], 80);
object[object_count]->described[80] = 0;
}
} else if ((resolved_cinteger = cinteger_resolve(word[0])) != nullptr) {
index = resolved_cinteger->value;
if (word[1] == nullptr) {
noproperr(line);
errors++;
} else if (object_count == 0) {
noobjerr(line);
errors++;
} else if (!strcmp(word[1], "here")) {
object[object_count]->integer[index] = location_count;
} else {
object[object_count]->integer[index] = value_of(word[1], FALSE);
if (!value_resolved) {
unkvalerr(line, 1);
errors++;
}
}
} else {
unkkeyerr(line, 0);
errors++;
}
result = glk_get_bin_line_stream(game_stream, text_buffer, (glui32) 1024);
line++;
if (!encrypted && strstr(text_buffer, "#encrypted")) {
encrypted = TRUE;
result = glk_get_bin_line_stream(game_stream, text_buffer, (glui32) 1024);
line++;
}
if (encrypted) jacl_decrypt(text_buffer);
}
/* CREATE THE CONSTANT THE RECORDS THE TOTAL NUMBER OF OBJECTS */
create_cinteger("objects", objects);
/* LOOP THROUGH ALL THE OBJECTS AND CALL THEIR CONSTRUCTORS
for (index = 1; index <= objects; index++) {
strcpy (function_name, "constructor_");
strcat (function_name, object[index]->label);
execute (function_name);
}
*/
if (errors) {
totalerrs(errors);
terminate(48);
return;
}
}
void build_grammar_table(struct word_type *pointer) {
do {
if (!strcmp(word[wp], pointer->word)) {
if (pointer->first_child == nullptr && word[wp + 1] != nullptr) {
if ((pointer->first_child = (struct word_type *)
malloc(sizeof(struct word_type)))
== nullptr)
outofmem();
else {
pointer = pointer->first_child;
strncpy(pointer->word, word[++wp], 40);
pointer->word[40] = 0;
pointer->next_sibling = nullptr;
pointer->first_child = nullptr;
}
} else {
pointer = pointer->first_child;
wp++;
}
} else {
if (pointer->next_sibling == nullptr) {
if ((pointer->next_sibling = (struct word_type *)
malloc(sizeof(struct word_type)))
== nullptr)
outofmem();
else {
pointer = pointer->next_sibling;
strncpy(pointer->word, word[wp], 40);
pointer->word[40] = 0;
pointer->next_sibling = nullptr;
pointer->first_child = nullptr;
}
} else
pointer = pointer->next_sibling;
}
} while (word[wp] != nullptr && wp < MAX_WORDS);
}
int legal_label_check(const char *label_word, int line, int type) {
struct integer_type *integer_pointer = integer_table;
struct cinteger_type *cinteger_pointer = cinteger_table;
struct string_type *string_pointer = string_table;
struct string_type *cstring_pointer = cstring_table;
struct attribute_type *attribute_pointer = attribute_table;
int index;
if (!strcmp(label_word, "here") ||
!strcmp(label_word, "player") ||
!strcmp(label_word, "integer") ||
!strcmp(label_word, "arg") ||
!strcmp(label_word, "string_arg") ||
!strcmp(label_word, "arg") ||
!strcmp(label_word, "$label_word") ||
!strcmp(label_word, "self") ||
!strcmp(label_word, "this") ||
!strcmp(label_word, "noun1") ||
!strcmp(label_word, "noun2") ||
!strcmp(label_word, "noun3") ||
!strcmp(label_word, "noun4") ||
!strcmp(label_word, "objects") ||
validate(label_word)) {
Common::sprintf_s(error_buffer, 1024, ILLEGAL_LABEL, line, label_word);
log_error(error_buffer, PLUS_STDERR);
return (TRUE);
}
if (type == CSTR_TYPE) {
if (!strcmp(label_word, "command_prompt")) {
Common::sprintf_s(error_buffer, 1024, USED_LABEL_STR, line, label_word);
log_error(error_buffer, PLUS_STDERR);
return (TRUE);
}
}
while (integer_pointer != nullptr && type != INT_TYPE) {
if (!strcmp(label_word, integer_pointer->name)) {
Common::sprintf_s(error_buffer, 1024, USED_LABEL_INT, line, label_word);
log_error(error_buffer, PLUS_STDERR);
return (TRUE);
} else
integer_pointer = integer_pointer->next_integer;
}
while (cinteger_pointer != nullptr && type != CINT_TYPE) {
if (!strcmp(label_word, cinteger_pointer->name)) {
Common::sprintf_s(error_buffer, 1024, USED_LABEL_CINT, line, label_word);
log_error(error_buffer, PLUS_STDERR);
return (TRUE);
} else
cinteger_pointer = cinteger_pointer->next_cinteger;
}
while (string_pointer != nullptr && type != STR_TYPE) {
if (!strcmp(label_word, string_pointer->name)) {
Common::sprintf_s(error_buffer, 1024, USED_LABEL_STR, line, label_word);
log_error(error_buffer, PLUS_STDERR);
return (TRUE);
} else
string_pointer = string_pointer->next_string;
}
while (cstring_pointer != nullptr && type != CSTR_TYPE) {
if (!strcmp(label_word, cstring_pointer->name)) {
Common::sprintf_s(error_buffer, 1024, USED_LABEL_CSTR, line, label_word);
log_error(error_buffer, PLUS_STDERR);
return (TRUE);
} else
cstring_pointer = cstring_pointer->next_string;
}
/* DON'T CHECK FOR ATT_TYPE AS YOU CAN'T HAVE ATTRIBUTE ARRAYS. */
while (attribute_pointer != nullptr) {
if (!strcmp(label_word, attribute_pointer->name)) {
Common::sprintf_s(error_buffer, 1024, USED_LABEL_ATT, line, label_word);
write_text(error_buffer);
return (TRUE);
} else
attribute_pointer = attribute_pointer->next_attribute;
}
for (index = 1; index <= objects; index++) {
if (!strcmp(label_word, object[index]->label)) {
Common::sprintf_s(error_buffer, 1024, USED_LABEL_OBJ,
line, label_word);
log_error(error_buffer, PLUS_STDERR);
return (TRUE);
}
}
return (FALSE);
}
void restart_game() {
int index;
integer_type *curr_integer;
integer_type *previous_integer;
synonym_type *current_synonym;
synonym_type *previous_synonym;
name_type *current_name;
name_type *next_name;
function_type *current_function;
function_type *previous_function;
string_type *curr_string;
string_type *previous_string;
attribute_type *current_attribute;
attribute_type *previous_attribute;
cinteger_type *previous_cinteger;
filter_type *current_filter;
filter_type *previous_filter;
if (SOUND_SUPPORTED->value) {
/* STOP ALL SOUNDS AND SET VOLUMES BACK TO 100% */
for (index = 0; index < 4; index++) {
g_vm->glk_schannel_stop(sound_channel[index]);
g_vm->glk_schannel_set_volume(sound_channel[index], 65535);
/* STORE A COPY OF THE CURRENT VOLUME FOR ACCESS
* FROM JACL CODE */
Common::sprintf_s(temp_buffer, 1024, "volume[%d]", index);
cinteger_resolve(temp_buffer)->value = 100;
}
}
/* FREE ALL OBJECTS */
for (index = 1; index <= objects; index++) {
current_name = object[index]->first_name;
while (current_name->next_name != nullptr) {
next_name = current_name->next_name;
free(current_name);
current_name = next_name;
}
free(current_name);
free(object[index]);
}
/* FREE ALL VARIABLES */
if (integer_table != nullptr) {
if (integer_table->next_integer != nullptr) {
do {
curr_integer = integer_table;
previous_integer = integer_table;
while (curr_integer->next_integer != nullptr) {
previous_integer = curr_integer;
curr_integer = curr_integer->next_integer;
}
free(curr_integer);
previous_integer->next_integer = nullptr;
} while (previous_integer != integer_table);
}
free(integer_table);
integer_table = nullptr;
}
/* FREE ALL FUNCTIONS */
if (function_table != nullptr) {
if (function_table->next_function != nullptr) {
do {
current_function = function_table;
previous_function = function_table;
while (current_function->next_function != nullptr) {
previous_function = current_function;
current_function = current_function->next_function;
}
free(current_function);
previous_function->next_function = nullptr;
} while (previous_function != function_table);
}
free(function_table);
function_table = nullptr;
}
/* FREE ALL FILTERS */
if (filter_table != nullptr) {
if (filter_table->next_filter != nullptr) {
do {
current_filter = filter_table;
previous_filter = filter_table;
while (current_filter->next_filter != nullptr) {
previous_filter = current_filter;
current_filter = current_filter->next_filter;
}
free(current_filter);
previous_filter->next_filter = nullptr;
} while (previous_filter != filter_table);
}
free(filter_table);
filter_table = nullptr;
}
/* FREE ALL STRINGS */
if (string_table != nullptr) {
if (string_table->next_string != nullptr) {
do {
curr_string = string_table;
previous_string = string_table;
while (curr_string->next_string != nullptr) {
previous_string = curr_string;
curr_string = curr_string->next_string;
}
free(curr_string);
previous_string->next_string = nullptr;
} while (previous_string != string_table);
}
free(string_table);
string_table = nullptr;
}
/* FREE ALL ATTRIBUTES */
if (attribute_table != nullptr) {
if (attribute_table->next_attribute != nullptr) {
do {
current_attribute = attribute_table;
previous_attribute = attribute_table;
while (current_attribute->next_attribute != nullptr) {
previous_attribute = current_attribute;
current_attribute = current_attribute->next_attribute;
}
free(current_attribute);
previous_attribute->next_attribute = nullptr;
} while (previous_attribute != attribute_table);
}
free(attribute_table);
attribute_table = nullptr;
}
/* FREE ALL CONSTANTS */
if (cinteger_table != nullptr) {
if (cinteger_table->next_cinteger != nullptr) {
do {
current_cinteger = cinteger_table;
previous_cinteger = cinteger_table;
while (current_cinteger->next_cinteger != nullptr) {
previous_cinteger = current_cinteger;
current_cinteger = current_cinteger->next_cinteger;
}
free(current_cinteger);
previous_cinteger->next_cinteger = nullptr;
} while (previous_cinteger != cinteger_table);
}
free(cinteger_table);
cinteger_table = nullptr;
}
if (cstring_table != nullptr) {
if (cstring_table->next_string != nullptr) {
do {
curr_string = cstring_table;
previous_string = cstring_table;
while (curr_string->next_string != nullptr) {
previous_string = curr_string;
curr_string = curr_string->next_string;
}
free(curr_string);
previous_string->next_string = nullptr;
} while (previous_string != cstring_table);
}
free(cstring_table);
cstring_table = nullptr;
}
/* FREE ALL SYNONYMS */
if (synonym_table != nullptr) {
if (synonym_table->next_synonym != nullptr) {
do {
current_synonym = synonym_table;
previous_synonym = synonym_table;
while (current_synonym->next_synonym != nullptr) {
previous_synonym = current_synonym;
current_synonym = current_synonym->next_synonym;
}
free(current_synonym);
previous_synonym->next_synonym = nullptr;
} while (previous_synonym != synonym_table);
}
free(synonym_table);
synonym_table = nullptr;
}
free_from(grammar_table);
grammar_table = nullptr;
read_gamefile();
}
void free_from(struct word_type *x) {
if (x) {
free_from(x->first_child);
free_from(x->next_sibling);
free(x);
}
}
void set_defaults() {
/* RESET THE BACK-REFERENCE VARIABLES */
them[0] = 0;
it = 0;
her = 0;
him = 0;
}
void create_cinteger(const char *name, int value) {
struct cinteger_type *new_cinteger = nullptr;
if ((new_cinteger = (struct cinteger_type *)
malloc(sizeof(struct cinteger_type))) == nullptr) {
outofmem();
} else {
if (cinteger_table == nullptr) {
cinteger_table = new_cinteger;
} else {
current_cinteger->next_cinteger = new_cinteger;
}
current_cinteger = new_cinteger;
strncpy(current_cinteger->name, name, 40);
current_cinteger->name[40] = 0;
current_cinteger->value = value;
current_cinteger->next_cinteger = nullptr;
}
}
void create_integer(const char *name, int value) {
struct integer_type *new_integer = nullptr;
if ((new_integer = (struct integer_type *)
malloc(sizeof(struct integer_type))) == nullptr) {
outofmem();
} else {
/* KEEP A COUNT OF HOW MANY INTEGERS ARE DEFINED TO
* VALIDATE SAVED GAMES */
integers++;
if (integer_table == nullptr) {
integer_table = new_integer;
} else {
current_integer->next_integer = new_integer;
}
current_integer = new_integer;
strncpy(current_integer->name, name, 40);
current_integer->name[40] = 0;
current_integer->value = value;
current_integer->next_integer = nullptr;
}
}
void create_string(const char *name, const char *value) {
struct string_type *new_string = nullptr;
if ((new_string = (struct string_type *)
malloc(sizeof(struct string_type))) == nullptr) {
outofmem();
} else {
/* KEEP A COUNT OF HOW MANY STRINGS ARE DEFINED TO
* VALIDATE SAVED GAMES */
strings++;
if (string_table == nullptr) {
string_table = new_string;
} else {
current_string->next_string = new_string;
}
current_string = new_string;
strncpy(current_string->name, name, 40);
current_string->name[40] = 0;
if (value != nullptr) {
strncpy(current_string->value, value, 255);
} else {
/* IF NO VALUE IS SUPPLIED, JUST NULL-TERMINATE
* THE STRING */
current_string->value[0] = 0;
}
current_string->value[255] = 0;
current_string->next_string = nullptr;
}
}
void create_cstring(const char *name, const char *value) {
struct string_type *new_string = nullptr;
if ((new_string = (struct string_type *)
malloc(sizeof(struct string_type))) == nullptr) {
outofmem();
} else {
if (cstring_table == nullptr) {
cstring_table = new_string;
} else {
current_cstring->next_string = new_string;
}
current_cstring = new_string;
strncpy(current_cstring->name, name, 40);
current_cstring->name[40] = 0;
if (value != nullptr) {
strncpy(current_cstring->value, value, 255);
} else {
/* IF NO VALUE IS SUPPLIED, JUST NULL-TERMINATE
* THE STRING */
current_cstring->value[0] = 0;
}
current_cstring->value[255] = 0;
current_cstring->next_string = nullptr;
}
}
void create_language_constants() {
/* SET THE DEFAULT LANGUAGE CONSTANTS IF ANY OR ALL OF THEM
* ARE MISSING FROM THE GAME THAT IS BEING LOADED. DEFAULT
* TO THE NATIVE_LANGUAGE SETTING IN language.h */
if (cstring_resolve("COMMENT_IGNORED") == nullptr)
create_cstring("COMMENT_IGNORED", COMMENT_IGNORED);
if (cstring_resolve("COMMENT_RECORDED") == nullptr)
create_cstring("COMMENT_RECORDED", COMMENT_RECORDED);
if (cstring_resolve("YES_WORD") == nullptr)
create_cstring("YES_WORD", YES_WORD);
if (cstring_resolve("NO_WORD") == nullptr)
create_cstring("NO_WORD", NO_WORD);
if (cstring_resolve("YES_OR_NO") == nullptr)
create_cstring("YES_OR_NO", YES_OR_NO);
if (cstring_resolve("INVALID_SELECTION") == nullptr)
create_cstring("INVALID_SELECTION", INVALID_SELECTION);
if (cstring_resolve("RESTARTING") == nullptr)
create_cstring("RESTARTING", RESTARTING);
if (cstring_resolve("RETURN_GAME") == nullptr)
create_cstring("RETURN_GAME", RETURN_GAME);
if (cstring_resolve("SCRIPTING_ON") == nullptr)
create_cstring("SCRIPTING_ON", SCRIPTING_ON);
if (cstring_resolve("SCRIPTING_OFF") == nullptr)
create_cstring("SCRIPTING_OFF", SCRIPTING_OFF);
if (cstring_resolve("SCRIPTING_ALREADY_OFF") == nullptr)
create_cstring("SCRIPTING_ALREADY_OFF", SCRIPTING_ALREADY_OFF);
if (cstring_resolve("SCRIPTING_ALREADY_ON") == nullptr)
create_cstring("SCRIPTING_ALREADY_ON", SCRIPTING_ALREADY_ON);
if (cstring_resolve("CANT_WRITE_SCRIPT") == nullptr)
create_cstring("CANT_WRITE_SCRIPT", CANT_WRITE_SCRIPT);
if (cstring_resolve("ERROR_READING_WALKTHRU") == nullptr)
create_cstring("ERROR_READING_WALKTHRU", ERROR_READING_WALKTHRU);
if (cstring_resolve("BAD_OOPS") == nullptr)
create_cstring("BAD_OOPS", BAD_OOPS);
if (cstring_resolve("CANT_CORRECT") == nullptr)
create_cstring("CANT_CORRECT", CANT_CORRECT);
if (cstring_resolve("SURE_QUIT") == nullptr)
create_cstring("SURE_QUIT", SURE_QUIT);
if (cstring_resolve("SURE_RESTART") == nullptr)
create_cstring("SURE_RESTART", SURE_RESTART);
if (cstring_resolve("NOT_CLEVER") == nullptr)
create_cstring("NOT_CLEVER", NOT_CLEVER);
if (cstring_resolve("NO_MOVES") == nullptr)
create_cstring("NO_MOVES", NO_MOVES);
if (cstring_resolve("TYPE_NUMBER") == nullptr)
create_cstring("TYPE_NUMBER", TYPE_NUMBER);
if (cstring_resolve("BY") == nullptr)
create_cstring("BY", BY);
if (cstring_resolve("REFERRING_TO") == nullptr)
create_cstring("REFERRING_TO", REFERRING_TO);
if (cstring_resolve("WALKTHRU_WORD") == nullptr)
create_cstring("WALKTHRU_WORD", WALKTHRU_WORD);
if (cstring_resolve("INFO_WORD") == nullptr)
create_cstring("INFO_WORD", INFO_WORD);
if (cstring_resolve("RESTART_WORD") == nullptr)
create_cstring("RESTART_WORD", RESTART_WORD);
if (cstring_resolve("AGAIN_WORD") == nullptr)
create_cstring("AGAIN_WORD", AGAIN_WORD);
if (cstring_resolve("SCRIPT_WORD") == nullptr)
create_cstring("SCRIPT_WORD", SCRIPT_WORD);
if (cstring_resolve("UNSCRIPT_WORD") == nullptr)
create_cstring("UNSCRIPT_WORD", UNSCRIPT_WORD);
if (cstring_resolve("QUIT_WORD") == nullptr)
create_cstring("QUIT_WORD", QUIT_WORD);
if (cstring_resolve("UNDO_WORD") == nullptr)
create_cstring("UNDO_WORD", UNDO_WORD);
if (cstring_resolve("OOPS_WORD") == nullptr)
create_cstring("OOPS_WORD", OOPS_WORD);
if (cstring_resolve("FROM_WORD") == nullptr)
create_cstring("FROM_WORD", FROM_WORD);
if (cstring_resolve("EXCEPT_WORD") == nullptr)
create_cstring("EXCEPT_WORD", EXCEPT_WORD);
if (cstring_resolve("FOR_WORD") == nullptr)
create_cstring("FOR_WORD", FOR_WORD);
if (cstring_resolve("BUT_WORD") == nullptr)
create_cstring("BUT_WORD", BUT_WORD);
if (cstring_resolve("AND_WORD") == nullptr)
create_cstring("AND_WORD", AND_WORD);
if (cstring_resolve("THEN_WORD") == nullptr)
create_cstring("THEN_WORD", THEN_WORD);
if (cstring_resolve("OF_WORD") == nullptr)
create_cstring("OF_WORD", OF_WORD);
if (cstring_resolve("SHE_WORD") == nullptr)
create_cstring("SHE_WORD", SHE_WORD);
if (cstring_resolve("HE_WORD") == nullptr)
create_cstring("HE_WORD", HE_WORD);
if (cstring_resolve("THAT_WORD") == nullptr)
create_cstring("THAT_WORD", THAT_WORD);
if (cstring_resolve("THEM_WORD") == nullptr)
create_cstring("THEM_WORD", THEM_WORD);
if (cstring_resolve("THOSE_WORD") == nullptr)
create_cstring("THOSE_WORD", THOSE_WORD);
if (cstring_resolve("THEY_WORD") == nullptr)
create_cstring("THEY_WORD", THEY_WORD);
if (cstring_resolve("IT_WORD") == nullptr)
create_cstring("IT_WORD", IT_WORD);
if (cstring_resolve("ITSELF_WORD") == nullptr)
create_cstring("ITSELF_WORD", ITSELF_WORD);
if (cstring_resolve("HIM_WORD") == nullptr)
create_cstring("HIM_WORD", HIM_WORD);
if (cstring_resolve("HIMSELF_WORD") == nullptr)
create_cstring("HIMSELF_WORD", HIMSELF_WORD);
if (cstring_resolve("HER_WORD") == nullptr)
create_cstring("HER_WORD", HER_WORD);
if (cstring_resolve("HERSELF_WORD") == nullptr)
create_cstring("HERSELF_WORD", HERSELF_WORD);
if (cstring_resolve("THEMSELVES_WORD") == nullptr)
create_cstring("THEMSELVES_WORD", THEMSELVES_WORD);
if (cstring_resolve("YOU_WORD") == nullptr)
create_cstring("YOU_WORD", YOU_WORD);
if (cstring_resolve("YOURSELF_WORD") == nullptr)
create_cstring("YOURSELF_WORD", YOURSELF_WORD);
if (cstring_resolve("ONES_WORD") == nullptr)
create_cstring("ONES_WORD", ONES_WORD);
if (cstring_resolve("NO_MULTI_VERB") == nullptr)
create_cstring("NO_MULTI_VERB", NO_MULTI_VERB);
if (cstring_resolve("NO_MULTI_START") == nullptr)
create_cstring("NO_MULTI_START", NO_MULTI_START);
if (cstring_resolve("PERSON_CONCEALING") == nullptr)
create_cstring("PERSON_CONCEALING", PERSON_CONCEALING);
if (cstring_resolve("PERSON_POSSESSIVE") == nullptr)
create_cstring("PERSON_POSSESSIVE", PERSON_POSSESSIVE);
if (cstring_resolve("CONTAINER_CLOSED") == nullptr)
create_cstring("CONTAINER_CLOSED", CONTAINER_CLOSED);
if (cstring_resolve("CONTAINER_CLOSED_FEM") == nullptr)
create_cstring("CONTAINER_CLOSED_FEM", CONTAINER_CLOSED_FEM);
if (cstring_resolve("FROM_NON_CONTAINER") == nullptr)
create_cstring("FROM_NON_CONTAINER", FROM_NON_CONTAINER);
if (cstring_resolve("DOUBLE_EXCEPT") == nullptr)
create_cstring("DOUBLE_EXCEPT", DOUBLE_EXCEPT);
if (cstring_resolve("NONE_HELD") == nullptr)
create_cstring("NONE_HELD", NONE_HELD);
if (cstring_resolve("NO_OBJECTS") == nullptr)
create_cstring("NO_OBJECTS", NO_OBJECTS);
if (cstring_resolve("NO_FILENAME") == nullptr)
create_cstring("NO_FILENAME", NO_FILENAME);
if (cstring_resolve("MOVE_UNDONE") == nullptr)
create_cstring("MOVE_UNDONE", MOVE_UNDONE);
if (cstring_resolve("NO_UNDO") == nullptr)
create_cstring("NO_UNDO", NO_UNDO);
if (cstring_resolve("CANT_SAVE") == nullptr)
create_cstring("CANT_SAVE", CANT_SAVE);
if (cstring_resolve("CANT_RESTORE") == nullptr)
create_cstring("CANT_RESTORE", CANT_RESTORE);
if (cstring_resolve("GAME_SAVED") == nullptr)
create_cstring("GAME_SAVED", GAME_SAVED);
if (cstring_resolve("INCOMPLETE_SENTENCE") == nullptr)
create_cstring("INCOMPLETE_SENTENCE", INCOMPLETE_SENTENCE);
if (cstring_resolve("UNKNOWN_OBJECT") == nullptr)
create_cstring("UNKNOWN_OBJECT", UNKNOWN_OBJECT);
if (cstring_resolve("UNKNOWN_OBJECT_END") == nullptr)
create_cstring("UNKNOWN_OBJECT_END", UNKNOWN_OBJECT_END);
if (cstring_resolve("CANT_USE_WORD") == nullptr)
create_cstring("CANT_USE_WORD", CANT_USE_WORD);
if (cstring_resolve("IN_CONTEXT") == nullptr)
create_cstring("IN_CONTEXT", IN_CONTEXT);
if (cstring_resolve("DONT_SEE") == nullptr)
create_cstring("DONT_SEE", DONT_SEE);
if (cstring_resolve("HERE_WORD") == nullptr)
create_cstring("HERE_WORD", HERE_WORD);
if (cstring_resolve("BAD_SAVED_GAME") == nullptr)
create_cstring("BAD_SAVED_GAME", BAD_SAVED_GAME);
if (cstring_resolve("ARENT") == nullptr)
create_cstring("ARENT", ARENT);
if (cstring_resolve("ISNT") == nullptr)
create_cstring("ISNT", ISNT);
if (cstring_resolve("ARE") == nullptr)
create_cstring("ARE", ARE);
if (cstring_resolve("IS") == nullptr)
create_cstring("IS", IS);
if (cstring_resolve("DONT") == nullptr)
create_cstring("DONT", DONT);
if (cstring_resolve("DOESNT") == nullptr)
create_cstring("DOESNT", DOESNT);
if (cstring_resolve("DO") == nullptr)
create_cstring("DO", DO);
if (cstring_resolve("DOES") == nullptr)
create_cstring("DOES", DOES);
if (cstring_resolve("SCORE_UP") == nullptr)
create_cstring("SCORE_UP", SCORE_UP);
if (cstring_resolve("POINT") == nullptr)
create_cstring("POINT", POINT);
if (cstring_resolve("POINTS") == nullptr)
create_cstring("POINTS", POINTS);
if (cstring_resolve("STARTING") == nullptr)
create_cstring("STARTING", STARTING);
if (cstring_resolve("NO_IT") == nullptr)
create_cstring("NO_IT", NO_IT);
if (cstring_resolve("NO_IT_END") == nullptr)
create_cstring("NO_IT_END", NO_IT_END);
if (cstring_resolve("BACK_REFERENCE") == nullptr)
create_cstring("BACK_REFERENCE", BACK_REFERENCE);
if (cstring_resolve("BACK_REFERENCE_END") == nullptr)
create_cstring("BACK_REFERENCE_END", BACK_REFERENCE_END);
if (cstring_resolve("WHEN_YOU_SAY") == nullptr)
create_cstring("WHEN_YOU_SAY", WHEN_YOU_SAY);
if (cstring_resolve("MUST_SPECIFY") == nullptr)
create_cstring("MUST_SPECIFY", MUST_SPECIFY);
if (cstring_resolve("OR_WORD") == nullptr)
create_cstring("OR_WORD", OR_WORD);
}
} // End of namespace JACL
} // End of namespace Glk
Reference in New Issue View Git Blame Copy Permalink