/* agtdata.c-- Miscellaneous utilities and data structures */ /* Copyright 1996,97 Robert Masenten */ /* */ /* This is part of the source for both AGiliTy: the (Mostly) Universal */ /* AGT Interpreter and for the Magx adventure game compiler. */ /* This is a mishmash of utilities and preinitialized arrays, including the verblist, the metacommand token list, and the dictionary routines. */ #include #include "agtread.h" #include #ifdef PROFILE_SUPPORT #include #endif /* ------------------------------------------------------------------- */ /* Preinitialized data structures */ /* Most of the preinitialized data structures used by all of the */ /* AGT-related programs go here . */ /* ------------------------------------------------------------------- */ /* ------------------------------------------------------------ */ /* The PC --> Ascii conversion table. This converts the 8th-bit */ /* PC charcters to their nearest ASCII equivalent. */ /* ------------------------------------------------------------ */ const char trans_ibm[]= "CueaaaaceeeiiiAA" /* 80 */ "E@@ooouuyOUc$$pf" /* 90 */ "aiounNao?....!<>" /* A0 */ "###|++|+++|\\/++\\" /* B0 */ "\\+++-+||\\/+++=+=" /* C0 */ "+=+++++++//@@@@@" /* D0 */ "abGpSsmtFTOd.fe^" /* E0 */ "=+> n-55 105,122 Dummy_verb1...Dummy_Verb50 */ /* Possible extension to verb definitons (not implemented): If it _requires_ a prep, use : ? If it takes a prep and no dobj, use | ? */ /* ------------------------------------------------------------------- */ /* Dictionary primitives: the basic functions for manipulating the */ /* dictionary data structures. */ /* ------------------------------------------------------------------- */ #define HASHSIZE (1<>HASHBITS))&HASHMASK; } return (n & HASHMASK); } static word search0_dict(const char *s) { int i; #ifdef DOHASH for(i=hashfunc(s); hash[i]!=-1 && strcmp(s,dict[hash[i]])!=0; i=(i+1)&HASHMASK); return hash[i]; #else for(i=0; strcmp(s,dict[i])!=0 && idictstrsize) { /* Enlarge dictstr */ while(newptr>dictstrsize) dictstrsize+=DICT_GRAN; newstr=rrealloc(dictstr,dictstrsize); for(i=0;iHASHSIZE) fatal("Hash table overflow"); for(i=hashfunc(s);hash[i]!=-1;i=(i+1)&HASHMASK); hash[i]=dp; #endif return dp++; } #ifdef DOHASH static void init_hash(void) { int i; for(i=0;iHASHSIZE) fatal("Hash table overflow"); init_hash(); for(i=0;i0) { /* word just ended: need to add it to dictionary etc */ curr[n]=0;n=0; addsyn(add0_dict(curr)); /* Add to syn list or prep list, depending */ } if (!isspace(*p)) addsyn(-1); /* Mark the end of the list */ if (*p==';' || *p=='.' || *p=='!') { if (*p==';') verbflag[vp]|=VERB_TAKEOBJ; if (*p=='!') verbflag[vp]|=VERB_META; vp++; if (vp>=TOTAL_VERB) break; auxsyn[vp]=synptr; /* The following words will be the syn list */ } else if (*p==',') preplist[vp]=synptr; /* The following words will be the prep list */ } else curr[n++]=*p; } static bool no_syn; void init_dict(void) { dict=NULL;verblist=NULL;syntbl=NULL;no_syn=0; auxsyn=NULL;preplist=NULL;verbflag=NULL; } /* This is called by agttest.c */ void build_verblist(void) { int i; verblist=rmalloc(sizeof(words)*TOTAL_VERB); for(i=0;i "); for(j=preplist[i];syntbl[j]!=0;j++) rprintf(" %s",dict[ syntbl[preplist[i]]] ); writeln(""); } } #endif } void set_verbflag(void) { verbflag[14]|=VERB_MULTI; /* throw */ verbflag[29]|=VERB_MULTI; /* put */ verbflag[33]|=VERB_MULTI; /* get */ verbflag[41]|=VERB_MULTI; /* drop */ verbflag[51]|=VERB_MULTI; /* wear */ verbflag[52]|=VERB_MULTI; /* remove */ } void reinit_dict(void) /* reinit_dict initializes verblist and sets up aux_syn as well as loading the initial vocabulary into the dictionary. */ { char buff[16]; /* Needs to be big enough to hold dummy_verbNNN\0 or subroutineNNN\0 */ int i; no_syn=no_auxsyn; auxsyn=rmalloc(sizeof(slist)*TOTAL_VERB); preplist=rmalloc(sizeof(slist)*TOTAL_VERB); verbflag=rmalloc(sizeof(uchar)*TOTAL_VERB); if (!agx_file) init0_dict(); #ifdef DOHASH else rebuild_hash(); #endif for(i=0;i0; j--); s[j+1]=0; /* Okay, now make sure it isn't 'none' */ if (strcmp(s,"none")==0) return 0; /* Finally, add it to the dictionary if it isn't already there */ return add0_dict(s); } /* Adds w to dynamically grown synonym list */ /* If no_syn is set, then *don't* add a synonym: return immediatly */ /* (This is done by agt2agx to avoid creating the auxsyn lists, */ /* since those should be created when the interpreter loads the */ /* game file and not before) */ void addsyn(word w) { if (no_syn) return; if (w==0) return; if (w==-1) w=0; if (synptr>=syntbl_size) { syntbl_size+=SYN_GRAIN; if (syntbl_size>0x7FFF) fatal("Too many synonyms."); syntbl=rrealloc(syntbl,((long)syntbl_size)*sizeof(word)); } syntbl[synptr++]=w; } /* ------------------------------------------------------------------- */ /* General utilities linking objects to their names */ /* ------------------------------------------------------------------- */ int verb_code(word w) /* Given a word w, searches auxsyn and returns the verb id */ { int i,j; /* Check game-specific synonyms first */ /* Scan in reverse so later synonyms will override earlier ones */ for(i=TOTAL_VERB-1;i>0;i--) for(j=synlist[i];syntbl[j]!=0;j++) if (w==syntbl[j]) return i; /* Then check built in verbs */ /* (Do this second so as to allow the game files to override this) */ for(i=1;i=first_room && i<=maxroom) return rstrdup(room[i-first_room].name); if (i>=first_noun && i<=maxnoun) { if (strcmp(dict[noun[i-first_noun].adj],"no_adjective")==0) return rstrdup(dict[noun[i-first_noun].name]); return concdup(dict[noun[i-first_noun].adj], dict[noun[i-first_noun].name]); } if (i>=first_creat && i<=maxcreat) return concdup(dict[creature[i-first_creat].adj], dict[creature[i-first_creat].name]); /* At this point we can't get a name: return ILLn. */ s=rmalloc(3+1+(5*sizeof(int))/2+1); /* Make sure we have enough space in case i is big */ sprintf(s,"ILL%d",i); return s; } /* ------------------------------------------------------------------- */ /* Routines to sort the command array and construct verbptr */ /* ------------------------------------------------------------------- */ #define SORT_META #ifdef SORT_META #define ch1 ((const cmd_rec*)cmd1) #define ch2 ((const cmd_rec*)cmd2) /* See notes below before trying to decipher this routine; during the sort, many of the fields are being used for nonstandard purposes */ #define s_verb(cmd) ( (cmd)->actor<0 ? (cmd)->data[0] : (cmd)->verbcmd) static int cmp_cmd(const void *cmd1, const void *cmd2) { word v1,v2; /* We are sorting on command[].verbcmd, but if one of the headers is really the object of a redirect command then we need to use its parent's verbcmd */ /* For commands with actors, we need to avoid sorting them at all. */ v1=s_verb(ch1); v2=s_verb(ch2); if (v1v2) return +1; /* v1==v2, so leave them in the same order as before */ /* We have to take absolute values here because we are using negatives to indicate redirection objects */ if ( abs(ch1->actor) < abs(ch2->actor) ) return -1; else return 1; /* Equality should be impossible */ } #undef ch1 #undef ch2 /* This sets things up for qsort */ /* We need a sort that is i) Stable and ii) Keeps "redirection headers" attached to the correct command */ /* We steal the field actor for this purpose */ /* actor will equal the index of the header in the original list. */ /* (or negative the header if the command is a redirection) */ /* For redirected commands, we steal the data pointer since it shouldn't be being used anyhow. */ /* In a field pointed to by data we store the verb word */ /* NOTE: this routine requires that the data type of *data (namely integer) is big enough to hold a value of type word. */ static void rsort(void) { long i; integer *save_actor; word *save_verb; save_actor=rmalloc(last_cmd*sizeof(integer)); save_verb=rmalloc(last_cmd*sizeof(word)); /* The following loop does three things: i) Copies command[].actor to save_actor[] ii) Sets command[].actor to the commands index in the array iii) For actor commands, sets the verb to .... after saving it in save_verb. iv) For redirection commands, stores the verb of the owning header in a block pointed to by data */ for(i=0;i1) /* i.e. there _is_ an actor */ command[i].verbcmd=syntbl[auxsyn[DIR_ADDR_CODE]]; save_actor[i]=command[i].actor; command[i].actor=i; if (save_actor[i]<0) { /* Redirected command */ command[i].actor=-i; rfree(command[i].data); /* data may be NULL, anyhow */ command[i].data=rmalloc(sizeof(integer)); if (i>0) command[i].data[0]=command[i-1].verbcmd; else { command[i].data[0]=0; agtwarn("First command header is REDIRECT object!",0); } } } /* Now do the sort... */ qsort(command,last_cmd,sizeof(cmd_rec),cmp_cmd); #if 0 /* This is code to test the integrity of the sort */ for(i=0;i1) curr_vb=DIR_ADDR_CODE; else curr_vb=cmdverb_code(command[i].verbcmd); if (iverbend[curr_vb]) verbend[curr_vb]=i; } for(i=0;iMAX_COND && opPREWIN_ACT && opMAX_ACT) ) { agtwarn("Illegal opcode found.",1); return &illegal_def; } if (op>=2000) return &end_def[op-2000]; if (op>=1000) return &act_def[op-1000]; return &cond_def[op]; } /* ------------------------------------------------------------------- */ /* Functions for reading in descriptions */ /* ------------------------------------------------------------------- */ descr_line *read_descr(long start,long size) { if (agx_file) return agx_read_descr(start,size); else return agt_read_descr(start,size); } void free_descr(descr_line *txt) { if (txt==NULL) return; rfree(txt[0]); /* First free the string block containing the text...*/ rfree(txt); /* ... then the array of pointers to it */ } /* ------------------------------------------------------------------- */ /* Warning and error functions */ /* ------------------------------------------------------------------- */ void agtwarn(const char *s,int elev) { if (ERR_LEVEL>=elev) rprintf("Warning: %s\n",s); } void agtnwarn(const char *s,int n,int elev) { if (ERR_LEVEL>=elev) rprintf("Warning: %s%d.\n",s,n); } void fatal(const char *s) { /* We don't use rprintf in this case since we may be in too much trouble for it to work */ rprintf("Fatal error: %s\n",s); close_interface(); exit(EXIT_FAILURE); }