X-Git-Url: https://jxself.org/git/?p=open-adventure.git;a=blobdiff_plain;f=misc.c;h=dbf4abb8f0dee6f63be8cec42cdc78e4d06a2fcd;hp=0126d692d2a02f9c80691356a30075c6e96d7cf4;hb=83fb64b5a817de3f1023c79ab2319d01d9dce9ae;hpb=fd10d380df6804dca3b19ea68dc32df2de6090bd diff --git a/misc.c b/misc.c index 0126d69..dbf4abb 100644 --- a/misc.c +++ b/misc.c @@ -2,854 +2,762 @@ #include #include #include +#include #include -#include "advent.h" -#include "funcs.h" -#include "database.h" - -/* hack to ignore GCC Unused Result */ -#define IGNORE(r) do{if(r){}}while(0) - -/* I/O routines (SPEAK, PSPEAK, RSPEAK, SETPRM, GETIN, YES) */ - -void SPEAK(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=labs(LINES[K])-1; - K=K+1; - LNLENG=0; - LNPOSN=1; - STATE=0; - for (I=K; I<=L; I++) { - PUTTXT(LINES[I],STATE,2); - } /* 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=labs(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); - 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); - {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; - goto L32; - -L40: if(BLANK)TYPE0(); - BLANK=false; - TYPE(); - K=L+1; - if(LINES[K] >= 0) goto L10; - return; -} - -void PSPEAK(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=labs(LINES[M]); - if(LINES[M] >= 0) goto L1; - /*etc*/ ; - } /* end loop */ -L9: SPEAK(M); - return; -} - -void RSPEAK(long I) { - -/* Print the I-TH "random" message (section 6 of database). */ - - - if(I != 0)SPEAK(RTEXT[I]); - return; -} - - -void SETPRM(long FIRST, long P1, long P2) { -; - -/* Stores parameters into the PRMCOM parms array for use by speak. P1 and P2 - * are stored into PARMS(FIRST) and PARMS(FIRST+1). */ - - - if(FIRST >= 25)BUG(29); - PARMS[FIRST]=P1; - {long x = FIRST+1; PARMS[x]=P2;} - return; -} - - -#undef GETIN -#define WORD1 (*wORD1) -#define WORD1X (*wORD1X) -#define WORD2 (*wORD2) -#define WORD2X (*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 - * 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 (feof(input)) - return false; - WORD1=GETTXT(true,true,true); - if(BLKLIN && WORD1 < 0) goto L10; - WORD1X=GETTXT(false,true,true); -L12: JUNK=GETTXT(false,true,true); - if(JUNK > 0) goto L12; - 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)return true; - 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) - -long YES(FILE *input, long X, long Y, long Z) { -long YEAH, REPLY, JUNK1, JUNK2, JUNK3; +#include -/* Print message X, wait for yes/no answer. If yes, print Y and return true; - * if no, print Z and return false. */ +#include "advent.h" +#include "linenoise/linenoise.h" +#include "newdb.h" -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: YEAH=true; - RSPEAK(Y); - return(YEAH); -L20: YEAH=false; - RSPEAK(Z); - return(YEAH); -} - - -/* Line-parsing routines (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. */ - -long GETTXT(long SKIP,long ONEWRD, long UPPER) { -/* 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. 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 TEXT is called, we return -1. */ - - long TEXT; - static long SPLITTING = -1; - - if(LNPOSN != SPLITTING) - SPLITTING = -1; - TEXT= -1; - while (true) { - if(LNPOSN > LNLENG) - return(TEXT); - if((!SKIP) || INLINE[LNPOSN] != 0) - break; - LNPOSN=LNPOSN+1; +char* xstrdup(const char* s) +{ + char* ptr = strdup(s); + 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); } + return(ptr); +} - TEXT=0; - for (int I=1; I<=5; I++) { - TEXT=TEXT*64; - if(LNPOSN > LNLENG || (ONEWRD && INLINE[LNPOSN] == 0)) - continue; - char current=INLINE[LNPOSN]; - if(current < 63) { - SPLITTING = -1; - if(UPPER && current >= 37) - current=current-26; - TEXT=TEXT+current; - LNPOSN=LNPOSN+1; - continue; +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 } - if(SPLITTING != LNPOSN) { - TEXT=TEXT+63; - SPLITTING = LNPOSN; - continue; + return (ptr); +} + +void packed_to_token(long packed, char token[6]) +{ + // Unpack and map back to ASCII. + for (int i = 0; i < 5; ++i) { + char advent = (packed >> i * 6) & 63; + token[i] = new_advent_to_ascii[(int) advent]; } - TEXT=TEXT+current-63; - SPLITTING = -1; - LNPOSN=LNPOSN+1; - } + // Ensure the last character is \0. + token[5] = '\0'; - return(TEXT); + // Replace trailing whitespace with \0. + for (int i = 4; i >= 0; --i) { + if (token[i] == ' ' || token[i] == '\t') + token[i] = '\0'; + else + break; + } } -long MAKEWD(long LETTRS) { -long I, L, WORD; +long token_to_packed(const char token[6]) +{ + size_t t_len = strlen(token); + long packed = 0; + for (size_t i = 0; i < t_len; ++i) + { + char mapped = new_ascii_to_advent[(int) token[i]]; + packed |= (mapped << (6 * i)); + } + return(packed); +} -/* 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. 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. */ +void tokenize(char* raw, long tokens[4]) +{ + // set each token to 0 + for (int i = 0; i < 4; ++i) + tokens[i] = 0; + + // grab the first two words + char* words[2]; + words[0] = (char*) xmalloc(strlen(raw)); + words[1] = (char*) xmalloc(strlen(raw)); + int word_count = sscanf(raw, "%s%s", words[0], words[1]); + + // make space for substrings and zero it out + char chunk_data[][6] = { + {"\0\0\0\0\0"}, + {"\0\0\0\0\0"}, + {"\0\0\0\0\0"}, + {"\0\0\0\0\0"}, + }; + + // break the words into up to 4 5-char substrings + sscanf(words[0], "%5s%5s", chunk_data[0], chunk_data[1]); + if (word_count == 2) + sscanf(words[1], "%5s%5s", chunk_data[2], chunk_data[3]); + free(words[0]); + free(words[1]); + + // uppercase all the substrings + for (int i = 0; i < 4; ++i) + for (unsigned int j = 0; j < strlen(chunk_data[i]); ++j) + chunk_data[i][j] = (char) toupper(chunk_data[i][j]); + + // pack the substrings + for (int i = 0; i < 4; ++i) + tokens[i] = token_to_packed(chunk_data[i]); +} + +/* Hide the fact that wods are corrently packed longs */ + +bool wordeq(token_t a, token_t b) +{ + return a == b; +} +bool wordempty(token_t a) +{ + return a == 0; +} - WORD=0; - I=1; - L=LETTRS; -L10: WORD=WORD+I*(MOD(L,50)+10); - I=I*64; - if(MOD(L,100) > 50)WORD=WORD+I*5; - L=L/100; - if(L != 0) goto L10; - I=64L*64L*64L*64L*64L/I; - WORD=WORD*I; - return(WORD); +void wordclear(token_t *v) +{ + *v = 0; } +/* I/O routines (speak, pspeak, rspeak, GETIN, YES) */ + +void vspeak(const char* msg, 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; + + // Print a newline if the global game.blklin says to. + if (game.blklin == 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] != '%') { + *renderp++ = msg[i]; + size--; + } else { + long arg = va_arg(ap, long); + if (arg == -1) + arg = 0; + 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--; + } + } + + // All-lowercase specifier. + if (msg[i] == 'L' || msg[i] == 'C') { + packed_to_token(arg, renderp); /* unpack directly to destination */ + int len = strlen(renderp); + for (int j = 0; j < len; ++j) { + renderp[j] = tolower(renderp[j]); + } + if (msg[i] == 'C') // First char uppercase, rest lowercase. + renderp[0] = toupper(renderp[0]); + renderp += len; + size -= len; + } + + previous_arg = arg; + } + } + *renderp = 0; -#define STATE (*sTATE) -void fPUTTXT(long WORD, long *sTATE, long CASE) { -long ALPH1, ALPH2, BYTE, DIV, I, W; + // Print the message. + printf("%s\n", rendered); -/* 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. 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). */ + free(rendered); +} +void speak(const char* msg, ...) +{ + va_list ap; + va_start(ap, msg); + vspeak(msg, ap); + va_end(ap); +} + +void pspeak(vocab_t msg, enum speaktype mode, int skip, ...) +/* 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, skip); + switch (mode) { + case touch: + vspeak(objects[msg].inventory, ap); + break; + case look: + vspeak(objects[msg].descriptions[skip], ap); + break; + case hear: + vspeak(objects[msg].sounds[skip], ap); + break; + case study: + vspeak(objects[msg].texts[skip], ap); + break; + case change: + vspeak(objects[msg].changes[skip], ap); + break; + } + va_end(ap); +} - ALPH1=13*CASE+24; - ALPH2=26*labs(CASE)+ALPH1; - if(labs(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; - /* 18 */ for (I=1; I<=5; I++) { - if(W <= 0 && STATE == 0 && labs(CASE) <= 1)return; - BYTE=W/DIV; - if(STATE != 0 || BYTE != 63) goto L12; - STATE=63; - goto L18; +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], ap); + va_end(ap); +} -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 echo_input(FILE* destination, char* input_prompt, 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); } -#undef STATE -#define PUTTXT(WORD,STATE,CASE) fPUTTXT(WORD,&STATE,CASE) - -void SHFTXT(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 TYPE0() { -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; +int word_count(char* s) +{ + char* copy = xstrdup(s); + char delims[] = " \t"; + int count = 0; + char* word; + + word = strtok(copy, delims); + while(word != NULL) + { + word = strtok(NULL, delims); + ++count; + } + free(copy); + return(count); } -/* Suspend/resume I/O routines (SAVWDS, SAVARR, SAVWRD) */ +char* get_input() +{ + // Set up the prompt + char input_prompt[] = "> "; + if (!prompt) + input_prompt[0] = '\0'; + + // Print a blank line if game.blklin tells us to. + if (game.blklin == true) + printf("\n"); + + char* input; + while (true) { + if (editline) + input = linenoise(input_prompt); + else { + input = NULL; + size_t n = 0; + if (isatty(0)) + // LCOV_EXCL_START + // Should be unreachable in tests, as they will use a non-interactive shell. + printf("%s", input_prompt); + // LCOV_EXCL_STOP + ssize_t numread = getline(&input, &n, stdin); + if (numread == -1) // Got EOF; return with it. + return(NULL); + } + + if (input == NULL) // Got EOF; return with it. + return(input); + else if (input[0] == '#') // Ignore comments. + continue; + else // We have a 'normal' line; leave the loop. + break; + } -#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. */ - - SAVWRD(0,(*W1)); - SAVWRD(0,(*W2)); - SAVWRD(0,(*W3)); - SAVWRD(0,(*W4)); - SAVWRD(0,(*W5)); - SAVWRD(0,(*W6)); - SAVWRD(0,(*W7)); - return; -} - - -#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; - -/* Write or read an array of N words. See SAVWRD. */ + // Strip trailing newlines from the input + input[strcspn(input, "\n")] = 0; + linenoiseHistoryAdd(input); - for (I=1; I<=N; I++) { - SAVWRD(0,ARR[I]); - } /* end loop */ - return; -} + if (!isatty(0)) + echo_input(stdout, input_prompt, input); + if (logfp) + echo_input(logfp, input_prompt, input); + return (input); +} -#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; +bool silent_yes() +{ + char* reply; + bool outcome; + + for (;;) { + reply = get_input(); + if (reply == NULL) { + // LCOV_EXCL_START + // Should be unreachable. Reply should never be NULL + linenoiseFree(reply); + exit(EXIT_SUCCESS); + // LCOV_EXCL_STOP + } -/* 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. */ + char* firstword = (char*) xmalloc(strlen(reply)+1); + sscanf(reply, "%s", firstword); - 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; + for (int i = 0; i < (int)strlen(firstword); ++i) + firstword[i] = tolower(firstword[i]); -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; + 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); -L15: SAVEIO(1,true,BUF); - HASH=MOD(1234L*5678L-BUF[0],1048576L); - goto L13; + free(firstword); -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; + if (yes == 0 || y == 0) { + outcome = true; + break; + } else if (no == 0 || n == 0) { + outcome = false; + break; + } else + rspeak(PLEASE_ANSWER); + } + linenoiseFree(reply); + 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. */ +{ + char* reply; + bool outcome; + + for (;;) { + speak(question); + + reply = get_input(); + if (reply == NULL) { + // LCOV_EXCL_START + // Should be unreachable. Reply should never be NULL + linenoiseFree(reply); + exit(EXIT_SUCCESS); + // LCOV_EXCL_STOP + } + + char* firstword = (char*) xmalloc(strlen(reply)+1); + sscanf(reply, "%s", firstword); + + 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) { + speak(yes_response); + outcome = true; + break; + } else if (no == 0 || n == 0) { + speak(no_response); + outcome = false; + break; + } else + rspeak(PLEASE_ANSWER); + } + linenoiseFree(reply); + return (outcome); +} +/* Data structure routines */ +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) + return(i); + } + } + // If execution reaches here, we didn't find the word. + return(WORD_NOT_FOUND); +} -/* Data struc. routines (VOCAB, DSTROY, JUGGLE, MOVE, PUT, CARRY, DROP, ATDWRF) - */ +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); +} -#undef WORD -#define SAVWRD(OP,WORD) fSAVWRD(OP,&WORD) +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) + return(i); + } + } + // If execution reaches here, we didn't find the word. + return(WORD_NOT_FOUND); +} -long VOCAB(long ID, long INIT) { -long I, LEXEME; +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); +} -/* 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. */ +long get_vocab_id(const char* word) +// Search the vocab categories in order for the supplied word. +{ + long ref_num; + + ref_num = get_motion_vocab_id(word); + if (ref_num != WORD_NOT_FOUND) + return(ref_num + 0); // FIXME: replace with a proper hash - /* 1 */ for (I=1; I<=TABSIZ; I++) { - if(KTAB[I] == -1) goto L2; - if(INIT >= 0 && KTAB[I]/1000 != INIT) goto L1; - if(ATAB[I] == ID) goto L3; -L1: /*etc*/ ; - } /* end loop */ - BUG(21); + ref_num = get_object_vocab_id(word); + if (ref_num != WORD_NOT_FOUND) + return(ref_num + 1000); // FIXME: replace with a proper hash -L2: LEXEME= -1; - if(INIT < 0)return(LEXEME); - BUG(5); + ref_num = get_action_vocab_id(word); + if (ref_num != WORD_NOT_FOUND) + return(ref_num + 2000); // FIXME: replace with a proper hash -L3: LEXEME=KTAB[I]; - if(INIT >= 0)LEXEME=MOD(LEXEME,1000); - return(LEXEME); -} + ref_num = get_special_vocab_id(word); + if (ref_num != WORD_NOT_FOUND) + return(ref_num + 3000); // FIXME: replace with a proper hash -void DSTROY(long OBJECT) { -/* Permanently eliminate "OBJECT" by moving to a non-existent location. */ + // Check for the reservoir magic word. + if (strcasecmp(word, game.zzword) == 0) + return(PART + 2000); // FIXME: replace with a proper hash - MOVE(OBJECT,0); - return; + return(WORD_NOT_FOUND); } -void JUGGLE(long OBJECT) { -long I, J; - +void juggle(long 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. */ +{ + long i, j; - I=PLACE[OBJECT]; - J=FIXED[OBJECT]; - MOVE(OBJECT,I); - MOVE(OBJECT+NOBJECTS,J); - return; + i = game.place[object]; + j = game.fixed[object]; + move(object, i); + move(object + NOBJECTS, j); } -void MOVE(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. */ - +void move(long object, long 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; - if(OBJECT > NOBJECTS) goto L1; - FROM=PLACE[OBJECT]; - goto L2; -L1: {long x = OBJECT-NOBJECTS; 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]; + if (from != LOC_NOWHERE && from != CARRIED && !SPECIAL(from)) + carry(object, from); + drop(object, where); } -long PUT(long OBJECT, long WHERE, long PVAL) { -long X; - +long put(long object, long where, long pval) /* 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); - X=(-1)-PVAL; - return(X); + * negated game.prop values for the repository objects. */ +{ + move(object, where); + return (-1) - pval;; } -void CARRY(long OBJECT, long WHERE) { -long TEMP; - +void carry(long object, long 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>NOBJECTS - * (moving "fixed" second loc), don't change PLACE or HOLDNG. */ + * 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) 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; + 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(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 > NOBJECTS) goto L1; - if(PLACE[OBJECT] == -1)HOLDNG=HOLDNG-1; - PLACE[OBJECT]=WHERE; - goto L2; -L1: {long x = OBJECT-NOBJECTS; FIXED[x]=WHERE;} -L2: if(WHERE <= 0)return; - LINK[OBJECT]=ATLOC[WHERE]; - ATLOC[WHERE]=OBJECT; - return; +void drop(long object, long 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 <= 0) + return; + game.link[object] = game.atloc[where]; + game.atloc[where] = object; } - - -long ATDWRF(long WHERE) { -long AT, I; - +long atdwrf(long 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). */ - - - AT=0; - if(DFLAG < 2)return(AT); - AT= -1; - for (I=1; I<=5; I++) { - if(DLOC[I] == WHERE) goto L2; - if(DLOC[I] != 0)AT=0; - } /* end loop */ - return(AT); - -L2: AT=I; - return(AT); +{ + long at; + + 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, RNDVOC, BUG) */ + * randrange, RNDVOC) */ -long SETBIT(long bit) { +long setbit(long bit) /* Returns 2**bit for use in constructing bit-masks. */ - return(2 << bit); +{ + return (1L << bit); } -bool TSTBIT(long mask, int bit) { +bool tstbit(long mask, int bit) /* Returns true if the specified bit is set in the mask. */ - return((mask & (1 << bit)) != 0); +{ + return (mask & (1 << bit)) != 0; } void set_seed(long seedval) +/* Set the LCG seed */ { - lcgstate.x = (unsigned long) seedval % lcgstate.m; + game.lcg_x = (unsigned long) seedval % game.lcg_m; } 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); -} - -long RNDVOC(long CHAR, long FORCE) { -/* 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 RND; - - RND=FORCE; - - if (RND == 0) { - for (int I = 1; I <= 5; I++) { - long J = 11 + randrange(26); - if (I == 2) - J = CHAR; - RND = RND * 64 + J; - } - } - - long DIV = 64L * 64L * 64L; - for (int I = 1; I <= TABSIZ; I++) { - if (MOD(ATAB[I]/DIV, 64L) == CHAR) - { - ATAB[I] = RND; - break; - } - } - - return(RND); -} - -void BUG(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) */ - -void MAPLIN(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 && OPENED == stdin) - fputs("> ", stdout); - do { - IGNORE(fgets(rawbuf,sizeof(rawbuf)-1,OPENED)); - } while - (!feof(OPENED) && rawbuf[0] == '#'); - if (feof(OPENED)) { - if (logfp && OPENED == stdin) - fclose(logfp); - } else { - if (logfp && OPENED == stdin) - IGNORE(fputs(rawbuf, logfp)); - else if (!isatty(0)) - IGNORE(fputs(rawbuf, stdout)); - strcpy(INLINE+1, rawbuf); - LNLENG=0; - for (I=1; I<=(long)sizeof(INLINE) && INLINE[I]!=0; I++) { - VAL=INLINE[I]+1; - INLINE[I]=MAP1[VAL]; - if(INLINE[I] != 0)LNLENG=I; - } /* end loop */ - LNPOSN=1; - } + return range * get_next_lcg_value() / game.lcg_m; } -void TYPE(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; +void make_zzword(char zzword[6]) +{ + for (int i = 0; i < 5; ++i) + { + zzword[i] = 'A' + randrange(26); + } + zzword[1] = '\''; // force second char to apostrophe + zzword[5] = '\0'; } -void MPINIT(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]; +/* Machine dependent routines (MAPLIN, SAVEIO) */ - 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; +bool MAPLIN(FILE *fp) +{ + bool eof; + + /* Read a line of input, from the specified input source. + * This logic is complicated partly because it has to serve + * several cases with different requirements and partly because + * of a quirk in linenoise(). + * + * The quirk shows up when you paste a test log from the clipboard + * to the program's command prompt. While fgets (as expected) + * consumes it a line at a time, linenoise() returns the first + * line and discards the rest. Thus, there needs to be an + * editline (-s) option to fall back to fgets while still + * prompting. Note that linenoise does behave properly when + * fed redirected stdin. + * + * The logging is a bit of a mess because there are two distinct cases + * in which you want to echo commands. One is when shipping them to + * a log under the -l option, in which case you want to suppress + * prompt generation (so test logs are unadorned command sequences). + * On the other hand, if you redirected stdin and are feeding the program + * a logfile, you *do* want prompt generation - it makes checkfiles + * easier to read when the commands are marked by a preceding prompt. + */ + do { + if (!editline) { + if (prompt) + fputs("> ", stdout); + IGNORE(fgets(rawbuf, sizeof(rawbuf) - 1, fp)); + eof = (feof(fp)); + } else { + char *cp = linenoise("> "); + eof = (cp == NULL); + if (!eof) { + strncpy(rawbuf, cp, sizeof(rawbuf) - 1); + linenoiseHistoryAdd(rawbuf); + strncat(rawbuf, "\n", sizeof(rawbuf) - strlen(rawbuf) - 1); + linenoiseFree(cp); + } + } + } while + (!eof && rawbuf[0] == '#'); + if (eof) { + if (logfp && fp == stdin) + fclose(logfp); + return false; + } else { + FILE *efp = NULL; + if (logfp && fp == stdin) + efp = logfp; + else if (!isatty(0)) + efp = stdout; + if (efp != NULL) { + if (prompt && efp == stdout) + fputs("> ", efp); + IGNORE(fputs(rawbuf, efp)); + } + strcpy(INLINE + 1, rawbuf); + /* 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 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 he mapping. MAP2(1) is set to 0 when the + * program starts and is not changed thereafter unless the + * routines in this module choose to do so. */ + LNLENG = 0; + for (long i = 1; i <= (long)sizeof(INLINE) && INLINE[i] != 0; i++) { + long val = INLINE[i]; + INLINE[i] = ascii_to_advent[val]; + if (INLINE[i] != 0) + LNLENG = i; + } + LNPOSN = 1; + return true; + } } -#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; - -L30: if(IN)IGNORE(fread(ARR,sizeof(long),250,F)); - if(!IN)fwrite(ARR,sizeof(long),250,F); - return; - +void datime(long* d, long* t) +{ + struct timeval tv; + gettimeofday(&tv, NULL); + *d = (long) tv.tv_sec; + *t = (long) tv.tv_usec; } -void DATIME(long* D, long* T) { - struct timeval tv; - gettimeofday(&tv, NULL); - *D = (long) tv.tv_sec; - *T = (long) tv.tv_usec; +// 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 -long MOD(N,M)long N, M; {return(N%M);} +/* end */