X-Git-Url: https://jxself.org/git/?p=open-adventure.git;a=blobdiff_plain;f=misc.c;h=93dce3b073b51f87dfcd0192b26a0b15fc2f75ad;hp=a08720cbeb20b08cd7414d20eb743343bb3f1d83;hb=6b6cfa37f11ebd53c4e293aa895ebb60fbb3515e;hpb=2bc887c84efbcd9ea4ae589d29285bc187173e9a diff --git a/misc.c b/misc.c index a08720c..93dce3b 100644 --- a/misc.c +++ b/misc.c @@ -1,10 +1,13 @@ #include #include #include +#include +#include #include "main.h" #include "share.h" /* for SETUP */ #include "misc.h" #include "funcs.h" +#include "database.h" /* hack to ignore GCC Unused Result */ #define IGNORE(r) do{if(r){}}while(0) @@ -29,7 +32,7 @@ L10: L=IABS(LINES[K])-1; LNPOSN=1; STATE=0; for (I=K; I<=L; I++) { - PUTTXT(LINES[I],STATE,2,I); + PUTTXT(LINES[I],STATE,2); } /* end loop */ LNPOSN=0; L30: LNPOSN=LNPOSN+1; @@ -78,7 +81,7 @@ L340: SHFTXT(LNPOSN+2,-2); CASE=2; L345: if(PARMS[NPARMS] < 0) goto L395; {long x = NPARMS+1; if(PARMS[x] < 0)CASE=0;} - PUTTXT(PARMS[NPARMS],STATE,CASE,0); + PUTTXT(PARMS[NPARMS],STATE,CASE); NPARMS=NPARMS+1; goto L345; @@ -97,8 +100,8 @@ L380: SHFTXT(LNPOSN+2,-2); if(PRMTYP == 31)CASE=1; if(PRMTYP == 33)CASE=0; I=LNPOSN; - PUTTXT(PARMS[NPARMS],STATE,CASE,0); - {long x = NPARMS+1; PUTTXT(PARMS[x],STATE,CASE,0);} + PUTTXT(PARMS[NPARMS],STATE,CASE); + {long x = NPARMS+1; PUTTXT(PARMS[x],STATE,CASE);} if(PRMTYP == 13 && INLINE[I] >= 37 && INLINE[I] <= 62)INLINE[I]=INLINE[I]-26; NPARMS=NPARMS+2; @@ -173,7 +176,7 @@ void fSETPRM(long FIRST, long P1, long P2) { #define WORD1X (*wORD1X) #define WORD2 (*wORD2) #define WORD2X (*wORD2X) -void fGETIN(FILE *input, long *wORD1, long *wORD1X, long *wORD2, long *wORD2X) { +bool fGETIN(FILE *input, long *wORD1, long *wORD1X, long *wORD2, long *wORD2X) { long JUNK; /* Get a command from the adventurer. Snarf out the first word, pad it with @@ -185,17 +188,18 @@ long JUNK; L10: if(BLKLIN)TYPE0(); MAPLIN(input); - if(input == stdin && feof(stdin)) score(1); - WORD1=GETTXT(true,true,true,0); + if (feof(input)) + return false; + WORD1=GETTXT(true,true,true); if(BLKLIN && WORD1 < 0) goto L10; - WORD1X=GETTXT(false,true,true,0); -L12: JUNK=GETTXT(false,true,true,0); + WORD1X=GETTXT(false,true,true); +L12: JUNK=GETTXT(false,true,true); if(JUNK > 0) goto L12; - WORD2=GETTXT(true,true,true,0); - WORD2X=GETTXT(false,true,true,0); -L22: JUNK=GETTXT(false,true,true,0); + WORD2=GETTXT(true,true,true); + WORD2X=GETTXT(false,true,true); +L22: JUNK=GETTXT(false,true,true); if(JUNK > 0) goto L22; - if(GETTXT(true,true,true,0) <= 0)return; + if(GETTXT(true,true,true) <= 0)return true; RSPEAK(53); goto L10; } @@ -281,14 +285,12 @@ L42: GETNUM=GETNUM*SIGN; #define GETNUM(K) fGETNUM(K) #undef GETTXT -long fGETTXT(long SKIP,long ONEWRD, long UPPER, long HASH) { +long fGETTXT(long SKIP,long ONEWRD, long UPPER) { long CHAR, GETTXT, I; static long SPLITTING = -1; /* Take characters from an input line and pack them into 30-bit words. * Skip says to skip leading blanks. ONEWRD says stop if we come to a - * blank. UPPER says to map all letters to uppercase. HASH may be used - * as a parameter for encrypting the text if desired; however, a hash of 0 - * should result in unmodified bytes being packed. If we reach the + * blank. UPPER says to map all letters to uppercase. If we reach the * end of the line, the word is filled up with blanks (which encode as 0's). * If we're already at end of line when GETTXT is called, we return -1. */ @@ -321,20 +323,19 @@ L14: LNPOSN=LNPOSN+1; L15: /*etc*/ ; } /* end loop */ - if(HASH)GETTXT=GETTXT+MOD(HASH*13579L+5432L,97531L)*12345L+HASH; return(GETTXT); } -#define GETTXT(SKIP,ONEWRD,UPPER,HASH) fGETTXT(SKIP,ONEWRD,UPPER,HASH) +#define GETTXT(SKIP,ONEWRD,UPPER) fGETTXT(SKIP,ONEWRD,UPPER) #undef MAKEWD long fMAKEWD(long LETTRS) { long I, L, MAKEWD; /* Combine five uppercase letters (represented by pairs of decimal digits * in lettrs) to form a 30-bit value matching the one that GETTXT would - * return given those characters plus trailing blanks and HASH=0. Caution: + * return given those characters plus trailing blanks. Caution: * lettrs will overflow 31 bits if 5-letter word starts with V-Z. As a * kludgey workaround, you can increment a letter by 5 by adding 50 to * the next pair of digits. */ @@ -358,13 +359,12 @@ L10: MAKEWD=MAKEWD+I*(MOD(L,50)+10); #define MAKEWD(LETTRS) fMAKEWD(LETTRS) #undef PUTTXT #define STATE (*sTATE) -void fPUTTXT(long WORD, long *sTATE, long CASE, long HASH) { +void fPUTTXT(long WORD, long *sTATE, long CASE) { long ALPH1, ALPH2, BYTE, DIV, I, W; /* Unpack the 30-bit value in word to obtain up to 5 integer-encoded chars, * and store them in inline starting at LNPOSN. If LNLENG>=LNPOSN, shift - * existing characters to the right to make room. HASH must be the same - * as it was when gettxt created the 30-bit word. STATE will be zero when + * existing characters to the right to make room. STATE will be zero when * puttxt is called with the first of a sequence of words, but is thereafter * unchanged by the caller, so PUTTXT can use it to maintain state across * calls. LNPOSN and LNLENG are incremented by the number of chars stored. @@ -379,7 +379,6 @@ long ALPH1, ALPH2, BYTE, DIV, I, W; /* ALPH1&2 DEFINE RANGE OF WRONG-CASE CHARS, 11-36 OR 37-62 OR EMPTY. */ DIV=64L*64L*64L*64L; W=WORD; - if(HASH)W=W-MOD(HASH*13579L+5432L,97531L)*12345L-HASH; /* 18 */ for (I=1; I<=5; I++) { if(W <= 0 && STATE == 0 && IABS(CASE) <= 1)return; BYTE=W/DIV; @@ -401,7 +400,7 @@ L18: W=(W-BYTE*DIV)*64; #undef STATE -#define PUTTXT(WORD,STATE,CASE,HASH) fPUTTXT(WORD,&STATE,CASE,HASH) +#define PUTTXT(WORD,STATE,CASE) fPUTTXT(WORD,&STATE,CASE) #undef SHFTXT void fSHFTXT(long FROM, long DELTA) { long I, II, JJ; @@ -545,7 +544,7 @@ L32: N--; WORD=BUF[N]-CKSUM; N++; #define SAVWRD(OP,WORD) fSAVWRD(OP,&WORD) #undef VOCAB long fVOCAB(long ID, long INIT) { -long HASH, I, VOCAB; +long I, VOCAB; /* Look up ID in the vocabulary (ATAB) and return its "definition" (KTAB), or * -1 if not found. If INIT is positive, this is an initialisation call setting @@ -554,12 +553,10 @@ long HASH, I, VOCAB; * (Thus "STEPS", which is a motion verb as well as an object, may be located * as an object.) And it also means the KTAB value is taken modulo 1000. */ - HASH=10000; /* 1 */ for (I=1; I<=TABSIZ; I++) { if(KTAB[I] == -1) goto L2; - HASH=HASH+7; if(INIT >= 0 && KTAB[I]/1000 != INIT) goto L1; - if(ATAB[I] == ID+HASH*HASH) goto L3; + if(ATAB[I] == ID) goto L3; L1: /*etc*/ ; } /* end loop */ BUG(21); @@ -723,7 +720,8 @@ L2: ATDWRF=I; -/* Utility routines (SETBIT, TSTBIT, RAN, RNDVOC, BUG) */ +/* Utility routines (SETBIT, TSTBIT, set_seed, get_next_lcg_value, + * randrange, RNDVOC, BUG) */ #undef SETBIT long fSETBIT(long BIT) { @@ -757,58 +755,56 @@ long TSTBIT; #define TSTBIT(MASK,BIT) fTSTBIT(MASK,BIT) -#undef RAN -long fRAN(long RANGE) { -static long D, R = 0, RAN, T; - -/* Since the ran function in LIB40 seems to be a real lose, we'll use one of - * our own. It's been run through many of the tests in Knuth vol. 2 and - * seems to be quite reliable. RAN returns a value uniformly selected - * between 0 and range-1. */ - - - D=1; - if(R != 0 && RANGE >= 0) goto L1; - DATIME(D,T); - R=MOD(T+5,1048576L); - D=1000+MOD(D,1000); -L1: for (T=1; T<=D; T++) { - R=MOD(R*1093L+221587L,1048576L); - } /* end loop */ - RAN=(RANGE*R)/1048576; - return(RAN); + +void set_seed(long seedval) +{ + lcgstate.x = (unsigned long) seedval % lcgstate.m; } +unsigned long get_next_lcg_value(void) +{ + /* Return the LCG's current value, and then iterate it. */ + unsigned long old_x = lcgstate.x; + lcgstate.x = (lcgstate.a * lcgstate.x + lcgstate.c) % lcgstate.m; + return(old_x); +} +long randrange(long range) +{ + /* Return a random integer from [0, range). */ + long result = range * get_next_lcg_value() / lcgstate.m; + return(result); +} -#define RAN(RANGE) fRAN(RANGE) #undef RNDVOC long fRNDVOC(long CHAR, long FORCE) { -long DIV, I, J, RNDVOC; - /* Searches the vocabulary for a word whose second character is char, and * changes that word such that each of the other four characters is a * random letter. If force is non-zero, it is used as the new word. * Returns the new word. */ + long RNDVOC; RNDVOC=FORCE; - if(RNDVOC != 0) goto L3; - for (I=1; I<=5; I++) { - J=11+RAN(26); - if(I == 2)J=CHAR; - RNDVOC=RNDVOC*64+J; - } /* end loop */ -L3: J=10000; - DIV=64L*64L*64L; - for (I=1; I<=TABSIZ; I++) { - J=J+7; - if(MOD((ATAB[I]-J*J)/DIV,64L) == CHAR) goto L8; - /*etc*/ ; - } /* end loop */ - BUG(5); -L8: ATAB[I]=RNDVOC+J*J; + if (RNDVOC == 0) { + for (int I = 1; I <= 5; I++) { + long J = 11 + randrange(26); + if (I == 2) + J = CHAR; + RNDVOC = RNDVOC * 64 + J; + } + } + + long DIV = 64L * 64L * 64L; + for (int I = 1; I <= TABSIZ; I++) { + if (MOD(ATAB[I]/DIV, 64L) == CHAR) + { + ATAB[I] = RNDVOC; + break; + } + } + return(RNDVOC); } @@ -886,17 +882,21 @@ long I, VAL; if(MAP2[1] == 0)MPINIT(); - if (!oldstyle && SETUP) - fputs("> ", stdout); - IGNORE(fgets(INLINE+1,sizeof(INLINE)-1,OPENED)); + if (!oldstyle && SETUP && OPENED == stdin) + fputs("> ", stdout); + do { + IGNORE(fgets(rawbuf,sizeof(rawbuf)-1,OPENED)); + } while + (!feof(OPENED) && rawbuf[0] == '#'); if (feof(OPENED)) { - if (logfp) + if (logfp && OPENED == stdin) fclose(logfp); } else { - if (logfp) - IGNORE(fputs(INLINE+1, logfp)); + if (logfp && OPENED == stdin) + IGNORE(fputs(rawbuf, logfp)); else if (!isatty(0)) - IGNORE(fputs(INLINE+1, stdout)); + IGNORE(fputs(rawbuf, stdout)); + strcpy(INLINE+1, rawbuf); LNLENG=0; for (I=1; I<=sizeof(INLINE) && INLINE[I]!=0; I++) { VAL=INLINE[I]+1; @@ -1005,5 +1005,11 @@ L30: if(IN)IGNORE(fread(ARR,sizeof(long),250,F)); +void DATIME(long* D, long* T) { + struct timeval tv; + gettimeofday(&tv, NULL); + *D = (long) tv.tv_sec; + *T = (long) tv.tv_usec; +} long fIABS(N)long N; {return(N<0? -N : N);} long fMOD(N,M)long N, M; {return(N%M);}