ifhub/inform7
1
0
Fork 0
mirror of https://github.com/ganelson/inform.git synced 2024-07-03 07:24:58 +03:00
Code Issues Projects Releases Wiki Activity
inform7/inform6/Inform6/inform.c
Graham Nelson 487618a642 Adopted Inform 6 v 6.34
2020-06-01 18:29:12 +01:00

1861 lines
64 KiB
C
Executable file
Raw Blame History

/* ------------------------------------------------------------------------- */
/* "inform" : The top level of Inform: switches, pathnames, filenaming */
/* conventions, ICL (Inform Command Line) files, main */
/* */
/* Part of Inform 6.34 */
/* copyright (c) Graham Nelson 1993 - 2020 */
/* */
/* ------------------------------------------------------------------------- */
#define MAIN_INFORM_FILE
#include "header.h"
/* ------------------------------------------------------------------------- */
/* Compiler progress */
/* ------------------------------------------------------------------------- */
static int no_compilations;
int endofpass_flag; /* set to TRUE when an "end" directive is reached
(the inputs routines insert one into the stream
if necessary) */
/* ------------------------------------------------------------------------- */
/* Version control */
/* ------------------------------------------------------------------------- */
int version_number, /* 3 to 8 (Z-code) */
instruction_set_number,
/* 3 to 6: versions 7 and 8 use instruction set of
version 5 */
extend_memory_map; /* extend using function- and string-offsets */
int32 scale_factor, /* packed address multiplier */
length_scale_factor; /* length-in-header multiplier */
int32 requested_glulx_version;
extern void select_version(int vn)
{ version_number = vn;
extend_memory_map = FALSE;
if ((version_number==6)||(version_number==7)) extend_memory_map = TRUE;
scale_factor = 4;
if (version_number==3) scale_factor = 2;
if (version_number==8) scale_factor = 8;
length_scale_factor = scale_factor;
if ((version_number==6)||(version_number==7)) length_scale_factor = 8;
instruction_set_number = version_number;
if ((version_number==7)||(version_number==8)) instruction_set_number = 5;
}
static int select_glulx_version(char *str)
{
/* Parse an "X.Y.Z" style version number, and store it for later use. */
char *cx = str;
int major=0, minor=0, patch=0;
while (isdigit(*cx))
major = major*10 + ((*cx++)-'0');
if (*cx == '.') {
cx++;
while (isdigit(*cx))
minor = minor*10 + ((*cx++)-'0');
if (*cx == '.') {
cx++;
while (isdigit(*cx))
patch = patch*10 + ((*cx++)-'0');
}
}
requested_glulx_version = ((major & 0x7FFF) << 16)
+ ((minor & 0xFF) << 8)
+ (patch & 0xFF);
return (cx - str);
}
/* ------------------------------------------------------------------------- */
/* Target: variables which vary between the Z-machine and Glulx */
/* ------------------------------------------------------------------------- */
int WORDSIZE; /* Size of a machine word: 2 or 4 */
int32 MAXINTWORD; /* 0x7FFF or 0x7FFFFFFF */
/* The first property number which is an individual property. The
eight class-system i-props (create, recreate, ... print_to_array)
are numbered from INDIV_PROP_START to INDIV_PROP_START+7.
*/
int INDIV_PROP_START;
/* The length of an object, as written in tables.c. It's easier to define
it here than to repeat the same expression all over the source code.
Not used in Z-code.
*/
int OBJECT_BYTE_LENGTH;
/* The total length of a dict entry, in bytes. Not used in Z-code.
*/
int DICT_ENTRY_BYTE_LENGTH;
/* The position in a dict entry that the flag values begin.
Not used in Z-code.
*/
int DICT_ENTRY_FLAG_POS;
static void select_target(int targ)
{
if (!targ) {
/* Z-machine */
WORDSIZE = 2;
MAXINTWORD = 0x7FFF;
if (INDIV_PROP_START != 64) {
INDIV_PROP_START = 64;
fatalerror("You cannot change INDIV_PROP_START in Z-code");
}
if (DICT_WORD_SIZE != 6) {
DICT_WORD_SIZE = 6;
fatalerror("You cannot change DICT_WORD_SIZE in Z-code");
}
if (DICT_CHAR_SIZE != 1) {
DICT_CHAR_SIZE = 1;
fatalerror("You cannot change DICT_CHAR_SIZE in Z-code");
}
if (NUM_ATTR_BYTES != 6) {
NUM_ATTR_BYTES = 6;
fatalerror("You cannot change NUM_ATTR_BYTES in Z-code");
}
if (MAX_LOCAL_VARIABLES != 16) {
MAX_LOCAL_VARIABLES = 16;
fatalerror("You cannot change MAX_LOCAL_VARIABLES in Z-code");
}
if (MAX_GLOBAL_VARIABLES != 240) {
MAX_GLOBAL_VARIABLES = 240;
fatalerror("You cannot change MAX_GLOBAL_VARIABLES in Z-code");
}
if (MAX_VERBS > 255) {
MAX_VERBS = 255;
fatalerror("MAX_VERBS can only go above 255 when Glulx is used");
}
}
else {
/* Glulx */
WORDSIZE = 4;
MAXINTWORD = 0x7FFFFFFF;
scale_factor = 0; /* It should never even get used in Glulx */
if (INDIV_PROP_START < 256) {
INDIV_PROP_START = 256;
warning_numbered("INDIV_PROP_START should be at least 256 in Glulx. Setting to", INDIV_PROP_START);
}
if (NUM_ATTR_BYTES % 4 != 3) {
NUM_ATTR_BYTES += (3 - (NUM_ATTR_BYTES % 4));
warning_numbered("NUM_ATTR_BYTES must be a multiple of four, plus three. Increasing to", NUM_ATTR_BYTES);
}
if (DICT_CHAR_SIZE != 1 && DICT_CHAR_SIZE != 4) {
DICT_CHAR_SIZE = 4;
warning_numbered("DICT_CHAR_SIZE must be either 1 or 4. Setting to", DICT_CHAR_SIZE);
}
}
if (MAX_LOCAL_VARIABLES >= 120) {
MAX_LOCAL_VARIABLES = 119;
warning("MAX_LOCAL_VARIABLES cannot exceed 119; resetting to 119");
/* This is because the keyword table in the lexer only has 120
entries. */
}
if (DICT_WORD_SIZE > MAX_DICT_WORD_SIZE) {
DICT_WORD_SIZE = MAX_DICT_WORD_SIZE;
warning_numbered(
"DICT_WORD_SIZE cannot exceed MAX_DICT_WORD_SIZE; resetting",
MAX_DICT_WORD_SIZE);
/* MAX_DICT_WORD_SIZE can be increased in header.h without fear. */
}
if (NUM_ATTR_BYTES > MAX_NUM_ATTR_BYTES) {
NUM_ATTR_BYTES = MAX_NUM_ATTR_BYTES;
warning_numbered(
"NUM_ATTR_BYTES cannot exceed MAX_NUM_ATTR_BYTES; resetting",
MAX_NUM_ATTR_BYTES);
/* MAX_NUM_ATTR_BYTES can be increased in header.h without fear. */
}
/* Set up a few more variables that depend on the above values */
if (!targ) {
/* Z-machine */
DICT_WORD_BYTES = DICT_WORD_SIZE;
/* The Z-code generator doesn't use the following variables, although
it would be a little cleaner if it did. */
OBJECT_BYTE_LENGTH = 0;
DICT_ENTRY_BYTE_LENGTH = (version_number==3)?7:9;
DICT_ENTRY_FLAG_POS = 0;
}
else {
/* Glulx */
OBJECT_BYTE_LENGTH = (1 + (NUM_ATTR_BYTES) + 6*4 + (GLULX_OBJECT_EXT_BYTES));
DICT_WORD_BYTES = DICT_WORD_SIZE*DICT_CHAR_SIZE;
if (DICT_CHAR_SIZE == 1) {
DICT_ENTRY_BYTE_LENGTH = (7+DICT_WORD_BYTES);
DICT_ENTRY_FLAG_POS = (1+DICT_WORD_BYTES);
}
else {
DICT_ENTRY_BYTE_LENGTH = (12+DICT_WORD_BYTES);
DICT_ENTRY_FLAG_POS = (4+DICT_WORD_BYTES);
}
}
}
/* ------------------------------------------------------------------------- */
/* Tracery: output control variables */
/* ------------------------------------------------------------------------- */
int asm_trace_level, /* trace assembly: 0 for off, 1 for assembly
only, 2 for full assembly tracing with hex dumps */
line_trace_level, /* line tracing: 0 off, 1 on */
expr_trace_level, /* expression tracing: 0 off, 1 full, 2 brief */
linker_trace_level, /* set by -y: 0 to 4 levels of tracing */
tokens_trace_level; /* lexer output tracing: 0 off, 1 on */
/* ------------------------------------------------------------------------- */
/* On/off switch variables (by default all FALSE); other switch settings */
/* ------------------------------------------------------------------------- */
int bothpasses_switch, /* -b */
concise_switch, /* -c */
economy_switch, /* -e */
frequencies_switch, /* -f */
ignore_switches_switch, /* -i */
listobjects_switch, /* -j */
debugfile_switch, /* -k */
listing_switch, /* -l */
memout_switch, /* -m */
printprops_switch, /* -n */
offsets_switch, /* -o */
percentages_switch, /* -p */
obsolete_switch, /* -q */
transcript_switch, /* -r */
statistics_switch, /* -s */
optimise_switch, /* -u */
version_set_switch, /* -v */
nowarnings_switch, /* -w */
hash_switch, /* -x */
memory_map_switch, /* -z */
oddeven_packing_switch, /* -B */
define_DEBUG_switch, /* -D */
temporary_files_switch, /* -F */
module_switch, /* -M */
runtime_error_checking_switch, /* -S */
define_USE_MODULES_switch, /* -U */
define_INFIX_switch; /* -X */
#ifdef ARC_THROWBACK
int throwback_switch; /* -T */
#endif
#ifdef ARCHIMEDES
int riscos_file_type_format; /* set by -R */
#endif
int compression_switch; /* set by -H */
int character_set_setting, /* set by -C0 through -C9 */
character_set_unicode, /* set by -Cu */
error_format, /* set by -E */
asm_trace_setting, /* set by -a and -t: value of
asm_trace_level to use when tracing */
double_space_setting, /* set by -d: 0, 1 or 2 */
trace_fns_setting, /* set by -g: 0, 1 or 2 */
linker_trace_setting, /* set by -y: ditto for linker_... */
store_the_text; /* when set, record game text to a chunk
of memory (used by both -r & -k) */
static int r_e_c_s_set; /* has -S been explicitly set? */
int glulx_mode; /* -G */
static void reset_switch_settings(void)
{ asm_trace_setting=0;
linker_trace_level=0;
tokens_trace_level=0;
store_the_text = FALSE;
bothpasses_switch = FALSE;
concise_switch = FALSE;
double_space_setting = 0;
economy_switch = FALSE;
frequencies_switch = FALSE;
trace_fns_setting = 0;
ignore_switches_switch = FALSE;
listobjects_switch = FALSE;
debugfile_switch = FALSE;
listing_switch = FALSE;
memout_switch = FALSE;
printprops_switch = FALSE;
offsets_switch = FALSE;
percentages_switch = FALSE;
obsolete_switch = FALSE;
transcript_switch = FALSE;
statistics_switch = FALSE;
optimise_switch = FALSE;
version_set_switch = FALSE;
nowarnings_switch = FALSE;
hash_switch = FALSE;
memory_map_switch = FALSE;
oddeven_packing_switch = FALSE;
define_DEBUG_switch = FALSE;
#ifdef USE_TEMPORARY_FILES
temporary_files_switch = TRUE;
#else
temporary_files_switch = FALSE;
#endif
define_USE_MODULES_switch = FALSE;
module_switch = FALSE;
#ifdef ARC_THROWBACK
throwback_switch = FALSE;
#endif
runtime_error_checking_switch = TRUE;
r_e_c_s_set = FALSE;
define_INFIX_switch = FALSE;
#ifdef ARCHIMEDES
riscos_file_type_format = 0;
#endif
error_format=DEFAULT_ERROR_FORMAT;
character_set_setting = 1; /* Default is ISO Latin-1 */
character_set_unicode = FALSE;
compression_switch = TRUE;
glulx_mode = FALSE;
requested_glulx_version = 0;
}
/* ------------------------------------------------------------------------- */
/* Number of files given as command line parameters (0, 1 or 2) */
/* ------------------------------------------------------------------------- */
static int cli_files_specified,
convert_filename_flag;
char Source_Name[PATHLEN]; /* Processed name of first input file */
char Code_Name[PATHLEN]; /* Processed name of output file */
static char *cli_file1, *cli_file2; /* Unprocessed (and unsafe to alter) */
/* ========================================================================= */
/* Data structure management routines */
/* ------------------------------------------------------------------------- */
static void init_vars(void)
{
init_arrays_vars();
init_asm_vars();
init_bpatch_vars();
init_chars_vars();
init_directs_vars();
init_errors_vars();
init_expressc_vars();
init_expressp_vars();
init_files_vars();
init_lexer_vars();
init_linker_vars();
init_memory_vars();
init_objects_vars();
init_states_vars();
init_symbols_vars();
init_syntax_vars();
init_tables_vars();
init_text_vars();
init_veneer_vars();
init_verbs_vars();
}
static void begin_pass(void)
{
arrays_begin_pass();
asm_begin_pass();
bpatch_begin_pass();
chars_begin_pass();
directs_begin_pass();
errors_begin_pass();
expressc_begin_pass();
expressp_begin_pass();
files_begin_pass();
endofpass_flag = FALSE;
line_trace_level = 0; expr_trace_level = 0;
asm_trace_level = asm_trace_setting;
linker_trace_level = linker_trace_setting;
if (listing_switch) line_trace_level=1;
lexer_begin_pass();
linker_begin_pass();
memory_begin_pass();
objects_begin_pass();
states_begin_pass();
symbols_begin_pass();
syntax_begin_pass();
tables_begin_pass();
text_begin_pass();
veneer_begin_pass();
verbs_begin_pass();
if (!module_switch)
{
/* Compile a Main__ routine (see "veneer.c") */
compile_initial_routine();
/* Make the four metaclasses: Class must be object number 1, so
it must come first */
veneer_mode = TRUE;
make_class("Class");
make_class("Object");
make_class("Routine");
make_class("String");
veneer_mode = FALSE;
}
}
extern void allocate_arrays(void)
{
arrays_allocate_arrays();
asm_allocate_arrays();
bpatch_allocate_arrays();
chars_allocate_arrays();
directs_allocate_arrays();
errors_allocate_arrays();
expressc_allocate_arrays();
expressp_allocate_arrays();
files_allocate_arrays();
lexer_allocate_arrays();
linker_allocate_arrays();
memory_allocate_arrays();
objects_allocate_arrays();
states_allocate_arrays();
symbols_allocate_arrays();
syntax_allocate_arrays();
tables_allocate_arrays();
text_allocate_arrays();
veneer_allocate_arrays();
verbs_allocate_arrays();
}
extern void free_arrays(void)
{
/* One array may survive this routine, all_the_text (used to hold
game text until the abbreviations optimiser begins work on it): this
array (if it was ever allocated) is freed at the top level. */
arrays_free_arrays();
asm_free_arrays();
bpatch_free_arrays();
chars_free_arrays();
directs_free_arrays();
errors_free_arrays();
expressc_free_arrays();
expressp_free_arrays();
files_free_arrays();
lexer_free_arrays();
linker_free_arrays();
memory_free_arrays();
objects_free_arrays();
states_free_arrays();
symbols_free_arrays();
syntax_free_arrays();
tables_free_arrays();
text_free_arrays();
veneer_free_arrays();
verbs_free_arrays();
}
/* ------------------------------------------------------------------------- */
/* Name translation code for filenames */
/* ------------------------------------------------------------------------- */
static char Source_Path[PATHLEN];
static char Include_Path[PATHLEN];
static char Code_Path[PATHLEN];
static char Module_Path[PATHLEN];
static char Temporary_Path[PATHLEN];
static char current_source_path[PATHLEN];
char Debugging_Name[PATHLEN];
char Transcript_Name[PATHLEN];
char Language_Name[PATHLEN];
char Charset_Map[PATHLEN];
static char ICL_Path[PATHLEN];
/* Set one of the above Path buffers to the given location, or list of
locations. (A list is comma-separated, and only accepted for Source_Path,
Include_Path, ICL_Path, Module_Path.)
*/
static void set_path_value(char *path, char *value)
{ int i, j;
for (i=0, j=0;;)
{
if (i >= PATHLEN-1) {
printf("A specified path is longer than %d characters.\n",
PATHLEN-1);
exit(1);
}
if ((value[j] == FN_ALT) || (value[j] == 0))
{ if ((value[j] == FN_ALT)
&& (path != Source_Path) && (path != Include_Path)
&& (path != ICL_Path) && (path != Module_Path))
{ printf("The character '%c' is used to divide entries in a list \
of possible locations, and can only be used in the Include_Path, Source_Path, \
Module_Path or ICL_Path variables. Other paths are for output only.\n", FN_ALT);
exit(1);
}
if ((path != Debugging_Name) && (path != Transcript_Name)
&& (path != Language_Name) && (path != Charset_Map)
&& (i>0) && (isalnum(path[i-1]))) path[i++] = FN_SEP;
path[i++] = value[j++];
if (value[j-1] == 0) return;
}
else path[i++] = value[j++];
}
}
/* Prepend the given location or list of locations to one of the above
Path buffers. This is only permitted for Source_Path, Include_Path,
ICL_Path, Module_Path.
An empty field (in the comma-separated list) means the current
directory. If the Path buffer is entirely empty, we assume that
we want to search both value and the current directory, so
the result will be "value,".
*/
static void prepend_path_value(char *path, char *value)
{
int i, j;
int oldlen = strlen(path);
int newlen;
char new_path[PATHLEN];
if ((path != Source_Path) && (path != Include_Path)
&& (path != ICL_Path) && (path != Module_Path))
{ printf("The character '+' is used to add to a list \
of possible locations, and can only be used in the Include_Path, Source_Path, \
Module_Path or ICL_Path variables. Other paths are for output only.\n");
exit(1);
}
for (i=0, j=0;;)
{
if (i >= PATHLEN-1) {
printf("A specified path is longer than %d characters.\n",
PATHLEN-1);
exit(1);
}
if ((value[j] == FN_ALT) || (value[j] == 0))
{ if ((path != Debugging_Name) && (path != Transcript_Name)
&& (path != Language_Name) && (path != Charset_Map)
&& (i>0) && (isalnum(new_path[i-1]))) new_path[i++] = FN_SEP;
new_path[i++] = value[j++];
if (value[j-1] == 0) {
newlen = i-1;
break;
}
}
else new_path[i++] = value[j++];
}
if (newlen+1+oldlen >= PATHLEN-1) {
printf("A specified path is longer than %d characters.\n",
PATHLEN-1);
exit(1);
}
i = newlen;
new_path[i++] = FN_ALT;
for (j=0; j<oldlen;)
new_path[i++] = path[j++];
new_path[i] = 0;
strcpy(path, new_path);
}
static void set_default_paths(void)
{
set_path_value(Source_Path, Source_Directory);
set_path_value(Include_Path, Include_Directory);
set_path_value(Code_Path, Code_Directory);
set_path_value(Module_Path, Module_Directory);
set_path_value(ICL_Path, ICL_Directory);
set_path_value(Temporary_Path, Temporary_Directory);
set_path_value(Debugging_Name, Debugging_File);
set_path_value(Transcript_Name, Transcript_File);
set_path_value(Language_Name, "English");
set_path_value(Charset_Map, "");
}
/* Parse a path option which looks like "dir", "+dir", "pathname=dir",
or "+pathname=dir". If there is no "=", we assume "include_path=...".
If the option begins with a "+" the directory is prepended to the
existing path instead of replacing it.
*/
static void set_path_command(char *command)
{ int i, j; char *path_to_set = NULL;
int prepend = 0;
if (command[0] == '+') {
prepend = 1;
command++;
}
for (i=0; (command[i]!=0) && (command[i]!='=');i++) ;
path_to_set=Include_Path;
if (command[i] == '=') {
char pathname[PATHLEN];
if (i>=PATHLEN) i=PATHLEN-1;
for (j=0;j<i;j++) {
char ch = command[j];
if (isupper(ch)) ch=tolower(ch);
pathname[j]=ch;
}
pathname[j]=0;
command = command+i+1;
path_to_set = NULL;
if (strcmp(pathname, "source_path")==0) path_to_set=Source_Path;
if (strcmp(pathname, "include_path")==0) path_to_set=Include_Path;
if (strcmp(pathname, "code_path")==0) path_to_set=Code_Path;
if (strcmp(pathname, "module_path")==0) path_to_set=Module_Path;
if (strcmp(pathname, "icl_path")==0) path_to_set=ICL_Path;
if (strcmp(pathname, "temporary_path")==0) path_to_set=Temporary_Path;
if (strcmp(pathname, "debugging_name")==0) path_to_set=Debugging_Name;
if (strcmp(pathname, "transcript_name")==0) path_to_set=Transcript_Name;
if (strcmp(pathname, "language_name")==0) path_to_set=Language_Name;
if (strcmp(pathname, "charset_map")==0) path_to_set=Charset_Map;
if (path_to_set == NULL)
{ printf("No such path setting as \"%s\"\n", pathname);
exit(1);
}
}
if (!prepend)
set_path_value(path_to_set, command);
else
prepend_path_value(path_to_set, command);
}
static int contains_separator(char *name)
{ int i;
for (i=0; name[i]!=0; i++)
if (name[i] == FN_SEP) return 1;
return 0;
}
static int write_translated_name(char *new_name, char *old_name,
char *prefix_path, int start_pos,
char *extension)
{ int x;
if (strlen(old_name)+strlen(extension) >= PATHLEN) {
printf("One of your filenames is longer than %d characters.\n", PATHLEN);
exit(1);
}
if (prefix_path == NULL)
{ sprintf(new_name,"%s%s", old_name, extension);
return 0;
}
strcpy(new_name, prefix_path + start_pos);
for (x=0; (new_name[x]!=0) && (new_name[x]!=FN_ALT); x++) ;
if (new_name[x] == 0) start_pos = 0; else start_pos += x+1;
if (x+strlen(old_name)+strlen(extension) >= PATHLEN) {
printf("One of your pathnames is longer than %d characters.\n", PATHLEN);
exit(1);
}
sprintf(new_name + x, "%s%s", old_name, extension);
return start_pos;
}
#ifdef FILE_EXTENSIONS
static char *check_extension(char *name, char *extension)
{ int i;
/* If a filename ends in '.', remove the dot and add no file extension: */
i = strlen(name)-1;
if (name[i] == '.') { name[i]=0; return ""; }
/* Remove the new extension if it's already got one: */
for (; (i>=0) && (name[i]!=FN_SEP); i--)
if (name[i] == '.') return "";
return extension;
}
#endif
/* ------------------------------------------------------------------------- */
/* Three translation routines have to deal with path variables which may */
/* contain alternative locations separated by the FN_ALT character. */
/* These have the protocol: */
/* */
/* int translate_*_filename(int last_value, ...) */
/* */
/* and should first be called with last_value equal to 0. If the */
/* translated filename works, fine. Otherwise, if the returned integer */
/* was zero, the caller knows that no filename works and can issue an */
/* error message. If it was non-zero, the caller should pass it on as */
/* the last_value again. */
/* */
/* As implemented below, last_value is the position in the path variable */
/* string at which the next directory name to try begins. */
/* ------------------------------------------------------------------------- */
extern int translate_in_filename(int last_value,
char *new_name, char *old_name,
int same_directory_flag, int command_line_flag)
{ char *prefix_path = NULL;
char *extension;
int add_path_flag = 1;
int i;
if ((same_directory_flag==0)
&& (contains_separator(old_name)==1)) add_path_flag=0;
if (add_path_flag==1)
{ if (command_line_flag == 0)
{ /* File is opened as a result of an Include directive */
if (same_directory_flag==1)
prefix_path = current_source_path;
else
if (Include_Path[0]!=0) prefix_path = Include_Path;
}
/* Main file being opened from the command line */
else if (Source_Path[0]!=0) prefix_path = Source_Path;
}
#ifdef FILE_EXTENSIONS
/* Which file extension is expected? */
if ((command_line_flag==1)||(same_directory_flag==1))
extension = Source_Extension;
else
extension = Include_Extension;
extension = check_extension(old_name, extension);
#else
extension = "";
#endif
last_value = write_translated_name(new_name, old_name,
prefix_path, last_value, extension);
/* Set the "current source path" (for use of Include ">...") */
if (command_line_flag==1)
{ strcpy(current_source_path, new_name);
for (i=strlen(current_source_path)-1;
((i>0)&&(current_source_path[i]!=FN_SEP));i--) ;
if (i!=0) current_source_path[i+1] = 0; /* Current file in subdir */
else current_source_path[0] = 0; /* Current file at root dir */
}
return last_value;
}
extern int translate_link_filename(int last_value,
char *new_name, char *old_name)
{ char *prefix_path = NULL;
char *extension;
if (contains_separator(old_name)==0)
if (Module_Path[0]!=0)
prefix_path = Module_Path;
#ifdef FILE_EXTENSIONS
extension = check_extension(old_name, Module_Extension);
#else
extension = "";
#endif
return write_translated_name(new_name, old_name,
prefix_path, last_value, extension);
}
static int translate_icl_filename(int last_value,
char *new_name, char *old_name)
{ char *prefix_path = NULL;
char *extension = "";
if (contains_separator(old_name)==0)
if (ICL_Path[0]!=0)
prefix_path = ICL_Path;
#ifdef FILE_EXTENSIONS
extension = check_extension(old_name, ICL_Extension);
#endif
return write_translated_name(new_name, old_name,
prefix_path, last_value, extension);
}
extern void translate_out_filename(char *new_name, char *old_name)
{ char *prefix_path;
char *extension = "";
int i;
/* If !convert_filename_flag, then the old_name is just the <file2>
parameter on the Inform command line, which we leave alone. */
if (!convert_filename_flag)
{ strcpy(new_name, old_name); return;
}
/* Remove any pathname or extension in <file1>. */
if (contains_separator(old_name)==1)
{ for (i=strlen(old_name)-1; (i>0)&&(old_name[i]!=FN_SEP) ;i--) { };
if (old_name[i]==FN_SEP) i++;
old_name += i;
}
#ifdef FILE_EXTENSIONS
for (i=strlen(old_name)-1; (i>=0)&&(old_name[i]!='.') ;i--) ;
if (old_name[i] == '.') old_name[i] = 0;
#endif
prefix_path = NULL;
if (module_switch)
{ extension = Module_Extension;
if (Module_Path[0]!=0) prefix_path = Module_Path;
}
else
{
if (!glulx_mode) {
switch(version_number)
{ case 3: extension = Code_Extension; break;
case 4: extension = V4Code_Extension; break;
case 5: extension = V5Code_Extension; break;
case 6: extension = V6Code_Extension; break;
case 7: extension = V7Code_Extension; break;
case 8: extension = V8Code_Extension; break;
}
}
else {
extension = GlulxCode_Extension;
}
if (Code_Path[0]!=0) prefix_path = Code_Path;
}
#ifdef FILE_EXTENSIONS
extension = check_extension(old_name, extension);
#endif
write_translated_name(new_name, old_name, prefix_path, 0, extension);
}
static char *name_or_unset(char *p)
{ if (p[0]==0) return "(unset)";
return p;
}
static void help_on_filenames(void)
{ char old_name[PATHLEN];
char new_name[PATHLEN];
int save_mm = module_switch, x;
module_switch = FALSE;
printf("Help information on filenames:\n\n");
printf(
"The command line can take one of two forms:\n\n\
inform [commands...] <file1>\n\
inform [commands...] <file1> <file2>\n\n\
Inform translates <file1> into a source file name (see below) for its input.\n\
<file2> is usually omitted: if so, the output filename is made from <file1>\n\
by cutting out the name part and translating that (see below).\n\
If <file2> is given, however, the output filename is set to just <file2>\n\
(not altered in any way).\n\n");
printf(
"Filenames given in the game source (with commands like Include \"name\" and\n\
Link \"name\") are also translated by the rules below.\n\n");
printf(
"Rules of translation:\n\n\
Inform translates plain filenames (such as \"xyzzy\") into full pathnames\n\
(such as \"adventure%cgames%cxyzzy\") according to the following rules.\n\n\
1. If the name contains a '%c' character (so it's already a pathname), it\n\
isn't changed.\n\n", FN_SEP, FN_SEP, FN_SEP);
printf(
" [Exception: when the name is given in an Include command using the >\n\
form (such as Include \">prologue\"), the \">\" is replaced by the path\n\
of the file doing the inclusion");
#ifdef FILE_EXTENSIONS
printf(" and a suitable file extension is added");
#endif
printf(".]\n\n");
printf(
" Filenames must never contain double-quotation marks \". To use filenames\n\
which contain spaces, write them in double-quotes: for instance,\n\n\
\"inform +code_path=\"Jigsaw Final Version\" jigsaw\".\n\n");
printf(
"2. The file is looked for at a particular \"path\" (the filename of a\n\
directory), depending on what kind of file it is.\n\n\
File type Name Current setting\n\n\
Source code (in) source_path %s\n\
Include file (in) include_path %s\n\
Story file (out) code_path %s\n",
name_or_unset(Source_Path), name_or_unset(Include_Path),
name_or_unset(Code_Path));
printf(
" Temporary file (out) temporary_path %s\n\
ICL command file (in) icl_path %s\n\
Module (in & out) module_path %s\n\n",
name_or_unset(Temporary_Path),
name_or_unset(ICL_Path), name_or_unset(Module_Path));
printf(
" If the path is unset, then the current working directory is used (so\n\
the filename doesn't change): if, for instance, include_path is set to\n\
\"backup%coldlib\" then when \"parser\" is included it is looked for at\n\
\"backup%coldlib%cparser\".\n\n\
The paths can be set or unset on the Inform command line by, eg,\n\
\"inform +code_path=finished jigsaw\" or\n\
\"inform +include_path= balances\" (which unsets include_path).\n\n",
FN_SEP, FN_SEP, FN_SEP);
printf(
" The four input path variables can be set to lists of alternative paths\n\
separated by '%c' characters: these alternatives are always tried in\n\
the order they are specified in, that is, left to right through the text\n\
in the path variable.\n\n",
FN_ALT);
printf(
" If two '+' signs are used (\"inform ++include_path=dir jigsaw\") then\n\
the path or paths are added to the existing list.\n\n");
printf(
" (Modules are written to the first alternative in the module_path list;\n\
it is an error to give alternatives at all for purely output paths.)\n\n");
#ifdef FILE_EXTENSIONS
printf("3. The following file extensions are added:\n\n\
Source code: %s\n\
Include files: %s\n\
Story files: %s (Version 3), %s (v4), %s (v5, the default),\n\
%s (v6), %s (v7), %s (v8), %s (Glulx)\n\
Temporary files: .tmp\n\
Modules: %s\n\n",
Source_Extension, Include_Extension,
Code_Extension, V4Code_Extension, V5Code_Extension, V6Code_Extension,
V7Code_Extension, V8Code_Extension, GlulxCode_Extension,
Module_Extension);
printf("\
except that any extension you give (on the command line or in a filename\n\
used in a program) will override these. If you give the null extension\n\
\".\" then Inform uses no file extension at all (removing the \".\").\n\n");
#endif
printf("Names of four individual files can also be set using the same\n\
+ command notation (though they aren't really pathnames). These are:\n\n\
transcript_name (text written by -r switch): now \"%s\"\n\
debugging_name (data written by -k switch): now \"%s\"\n\
language_name (library file defining natural language of game):\n\
now \"%s\"\n\
charset_map (file for character set mapping): now \"%s\"\n\n",
Transcript_Name, Debugging_Name, Language_Name, Charset_Map);
translate_in_filename(0, new_name, "rezrov", 0, 1);
printf("Examples: 1. \"inform rezrov\"\n\
the source code is read from \"%s\"\n",
new_name);
convert_filename_flag = TRUE;
translate_out_filename(new_name, "rezrov");
printf(" and a story file is compiled to \"%s\".\n\n", new_name);
translate_in_filename(0, new_name, "frotz", 0, 1);
printf("2. \"inform -M frotz\"\n\
the source code is read from \"%s\"\n",
new_name);
module_switch = TRUE;
convert_filename_flag = TRUE;
translate_out_filename(new_name, "frotz");
printf(" and a module is compiled to \"%s\".\n\n", new_name);
module_switch = FALSE;
sprintf(old_name, "demos%cplugh", FN_SEP);
printf("3. \"inform %s\"\n", old_name);
translate_in_filename(0, new_name, old_name, 0, 1);
printf(" the source code is read from \"%s\"\n", new_name);
sprintf(old_name, "demos%cplugh", FN_SEP);
convert_filename_flag = TRUE;
translate_out_filename(new_name, old_name);
printf(" and a story file is compiled to \"%s\".\n\n", new_name);
printf("4. \"inform plover my_demo\"\n");
translate_in_filename(0, new_name, "plover", 0, 1);
printf(" the source code is read from \"%s\"\n", new_name);
convert_filename_flag = FALSE;
translate_out_filename(new_name, "my_demo");
printf(" and a story file is compiled to \"%s\".\n\n", new_name);
strcpy(old_name, Source_Path);
sprintf(new_name, "%cnew%cold%crecent%cold%cancient",
FN_ALT, FN_ALT, FN_SEP, FN_ALT, FN_SEP);
printf("5. \"inform +source_path=%s zooge\"\n", new_name);
printf(
" Note that four alternative paths are given, the first being the empty\n\
path-name (meaning: where you are now). Inform looks for the source code\n\
by trying these four places in turn, stopping when it finds anything:\n\n");
set_path_value(Source_Path, new_name);
x = 0;
do
{ x = translate_in_filename(x, new_name, "zooge", 0, 1);
printf(" \"%s\"\n", new_name);
} while (x != 0);
strcpy(Source_Path, old_name);
module_switch = save_mm;
}
/* ------------------------------------------------------------------------- */
/* Naming temporary files */
/* (Arguably temporary files should be made using "tmpfile" in */
/* the ANSI C library, but many supposed ANSI libraries lack it.) */
/* ------------------------------------------------------------------------- */
extern void translate_temp_filename(int i)
{ char *p = NULL;
switch(i)
{ case 1: p=Temp1_Name; break;
case 2: p=Temp2_Name; break;
case 3: p=Temp3_Name; break;
}
if (strlen(Temporary_Path)+strlen(Temporary_File)+6 >= PATHLEN) {
printf ("Temporary_Path is too long.\n");
exit(1);
}
sprintf(p,"%s%s%d", Temporary_Path, Temporary_File, i);
#ifdef INCLUDE_TASK_ID
sprintf(p+strlen(p), "_proc%08lx", (long int) unique_task_id());
#endif
#ifdef FILE_EXTENSIONS
sprintf(p+strlen(p), ".tmp");
#endif
}
#ifdef ARCHIMEDES
static char riscos_ft_buffer[4];
extern char *riscos_file_type(void)
{
if (riscos_file_type_format == 1)
{ if (module_switch) return("data");
return("11A");
}
if (module_switch) return("075");
sprintf(riscos_ft_buffer, "%03x", 0x60 + version_number);
return(riscos_ft_buffer);
}
#endif
/* ------------------------------------------------------------------------- */
/* The compilation pass */
/* ------------------------------------------------------------------------- */
static void run_pass(void)
{
lexer_begin_prepass();
files_begin_prepass();
load_sourcefile(Source_Name, 0);
begin_pass();
parse_program(NULL);
find_the_actions();
issue_unused_warnings();
compile_veneer();
lexer_endpass();
if (module_switch) linker_endpass();
close_all_source();
if (hash_switch && hash_printed_since_newline) printf("\n");
if (temporary_files_switch)
{ if (module_switch) flush_link_data();
check_temp_files();
}
sort_dictionary();
if (track_unused_routines)
locate_dead_functions();
construct_storyfile();
}
int output_has_occurred;
static void rennab(int32 time_taken)
{ /* rennab = reverse of banner */
int t = no_warnings + no_suppressed_warnings;
if (memout_switch) print_memory_usage();
if ((no_errors + t)!=0)
{ printf("Compiled with ");
if (no_errors > 0)
{ printf("%d error%s", no_errors,(no_errors==1)?"":"s");
if (t > 0) printf(" and ");
}
if (no_warnings > 0)
printf("%d warning%s", t, (t==1)?"":"s");
if (no_suppressed_warnings > 0)
{ if (no_warnings > 0)
printf(" (%d suppressed)", no_suppressed_warnings);
else
printf("%d suppressed warning%s", no_suppressed_warnings,
(no_suppressed_warnings==1)?"":"s");
}
if (output_has_occurred == FALSE) printf(" (no output)");
printf("\n");
}
if (no_compiler_errors > 0) print_sorry_message();
if (statistics_switch)
printf("Completed in %ld seconds\n", (long int) time_taken);
}
/* ------------------------------------------------------------------------- */
/* The compiler abstracted to a routine. */
/* ------------------------------------------------------------------------- */
static int execute_icl_header(char *file1);
static int compile(int number_of_files_specified, char *file1, char *file2)
{ int32 time_start;
if (execute_icl_header(file1))
return 1;
select_target(glulx_mode);
if (define_INFIX_switch && glulx_mode) {
printf("Infix (-X) facilities are not available in Glulx: \
disabling -X switch\n");
define_INFIX_switch = FALSE;
}
if (module_switch && glulx_mode) {
printf("Modules are not available in Glulx: \
disabling -M switch\n");
module_switch = FALSE;
}
if (define_INFIX_switch && module_switch)
{ printf("Infix (-X) facilities are not available when compiling \
modules: disabling -X switch\n");
define_INFIX_switch = FALSE;
}
if (runtime_error_checking_switch && module_switch)
{ printf("Strict checking (-S) facilities are not available when \
compiling modules: disabling -S switch\n");
runtime_error_checking_switch = FALSE;
}
time_start=time(0); no_compilations++;
strcpy(Source_Name, file1); convert_filename_flag = TRUE;
strcpy(Code_Name, file1);
if (number_of_files_specified == 2)
{ strcpy(Code_Name, file2); convert_filename_flag = FALSE;
}
init_vars();
if (debugfile_switch) begin_debug_file();
allocate_arrays();
if (transcript_switch) open_transcript_file(Source_Name);
run_pass();
if (transcript_switch)
{ write_dictionary_to_transcript();
close_transcript_file();
}
if (no_errors==0) { output_file(); output_has_occurred = TRUE; }
else { output_has_occurred = FALSE; }
if (debugfile_switch)
{ end_debug_file();
}
if (temporary_files_switch && (no_errors>0)) remove_temp_files();
free_arrays();
rennab((int32) (time(0)-time_start));
if (optimise_switch) optimise_abbreviations();
if (store_the_text) my_free(&all_text,"transcription text");
return (no_errors==0)?0:1;
}
/* ------------------------------------------------------------------------- */
/* The command line interpreter */
/* ------------------------------------------------------------------------- */
static void cli_print_help(int help_level)
{
printf(
"\nThis program is a compiler of Infocom format (also called \"Z-machine\")\n\
story files: copyright (c) Graham Nelson 1993 - 2020.\n\n");
/* For people typing just "inform", a summary only: */
if (help_level==0)
{
#ifndef PROMPT_INPUT
printf("Usage: \"inform [commands...] <file1> [<file2>]\"\n\n");
#else
printf("When run, Inform prompts you for commands (and switches),\n\
which are optional, then an input <file1> and an (optional) output\n\
<file2>.\n\n");
#endif
printf(
"<file1> is the Inform source file of the game to be compiled. <file2>,\n\
if given, overrides the filename Inform would normally use for the\n\
compiled output. Try \"inform -h1\" for file-naming conventions.\n\n\
One or more words can be supplied as \"commands\". These may be:\n\n\
-switches a list of compiler switches, 1 or 2 letter\n\
(see \"inform -h2\" for the full range)\n\n\
+dir set Include_Path to this directory\n\
+PATH=dir change the PATH to this directory\n\n\
$... one of the following memory commands:\n");
printf(
" $list list current memory allocation settings\n\
$huge make standard \"huge game\" settings %s\n\
$large make standard \"large game\" settings %s\n\
$small make standard \"small game\" settings %s\n\
$?SETTING explain briefly what SETTING is for\n\
$SETTING=number change SETTING to given number\n\n\
(filename) read in a list of commands (in the format above)\n\
from this \"setup file\"\n\n",
(DEFAULT_MEMORY_SIZE==HUGE_SIZE)?"(default)":"",
(DEFAULT_MEMORY_SIZE==LARGE_SIZE)?"(default)":"",
(DEFAULT_MEMORY_SIZE==SMALL_SIZE)?"(default)":"");
#ifndef PROMPT_INPUT
printf("For example: \"inform -dexs $huge curses\".\n\n");
#endif
printf(
"For fuller information, see the Inform Designer's Manual.\n");
return;
}
/* The -h1 (filenaming) help information: */
if (help_level == 1) { help_on_filenames(); return; }
/* The -h2 (switches) help information: */
printf("Help on the full list of legal switch commands:\n\n\
a trace assembly-language (without hex dumps; see -t)\n\
c more concise error messages\n\
d contract double spaces after full stops in text\n\
d2 contract double spaces after exclamation and question marks, too\n\
e economy mode (slower): make use of declared abbreviations\n");
printf("\
f frequencies mode: show how useful abbreviations are\n\
g traces calls to functions (except in the library)\n\
g2 traces calls to all functions\n\
h print this information\n");
printf("\
i ignore default switches set within the file\n\
j list objects as constructed\n\
k output Infix debugging information to \"%s\" (and switch -D on)\n\
l list every statement run through Inform\n\
m say how much memory has been allocated\n\
n print numbers of properties, attributes and actions\n",
Debugging_Name);
printf("\
o print offset addresses\n\
p give percentage breakdown of story file\n\
q keep quiet about obsolete usages\n\
r record all the text to \"%s\"\n\
s give statistics\n\
t trace assembly-language (with full hex dumps; see -a)\n",
Transcript_Name);
printf("\
u work out most useful abbreviations (very very slowly)\n\
v3 compile to version-3 (\"Standard\") story file\n\
v4 compile to version-4 (\"Plus\") story file\n\
v5 compile to version-5 (\"Advanced\") story file: the default\n\
v6 compile to version-6 (graphical) story file\n\
v8 compile to version-8 (expanded \"Advanced\") story file\n\
w disable warning messages\n\
x print # for every 100 lines compiled\n\
y trace linking system\n\
z print memory map of the Z-machine\n\n");
printf("\
B use big memory model (for large V6/V7 files)\n\
C0 text character set is plain ASCII only\n\
Cu text character set is UTF-8\n\
Cn text character set is ISO 8859-n (n = 1 to 9)\n\
(1 to 4, Latin1 to Latin4; 5, Cyrillic; 6, Arabic;\n\
7, Greek; 8, Hebrew; 9, Latin5. Default is -C1.)\n");
printf(" D insert \"Constant DEBUG;\" automatically\n");
printf(" E0 Archimedes-style error messages%s\n",
(error_format==0)?" (current setting)":"");
printf(" E1 Microsoft-style error messages%s\n",
(error_format==1)?" (current setting)":"");
printf(" E2 Macintosh MPW-style error messages%s\n",
(error_format==2)?" (current setting)":"");
#ifdef USE_TEMPORARY_FILES
printf(" F0 use extra memory rather than temporary files\n");
#else
printf(" F1 use temporary files to reduce memory consumption\n");
#endif
printf(" G compile a Glulx game file\n");
printf(" H use Huffman encoding to compress Glulx strings\n");
printf(" M compile as a Module for future linking\n");
#ifdef ARCHIMEDES
printf("\
R0 use filetype 060 + version number for games (default)\n\
R1 use official Acorn filetype 11A for all games\n");
#endif
printf(" S compile strict error-checking at run-time (on by default)\n");
#ifdef ARC_THROWBACK
printf(" T enable throwback of errors in the DDE\n");
#endif
printf(" U insert \"Constant USE_MODULES;\" automatically\n");
printf(" V print the version and date of this program\n");
printf(" Wn header extension table is at least n words (n = 3 to 99)\n");
printf(" X compile with INFIX debugging facilities present\n");
printf("\n");
}
extern void switches(char *p, int cmode)
{ int i, s=1, state;
/* Here cmode is 0 if switches list is from a "Switches" directive
and 1 if from a "-switches" command-line or ICL list */
if (cmode==1)
{ if (p[0]!='-')
{ printf(
"Ignoring second word which should be a -list of switches.\n");
return;
}
}
for (i=cmode; p[i]!=0; i+=s, s=1)
{ state = TRUE;
if (p[i] == '~')
{ state = FALSE;
i++;
}
switch(p[i])
{
case 'a': asm_trace_setting = 1; break;
case 'b': bothpasses_switch = state; break;
case 'c': concise_switch = state; break;
case 'd': switch(p[i+1])
{ case '1': double_space_setting=1; s=2; break;
case '2': double_space_setting=2; s=2; break;
default: double_space_setting=1; break;
}
break;
case 'e': economy_switch = state; break;
case 'f': frequencies_switch = state; break;
case 'g': switch(p[i+1])
{ case '1': trace_fns_setting=1; s=2; break;
case '2': trace_fns_setting=2; s=2; break;
default: trace_fns_setting=1; break;
}
break;
case 'h': switch(p[i+1])
{ case '1': cli_print_help(1); s=2; break;
case '2': cli_print_help(2); s=2; break;
case '0': s=2;
default: cli_print_help(0); break;
}
break;
case 'i': ignore_switches_switch = state; break;
case 'j': listobjects_switch = state; break;
case 'k': if (cmode == 0)
error("The switch '-k' can't be set with 'Switches'");
else
{ debugfile_switch = state;
if (state) define_DEBUG_switch = TRUE;
}
break;
case 'l': listing_switch = state; break;
case 'm': memout_switch = state; break;
case 'n': printprops_switch = state; break;
case 'o': offsets_switch = state; break;
case 'p': percentages_switch = state; break;
case 'q': obsolete_switch = state; break;
case 'r': if (cmode == 0)
error("The switch '-r' can't be set with 'Switches'");
else
transcript_switch = state; break;
case 's': statistics_switch = state; break;
case 't': asm_trace_setting=2; break;
case 'u': if (cmode == 0) {
error("The switch '-u' can't be set with 'Switches'");
break;
}
optimise_switch = state; break;
case 'v': if (glulx_mode) { s = select_glulx_version(p+i+1)+1; break; }
if ((cmode==0) && (version_set_switch)) { s=2; break; }
version_set_switch = TRUE; s=2;
switch(p[i+1])
{ case '3': select_version(3); break;
case '4': select_version(4); break;
case '5': select_version(5); break;
case '6': select_version(6); break;
case '7': select_version(7); break;
case '8': select_version(8); break;
default: printf("-v must be followed by 3 to 8\n");
version_set_switch=0; s=1;
break;
}
if ((version_number < 5) && (r_e_c_s_set == FALSE))
runtime_error_checking_switch = FALSE;
break;
case 'w': nowarnings_switch = state; break;
case 'x': hash_switch = state; break;
case 'y': s=2; linker_trace_setting=p[i+1]-'0'; break;
case 'z': memory_map_switch = state; break;
case 'B': oddeven_packing_switch = state; break;
case 'C': s=2;
if (p[i+1] == 'u') {
character_set_unicode = TRUE;
/* Leave the set_setting on Latin-1, because that
matches the first block of Unicode. */
character_set_setting = 1;
}
else
{ character_set_setting=p[i+1]-'0';
if ((character_set_setting < 0)
|| (character_set_setting > 9))
{ printf("-C must be followed by 'u' or 0 to 9. Defaulting to ISO-8859-1.\n");
character_set_unicode = FALSE;
character_set_setting = 1;
}
}
if (cmode == 0) change_character_set();
break;
case 'D': define_DEBUG_switch = state; break;
case 'E': switch(p[i+1])
{ case '0': s=2; error_format=0; break;
case '1': s=2; error_format=1; break;
case '2': s=2; error_format=2; break;
default: error_format=1; break;
}
break;
case 'F': if (cmode == 0) {
error("The switch '-F' can't be set with 'Switches'");
break;
}
switch(p[i+1])
{ case '0': s=2; temporary_files_switch = FALSE; break;
case '1': s=2; temporary_files_switch = TRUE; break;
default: temporary_files_switch = state; break;
}
break;
case 'M': module_switch = state;
if (state && (r_e_c_s_set == FALSE))
runtime_error_checking_switch = FALSE;
break;
#ifdef ARCHIMEDES
case 'R': switch(p[i+1])
{ case '0': s=2; riscos_file_type_format=0; break;
case '1': s=2; riscos_file_type_format=1; break;
default: riscos_file_type_format=1; break;
}
break;
#endif
#ifdef ARC_THROWBACK
case 'T': throwback_switch = state; break;
#endif
case 'S': runtime_error_checking_switch = state;
r_e_c_s_set = TRUE; break;
case 'G': if (cmode == 0)
error("The switch '-G' can't be set with 'Switches'");
else
{ glulx_mode = state;
adjust_memory_sizes();
}
break;
case 'H': compression_switch = state; break;
case 'U': define_USE_MODULES_switch = state; break;
case 'V': exit(0); break;
case 'W': if ((p[i+1]>='0') && (p[i+1]<='9'))
{ s=2; ZCODE_HEADER_EXT_WORDS = p[i+1]-'0';
if ((p[i+2]>='0') && (p[i+2]<='9'))
{ s=3; ZCODE_HEADER_EXT_WORDS *= 10;
ZCODE_HEADER_EXT_WORDS += p[i+2]-'0';
}
}
break;
case 'X': define_INFIX_switch = state; break;
default:
printf("Switch \"-%c\" unknown (try \"inform -h2\" for the list)\n",
p[i]);
break;
}
}
if (optimise_switch && (!store_the_text))
{ store_the_text=TRUE;
#ifdef PC_QUICKC
if (memout_switch)
printf("Allocation %ld bytes for transcription text\n",
(long) MAX_TRANSCRIPT_SIZE);
all_text = halloc(MAX_TRANSCRIPT_SIZE,1);
malloced_bytes += MAX_TRANSCRIPT_SIZE;
if (all_text==NULL)
fatalerror("Can't hallocate memory for transcription text. Darn.");
#else
all_text=my_malloc(MAX_TRANSCRIPT_SIZE,"transcription text");
#endif
}
}
static int icl_command(char *p)
{ if ((p[0]=='+')||(p[0]=='-')||(p[0]=='$')
|| ((p[0]=='(')&&(p[strlen(p)-1]==')')) ) return TRUE;
return FALSE;
}
static void icl_error(char *filename, int line)
{ printf("Error in ICL file '%s', line %d:\n", filename, line);
}
static void icl_header_error(char *filename, int line)
{ printf("Error in ICL header of file '%s', line %d:\n", filename, line);
}
static int copy_icl_word(char *from, char *to, int max)
{
/* Copies one token from 'from' to 'to', null-terminated:
returns the number of chars in 'from' read past (possibly 0). */
int i, j, quoted_mode, truncated;
i = 0; truncated = 0;
while ((from[i] == ' ') || (from[i] == TAB_CHARACTER)
|| (from[i] == (char) 10) || (from[i] == (char) 13)) i++;
if (from[i] == '!')
{ while (from[i] != 0) i++;
to[0] = 0; return i;
}
for (quoted_mode = FALSE, j=0;;)
{ if (from[i] == 0) break;
if (from[i] == 10) break;
if (from[i] == 13) break;
if (from[i] == TAB_CHARACTER) break;
if ((from[i] == ' ') && (!quoted_mode)) break;
if (from[i] == '\"') { quoted_mode = !quoted_mode; i++; }
else to[j++] = from[i++];
if (j == max) {
j--;
truncated = 1;
}
}
to[j] = 0;
if (truncated == 1)
printf("The following parameter has been truncated:\n%s\n", to);
return i;
}
static void execute_icl_command(char *p);
static int execute_icl_header(char *argname)
{
FILE *command_file;
char cli_buff[256], fw[256];
int line = 0;
int errcount = 0;
int i;
char filename[PATHLEN];
int x = 0;
do
{ x = translate_in_filename(x, filename, argname, 0, 1);
command_file = fopen(filename,"r");
} while ((command_file == NULL) && (x != 0));
if (!command_file) {
/* Fail silently. The regular compiler will try to open the file
again, and report the problem. */
return 0;
}
while (feof(command_file)==0) {
if (fgets(cli_buff,256,command_file)==0) break;
line++;
if (!(cli_buff[0] == '!' && cli_buff[1] == '%'))
break;
i = copy_icl_word(cli_buff+2, fw, 256);
if (icl_command(fw)) {
execute_icl_command(fw);
copy_icl_word(cli_buff+2 + i, fw, 256);
if ((fw[0] != 0) && (fw[0] != '!')) {
icl_header_error(filename, line);
errcount++;
printf("expected comment or nothing but found '%s'\n", fw);
}
}
else {
if (fw[0]!=0) {
icl_header_error(filename, line);
errcount++;
printf("Expected command or comment but found '%s'\n", fw);
}
}
}
fclose(command_file);
return (errcount==0)?0:1;
}
static void run_icl_file(char *filename, FILE *command_file)
{ char cli_buff[256], fw[256];
int i, x, line = 0;
printf("[Running ICL file '%s']\n", filename);
while (feof(command_file)==0)
{ if (fgets(cli_buff,256,command_file)==0) break;
line++;
i = copy_icl_word(cli_buff, fw, 256);
if (icl_command(fw))
{ execute_icl_command(fw);
copy_icl_word(cli_buff + i, fw, 256);
if ((fw[0] != 0) && (fw[0] != '!'))
{ icl_error(filename, line);
printf("expected comment or nothing but found '%s'\n", fw);
}
}
else
{ if (strcmp(fw, "compile")==0)
{ char story_name[PATHLEN], code_name[PATHLEN];
i += copy_icl_word(cli_buff + i, story_name, PATHLEN);
i += copy_icl_word(cli_buff + i, code_name, PATHLEN);
if (code_name[0] != 0) x=2;
else if (story_name[0] != 0) x=1;
else x=0;
switch(x)
{ case 0: icl_error(filename, line);
printf("No filename given to 'compile'\n");
break;
case 1: printf("[Compiling <%s>]\n", story_name);
compile(x, story_name, code_name);
break;
case 2: printf("[Compiling <%s> to <%s>]\n",
story_name, code_name);
compile(x, story_name, code_name);
copy_icl_word(cli_buff + i, fw, 256);
if (fw[0]!=0)
{ icl_error(filename, line);
printf("Expected comment or nothing but found '%s'\n",
fw);
}
break;
}
}
else
if (fw[0]!=0)
{ icl_error(filename, line);
printf("Expected command or comment but found '%s'\n", fw);
}
}
}
}
static void execute_icl_command(char *p)
{ char filename[PATHLEN], cli_buff[256];
FILE *command_file;
switch(p[0])
{ case '+': set_path_command(p+1); break;
case '-': switches(p,1); break;
case '$': memory_command(p+1); break;
case '(': strcpy(cli_buff,p+1); cli_buff[strlen(cli_buff)-1]=0;
{ int x = 0;
do
{ x = translate_icl_filename(x, filename, cli_buff);
command_file = fopen(filename,"r");
} while ((command_file == NULL) && (x != 0));
}
if (command_file == NULL)
printf("Error in ICL: Couldn't open command file '%s'\n",
filename);
else
{ run_icl_file(filename, command_file);
fclose(command_file);
}
break;
}
}
/* ------------------------------------------------------------------------- */
/* Opening and closing banners */
/* ------------------------------------------------------------------------- */
char banner_line[80];
static void banner(void)
{
sprintf(banner_line, "Inform %d.%d%d",
(VNUMBER/100)%10, (VNUMBER/10)%10, VNUMBER%10);
#ifdef RELEASE_SUFFIX
strcat(banner_line, RELEASE_SUFFIX);
#endif
#ifdef MACHINE_STRING
sprintf(banner_line+strlen(banner_line), " for %s", MACHINE_STRING);
#endif
sprintf(banner_line+strlen(banner_line), " (%s)", RELEASE_DATE);
printf("%s\n", banner_line);
}
/* ------------------------------------------------------------------------- */
/* Input from the outside world */
/* ------------------------------------------------------------------------- */
#ifdef PROMPT_INPUT
static void read_command_line(int argc, char **argv)
{ int i;
char buffer1[PATHLEN], buffer2[PATHLEN], buffer3[PATHLEN];
i=0;
printf("Source filename?\n> ");
while (gets(buffer1)==NULL); cli_file1=buffer1;
printf("Output filename (RETURN for the same)?\n> ");
while (gets(buffer2)==NULL); cli_file2=buffer2;
cli_files_specified=1;
if (buffer2[0]!=0) cli_files_specified=2;
do
{ printf("List of commands (RETURN to finish; \"-h\" for help)?\n> ");
while (gets(buffer3)==NULL); execute_icl_command(buffer3);
} while (buffer3[0]!=0);
}
#else
static void read_command_line(int argc, char **argv)
{ int i;
if (argc==1) switches("-h",1);
for (i=1, cli_files_specified=0; i<argc; i++)
if (icl_command(argv[i]))
execute_icl_command(argv[i]);
else
switch(++cli_files_specified)
{ case 1: cli_file1 = argv[i]; break;
case 2: cli_file2 = argv[i]; break;
default:
printf("Command line error: unknown parameter '%s'\n",
argv[i]); return;
}
}
#endif
/* ------------------------------------------------------------------------- */
/* M A I N : An outer shell for machine-specific quirks */
/* Omitted altogether if EXTERNAL_SHELL is defined, as for instance is */
/* needed for the Macintosh front end. */
/* ------------------------------------------------------------------------- */
#ifdef EXTERNAL_SHELL
extern int sub_main(int argc, char **argv);
#else
static int sub_main(int argc, char **argv);
#ifdef MAC_MPW
int main(int argc, char **argv, char *envp[])
#else
int main(int argc, char **argv)
#endif
{ int rcode;
#ifdef MAC_MPW
InitCursorCtl((acurHandle)NULL); Show_Cursor(WATCH_CURSOR);
#endif
rcode = sub_main(argc, argv);
#ifdef ARC_THROWBACK
throwback_end();
#endif
return rcode;
}
#endif
/* ------------------------------------------------------------------------- */
/* M A I N II: Starting up ICL with the command line */
/* ------------------------------------------------------------------------- */
#ifdef EXTERNAL_SHELL
extern int sub_main(int argc, char **argv)
#else
static int sub_main(int argc, char **argv)
#endif
{ int return_code;
#ifdef MAC_FACE
ProcessEvents (&g_proc);
if (g_proc != true)
{ free_arrays();
if (store_the_text) my_free(&all_text,"transcription text");
longjmp (g_fallback, 1);
}
#endif
banner();
set_memory_sizes(DEFAULT_MEMORY_SIZE); set_default_paths();
reset_switch_settings(); select_version(5);
cli_files_specified = 0; no_compilations = 0;
cli_file1 = "source"; cli_file2 = "output";
read_command_line(argc, argv);
if (cli_files_specified > 0)
{ return_code = compile(cli_files_specified, cli_file1, cli_file2);
if (return_code != 0) return(return_code);
}
if (no_compilations == 0)
printf("\n[No compilation requested]\n");
if (no_compilations > 1)
printf("[%d compilations completed]\n", no_compilations);
return(0);
}
/* ========================================================================= */
Reference in a new issue View git blame Copy permalink