/* ------------------------------------------------------------------------- */
/* "tables" : Maintains tables of dictionary, objects, actions, */
/* grammar and global variables; */
/* and constructs the tables part of the story file */
/* */
/* Part of Inform release 5 */
/* */
/* ------------------------------------------------------------------------- */
#include "header.h"
int no_attributes, no_properties, no_globals, no_fake_actions=0;
int dict_entries;
int release_number=1, statusline_flag=0;
int time_set=0;
char time_given[7];
int globals_size, properties_size;
int32 prop_defaults[64];
int prop_longflag[64];
int prop_additive[64];
char *properties_table;
int max_no_objects=0;
int resobj_flag = 0;
static int no_verbs=0, no_actions=0, no_adjectives=0,
no_objects=0, no_classes=0, classes_size=0;
static int fp_no_actions=0;
static int embedded_routine = 0;
static fpropt full_object;
/* ------------------------------------------------------------------------- */
/* Arrays used by this file */
/* ------------------------------------------------------------------------- */
#ifndef ALLOCATE_BIG_ARRAYS
static verbt vs[MAX_VERBS];
static objectt objects[MAX_OBJECTS];
static int table_init[MAX_STATIC_DATA];
static int32 actions[MAX_ACTIONS],
preactions[MAX_ACTIONS],
adjectives[MAX_ADJECTIVES];
static dict_word adjcomps[MAX_ADJECTIVES];
static int32 gvalues[240];
static int dict_places_list[MAX_DICT_ENTRIES],
dict_places_back[MAX_DICT_ENTRIES],
dict_places_inverse[MAX_DICT_ENTRIES];
static dict_word dict_sorts[MAX_DICT_ENTRIES];
static zip class_pointer[MAX_CLASS_TABLE_SIZE];
static int classes_here[MAX_CLASSES];
static int32 *classes_at[MAX_CLASSES];
#else
static verbt *vs;
static objectt *objects;
static int *table_init;
static int32 *actions,
*preactions,
*adjectives;
static dict_word *adjcomps;
static int32 *gvalues;
static int *dict_places_list,
*dict_places_back,
*dict_places_inverse;
static dict_word *dict_sorts;
static int *classes_here;
static int32 **classes_at;
static zip *class_pointer;
#endif
static char *verblist;
static char *verblist_p;
extern void tables_allocate_arrays(void)
{
#ifdef ALLOCATE_BIG_ARRAYS
vs = my_calloc(sizeof(verbt), MAX_VERBS, "verbs");
objects = my_calloc(sizeof(objectt), MAX_OBJECTS, "objects");
table_init = my_calloc(sizeof(int), MAX_STATIC_DATA, "static data");
actions = my_calloc(sizeof(int32), MAX_ACTIONS, "actions");
preactions = my_calloc(sizeof(int32), MAX_ACTIONS, "preactions");
adjectives = my_calloc(sizeof(int32), MAX_ADJECTIVES, "adjectives");
adjcomps = my_calloc(sizeof(dict_word), MAX_ADJECTIVES, "adj comps");
gvalues = my_calloc(sizeof(int32), 240, "global values");
dict_places_list = my_calloc(sizeof(int), MAX_DICT_ENTRIES,
"dictionary places list");
dict_places_back = my_calloc(sizeof(int), MAX_DICT_ENTRIES,
"dictionary places back");
dict_places_inverse = my_calloc(sizeof(int), MAX_DICT_ENTRIES,
"inverse of dictionary places");
dict_sorts = my_calloc(sizeof(dict_word), MAX_DICT_ENTRIES,
"dictionary sort codes");
class_pointer = my_malloc(MAX_CLASS_TABLE_SIZE, "class table");
classes_here = my_calloc(sizeof(int), MAX_CLASSES,
"inherited classes list");
classes_at = my_calloc(sizeof(int32), MAX_CLASSES,
"pointers to classes");
#endif
verblist = my_malloc(MAX_VERBSPACE, "register of verbs");
verblist_p = verblist;
}
extern void tables_free_arrays(void)
{
#ifdef ALLOCATE_BIG_ARRAYS
my_free(&vs, "verbs");
my_free(&objects, "objects");
my_free(&table_init, "static data");
my_free(&actions, "actions");
my_free(&preactions, "preactions");
my_free(&adjectives, "adjectives");
my_free(&adjcomps, "adj comps");
my_free(&gvalues, "global values");
my_free(&dict_places_list, "dictionary places list");
my_free(&dict_places_back, "dictionary places back");
my_free(&dict_places_inverse, "inverse of dictionary places");
my_free(&dict_sorts, "dictionary sort codes");
my_free(&class_pointer,"class table");
my_free(&classes_here, "inherited classes list");
my_free(&classes_at, "pointers to classes");
#endif
my_free(&verblist,"register of verbs");
}
/* ------------------------------------------------------------------------- */
/* A routine using an unusual ANSI library function: */
/* */
/* write_serialnumber writes today's date in the form YYMMDD as a string */
/* (as can be seen, the VAX doesn't know it) */
/* ------------------------------------------------------------------------- */
static void write_serialnumber(char *buffer)
{ time_t tt; tt=time(0);
if (time_set==0)
#ifdef TIME_UNAVAILABLE
sprintf(buffer,"940000");
#else
strftime(buffer,10,"%y%m%d",localtime(&tt));
#endif
else
sprintf(buffer,"%06s",time_given);
}
/* ------------------------------------------------------------------------- */
/* Dictionary table builder */
/* The dictionary is, so to speak, thumb-indexed: the beginning of each */
/* letter in the double-linked-list is marked. Experiments with */
/* increasing the number of markers (to the first two letters, say) result */
/* in extra bureaucracy which cancels out any speed gain. */
/* ------------------------------------------------------------------------- */
#define NUMBER_DICT_MARKERS 26
static int total_dict_entries;
static dict_word letter_keys[NUMBER_DICT_MARKERS];
static int letter_starts[NUMBER_DICT_MARKERS];
static int start_list;
static dict_word prepared_sort;
static int initial_letter;
static void dictionary_begin_pass(void)
{ int i, j;
dict_p=dictionary+7;
total_dict_entries=dict_entries; dict_entries=0;
if (pass_number==1)
{ start_list=0; dict_places_list[0]= -2; dict_places_back[0]= -1;
for (i=0; i<NUMBER_DICT_MARKERS; i++)
{ letter_keys[i].b[0]=0xff;
letter_starts[i]= -1;
}
}
else
{ for (j=start_list, i=0; i<total_dict_entries; i++)
{ dict_places_inverse[j]=i; j=dict_places_list[j]; }
}
}
static int compare_sorts(dict_word d1, dict_word d2)
{ int i;
for (i=0; i<6; i++) if (d1.b[i]!=d2.b[i]) return(d1.b[i]-d2.b[i]);
/* since memcmp(d1.b, d2.b, 6); doesn't work in the Unix port - ? */
return(0);
}
static dict_word dictionary_prepare(char *dword)
{ int i, j, k, wd[10]; int32 tot;
for (i=0, j=0; (i<9)&&(dword[j]!=0); i++, j++)
{ k=(int) dword[j];
if (k==(int) '\'')
obsolete_warning("use the ^ character for an apostrophe \
in a dictionary word, e.g. 'peter^s'");
if (k==(int) '^') k=(int) '\'';
k=chars_lookup[k];
if ((k>=26)&&(k<2*26)) k=k-26;
if ((k/26)!=0) wd[i++]=3+(k/26);
wd[i]=6+(k%26);
}
for (; i<9; i++) wd[i]=5;
InV3 { wd[6]=5; wd[7]=5; wd[8]=5;
if ((wd[5]==3)||(wd[5]==4)) wd[5]=5;
}
InV5 { if ((wd[8]==3)||(wd[8]==4)) wd[8]=5; }
initial_letter = wd[0]-6;
if (initial_letter<0)
{ error("Dictionary words must begin with a letter of the alphabet");
initial_letter=0;
}
/* Note... this doesn't depend on A to Z being contiguous in the
machine's character set */
tot = wd[2] + wd[1]*(1<<5) + wd[0]*(1<<10);
prepared_sort.b[1]=tot%0x100;
prepared_sort.b[0]=(tot/0x100)%0x100;
tot = wd[5] + wd[4]*(1<<5) + wd[3]*(1<<10);
prepared_sort.b[3]=tot%0x100;
prepared_sort.b[2]=(tot/0x100)%0x100;
tot = wd[8] + wd[7]*(1<<5) + wd[6]*(1<<10);
prepared_sort.b[5]=tot%0x100;
prepared_sort.b[4]=(tot/0x100)%0x100;
InV3 { prepared_sort.b[2]+=0x80; }
InV5 { prepared_sort.b[4]+=0x80; }
return(prepared_sort);
}
extern int dictionary_find(char *dword, int scope)
{ int32 j, j2, k, jlim;
dict_word i;
i=dictionary_prepare(dword);
if (scope==1) jlim=dict_entries; else jlim=total_dict_entries;
if (pass_number==1)
{ for (j=0; j<jlim; j++)
if (compare_sorts(i,dict_sorts[j])==0) return((int) j+1);
return(0);
}
if ((k=letter_starts[initial_letter])==-1) return(0);
j=initial_letter+1;
while ((j<NUMBER_DICT_MARKERS)&&((j2=letter_starts[j])==-1)) j++;
if (j==NUMBER_DICT_MARKERS) { j2= -2; }
while (k!=j2)
{
if ((compare_sorts(i,dict_sorts[k])==0)&&(k<jlim))
return(dict_places_inverse[k]+1);
k=dict_places_list[k];
}
return(0);
}
static void show_letter(int code)
{
if (code<6) { printf("."); return; }
printf("%c",(alphabet[0])[code-6]);
}
extern void show_dictionary(void)
{ int i, j; char *p;
int res=((version_number==3)?4:6);
printf("Dictionary contains %d entries:\n",dict_entries);
for (i=0; i<dict_entries; i++)
{ p=(char *)dictionary+7+(3+res)*i;
if (dict_entries==0)
printf("Entry %03d (%03d > %03d) at %04x: ",
i,dict_places_back[i],dict_places_list[i],
dictionary_offset+7+(3+res)*i);
else
printf("Entry %03d at %04x: ",i,dictionary_offset+7+(3+res)*i);
show_letter( (((int) p[0])&0x7c)/4 );
show_letter( 8*(((int) p[0])&0x3) + (((int) p[1])&0xe0)/32 );
show_letter( ((int) p[1])&0x1f );
show_letter( (((int) p[2])&0x7c)/4 );
show_letter( 8*(((int) p[2])&0x3) + (((int) p[3])&0xe0)/32 );
show_letter( ((int) p[3])&0x1f );
printf(" ");
for (j=0; j<3+res; j++) printf("%02x ",p[j]);
printf("\n");
}
}
static void dictionary_set_verb_number(char *dword, int to)
{ int i; zip *p;
int res=((version_number==3)?4:6);
i=dictionary_find(dword,1);
if (i!=0)
{ p=dictionary+7+(i-1)*(3+res)+res; p[1]=to;
}
}
extern int dictionary_add(char *dword, int x, int y, int z)
{ int off, i, k, l; zip *p; dict_word pcomp, qcomp;
int res=((version_number==3)?4:6);
if (dict_entries==MAX_DICT_ENTRIES)
{ memoryerror("MAX_DICT_ENTRIES",MAX_DICT_ENTRIES); }
i=dictionary_find(dword,1);
if (i!=0)
{ p=dictionary+7+(i-1)*(3+res)+res;
p[0]=(p[0])|x; p[1]=(p[1])|y; p[2]=(p[2])|z;
return(dictionary_offset+7+(3+res)*(i-1));
}
if (pass_number==1) i=dict_entries;
else { i=dict_places_inverse[dict_entries]; }
off=(3+res)*i+7;
p=dictionary+off;
p[0]=prepared_sort.b[0]; p[1]=prepared_sort.b[1];
p[2]=prepared_sort.b[2]; p[3]=prepared_sort.b[3];
InV5 { p[4]=prepared_sort.b[4]; p[5]=prepared_sort.b[5]; }
p[res]=x; p[res+1]=y; p[res+2]=z;
if (pass_number==1)
{ pcomp=prepared_sort;
if (dict_entries==0)
{ dict_places_list[0]= -2; dict_places_list[1]= -1;
goto PlaceFound;
}
l=initial_letter; do { k=letter_starts[l--]; } while ((l>=0)&&(k==-1));
if (k==-1) k=start_list;
for (; k!=-2; k=dict_places_list[k])
{ qcomp=dict_sorts[k];
if (compare_sorts(pcomp,qcomp)<0)
{ l=dict_places_back[k];
if (l==-1)
{ dict_places_list[dict_entries]=start_list;
dict_places_back[dict_entries]= -1;
dict_places_back[k]=dict_entries;
start_list=dict_entries; goto PlaceFound;
}
dict_places_list[l]=dict_entries;
dict_places_back[k]=dict_entries;
dict_places_list[dict_entries]=k;
dict_places_back[dict_entries]=l;
goto PlaceFound;
}
l=k;
}
dict_places_list[l]=dict_entries;
dict_places_back[dict_entries]=l;
dict_places_list[dict_entries]= -2;
PlaceFound: dict_sorts[dict_entries]=pcomp;
if (compare_sorts(pcomp,letter_keys[initial_letter])<0)
{ letter_keys[initial_letter]=pcomp;
letter_starts[initial_letter]=dict_entries;
}
}
dict_entries++; dict_p+=res+3;
/* show_dictionary(); */
return(dictionary_offset+off);
}
extern void list_object_tree(void)
{ int i;
printf("obj par nxt chl Object tree:\n");
for (i=0; i<no_objects; i++)
printf("%3d %3d %3d %3d\n",
i+1,objects[i].parent,objects[i].next, objects[i].child);
}
extern void list_verb_table(void)
{ int i, j, k;
for (i=0; i<no_verbs; i++)
{ printf("Verb entry %2d [%d]\n",i,vs[i].lines);
for (j=0; j<vs[i].lines; j++)
{ for (k=0; k<8; k++) printf("%03d ",vs[i].l[j].e[k]);
printf("\n");
}
}
}
/* ------------------------------------------------------------------------- */
/* Keep track of actions */
/* ------------------------------------------------------------------------- */
static int make_action(int32 addr)
{ int i;
if (no_actions>=MAX_ACTIONS)
memoryerror("MAX_ACTIONS",MAX_ACTIONS);
for (i=0; i<no_actions; i++) if (actions[i]==addr) return(i);
actions[no_actions]=addr; preactions[no_actions]= -1;
return(no_actions++);
}
extern int find_action(int32 addr)
{ int i;
for (i=0; i<fp_no_actions; i++) if (actions[i]==addr) return(i);
if (pass_number==2)
error("Action given in constant does not exist");
return(0);
}
extern void new_action(char *b, int c)
{ if ((printprops_mode==0)||(pass_number==2)) return;
printf("Action '%s' is numbered %d\n",b,c);
}
/* ------------------------------------------------------------------------- */
/* Parsing the grammar table, and making new adjectives and verbs */
/* (see the documentation for what the verb table it makes looks like) */
/* ------------------------------------------------------------------------- */
static int make_adjective(char *c)
{ int i; dict_word acomp;
acomp=dictionary_prepare(c);
for (i=0; i<no_adjectives; i++)
{ if (compare_sorts(acomp,adjcomps[i])==0) return(0xff-i);
}
adjectives[no_adjectives]=dictionary_add(c,8,0,0xff-no_adjectives);
adjcomps[no_adjectives]=acomp;
return(0xff-no_adjectives++);
}
static int find_verb(char *verb)
{ char *p;
p=verblist;
while (p<verblist_p)
{ if (strcmp(verb, p+2)==0) return(p[1]);
p=p+p[0];
}
return(-1);
}
static int verbspace_consumed = 0;
static void register_verb(char *verb, int number)
{ if (find_verb(verb)>=0)
{ error_named("Two different verb definitions refer to", verb);
return;
}
verbspace_consumed += strlen(verb)+3;
if (verbspace_consumed >= MAX_VERBSPACE)
memoryerror("MAX_VERBSPACE",MAX_VERBSPACE);
strcpy(verblist_p+2,verb);
verblist_p[1]=number;
verblist_p[0]=3+strlen(verb);
verblist_p += verblist_p[0];
}
static int32 parsing_routines[64];
static int no_prs;
static int debug_acts_writ[256];
static int action_exists[256];
static int grammar_line(int verbnum, int line, int i, char *b)
{ int j, l, flag=0; int32 k;
int vargs, vtokens, vinsert;
if (line>=MAX_LINES_PER_VERB)
{ error("Too many lines of grammar for verb: increase \
#define MAX_LINES_PER_VERB"); return(0); }
word(b,i++); flag=2;
if (b[0]==0) return(0);
if (strcmp(b,"*")!=0)
{ error_named("'*' divider expected, but found",b); return(0); }
vtokens=1; vargs=0; for (j=0; j<8; j++) vs[verbnum].l[line].e[j]=0;
do
{ word(b,i++);
if (b[0]==0) { error("'->' clause missing"); return(0); }
if (strcmp(b,"->")==0) break;
if (b[0]=='\"')
{ textword(b,i-1); vinsert=make_adjective(b);
}
else On_("noun") { vargs++; vinsert=0; }
else On_("held") { vargs++; vinsert=1; }
else On_("multi") { vargs++; vinsert=2; }
else On_("multiheld") { vargs++; vinsert=3; }
else On_("multiexcept") { vargs++; vinsert=4; }
else On_("multiinside") { vargs++; vinsert=5; }
else On_("creature") { vargs++; vinsert=6; }
else On_("special") { vargs++; vinsert=7; }
else On_("number") { vargs++; vinsert=8; }
else On_("scope")
{ word(b,i++);
if (strcmp(b,"=")!=0)
{ error_named("Expected '=' after 'scope' but found",b);
return(0);
}
word(b,i++);
j=find_symbol(b);
if ((j<0) || (stypes[j]!=1))
{ error_named(
"Expected routine after 'scope=' but found",b);
return(0);
}
for (l=0; (l<no_prs)
&& parsing_routines[l]!=svals[j]; l++) ;
parsing_routines[l]=svals[j]; if (l==no_prs) no_prs++;
vargs++; vinsert=l+80;
}
else On_("=")
{ if ((vtokens==0)||(vs[verbnum].l[line].e[vtokens-1]!=0))
{ error("'=' is only legal here as 'noun=Routine'");
return(0);
}
word(b,i++);
j=find_symbol(b);
if ((j<0) || (stypes[j]!=1))
{ error_named(
"Expected routine after 'noun=' but found", b);
return(0);
}
vtokens--;
for (l=0; (l<no_prs)
&& parsing_routines[l]!=svals[j]; l++) ;
parsing_routines[l]=svals[j]; if (l==no_prs) no_prs++;
vinsert=l+16;
}
else
{ j=find_symbol(b);
if ((j<0) || ((stypes[j]!=7)&&(stypes[j]!=1)))
{ error_named("No such token as",b); return(0); }
if (stypes[j]==7)
{ vargs++; vinsert=svals[j]+128;
}
else
{ vargs++;
for (l=0; (l<no_prs)
&& parsing_routines[l]!=svals[j]; l++) ;
parsing_routines[l]=svals[j]; if (l==no_prs) no_prs++;
vinsert=l+48;
}
}
vs[verbnum].l[line].e[vtokens]=vinsert;
vtokens++;
} while (1==1);
word(b,i++);
j=strlen(b)-3;
if ((j<0)||(b[j]!='S')||(b[j+1]!='u')||(b[j+2]!='b'))
sprintf(b+j+3,"Sub");
j=find_symbol(b);
if ((j==-1)&&(pass_number==2))
{ error_named("No such action routine as",b);
return(0);
}
if (j==-1) k=0;
else
{ if (stypes[j]!=1) { error_named("Not an action:",b); return(0); }
k=svals[j];
}
vs[verbnum].l[line].e[0]=vargs;
vs[verbnum].l[line].e[7]=make_action(k);
j=find_action(k);
if (action_exists[j]==0)
{ action_exists[j]=1; new_action(b,j);
}
if ((debugging_file==1)&&(k!=0)
&&(debug_acts_writ[j]==0))
{ debug_pass=2;
b[strlen(b)-3]=0;
write_debug_byte(8); write_debug_byte(j);
write_debug_string(b);
debug_pass=1;
if (pass_number==2) debug_acts_writ[j]=1;
}
return(i);
}
static int get_verb(char *b, int wn)
{ int j;
textword(b,wn); j=find_verb(b);
if (j==-1)
error_named("There is no previous grammar for the verb", b);
return(j);
}
extern void make_verb(char *b)
{ int i, i2, x=-1, flag=0;
int lines=0;
i=2;
word(b,i);
On_("meta") { i++; flag=2; }
i2=i;
do word(b,i2++); while (b[0]=='\"');
if (b[0]=='=') x=get_verb(b,i2++);
else
{ x=no_verbs;
if (no_verbs==MAX_VERBS)
memoryerror("MAX_VERBS",MAX_VERBS);
}
do
{ word(b,i);
if (b[0]!='\"') break;
textword(b,i++);
dictionary_add(b,0x41+flag,0xff-x,0);
if (pass_number==1) register_verb(b,x);
} while (1==1);
if (x!=no_verbs)
{ word(b,i2);
if (b[0]!=0)
error_named("Expected end of command but found",b);
return;
}
do
{ i=grammar_line(no_verbs, lines++,i,b);
} while (i!=0);
vs[no_verbs].lines=--lines;
no_verbs++;
}
extern void extend_verb(char *b)
{ int i, j, k, l, lines, mode;
word(b,2);
if (strcmp(b,"only")==0)
{ i=3; l=-1;
if (no_verbs==MAX_VERBS)
memoryerror("MAX_VERBS",MAX_VERBS);
do
{ j=get_verb(b,i++);
if (j==-1) return;
if ((l!=-1) && (j!=l) && (pass_number==1))
{ warning_named("Verb disagrees with previous verbs", b);
}
l=j;
dictionary_set_verb_number(b,0xff-no_verbs);
word(b,i);
} while (b[0]=='\"');
vs[no_verbs]=vs[j];
j=no_verbs++;
}
else { j=get_verb(b,2); if (j==-1) return; i=3; }
word(b,i); mode=3;
if (strcmp(b,"*")!=0)
{ mode=0;
if (strcmp(b,"replace")==0) mode=1;
if (strcmp(b,"first")==0) mode=2;
if (strcmp(b,"last")==0) mode=3;
if (mode==0)
{ error_named(
"Expected 'replace', 'last' or 'first' but found",b);
mode=3;
}
i++;
}
l=vs[j].lines; if (mode<=2) lines=0; else lines=l;
do
{ if (mode==2)
for (k=l; k>0; k--)
vs[j].l[k+lines]=vs[j].l[k-1+lines];
i=grammar_line(j, lines++,i,b);
} while (i!=0);
if (mode==2)
{ vs[j].lines = l+lines-1;
for (k=0; k<l; k++)
vs[j].l[k+lines-1]=vs[j].l[k+lines];
}
else vs[j].lines=--lines;
}
/* ------------------------------------------------------------------------- */
/* Object manufacture. Note that property lists are not kept for each */
/* object, only written in game-file format and then forgotten; but the */
/* object tree structure so far, is kept */
/* ------------------------------------------------------------------------- */
static int class_flag;
static int no_c_here;
static int properties(int w)
{ int i, k, x, y, pnw, flag=0; int32 j;
do
{ pnw=w;
word(sub_buffer,w++);
if (sub_buffer[0]==0) return(w-1);
/* if (strcmp(sub_buffer,",")==0) return(w-1); */
if (strcmp(sub_buffer,"has")==0) return(w-1);
if (strcmp(sub_buffer,"class")==0) return(w-1);
i=find_symbol(sub_buffer);
if (i==-1)
{ error_named("No such property as",sub_buffer);
return(w);
}
if (stypes[i]!=12)
{ error_named("Not a property:",sub_buffer);
return(w);
}
i=svals[i];
x=full_object.l++;
full_object.pp[x].num=i;
y=0;
do
{ word(sub_buffer,w++);
if (strcmp(sub_buffer,",")==0) break;
if (strcmp(sub_buffer,"has")==0) { w--; break; }
if (strcmp(sub_buffer,"class")==0) { w--; break; }
if (sub_buffer[0]==0) break;
if (strcmp(sub_buffer,"[")==0)
{ flag=1;
sprintf(sub_buffer,"Mb__%d",embedded_routine);
}
if ((i==1)&&(sub_buffer[0]=='\"'))
{ textword(sub_buffer,w-1);
j=dictionary_add(sub_buffer,0x80,0,0);
}
else
{ if ((pass_number==2)&&(y!=0))
{ k=find_symbol(sub_buffer);
if ((k!=-1)&&(stypes[k]==12))
{ warning_named(
"Missing ','? Property data seems to contain the property name",
sub_buffer);
}
}
j=constant_value(sub_buffer);
if (j==0)
{ if (prop_defaults[i]>=256) j=0x1000;
}
}
if ((j>=256)||(prop_longflag[i]==1))
full_object.pp[x].p[y++]=j/256;
full_object.pp[x].p[y++]=j%256;
} while (flag==0);
if (y==0) { full_object.pp[x].p[y++]=0;
full_object.pp[x].p[y++]=0;
}
full_object.pp[x].l=y;
InV3
{ if (y>8)
{ word(sub_buffer, pnw);
if (pass_number==2)
warning_named("Standard-game limit of 8 bytes per property exceeded \
(use Advanced to get 64), so truncating property", sub_buffer);
full_object.pp[x].l=8;
}
}
} while (flag==0);
sprintf(buffer,"[ Mb__%d",embedded_routine++);
do
{ word(sub_buffer,w++);
sprintf(buffer+strlen(buffer)," %s",sub_buffer);
} while (sub_buffer[0]!=0);
stack_line(buffer);
return(-1);
}
static int attributes(int w)
{ int i, negate_flag;
do
{ word(sub_buffer,w++);
if (sub_buffer[0]==0) return(w-1);
if ((strcmp(sub_buffer,"with")==0)
|| (strcmp(sub_buffer,",")==0)
|| (strcmp(sub_buffer,"class")==0)) return(w-1);
if (sub_buffer[0]=='~')
{ negate_flag=1; i=find_symbol(sub_buffer+1); }
else
{ negate_flag=0; i=find_symbol(sub_buffer); }
if ((i==-1)||(stypes[i]!=7))
{ error_named("No such attribute as",sub_buffer); return(w); }
i=svals[i];
if (negate_flag==0)
full_object.atts[i/8] =
full_object.atts[i/8] | (1 << (7-i%8));
else
full_object.atts[i/8] =
full_object.atts[i/8] & ~(1 << (7-i%8));
} while (1==1);
return(0);
}
static int classes(int w)
{ int i; zip *p;
do
{ word(sub_buffer,w++);
if (sub_buffer[0]==0) return(w-1);
if ((strcmp(sub_buffer,",")==0)
|| (strcmp(sub_buffer,"with")==0)
|| (strcmp(sub_buffer,"has")==0)) return(w-1);
i=find_symbol(sub_buffer);
if ((i==-1)||(stypes[i]!=13))
{ error_named("No such class as",sub_buffer); return(w); }
classes_here[no_c_here++]=svals[i];
/* printf("Inheriting attrs from %d\n",svals[i]); */
p=(zip *)classes_at[svals[i]-1];
for (i=0; i<6; i++) full_object.atts[i] |= p[i];
/* for (i=0; i<6; i++) printf("Data %d %x\n",i,p[i]); */
} while (1==1);
return(0);
}
static int write_properties(zip *p, char *shortname)
{ int i, l, j, k, count, number; zip *tmp; zip *from;
int32 props=0;
if (class_flag==0)
{ for (i=0;i<6;i++)
objects[no_objects].atts[i]=full_object.atts[i];
tmp=translate_text(p+1,shortname);
props=subtract_pointers(tmp,p);
p[0]=(props-1)/2;
}
else
{ p=class_pointer+classes_size;
classes_at[no_classes]=(int32 *) p;
/* printf("Class data at %08x\n",p); */
for (i=0;i<6;i++) p[i]=full_object.atts[i];
p+=6;
}
for (l=0; l<no_c_here; l++)
{ j=0; from=6+(zip *)classes_at[classes_here[l]-1];
/* printf("Inheriting from %d at %08x\n",classes_here[l],from); */
/* for (j=0; j<32; j++) printf("%02x ",from[j]); printf("\n"); j=0; */
while (from[j]!=0)
{ InV3
{ number=from[j]%32; count=1+from[j++]/32;
}
InV5
{ number=from[j]%64; count=1+from[j++]/64;
if (count>2) count=from[j++]%64;
}
/* printf("Inheriting no %d count %d\n",number,count); */
for (k=0; k<full_object.l; k++)
{ if (full_object.pp[k].num == number)
{ if ((number==1) || (prop_additive[number]!=0))
{ /* printf("Appending %d\n",number); */
for (i=full_object.pp[k].l;
i<full_object.pp[k].l+count; i++)
full_object.pp[k].p[i]=from[j++];
full_object.pp[k].l += count;
}
else
{ j+=count;
/* printf("Ignoring %d\n",number); */
}
goto DunInheriting;
}
}
k=full_object.l++;
full_object.pp[k].num = number;
full_object.pp[k].l = count;
for (i=0; i<count; i++)
full_object.pp[k].p[i]=from[j++];
/* printf("Creating %d\n",number); */
DunInheriting: ;
}
}
for (l=((version_number==3)?31:63); l>0; l--)
{ for (j=0; j<full_object.l; j++)
{ if (full_object.pp[j].num == l)
{ count=full_object.pp[j].l; number=full_object.pp[j].num;
InV3
{ p[props++] = number + (count - 1)*32;
}
InV5
{ switch(count)
{ case 1:
p[props++] = number; break;
case 2:
p[props++] = number + 0x40; break;
default:
p[props++] = number + 0x80;
p[props++] = count + 0x80;
break;
}
}
for (k=0; k<full_object.pp[j].l; k++)
{ p[props++]=full_object.pp[j].p[k];
}
}
}
}
p[props]=0; props++;
if (class_flag==1)
{
classes_size+=props+6;
if (classes_size >= MAX_CLASS_TABLE_SIZE)
memoryerror("MAX_CLASS_TABLE_SIZE",MAX_CLASS_TABLE_SIZE);
}
else
{
properties_size+=props;
if (properties_size >= MAX_PROP_TABLE_SIZE)
memoryerror("MAX_PROP_TABLE_SIZE",MAX_PROP_TABLE_SIZE);
}
return(props);
}
static char shortname_buffer[256];
extern void finish_object(void)
{ int j;
if (class_flag == 0)
{ j=objects[no_objects].propsize;
objects[no_objects].propsize=
write_properties((zip *) (properties_table+properties_size),
shortname_buffer);
if (pass_number==2)
{ if (j != objects[no_objects].propsize)
{ error("Object has altered in memory usage between passes: \
perhaps an attempt to use a routine name as value of a small property");
}
}
no_objects++;
if (pass_number==1) max_no_objects++;
}
else { write_properties(NULL,NULL); no_classes++; }
if (debugging_file==1)
{ write_present_linenum();
}
}
extern void resume_object(char *b, int j)
{ int flag=0, commas=0;
if (j==1)
{ word(b,1); flag=1;
if ((strcmp(b,"has")==0)
|| (strcmp(b,",")==0)
|| (strcmp(b,"class")==0)
|| (strcmp(b,"with")==0)) flag=0;
}
do
{ RO_Comma:
if (flag==0)
{ word(b,j++);
if (b[0]==0)
{ if (commas>0)
error("Object/class definition finishes with ','");
break;
}
}
if (strcmp(b,",")==0) { commas++; goto RO_Comma; }
if (commas>1)
error("Two commas ',' in a row in object/class definition");
commas=0;
if ((flag==1)||(strcmp(b,"with")==0))
{ j=properties(j);
if (j==-1) { resobj_flag=1; return; }
}
else if (strcmp(b,"has")==0) j=attributes(j);
else if (strcmp(b,"class")==0) j=classes(j);
else error_named("Expected 'with', 'has' or \
'class' in object/class definition but found",b);
flag=0;
} while (1==1);
finish_object();
}
extern void make_class(char *b)
{ class_flag = 1; no_c_here=0;
if (no_classes==MAX_CLASSES)
memoryerror("MAX_CLASSES", MAX_CLASSES);
word(b,2); new_symbol(b,no_classes+1,13);
if (debugging_file==1)
{ write_debug_byte(2); write_debug_linenum();
write_debug_string(b);
}
full_object.l=0;
full_object.atts[0]=0;
full_object.atts[1]=0;
full_object.atts[2]=0;
full_object.atts[3]=0;
full_object.atts[4]=0;
full_object.atts[5]=0;
resume_object(b,3);
}
static int near_obj;
extern void make_object(char *b, int nearby_flag)
{ int i, j, k, non=0, later, subof;
if (no_objects==MAX_OBJECTS)
memoryerror("MAX_OBJECTS", MAX_OBJECTS);
class_flag = 0; no_c_here=0;
word(b,2);
if (b[0]=='\"')
{ textword(b,2);
error_named(
"Expected an (internal) name for object, but found the string", b);
sprintf(b,"failedobj");
}
new_symbol(b,no_objects+1,9);
if (debugging_file==1)
{ write_debug_byte(3);
write_debug_byte((no_objects+1)/256);
write_debug_byte((no_objects+1)%256);
write_debug_linenum(); write_debug_string(b);
}
do
{ word(b,3+non);
if (b[0]!='\"')
{ new_symbol(b,no_objects+1,9); non++;
obsolete_warning("an object should only have one internal name");
}
} while (b[0]!='\"');
later=non+5;
if (nearby_flag==0)
{ word(b,4+non);
subof=0;
if ((b[0]==0)
|| (strcmp(b,",")==0)
|| (strcmp(b,"with")==0)
|| (strcmp(b,"has")==0)
|| (strcmp(b,"class")==0)) later--;
else
{ i=find_symbol(b);
if (i<0)
{ error_named("An object must be defined \
after the one which contains it: (so far) there is no such object as",b);
return;
}
if (stypes[i]!=9)
{ error_named("Not an object:",b); return; }
subof=svals[i];
}
near_obj=no_objects+1;
}
else
{ subof=near_obj; later--;
}
full_object.atts[0]=0;
full_object.atts[1]=0;
full_object.atts[2]=0;
full_object.atts[3]=0;
full_object.atts[4]=0;
full_object.atts[5]=0;
objects[no_objects].parent=subof;
objects[no_objects].next=0;
objects[no_objects].child=0;
full_object.l=0;
if (subof>0)
{ j=subof-1; k=objects[j].child;
if (k==0)
{ objects[j].child=no_objects+1; }
else
{ while(objects[k-1].next!=0) { k=objects[k-1].next; }
objects[k-1].next=no_objects+1;
}
}
textword(b,3+non);
if ((listobjects_mode==1) && ((pass_number==2)||(bothpasses_mode==1)))
printf("%3d \"%s\"\n",no_objects+1,b);
strcpy(shortname_buffer,b);
resume_object(b, later);
}
/* ------------------------------------------------------------------------- */
/* Making and initialising variables and arrays */
/* ------------------------------------------------------------------------- */
#define NON_VALUE (int32)0x100000L
extern void check_globals(void)
{ int i;
for (i=0;i<no_globals;i++)
if (gvalues[i]==NON_VALUE)
{ error("An initialised global variable was defined only in Pass 1");
return;
}
}
static int multiplier;
static int32 table_posn;
static int array_base;
int doing_table_mode;
static void finish_array(int32 i)
{ doing_table_mode=0;
if ((pass_number==1)&&(array_base!=globals_size))
{ if (multiplier==2)
{ table_init[array_base] = i/256;
table_init[array_base+1] = i%256;
}
else
{ if (i>=256)
error("A 'string' array can have at most 256 entries");
table_init[array_base] = i;
}
}
globals_size+=i*multiplier;
}
static void array_entry(int32 i, int32 j, char *b)
{ if (globals_size+i*multiplier >= MAX_STATIC_DATA)
memoryerror("MAX_STATIC_DATA", MAX_STATIC_DATA);
if (multiplier==1)
{ table_init[globals_size+i]=j;
if ((pass_number==2)&&(j>=256))
warning_named("Array entry too large for a byte:",b);
}
else
{ table_init[globals_size+2*i]=j/256;
table_init[globals_size+2*i+1]=j%256;
}
}
extern void assemble_table(char *b, int from)
{ int32 j; int i;
for (i=from;1==1;i++)
{ word(b,i); if (b[0]==0) return;
if (strcmp(b,"]")==0)
{ finish_array(table_posn);
return;
}
if (strcmp(b,"[")==0)
{ stack_line("]");
error("Expected ']' but found '['"); return;
}
j=constant_value(b);
array_entry(table_posn++, j, b);
}
return;
}
extern void make_global(char *b, int array_flag)
{ int32 i, j; int array_type, data_type, one_word;
word(b,2);
if (array_flag==0)
{ if (no_globals==235)
{ error("All 235 global variables already declared");
return;
}
if (pass_number==1)
{ new_symbol(b,no_globals,2);
if (debugging_file==1)
{ write_debug_byte(4); write_debug_byte(no_globals);
write_debug_string(b);
}
}
else
{ i=find_symbol(b);
no_globals=svals[i];
}
gvalues[no_globals]=0; no_globals++;
}
else
{ IfPass2
{ j=find_symbol(b);
svals[j]=variables_offset+globals_size;
}
else new_symbol(b,0x800+globals_size,8);
}
word(b,3);
if (b[0]==0)
{ if (array_flag==1) error("Missing array definition");
return;
}
if ((pass_number==1) && (array_flag==0))
gvalues[no_globals-1]=NON_VALUE;
if ((strcmp(b,"=")==0) && (array_flag==0))
{ word(b,4); i=constant_value(b);
if (pass_number==2) gvalues[no_globals-1]=i;
return;
}
if ((pass_number==2) && (array_flag==0))
gvalues[no_globals-1]=globals_size+variables_offset;
array_type=0; data_type=-1;
if ((array_flag==0)&&(strcmp(b,"data")==0)) { data_type=0; }
else if ((array_flag==0)&&(strcmp(b,"initial")==0)) { data_type=1; }
else if ((array_flag==0)&&(strcmp(b,"initstr")==0)) { data_type=2; }
else if (strcmp(b,"->")==0) array_type=0;
else if (strcmp(b,"-->")==0) array_type=1;
else if (strcmp(b,"string")==0) array_type=2;
else if (strcmp(b,"table")==0) array_type=3;
else { if (array_flag==0)
error_named("Expected '=', '->', '-->', 'string' or 'table' but found",b);
else
error_named("Expected '->', '-->', 'string' or 'table' but found",b);
return;
}
multiplier=1; if ((array_type==1) || (array_type==3)) multiplier=2;
word(b,5);
one_word=0; if (b[0]==0) one_word=1;
word(b,4);
if (b[0]==0) { error("Missing array definition"); return; }
switch(data_type)
{ case -1:
if (b[0]=='[') data_type=3;
else
{ if (one_word==1)
{ if (b[0]=='\"') data_type=2; else data_type=0;
}
else data_type=1;
}
break;
case 0: obsolete_warning("use '->' instead of 'data'"); break;
case 1: obsolete_warning("use '->' instead of 'initial'"); break;
case 2: obsolete_warning("use '->' instead of 'initstr'"); break;
}
array_base=globals_size;
if ((array_type==2) || (array_type==3)) globals_size+=multiplier;
switch(data_type)
{ case 0:
word(b,4); j=constant_value(b);
for (i=0; i<j; i++) array_entry(i, 0, b);
break;
case 1:
i=0;
do
{ word(b,4+i); if (b[0]==0) break;
if ((strcmp(b,"]")==0) || (strcmp(b,"[")==0))
{ error_named("Misplaced ",b); return; }
j=constant_value(b);
array_entry(i, j, b);
i++;
} while (1==1);
break;
case 2:
textword(b,4);
for (i=0; b[i]!=0; i++) array_entry(i, b[i], b);
break;
case 3:
doing_table_mode=1; table_posn=0;
if (one_word==0) assemble_table(b,5);
return;
}
finish_array(i);
}
/* ------------------------------------------------------------------------- */
/* Construct story file up as far as code area */
/* (see documentation for description of what goes on here) */
/* ------------------------------------------------------------------------- */
static void percentage(char *name, int32 x, int32 total)
{ printf(" %-20s %2d.%d%%\n",name,x*100/total,(x*1000/total)%10);
}
static int alloc_done_flag=0;
static char *version_name(int v)
{ switch(v)
{ case 3: return "Standard";
case 4: return "Plus";
case 5: return "Advanced";
case 6: return "graphical";
}
return "extended format";
}
extern void construct_storyfile(void)
{ char *p; unsigned char *u; int32 i, j, k; int32 excess;
int32 syns, objs, props, vars, parse, code, strs, dict, nparse,
actshere, preactshere;
int32 synsat, glpat, objat, propat, parsat;
int32 code_length, strings_length, alloc_size;
int32 limit;
int extend_offset;
if (alloc_done_flag==0)
{ alloc_done_flag=1;
alloc_size=0x4000 + subtract_pointers(dict_p,dictionary);
for (i=0; i<no_objects; i++) alloc_size+=objects[i].propsize;
output_p=my_malloc(alloc_size, "output buffer");
}
p=(char *)output_p; u=(unsigned char *) p;
for (i=0; i<=0x3f; i++) p[i]=0;
p[0]=actual_version; p[1]=statusline_flag*2;
p[2]=(release_number/256); p[3]=(release_number%256);
p[16]=0; p[17]=0;
write_serialnumber(buffer);
for (i=0; i<6; i++) p[18+i]=buffer[i];
syns=0x40;
u[syns]=0x80; p[syns+1]=0; syns+=2;
for (i=0; i+low_strings<low_strings_p; syns++, i++)
p[0x42+i]=low_strings[i];
p[24]=syns/256; p[25]=syns%256; synsat=syns;
for (i=0; i<3*32; i++)
{ p[syns++]=0; p[syns++]=0x20;
}
for (i=0; i<no_abbrevs; i++)
{ j=abbrev_values[i];
p[synsat+64+2*i]=j/256;
p[synsat+65+2*i]=j%256;
}
objs=syns;
p[10]=objs/256; p[11]=objs%256; glpat=objs;
p[objs]=0; p[objs+1]=0;
for (i=2; i< ((version_number==3)?32:64); i++)
{ p[objs+2*i-2]=prop_defaults[i]/256;
p[objs+2*i-1]=prop_defaults[i]%256;
}
objs+=2*i-2;
props=objs+((version_number==3)?9:14)*no_objects;
objat=objs; propat=props;
for (i=0; i<properties_size; i++)
p[props+i]=properties_table[i];
for (i=0; i<no_objects; i++)
{
InV3
{ p[objs]=objects[i].atts[0];
p[objs+1]=objects[i].atts[1];
p[objs+2]=objects[i].atts[2];
p[objs+3]=objects[i].atts[3];
p[objs+4]=objects[i].parent;
p[objs+5]=objects[i].next;
p[objs+6]=objects[i].child;
p[objs+7]=props/256;
p[objs+8]=props%256;
objs+=9;
}
InV5
{ p[objs]=objects[i].atts[0];
p[objs+1]=objects[i].atts[1];
p[objs+2]=objects[i].atts[2];
p[objs+3]=objects[i].atts[3];
p[objs+4]=objects[i].atts[4];
p[objs+5]=objects[i].atts[5];
p[objs+6]=(objects[i].parent)/256;
p[objs+7]=(objects[i].parent)%256;
p[objs+8]=(objects[i].next)/256;
p[objs+9]=(objects[i].next)%256;
p[objs+10]=(objects[i].child)/256;
p[objs+11]=(objects[i].child)%256;
p[objs+12]=props/256;
p[objs+13]=props%256;
objs+=14;
}
props+=objects[i].propsize;
}
vars=props;
p[12]=(vars/256); p[13]=(vars%256);
for (i=vars; i<vars+globals_size; i++) p[i]=table_init[i-vars];
for (i=0; i<240; i++)
{ j=gvalues[i];
p[vars+i*2] = j/256;
p[vars+i*2+1] = j%256;
}
parse=vars+globals_size;
p[14]=(parse/256); p[15]=(parse%256); parsat=parse;
nparse=parse+no_verbs*2;
for (i=0; i<no_verbs; i++)
{ p[parse]=(nparse/256); p[parse+1]=(nparse%256);
parse+=2;
p[nparse]=vs[i].lines; nparse++;
for (j=0; j<vs[i].lines; j++)
{ for (k=0; k<8; k++) p[nparse+k]=vs[i].l[j].e[k];
nparse+=8;
}
}
actshere=nparse; nparse+=2*no_actions;
preactshere=nparse; nparse+=2*no_actions;
p[nparse]=0; p[nparse+1]=no_adjectives; nparse+=2;
dict=nparse+4*no_adjectives;
adjectives_offset=nparse;
for (i=0; i<no_adjectives; i++)
{ j=adjectives[no_adjectives-i-1];
p[nparse]=j/256; p[nparse+1]=j%256; p[nparse+2]=0;
p[nparse+3]=(256-no_adjectives+i); nparse+=4;
}
dictionary[0]=3; dictionary[1]='.'; dictionary[2]=','; dictionary[3]='"';
dictionary[4]=(version_number==3)?7:9;
dictionary[5]=(dict_entries/256); dictionary[6]=(dict_entries%256);
p[8]=(dict/256); p[9]=(dict%256);
for (i=0; i+dictionary<dict_p; i++) p[dict+i]=dictionary[i];
code=dict+i;
while ((code%scale_factor) != 0) p[code++]=0;
p[4]=(code/256); p[5]=(code%256);
p[6]=((code+1)/256); p[7]=((code+1)%256);
Write_Code_At = code;
code_length=subtract_pointers(zcode_p,zcode);
strs=code+code_length;
while ((strs%scale_factor) != 0) strs++;
Write_Strings_At = strs;
strings_length=subtract_pointers(strings_p,strings);
Out_Size=strs+strings_length;
if (actual_version==3)
{ excess=Out_Size-((int32) 0x20000L); limit=128; }
if ((actual_version==4)||(actual_version==5))
{ excess=Out_Size-((int32) 0x40000L); limit=256; }
if ((actual_version==6)||(actual_version==8))
{ excess=Out_Size-((int32) 0x80000L); limit=512; }
if (actual_version==7) { excess=0; limit=320; }
if (excess>0)
{ sprintf(buffer,
"Story file exceeds version-%d limit (%dK) by %d bytes",
version_number, limit, excess);
fatalerror(buffer);
}
extend_offset=256;
if (no_objects+5 > extend_offset) extend_offset=no_objects+5;
if (extend_memory_map==1) code_offset = extend_offset*scale_factor;
else code_offset = code;
if (extend_memory_map==1)
strings_offset = code_offset + (strs-code);
else strings_offset = strs;
dictionary_offset = dict;
variables_offset = vars;
actions_offset = actshere;
preactions_offset = preactshere;
j=Out_Size/scale_factor;
p[26]=j/256; p[27]=j%256; p[28]=0; p[29]=0;
for (i=0; i<no_actions; i++)
{ j=(actions[i]+code_offset)/scale_factor;
p[actshere+i*2]=j/256; p[actshere+i*2+1]=j%256;
if (i<no_prs) j=(parsing_routines[i]+code_offset)/scale_factor;
else if (preactions[i]==-1) j=0;
else j=(preactions[i]+code_offset)/scale_factor;
p[preactshere+i*2]=j/256; p[preactshere+i*2+1]=j%256;
}
if (extend_memory_map==1)
{ j=Write_Code_At/scale_factor - extend_offset;
p[40]=j/256; p[41]=j%256;
j=Write_Code_At/scale_factor - extend_offset;
p[42]=j/256; p[43]=j%256;
}
/* From here on, it's all reportage: construction is finished */
if (statistics_mode==1)
{ int32 k_long, rate; char *k_str="";
k_long=(Out_Size/1024);
if ((Out_Size-1024*k_long) >= 512) { k_long++; k_str=""; }
else if ((Out_Size-1024*k_long) > 0) { k_str=".5"; }
rate=total_bytes_trans*1000/total_chars_trans;
if ((pass_number==2)||(bothpasses_mode==1))
{ printf("Input %d lines (%d statements, %d chars)",
total_source_line,internal_line,marker_in_file);
if (total_files_read > 1) { printf(" from %d files",
total_files_read); }
printf(
"\nVersion %d (%s) story file\n\
%4d objects (maximum %3d) %4d dictionary entries (maximum %d)\n\
%4d attributes (maximum %2d) %4d properties (maximum %2d)\n\
%4d adjectives (maximum 240) %4d verbs (maximum %d)\n\
%4d actions (maximum %3d) %4d abbreviations (maximum %d)\n",
actual_version, version_name(actual_version),
no_objects, ((version_number==3)?255:(MAX_OBJECTS-1)),
dict_entries, MAX_DICT_ENTRIES,
no_attributes, ((version_number==3)?32:48),
no_properties-2, ((version_number==3)?30:62),
no_adjectives,
no_verbs, MAX_VERBS,
no_actions, MAX_ACTIONS,
no_abbrevs, MAX_ABBREVS);
printf(
"%4d globals (maximum 240) %4d variable space (maximum %d)\n\
%4d symbols (maximum %4d) %4d routines (maximum %d)\n\
%4d classes (maximum %2d) %4d fake actions (unlimited)\n\
%4ld characters of text (compressed to %ld bytes, rate 0.%3ld)\n\
Output story file is %3ld%sK long (maximum %ldK)\n",
no_globals,
globals_size, MAX_STATIC_DATA,
no_symbols, MAX_SYMBOLS,
no_routines, MAX_ROUTINES,
no_classes, MAX_CLASSES,
no_fake_actions,
(long int) total_chars_trans,
(long int) total_bytes_trans,
(long int) rate,
(long int) k_long, k_str, (long int) limit);
}
}
if ((debugging_file==1)&&(pass_number==2))
{ debug_pass=2;
write_debug_byte(13);
write_debug_address(vars+480);
write_debug_address(parsat);
write_debug_address(dict);
write_debug_address(code);
write_debug_address(strs);
debug_pass=1;
}
if (offsets_mode==1)
{ if ((pass_number==2)||(bothpasses_mode==1))
{ printf(
"\nOffsets in story file:\n\
%05lx Synonyms %05lx Defaults %05lx Objects %05lx Properties\n\
%05lx Variables %05lx Parse table %05lx Actions %05lx Preactions\n\
%05lx Adjectives %05lx Dictionary %05lx Code %05lx Strings\n\n",
(long int) synsat, (long int) glpat, (long int) objat, (long int) propat,
(long int) vars, (long int) parsat, (long int) actshere,
(long int) preactshere, (long int) adjectives_offset, (long int) dict,
(long int) code, (long int) strs);
}
}
if (memory_map_mode==1)
{ if ((pass_number==2)||(bothpasses_mode==1))
{
printf("Dynamic +---------------------+ 00000\n");
printf("memory | header |\n");
printf(" +---------------------+ 00040\n");
printf(" | synonym strings |\n");
printf(" + - - - - - - - - - - + %05lx\n", (long int) synsat);
printf(" | synonym table |\n");
printf(" +---------------------+ %05lx\n", (long int) glpat);
printf(" | property defaults |\n");
printf(" + - - - - - - - - - - + %05lx\n", (long int) objat);
printf(" | objects |\n");
printf(" + - - - - - - - - - - + %05lx\n", (long int) propat);
printf(" | object short names |\n");
printf(" | and properties |\n");
printf(" +---------------------+ %05lx\n", (long int) vars);
printf(" | global variables |\n");
printf(" + - - - - - - - - - - + %05lx\n", ((long int) vars)+480L);
printf(" | arrays |\n");
printf(" +=====================+ %05lx\n", (long int) parsat);
printf("Static | grammar table |\n");
printf("cached + - - - - - - - - - - + %05lx\n", (long int) actshere);
printf("data | actions |\n");
printf(" + - - - - - - - - - - + %05lx\n", (long int) preactshere);
printf(" | preactions |\n");
printf(" + - - - - - - - - - - + %05lx\n",
(long int) adjectives_offset);
printf(" | adjectives |\n");
printf(" +---------------------+ %05lx\n", (long int) dict);
printf(" | dictionary |\n");
printf(" +---------------------+ %05lx\n", (long int) code);
printf("Static | Z-code |\n");
printf("paged +---------------------+ %05lx\n", (long int) strs);
printf("data | strings |\n");
printf(" +---------------------+ %05lx\n", (long int) Out_Size);
}
}
if (percentages_mode==1)
{ if ((pass_number==2)||(bothpasses_mode==1))
{ printf("Approximate percentage breakdown of story file:\n");
percentage("Z-code",code_length,Out_Size);
percentage("Static strings",strings_length,Out_Size);
percentage("Dictionary",code-dict,Out_Size);
percentage("Objects",vars-glpat,Out_Size);
percentage("Globals",parsat-vars,Out_Size);
percentage("Parsing tables",dict-parsat,Out_Size);
percentage("Header and synonyms",glpat,Out_Size);
percentage("Total of save area",parsat,Out_Size);
percentage("Total of text",total_bytes_trans,Out_Size);
}
}
if (frequencies_mode==1)
{ if ((pass_number==2)||(bothpasses_mode==1))
{ printf("How frequently abbreviations were used, and roughly\n");
printf("how many bytes they saved: ('_' denotes spaces)\n");
for (i=0; i<no_abbrevs; i++)
{ sprintf(sub_buffer,
(char *)abbreviations_at+i*MAX_ABBREV_LENGTH);
for (j=0; sub_buffer[j]!=0; j++)
if (sub_buffer[j]==' ') sub_buffer[j]='_';
printf("%10s %5d/%5d ",sub_buffer,abbrev_freqs[i],
2*((abbrev_freqs[i]-1)*abbrev_quality[i])/3);
if ((i%3)==2) printf("\n");
}
if ((i%3)!=0) printf("\n");
if (no_abbrevs==0) printf("None were declared.\n");
}
}
if (((statistics_mode==1)||(economy_mode==1))&&(pass_number==2))
{ printf("Essential size %ld bytes: %ld remaining\n",
(long int) Out_Size,
(long int) (((long int) (limit*1024L)) - ((long int) Out_Size)));
}
}
/* ------------------------------------------------------------------------- */
/* Begin pass */
/* ------------------------------------------------------------------------- */
extern void tables_begin_pass(void)
{ int i;
for (i=0; i<256; i++) debug_acts_writ[i]=0;
dictionary_begin_pass();
properties_size=0; classes_size=0;
no_objects=0; no_classes=0; embedded_routine=0;
no_verbs=0; fp_no_actions=no_actions; no_actions=0; no_adjectives=0;
no_properties=2; no_attributes=0; no_fake_actions=0;
no_globals=0; globals_size=0x1e0;
no_prs=0;
objects[0].parent=0; objects[0].child=0; objects[0].next=0;
doing_table_mode = 0;
}
extern void init_tables_vars(void)
{
no_fake_actions = 0;
release_number = 1;
statusline_flag = 0;
max_no_objects = 0;
resobj_flag = 0;
no_verbs = 0;
no_actions = 0;
no_adjectives = 0;
no_objects = 0;
no_classes = 0;
classes_size = 0;
fp_no_actions = 0;
embedded_routine = 0;
verbspace_consumed = 0;
alloc_done_flag = 0;
#ifdef ALLOCATE_BIG_ARRAYS
vs = NULL;
objects = NULL;
table_init = NULL;
actions = NULL;
preactions = NULL;
adjectives = NULL;
adjcomps = NULL;
gvalues = NULL;
dict_places_list = NULL;
dict_places_back = NULL;
dict_places_inverse = NULL;
dict_sorts = NULL;
class_pointer = NULL;
classes_here = NULL;
classes_at = NULL;
#endif
verblist = NULL;
output_p = NULL;
}
