X-Git-Url: https://jxself.org/git/?p=open-adventure.git;a=blobdiff_plain;f=misc.c;h=c4dc35124b4e9885007e4110f85cad7d7163125e;hp=b87c76913f6aab68b500979b20adce84fb05d443;hb=33dfafc705db5855b47e0427b2a4622dc03221a5;hpb=627144354c9d16d1d6d6ea0fb2d5925ab16fffcb diff --git a/misc.c b/misc.c index b87c769..c4dc351 100644 --- a/misc.c +++ b/misc.c @@ -1,1007 +1,731 @@ #include #include #include -#include "main.h" -#include "share.h" /* for SETUP */ -#include "misc.h" -#include "funcs.h" - -/* hack to ignore GCC Unused Result */ -#define IGNORE(r) do{if(r){}}while(0) - -/* I/O routines (SPEAK, PSPEAK, RSPEAK, SETPRM, GETIN, YES) */ - -#undef SPEAK -void fSPEAK(long N) { -long BLANK, CASE, I, K, L, NEG, NPARMS, PARM, PRMTYP, STATE; - -/* Print the message which starts at LINES(N). Precede it with a blank line - * unless BLKLIN is false. */ - - - if(N == 0)return; - BLANK=BLKLIN; - K=N; - NPARMS=1; -L10: L=IABS(LINES[K])-1; - K=K+1; - LNLENG=0; - LNPOSN=1; - STATE=0; - for (I=K; I<=L; I++) { - PUTTXT(LINES[I],STATE,2,I); - } /* end loop */ - LNPOSN=0; -L30: LNPOSN=LNPOSN+1; -L32: if(LNPOSN > LNLENG) goto L40; - if(INLINE[LNPOSN] != 63) goto L30; - {long x = LNPOSN+1; PRMTYP=INLINE[x];} -/* 63 is a "%"; the next character determine the type of parameter: 1 (!) = - * suppress message completely, 29 (S) = NULL If PARM=1, else 'S' (optional - * plural ending), 33 (W) = word (two 30-bit values) with trailing spaces - * suppressed, 22 (L) or 31 (U) = word but map to lower/upper case, 13 (C) = - * word in lower case with first letter capitalised, 30 (T) = text ending - * with a word of -1, 65-73 (1-9) = number using that many characters, - * 12 (B) = variable number of blanks. */ - if(PRMTYP == 1)return; - if(PRMTYP == 29) goto L320; - if(PRMTYP == 30) goto L340; - if(PRMTYP == 12) goto L360; - if(PRMTYP == 33 || PRMTYP == 22 || PRMTYP == 31 || PRMTYP == 13) goto - L380; - PRMTYP=PRMTYP-64; - if(PRMTYP < 1 || PRMTYP > 9) goto L30; - SHFTXT(LNPOSN+2,PRMTYP-2); - LNPOSN=LNPOSN+PRMTYP; - PARM=IABS(PARMS[NPARMS]); - NEG=0; - if(PARMS[NPARMS] < 0)NEG=9; - /* 390 */ for (I=1; I<=PRMTYP; I++) { - LNPOSN=LNPOSN-1; - INLINE[LNPOSN]=MOD(PARM,10)+64; - if(I == 1 || PARM != 0) goto L390; - INLINE[LNPOSN]=NEG; - NEG=0; -L390: PARM=PARM/10; - } /* end loop */ - LNPOSN=LNPOSN+PRMTYP; -L395: NPARMS=NPARMS+1; - goto L32; - -L320: SHFTXT(LNPOSN+2,-1); - INLINE[LNPOSN]=55; - if(PARMS[NPARMS] == 1)SHFTXT(LNPOSN+1,-1); - goto L395; - -L340: SHFTXT(LNPOSN+2,-2); - STATE=0; - 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); - NPARMS=NPARMS+1; - goto L345; - -L360: PRMTYP=PARMS[NPARMS]; - SHFTXT(LNPOSN+2,PRMTYP-2); - if(PRMTYP == 0) goto L395; - for (I=1; I<=PRMTYP; I++) { - INLINE[LNPOSN]=0; - LNPOSN=LNPOSN+1; - } /* end loop */ - goto L395; - -L380: SHFTXT(LNPOSN+2,-2); - STATE=0; - CASE= -1; - 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);} - if(PRMTYP == 13 && INLINE[I] >= 37 && INLINE[I] <= - 62)INLINE[I]=INLINE[I]-26; - NPARMS=NPARMS+2; - goto L32; - -L40: if(BLANK)TYPE0(); - BLANK=false; - TYPE(); - K=L+1; - if(LINES[K] >= 0) goto L10; - return; -} - - - -#define SPEAK(N) fSPEAK(N) -#undef PSPEAK -void fPSPEAK(long MSG,long SKIP) { -long I, M; - -/* Find the skip+1st message from msg and print it. MSG should be the index of - * the inventory message for object. (INVEN+N+1 message is PROP=N message). */ - - - M=PTEXT[MSG]; - if(SKIP < 0) goto L9; - for (I=0; I<=SKIP; I++) { -L1: M=IABS(LINES[M]); - if(LINES[M] >= 0) goto L1; - /*etc*/ ; - } /* end loop */ -L9: SPEAK(M); - return; -} - - - -#define PSPEAK(MSG,SKIP) fPSPEAK(MSG,SKIP) -#undef RSPEAK -void fRSPEAK(long I) { -; - -/* Print the I-TH "random" message (section 6 of database). */ - - - if(I != 0)SPEAK(RTEXT[I]); - return; -} - - - -#define RSPEAK(I) fRSPEAK(I) -#undef SETPRM -void fSETPRM(long FIRST, long P1, long P2) { -; +#include +#include +#include +#include +#include -/* Stores parameters into the PRMCOM parms array for use by speak. P1 and P2 - * are stored into PARMS(FIRST) and PARMS(FIRST+1). */ +#include "advent.h" +#include "dungeon.h" - - if(FIRST >= 25)BUG(29); - PARMS[FIRST]=P1; - {long x = FIRST+1; PARMS[x]=P2;} - return; -} - - - -#define SETPRM(FIRST,P1,P2) fSETPRM(FIRST,P1,P2) -#undef GETIN -#define WORD1 (*wORD1) -#define WORD1X (*wORD1X) -#define WORD2 (*wORD2) -#define WORD2X (*wORD2X) -void 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 - * blanks, and return it in WORD1. Chars 6 thru 10 are returned in WORD1X, in - * case we need to print out the whole word in an error message. Any number of - * blanks may follow the word. If a second word appears, it is returned in - * WORD2 (chars 6 thru 10 in WORD2X), else WORD2 is -1. */ - - -L10: if(BLKLIN)TYPE0(); - MAPLIN(input); - if(input == stdin && feof(stdin)) score(1); - WORD1=GETTXT(true,true,true,0); - if(BLKLIN && WORD1 < 0) goto L10; - WORD1X=GETTXT(false,true,true,0); -L12: JUNK=GETTXT(false,true,true,0); - if(JUNK > 0) goto L12; - WORD2=GETTXT(true,true,true,0); - WORD2X=GETTXT(false,true,true,0); -L22: JUNK=GETTXT(false,true,true,0); - if(JUNK > 0) goto L22; - if(GETTXT(true,true,true,0) <= 0)return; - RSPEAK(53); - goto L10; -} - - - -#undef WORD1 -#undef WORD1X -#undef WORD2 -#undef WORD2X -#define GETIN(SRC,WORD1,WORD1X,WORD2,WORD2X) fGETIN(SRC,&WORD1,&WORD1X,&WORD2,&WORD2X) -#undef YES -long fYES(FILE *input, long X, long Y, long Z) { - -long YES, REPLY, JUNK1, JUNK2, JUNK3; - -/* Print message X, wait for yes/no answer. If yes, print Y and return true; - * if no, print Z and return false. */ - -L1: RSPEAK(X); - GETIN(input, REPLY,JUNK1,JUNK2,JUNK3); - if(REPLY == MAKEWD(250519) || REPLY == MAKEWD(25)) goto L10; - if(REPLY == MAKEWD(1415) || REPLY == MAKEWD(14)) goto L20; - RSPEAK(185); - goto L1; -L10: YES=true; - RSPEAK(Y); - return(YES); -L20: YES=false; - RSPEAK(Z); - return(YES); -} - - - - - -/* Line-parsing routines (GETNUM, GETTXT, MAKEWD, PUTTXT, SHFTXT, TYPE0) - */ - -/* The routines on this page handle all the stuff that would normally be - * taken care of by format statements. We do it this way instead so that - * we can handle textual data in a machine independent fashion. All the - * machine dependent i/o stuff is on the following page. See that page - * for a description of MAPCOM's inline array. */ - -#define YES(X,Y,Z) fYES(X,Y,Z) -#undef GETNUM -long fGETNUM(FILE *source) { -long DIGIT, GETNUM, SIGN; - -/* Obtain the next integer from an input line. If K>0, we first read a - * new input line from a file; if K<0, we read a line from the keyboard; - * if K=0 we use a line that has already been read (and perhaps partially - * scanned). If we're at the end of the line or encounter an illegal - * character (not a digit, hyphen, or blank), we return 0. */ - - - if(source != NULL)MAPLIN(source); - GETNUM=0; -L10: if(LNPOSN > LNLENG)return(GETNUM); - if(INLINE[LNPOSN] != 0) goto L20; - LNPOSN=LNPOSN+1; - goto L10; - -L20: SIGN=1; - if(INLINE[LNPOSN] != 9) goto L32; - SIGN= -1; -L30: LNPOSN=LNPOSN+1; -L32: if(LNPOSN > LNLENG || INLINE[LNPOSN] == 0) goto L42; - DIGIT=INLINE[LNPOSN]-64; - if(DIGIT < 0 || DIGIT > 9) goto L40; - GETNUM=GETNUM*10+DIGIT; - goto L30; - -L40: GETNUM=0; -L42: GETNUM=GETNUM*SIGN; - LNPOSN=LNPOSN+1; - return(GETNUM); -} - - - -#define GETNUM(K) fGETNUM(K) -#undef GETTXT -long fGETTXT(long SKIP,long ONEWRD, long UPPER, long HASH) { -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 - * 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. */ - - if(LNPOSN != SPLITTING)SPLITTING = -1; - GETTXT= -1; -L10: if(LNPOSN > LNLENG)return(GETTXT); - if((!SKIP) || INLINE[LNPOSN] != 0) goto L11; - LNPOSN=LNPOSN+1; - goto L10; - -L11: GETTXT=0; - /* 15 */ for (I=1; I<=5; I++) { - GETTXT=GETTXT*64; - if(LNPOSN > LNLENG || (ONEWRD && INLINE[LNPOSN] == 0)) goto L15; - CHAR=INLINE[LNPOSN]; - if(CHAR >= 63) goto L12; - SPLITTING = -1; - if(UPPER && CHAR >= 37)CHAR=CHAR-26; - GETTXT=GETTXT+CHAR; - goto L14; - -L12: if(SPLITTING == LNPOSN) goto L13; - GETTXT=GETTXT+63; - SPLITTING = LNPOSN; - goto L15; - -L13: GETTXT=GETTXT+CHAR-63; - SPLITTING = -1; -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) -#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: - * 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. */ - - - MAKEWD=0; - I=1; - L=LETTRS; -L10: MAKEWD=MAKEWD+I*(MOD(L,50)+10); - I=I*64; - if(MOD(L,100) > 50)MAKEWD=MAKEWD+I*5; - L=L/100; - if(L != 0) goto L10; - I=64L*64L*64L*64L*64L/I; - MAKEWD=MAKEWD*I; - return(MAKEWD); +static void* xmalloc(size_t size) +{ + void* ptr = malloc(size); + if (ptr == NULL) { + // LCOV_EXCL_START + // exclude from coverage analysis because we can't simulate an out of memory error in testing + fprintf(stderr, "Out of memory!\n"); + exit(EXIT_FAILURE); + // LCOV_EXCL_STOP + } + return (ptr); +} + +void packed_to_token(long packed, char token[TOKLEN + 1]) +{ + // The advent->ascii mapping. + const char advent_to_ascii[] = { + ' ', '!', '"', '#', '$', '%', '&', '\'', + '(', ')', '*', '+', ',', '-', '.', '/', + '0', '1', '2', '3', '4', '5', '6', '7', + '8', '9', ':', ';', '<', '=', '>', '?', + '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', + 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', + 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', + 'X', 'Y', 'Z', '\0', '\0', '\0', '\0', '\0', + }; + + // Unpack and map back to ASCII. + for (int i = 0; i < 5; ++i) { + char advent = (packed >> i * 6) & 63; + token[i] = advent_to_ascii[(int) advent]; + } + + // Ensure the last character is \0. + token[5] = '\0'; + + // Replace trailing whitespace with \0. + for (int i = 4; i >= 0; --i) { + if (token[i] == ' ' || + token[i] == '\t') + token[i] = '\0'; + else + break; + } +} + +long token_to_packed(const char token[]) +{ + const char ascii_to_advent[] = { + 63, 63, 63, 63, 63, 63, 63, 63, + 63, 63, 63, 63, 63, 63, 63, 63, + 63, 63, 63, 63, 63, 63, 63, 63, + 63, 63, 63, 63, 63, 63, 63, 63, + + 0, 1, 2, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, 61, 62, 63, + + 63, 63, 63, 63, 63, 63, 63, 63, + 63, 63, 63, 63, 63, 63, 63, 63, + 63, 63, 63, 63, 63, 63, 63, 63, + 63, 63, 63, 63, 63, 63, 63, 63, + }; + + size_t t_len = strlen(token); + if (t_len > TOKLEN) + t_len = TOKLEN; + long packed = 0; + for (size_t i = 0; i < t_len; ++i) { + char mapped = ascii_to_advent[(int) toupper(token[i])]; + packed |= (mapped << (6 * i)); + } + return (packed); +} + +void tokenize(char* raw, struct command_t *cmd) +{ + memset(cmd, '\0', sizeof(struct command_t)); + + /* Bound prefix on the %s would be needed to prevent buffer + * overflow. but we shortstop this more simply by making each + * raw-input buffer as long as the enrire inout buffer. */ + sscanf(raw, "%s%s", cmd->raw1, cmd->raw2); + + // pack the substrings + cmd->wd1 = token_to_packed(cmd->raw1); + cmd->wd2 = token_to_packed(cmd->raw2); + + /* (ESR) In oldstyle mode, simulate the uppercasing and truncating + * effect on raw tokens of packing them into sixbit characters, 5 + * to a 32-bit word. This is something the FORTRAN version did + * becuse archaic FORTRAN had no string types. Don Wood's + * mechanical translation of 2.5 to C retained the packing and + * thus this misfeature. + * + * It's philosophically questionable whether this is the right + * thing to do even in oldstyle mode. On one hand, the text + * mangling was not authorial intent, but a result of limitations + * in their tools. On the other, not simulating this misbehavior + * goes against the goal of making oldstyle as accurate as + * possible an emulation of the original UI. + */ + if (settings.oldstyle) { + cmd->raw1[TOKLEN + TOKLEN] = cmd->raw2[TOKLEN + TOKLEN] = '\0'; + for (size_t i = 0; i < strlen(cmd->raw1); i++) + cmd->raw1[i] = toupper(cmd->raw1[i]); + for (size_t i = 0; i < strlen(cmd->raw2); i++) + cmd->raw2[i] = toupper(cmd->raw2[i]); + } +} + +/* Hide the fact that wods are corrently packed longs */ + +void wordclear(token_t *v) +{ + *v = 0; } +/* I/O routines (speak, pspeak, rspeak, sspeak, get_input, yes) */ - -#define MAKEWD(LETTRS) fMAKEWD(LETTRS) -#undef PUTTXT -#define STATE (*sTATE) -void fPUTTXT(long WORD, long *sTATE, long CASE, long HASH) { -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 - * 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. - * If CASE=1, all letters are made uppercase; if -1, lowercase; if 0, as is. - * any other value for case is the same as 0 but also causes trailing blanks - * to be included (in anticipation of subsequent additional text). */ - - - ALPH1=13*CASE+24; - ALPH2=26*IABS(CASE)+ALPH1; - if(IABS(CASE) > 1)ALPH1=ALPH2; -/* 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; - if(STATE != 0 || BYTE != 63) goto L12; - STATE=63; - goto L18; - -L12: SHFTXT(LNPOSN,1); - STATE=STATE+BYTE; - if(STATE < ALPH2 && STATE >= ALPH1)STATE=STATE-26*CASE; - INLINE[LNPOSN]=STATE; - LNPOSN=LNPOSN+1; - STATE=0; -L18: W=(W-BYTE*DIV)*64; - } /* end loop */ - return; +void vspeak(const char* msg, bool blank, va_list ap) +{ + // Do nothing if we got a null pointer. + if (msg == NULL) + return; + + // Do nothing if we got an empty string. + if (strlen(msg) == 0) + return; + + if (blank == true) + printf("\n"); + + int msglen = strlen(msg); + + // Rendered string + ssize_t size = 2000; /* msglen > 50 ? msglen*2 : 100; */ + char* rendered = xmalloc(size); + char* renderp = rendered; + + // Handle format specifiers (including the custom %C, %L, %S) by + // adjusting the parameter accordingly, and replacing the + // specifier with %s. + long previous_arg = 0; + for (int i = 0; i < msglen; i++) { + if (msg[i] != '%') { + /* Ugh. Least obtrusive way to deal with artifacts "on the floor" + * being dropped outside of both cave and building. */ + if (strncmp(msg + i, "floor", 5) == 0 && strchr(" .", msg[i + 5]) && !INSIDE(game.loc)) { + strcpy(renderp, "ground"); + renderp += 6; + i += 4; + size -= 5; + } else { + *renderp++ = msg[i]; + size--; + } + } else { + long arg = va_arg(ap, long); + if (arg == -1) + arg = 0; // LCOV_EXCL_LINE - don't think we can get here. + i++; + // Integer specifier. In order to accommodate the fact + // that PARMS can have both legitimate integers *and* + // packed tokens, stringify everything. Future work may + // eliminate the need for this. + if (msg[i] == 'd') { + int ret = snprintf(renderp, size, "%ld", arg); + if (ret < size) { + renderp += ret; + size -= ret; + } + } + + // Unmodified string specifier. + if (msg[i] == 's') { + packed_to_token(arg, renderp); /* unpack directly to destination */ + size_t len = strlen(renderp); + renderp += len; + size -= len; + } + + // Singular/plural specifier. + if (msg[i] == 'S') { + if (previous_arg > 1) { // look at the *previous* parameter (which by necessity must be numeric) + *renderp++ = 's'; + size--; + } + } + + /* Version specifier */ + if (msg[i] == 'V') { + strcpy(renderp, VERSION); + size_t len = strlen(VERSION); + renderp += len; + size -= len; + } + + previous_arg = arg; + } + } + *renderp = 0; + + // Print the message. + printf("%s\n", rendered); + + free(rendered); +} + +void speak(const char* msg, ...) +{ + va_list ap; + va_start(ap, msg); + vspeak(msg, true, ap); + va_end(ap); } - - -#undef STATE -#define PUTTXT(WORD,STATE,CASE,HASH) fPUTTXT(WORD,&STATE,CASE,HASH) -#undef SHFTXT -void fSHFTXT(long FROM, long DELTA) { -long I, II, JJ; - -/* Move INLINE(N) to INLINE(N+DELTA) for N=FROM,LNLENG. Delta can be - * negative. LNLENG is updated; LNPOSN is not changed. */ - - - if(LNLENG < FROM || DELTA == 0) goto L2; - for (I=FROM; I<=LNLENG; I++) { - II=I; - if(DELTA > 0)II=FROM+LNLENG-I; - JJ=II+DELTA; - INLINE[JJ]=INLINE[II]; - } /* end loop */ -L2: LNLENG=LNLENG+DELTA; - return; +void sspeak(const long msg, ...) +{ + va_list ap; + va_start(ap, msg); + fputc('\n', stdout); + vprintf(arbitrary_messages[msg], ap); + fputc('\n', stdout); + va_end(ap); +} + +void pspeak(vocab_t msg, enum speaktype mode, int skip, bool blank, ...) +/* Find the skip+1st message from msg and print it. Modes are: + * feel = for inventory, what you can touch + * look = the long description for the state the object is in + * listen = the sound for the state the object is in + * study = text on the object. */ +{ + va_list ap; + va_start(ap, blank); + switch (mode) { + case touch: + vspeak(objects[msg].inventory, blank, ap); + break; + case look: + vspeak(objects[msg].descriptions[skip], blank, ap); + break; + case hear: + vspeak(objects[msg].sounds[skip], blank, ap); + break; + case study: + vspeak(objects[msg].texts[skip], blank, ap); + break; + case change: + vspeak(objects[msg].changes[skip], blank, ap); + break; + } + va_end(ap); +} + +void rspeak(vocab_t i, ...) +/* Print the i-th "random" message (section 6 of database). */ +{ + va_list ap; + va_start(ap, i); + vspeak(arbitrary_messages[i], true, ap); + va_end(ap); } - - -#define SHFTXT(FROM,DELTA) fSHFTXT(FROM,DELTA) -#undef TYPE0 -void fTYPE0() { -long TEMP; - -/* Type a blank line. This procedure is provided as a convenience for callers - * who otherwise have no use for MAPCOM. */ - - - TEMP=LNLENG; - LNLENG=0; - TYPE(); - LNLENG=TEMP; - return; +void echo_input(FILE* destination, const char* input_prompt, const char* input) +{ + size_t len = strlen(input_prompt) + strlen(input) + 1; + char* prompt_and_input = (char*) xmalloc(len); + strcpy(prompt_and_input, input_prompt); + strcat(prompt_and_input, input); + fprintf(destination, "%s\n", prompt_and_input); + free(prompt_and_input); } +int word_count(char* str) +{ + char delims[] = " \t"; + int count = 0; + int inblanks = true; + + for (char *s = str; *s; s++) + if (inblanks) { + if (strchr(delims, *s) == 0) { + ++count; + inblanks = false; + } + } else { + if (strchr(delims, *s) != 0) { + inblanks = true; + } + } + + return (count); +} + +char* get_input() +{ + // Set up the prompt + char input_prompt[] = "> "; + if (!settings.prompt) + input_prompt[0] = '\0'; + // Print a blank line + printf("\n"); -#define TYPE0() fTYPE0() - - -/* Suspend/resume I/O routines (SAVWDS, SAVARR, SAVWRD) */ - -#undef SAVWDS -void fSAVWDS(long *W1, long *W2, long *W3, long *W4, long *W5, long *W6, long *W7) { - -/* Write or read 7 variables. See SAVWRD. */ - + char* input; + while (true) { + input = readline(input_prompt); - SAVWRD(0,(*W1)); - SAVWRD(0,(*W2)); - SAVWRD(0,(*W3)); - SAVWRD(0,(*W4)); - SAVWRD(0,(*W5)); - SAVWRD(0,(*W6)); - SAVWRD(0,(*W7)); - return; -} + if (input == NULL) // Got EOF; return with it. + return (input); + if (input[0] == '#') { // Ignore comments. + free(input); + continue; + } + // We have a 'normal' line; leave the loop. + break; + } + // Strip trailing newlines from the input + input[strcspn(input, "\n")] = 0; -#define SAVWDS(W1,W2,W3,W4,W5,W6,W7) fSAVWDS(&W1,&W2,&W3,&W4,&W5,&W6,&W7) -#undef SAVARR -void fSAVARR(long ARR[], long N) { -long I; + add_history(input); -/* Write or read an array of N words. See SAVWRD. */ + if (!isatty(0)) + echo_input(stdout, input_prompt, input); + if (settings.logfp) + echo_input(settings.logfp, "", input); - for (I=1; I<=N; I++) { - SAVWRD(0,ARR[I]); - } /* end loop */ - return; + return (input); } +bool silent_yes() +{ + bool outcome = false; + + for (;;) { + char* reply = get_input(); + if (reply == NULL) { + // LCOV_EXCL_START + // Should be unreachable. Reply should never be NULL + free(reply); + exit(EXIT_SUCCESS); + // LCOV_EXCL_STOP + } + if (strlen(reply) == 0) { + free(reply); + rspeak(PLEASE_ANSWER); + continue; + } + + char* firstword = (char*) xmalloc(strlen(reply) + 1); + sscanf(reply, "%s", firstword); + + free(reply); + + for (int i = 0; i < (int)strlen(firstword); ++i) + firstword[i] = tolower(firstword[i]); + + int yes = strncmp("yes", firstword, sizeof("yes") - 1); + int y = strncmp("y", firstword, sizeof("y") - 1); + int no = strncmp("no", firstword, sizeof("no") - 1); + int n = strncmp("n", firstword, sizeof("n") - 1); + + free(firstword); + + if (yes == 0 || + y == 0) { + outcome = true; + break; + } else if (no == 0 || + n == 0) { + outcome = false; + break; + } else + rspeak(PLEASE_ANSWER); + } + return (outcome); +} + + +bool yes(const char* question, const char* yes_response, const char* no_response) +/* Print message X, wait for yes/no answer. If yes, print Y and return true; + * if no, print Z and return false. */ +{ + bool outcome = false; + for (;;) { + speak(question); -#define SAVARR(ARR,N) fSAVARR(ARR,N) -#undef SAVWRD -#define WORD (*wORD) -void fSAVWRD(long OP, long *wORD) { -static long BUF[250], CKSUM = 0, H1, HASH = 0, N = 0, STATE = 0; - -/* If OP<0, start writing a file, using word to initialise encryption; save - * word in the file. If OP>0, start reading a file; read the file to find - * the value with which to decrypt the rest. In either case, if a file is - * already open, finish writing/reading it and don't start a new one. If OP=0, - * read/write a single word. Words are buffered in case that makes for more - * efficient disk use. We also compute a simple checksum to catch elementary - * poking within the saved file. When we finish reading/writing the file, - * we store zero into WORD if there's no checksum error, else nonzero. */ - - - if(OP != 0){long ifvar; ifvar=(STATE); switch (ifvar<0? -1 : ifvar>0? 1 : - 0) { case -1: goto L30; case 0: goto L10; case 1: goto L30; }} - if(STATE == 0)return; - if(N == 250)SAVEIO(1,STATE > 0,BUF); - N=MOD(N,250)+1; - H1=MOD(HASH*1093L+221573L,1048576L); - HASH=MOD(H1*1093L+221573L,1048576L); - H1=MOD(H1,1234)*765432+MOD(HASH,123); - N--; - if(STATE > 0)WORD=BUF[N]+H1; - BUF[N]=WORD-H1; - N++; - CKSUM=MOD(CKSUM*13+WORD,1000000000L); - return; - -L10: STATE=OP; - SAVEIO(0,STATE > 0,BUF); - N=1; - if(STATE > 0) goto L15; - HASH=MOD(WORD,1048576L); - BUF[0]=1234L*5678L-HASH; -L13: CKSUM=BUF[0]; - return; - -L15: SAVEIO(1,true,BUF); - HASH=MOD(1234L*5678L-BUF[0],1048576L); - goto L13; - -L30: if(N == 250)SAVEIO(1,STATE > 0,BUF); - N=MOD(N,250)+1; - if(STATE > 0) goto L32; - N--; BUF[N]=CKSUM; N++; - SAVEIO(1,false,BUF); -L32: N--; WORD=BUF[N]-CKSUM; N++; - SAVEIO(-1,STATE > 0,BUF); - STATE=0; - return; -} - + char* reply = get_input(); + if (reply == NULL) { + // LCOV_EXCL_START + // Should be unreachable. Reply should never be NULL + free(reply); + exit(EXIT_SUCCESS); + // LCOV_EXCL_STOP + } + if (strlen(reply) == 0) { + free(reply); + rspeak(PLEASE_ANSWER); + continue; + } + char* firstword = (char*) xmalloc(strlen(reply) + 1); + sscanf(reply, "%s", firstword); + free(reply); -/* Data struc. routines (VOCAB, DSTROY, JUGGLE, MOVE, PUT, CARRY, DROP, ATDWRF) - */ + for (int i = 0; i < (int)strlen(firstword); ++i) + firstword[i] = tolower(firstword[i]); -#undef WORD -#define SAVWRD(OP,WORD) fSAVWRD(OP,&WORD) -#undef VOCAB -long fVOCAB(long ID, long INIT) { -long HASH, I, VOCAB; + int yes = strncmp("yes", firstword, sizeof("yes") - 1); + int y = strncmp("y", firstword, sizeof("y") - 1); + int no = strncmp("no", firstword, sizeof("no") - 1); + int n = strncmp("n", firstword, sizeof("n") - 1); -/* 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 - * up a keyword variable, and not finding it constitutes a bug. It also means - * that only KTAB values which taken over 1000 equal INIT may be considered. - * (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. */ + free(firstword); - 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; -L1: /*etc*/ ; - } /* end loop */ - BUG(21); + if (yes == 0 || + y == 0) { + speak(yes_response); + outcome = true; + break; + } else if (no == 0 || + n == 0) { + speak(no_response); + outcome = false; + break; + } else + rspeak(PLEASE_ANSWER); -L2: VOCAB= -1; - if(INIT < 0)return(VOCAB); - BUG(5); + } -L3: VOCAB=KTAB[I]; - if(INIT >= 0)VOCAB=MOD(VOCAB,1000); - return(VOCAB); + return (outcome); } +/* Data structure routines */ - -#define VOCAB(ID,INIT) fVOCAB(ID,INIT) -#undef DSTROY -void fDSTROY(long OBJECT) { -; - -/* Permanently eliminate "OBJECT" by moving to a non-existent location. */ - - - MOVE(OBJECT,0); - return; +int get_motion_vocab_id(const char* word) +// Return the first motion number that has 'word' as one of its words. +{ + for (int i = 0; i < NMOTIONS; ++i) { + for (int j = 0; j < motions[i].words.n; ++j) { + if (strcasecmp(word, motions[i].words.strs[j]) == 0 && (strlen(word) > 1 || + strchr(ignore, word[0]) == NULL || + !settings.oldstyle)) + return (i); + } + } + // If execution reaches here, we didn't find the word. + return (WORD_NOT_FOUND); +} + +int get_object_vocab_id(const char* word) +// Return the first object number that has 'word' as one of its words. +{ + for (int i = 0; i < NOBJECTS + 1; ++i) { // FIXME: the + 1 should go when 1-indexing for objects is removed + for (int j = 0; j < objects[i].words.n; ++j) { + if (strcasecmp(word, objects[i].words.strs[j]) == 0) + return (i); + } + } + // If execution reaches here, we didn't find the word. + return (WORD_NOT_FOUND); +} + +int get_action_vocab_id(const char* word) +// Return the first motion number that has 'word' as one of its words. +{ + for (int i = 0; i < NACTIONS; ++i) { + for (int j = 0; j < actions[i].words.n; ++j) { + if (strcasecmp(word, actions[i].words.strs[j]) == 0 && (strlen(word) > 1 || + strchr(ignore, word[0]) == NULL || + !settings.oldstyle)) + return (i); + } + } + // If execution reaches here, we didn't find the word. + return (WORD_NOT_FOUND); +} + +int get_special_vocab_id(const char* word) +// Return the first special number that has 'word' as one of its words. +{ + for (int i = 0; i < NSPECIALS; ++i) { + for (int j = 0; j < specials[i].words.n; ++j) { + if (strcasecmp(word, specials[i].words.strs[j]) == 0) + return (i); + } + } + // If execution reaches here, we didn't find the word. + return (WORD_NOT_FOUND); } - - -#define DSTROY(OBJECT) fDSTROY(OBJECT) -#undef JUGGLE -void fJUGGLE(long OBJECT) { -long I, J; - +void get_vocab_metadata(const char* word, long* id, enum wordtype* type) +{ + /* Check for an empty string */ + if (strncmp(word, "", sizeof("")) == 0) { + *id = WORD_EMPTY; + *type = NO_WORD_TYPE; + return; + } + + long ref_num; + + ref_num = get_motion_vocab_id(word); + if (ref_num != WORD_NOT_FOUND) { + *id = ref_num; + *type = MOTION; + return; + } + + ref_num = get_object_vocab_id(word); + if (ref_num != WORD_NOT_FOUND) { + *id = ref_num; + *type = OBJECT; + return; + } + + ref_num = get_action_vocab_id(word); + if (ref_num != WORD_NOT_FOUND) { + *id = ref_num; + *type = ACTION; + return; + } + + ref_num = get_special_vocab_id(word); + if (ref_num != WORD_NOT_FOUND) { + *id = ref_num; + *type = SPECIAL; + return; + } + + // Check for the reservoir magic word. + if (strcasecmp(word, game.zzword) == 0) { + *id = PART; + *type = ACTION; + return; + } + + *id = WORD_NOT_FOUND; + *type = NO_WORD_TYPE; + return; +} + +void juggle(obj_t object) /* Juggle an object by picking it up and putting it down again, the purpose * being to get the object to the front of the chain of things at its loc. */ +{ + loc_t i, j; - - I=PLACE[OBJECT]; - J=FIXED[OBJECT]; - MOVE(OBJECT,I); - MOVE(OBJECT+100,J); - return; + i = game.place[object]; + j = game.fixed[object]; + move(object, i); + move(object + NOBJECTS, j); } +void move(obj_t object, loc_t where) +/* Place any object anywhere by picking it up and dropping it. May + * already be toting, in which case the carry is a no-op. Mustn't + * pick up objects which are not at any loc, since carry wants to + * remove objects from game.atloc chains. */ +{ + long from; - -#define JUGGLE(OBJECT) fJUGGLE(OBJECT) -#undef MOVE -void fMOVE(long OBJECT, long WHERE) { -long FROM; - -/* Place any object anywhere by picking it up and dropping it. May already be - * toting, in which case the carry is a no-op. Mustn't pick up objects which - * are not at any loc, since carry wants to remove objects from ATLOC chains. */ - - - if(OBJECT > 100) goto L1; - FROM=PLACE[OBJECT]; - goto L2; -L1: {long x = OBJECT-100; FROM=FIXED[x];} -L2: if(FROM > 0 && FROM <= 300)CARRY(OBJECT,FROM); - DROP(OBJECT,WHERE); - return; + if (object > NOBJECTS) + from = game.fixed[object - NOBJECTS]; + else + from = game.place[object]; + /* (ESR) Used to check for !SPECIAL(from). I *think* that was wrong... */ + if (from != LOC_NOWHERE && from != CARRIED) + carry(object, from); + drop(object, where); } - - -#define MOVE(OBJECT,WHERE) fMOVE(OBJECT,WHERE) -#undef PUT -long fPUT(long OBJECT, long WHERE, long PVAL) { -long PUT; - -/* PUT is the same as MOVE, except it returns a value used to set up the - * negated PROP values for the repository objects. */ - - - MOVE(OBJECT,WHERE); - PUT=(-1)-PVAL; - return(PUT); +long put(obj_t object, loc_t where, long pval) +/* put() is the same as move(), except it returns a value used to set up the + * negated game.prop values for the repository objects. */ +{ + move(object, where); + return STASHED(pval); } - - -#define PUT(OBJECT,WHERE,PVAL) fPUT(OBJECT,WHERE,PVAL) -#undef CARRY -void fCARRY(long OBJECT, long WHERE) { -long TEMP; - +void carry(obj_t object, loc_t where) /* Start toting an object, removing it from the list of things at its former - * location. Incr holdng unless it was already being toted. If OBJECT>100 - * (moving "fixed" second loc), don't change PLACE or HOLDNG. */ - - - if(OBJECT > 100) goto L5; - if(PLACE[OBJECT] == -1)return; - PLACE[OBJECT]= -1; - HOLDNG=HOLDNG+1; -L5: if(ATLOC[WHERE] != OBJECT) goto L6; - ATLOC[WHERE]=LINK[OBJECT]; - return; -L6: TEMP=ATLOC[WHERE]; -L7: if(LINK[TEMP] == OBJECT) goto L8; - TEMP=LINK[TEMP]; - goto L7; -L8: LINK[TEMP]=LINK[OBJECT]; - return; -} - - - -#define CARRY(OBJECT,WHERE) fCARRY(OBJECT,WHERE) -#undef DROP -void fDROP(long OBJECT, long WHERE) { -; - -/* Place an object at a given loc, prefixing it onto the ATLOC list. Decr - * HOLDNG if the object was being toted. */ - - - if(OBJECT > 100) goto L1; - if(PLACE[OBJECT] == -1)HOLDNG=HOLDNG-1; - PLACE[OBJECT]=WHERE; - goto L2; -L1: {long x = OBJECT-100; FIXED[x]=WHERE;} -L2: if(WHERE <= 0)return; - LINK[OBJECT]=ATLOC[WHERE]; - ATLOC[WHERE]=OBJECT; - return; -} - - - -#define DROP(OBJECT,WHERE) fDROP(OBJECT,WHERE) -#undef ATDWRF -long fATDWRF(long WHERE) { -long ATDWRF, I; - + * location. Incr holdng unless it was already being toted. If object>NOBJECTS + * (moving "fixed" second loc), don't change game.place or game.holdng. */ +{ + long temp; + + if (object <= NOBJECTS) { + if (game.place[object] == CARRIED) + return; + game.place[object] = CARRIED; + ++game.holdng; + } + if (game.atloc[where] == object) { + game.atloc[where] = game.link[object]; + return; + } + temp = game.atloc[where]; + while (game.link[temp] != object) { + temp = game.link[temp]; + } + game.link[temp] = game.link[object]; +} + +void drop(obj_t object, loc_t where) +/* Place an object at a given loc, prefixing it onto the game.atloc list. Decr + * game.holdng if the object was being toted. */ +{ + if (object > NOBJECTS) + game.fixed[object - NOBJECTS] = where; + else { + if (game.place[object] == CARRIED) + --game.holdng; + game.place[object] = where; + } + if (where == LOC_NOWHERE || + where == CARRIED) + return; + game.link[object] = game.atloc[where]; + game.atloc[where] = object; +} + +long atdwrf(loc_t where) /* Return the index of first dwarf at the given location, zero if no dwarf is * there (or if dwarves not active yet), -1 if all dwarves are dead. Ignore * the pirate (6th dwarf). */ +{ + long at; - - ATDWRF=0; - if(DFLAG < 2)return(ATDWRF); - ATDWRF= -1; - for (I=1; I<=5; I++) { - if(DLOC[I] == WHERE) goto L2; - if(DLOC[I] != 0)ATDWRF=0; - } /* end loop */ - return(ATDWRF); - -L2: ATDWRF=I; - return(ATDWRF); + at = 0; + if (game.dflag < 2) + return (at); + at = -1; + for (long i = 1; i <= NDWARVES - 1; i++) { + if (game.dloc[i] == where) + return i; + if (game.dloc[i] != 0) + at = 0; + } + return (at); } +/* Utility routines (setbit, tstbit, set_seed, get_next_lcg_value, + * randrange) */ - - -#define ATDWRF(WHERE) fATDWRF(WHERE) - - - -/* Utility routines (SETBIT, TSTBIT, set_seed_from_time, get_next_lcg_value, randrange, RNDVOC, BUG) */ - -#undef SETBIT -long fSETBIT(long BIT) { -long I, SETBIT; - +long setbit(long bit) /* Returns 2**bit for use in constructing bit-masks. */ - - - SETBIT=1; - if(BIT <= 0)return(SETBIT); - for (I=1; I<=BIT; I++) { - SETBIT=SETBIT+SETBIT; - } /* end loop */ - return(SETBIT); +{ + return (1L << bit); } - - -#define SETBIT(BIT) fSETBIT(BIT) -#undef TSTBIT -long fTSTBIT(long MASK, long BIT) { -long TSTBIT; - +bool tstbit(long mask, int bit) /* Returns true if the specified bit is set in the mask. */ - - - TSTBIT=MOD(MASK/SETBIT(BIT),2) != 0; - return(TSTBIT); +{ + return (mask & (1 << bit)) != 0; } - - -#define TSTBIT(MASK,BIT) fTSTBIT(MASK,BIT) - -void set_seed_from_time(void) +void set_seed(long seedval) +/* Set the LCG seed */ { - /* Use the current system time to get seed the ISO rand() function, from which we get a seed for the LCG. */ - srand(time(NULL)); - lcgstate.x = (unsigned long) rand() % lcgstate.m; + game.lcg_x = (unsigned long) seedval % game.lcg_m; + + // once seed is set, we need to generate the Z`ZZZ word + make_zzword(game.zzword); } unsigned long get_next_lcg_value(void) +/* Return the LCG's current value, and then iterate it. */ { - /* 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); + unsigned long old_x = game.lcg_x; + game.lcg_x = (game.lcg_a * game.lcg_x + game.lcg_c) % game.lcg_m; + return old_x; } long randrange(long range) +/* Return a random integer from [0, range). */ { - /* Return a random integer from [0, range). */ - long result = range * get_next_lcg_value() / lcgstate.m; - return(result); -} - -#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. */ - - - RNDVOC=FORCE; - if(RNDVOC != 0) goto L3; - for (I=1; I<=5; I++) { - J=11+randrange(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; - return(RNDVOC); -} - - - -#define RNDVOC(CHAR,FORCE) fRNDVOC(CHAR,FORCE) -#undef BUG -void fBUG(long NUM) { - -/* The following conditions are currently considered fatal bugs. Numbers < 20 - * are detected while reading the database; the others occur at "run time". - * 0 Message line > 70 characters - * 1 Null line in message - * 2 Too many words of messages - * 3 Too many travel options - * 4 Too many vocabulary words - * 5 Required vocabulary word not found - * 6 Too many RTEXT messages - * 7 Too many hints - * 8 Location has cond bit being set twice - * 9 Invalid section number in database - * 10 Too many locations - * 11 Too many class or turn messages - * 20 Special travel (500>L>300) exceeds goto list - * 21 Ran off end of vocabulary table - * 22 Vocabulary type (N/1000) not between 0 and 3 - * 23 Intransitive action verb exceeds goto list - * 24 Transitive action verb exceeds goto list - * 25 Conditional travel entry with no alternative - * 26 Location has no travel entries - * 27 Hint number exceeds goto list - * 28 Invalid month returned by date function - * 29 Too many parameters given to SETPRM */ - - printf("Fatal error %ld. See source code for interpretation.\n", - NUM); - exit(0); -} - - - - - -/* Machine dependent routines (MAPLIN, TYPE, MPINIT, SAVEIO) */ - -#define BUG(NUM) fBUG(NUM) -#undef MAPLIN -void fMAPLIN(FILE *OPENED) { -long I, VAL; - -/* Read a line of input, from the specified input source, - * translate the chars to integers in the range 0-126 and store - * them in the common array "INLINE". Integer values are as follows: - * 0 = space [ASCII CODE 40 octal, 32 decimal] - * 1-2 = !" [ASCII 41-42 octal, 33-34 decimal] - * 3-10 = '()*+,-. [ASCII 47-56 octal, 39-46 decimal] - * 11-36 = upper-case letters - * 37-62 = lower-case letters - * 63 = percent (%) [ASCII 45 octal, 37 decimal] - * 64-73 = digits, 0 through 9 - * Remaining characters can be translated any way that is convenient; - * The "TYPE" routine below is used to map them back to characters when - * necessary. The above mappings are required so that certain special - * characters are known to fit in 6 bits and/or can be easily spotted. - * Array elements beyond the end of the line should be filled with 0, - * and LNLENG should be set to the index of the last character. - * - * If the data file uses a character other than space (e.g., tab) to - * separate numbers, that character should also translate to 0. - * - * This procedure may use the map1,map2 arrays to maintain static data for - * the mapping. MAP2(1) is set to 0 when the program starts - * and is not changed thereafter unless the routines on this page choose - * to do so. */ - - if(MAP2[1] == 0)MPINIT(); - - if (!oldstyle && SETUP) - fputs("> ", stdout); - IGNORE(fgets(INLINE+1,sizeof(INLINE)-1,OPENED)); - if (feof(OPENED)) { - if (logfp) - fclose(logfp); - } else { - if (logfp) - IGNORE(fputs(INLINE+1, logfp)); - else if (!isatty(0)) - IGNORE(fputs(INLINE+1, stdout)); - LNLENG=0; - for (I=1; I<=sizeof(INLINE) && INLINE[I]!=0; I++) { - VAL=INLINE[I]+1; - INLINE[I]=MAP1[VAL]; - if(INLINE[I] != 0)LNLENG=I; - } /* end loop */ - LNPOSN=1; - } -} -#define MAPLIN(FIL) fMAPLIN(FIL) - -#undef TYPE -void fTYPE(void) { -long I, VAL; - -/* Type the first "LNLENG" characters stored in inline, mapping them - * from integers to text per the rules described above. INLINE(I), - * I=1,LNLENG may be changed by this routine. */ - - - if(LNLENG != 0) goto L10; - printf("\n"); - return; - -L10: if(MAP2[1] == 0)MPINIT(); - for (I=1; I<=LNLENG; I++) { - VAL=INLINE[I]; - {long x = VAL+1; INLINE[I]=MAP2[x];} - } /* end loop */ - {long x = LNLENG+1; INLINE[x]=0;} - printf("%s\n",INLINE+1); - return; -} - - - -#define TYPE() fTYPE() -#undef MPINIT -void fMPINIT(void) { -long FIRST, I, J, LAST, VAL; -static long RUNS[7][2] = {32,34, 39,46, 65,90, 97,122, 37,37, 48,57, 0,126}; - - - for (I=1; I<=128; I++) { - MAP1[I]= -1; - } /* end loop */ - VAL=0; - for (I=0; I<7; I++) { - FIRST=RUNS[I][0]; - LAST=RUNS[I][1]; - /* 22 */ for (J=FIRST; J<=LAST; J++) { - J++; if(MAP1[J] >= 0) goto L22; - MAP1[J]=VAL; - VAL=VAL+1; -L22: J--; - } /* end loop */ - /*etc*/ ; - } /* end loop */ - MAP1[128]=MAP1[10]; -/* For this version, tab (9) maps to space (32), so del (127) uses tab's value */ - MAP1[10]=MAP1[33]; - MAP1[11]=MAP1[33]; - - for (I=0; I<=126; I++) { - I++; VAL=MAP1[I]+1; I--; - MAP2[VAL]=I*('B'-'A'); - if(I >= 64)MAP2[VAL]=(I-64)*('B'-'A')+'@'; - } /* end loop */ - - return; -} - - - -#define MPINIT() fMPINIT() -#undef SAVEIO -void fSAVEIO(long OP, long IN, long ARR[]) { -static FILE *F; char NAME[50]; - -/* If OP=0, ask for a file name and open a file. (If IN=true, the file is for - * input, else output.) If OP>0, read/write ARR from/into the previously-opened - * file. (ARR is a 250-integer array.) If OP<0, finish reading/writing the - * file. (Finishing writing can be a no-op if a "stop" statement does it - * automatically. Finishing reading can be a no-op as long as a subsequent - * SAVEIO(0,false,X) will still work.) If you can catch errors (e.g., no such - * file) and try again, great. DEC F40 can't. */ - - - {long ifvar; ifvar=(OP); switch (ifvar<0? -1 : ifvar>0? 1 : 0) { case -1: - goto L10; case 0: goto L20; case 1: goto L30; }} - -L10: fclose(F); - return; - -L20: printf("\nFile name: "); - IGNORE(fgets(NAME, sizeof(NAME), stdin)); - F=fopen(NAME,(IN ? READ_MODE : WRITE_MODE)); - if(F == NULL) {printf("Can't open file, try again.\n"); goto L20;} - return; + return range * get_next_lcg_value() / game.lcg_m; +} -L30: if(IN)IGNORE(fread(ARR,sizeof(long),250,F)); - if(!IN)fwrite(ARR,sizeof(long),250,F); - return; +void make_zzword(char zzword[TOKLEN + 1]) +{ + for (int i = 0; i < 5; ++i) { + zzword[i] = 'A' + randrange(26); + } + zzword[1] = '\''; // force second char to apostrophe + zzword[5] = '\0'; +} +// LCOV_EXCL_START +void bug(enum bugtype num, const char *error_string) +{ + fprintf(stderr, "Fatal error %d, %s.\n", num, error_string); + exit(EXIT_FAILURE); } +// LCOV_EXCL_STOP +/* end */ +void state_change(obj_t obj, long state) +/* Object must have a change-message list for this to be useful; only some do */ +{ + game.prop[obj] = state; + pspeak(obj, change, state, true); +} -long fIABS(N)long N; {return(N<0? -N : N);} -long fMOD(N,M)long N, M; {return(N%M);} +/* end */