GLK: ALAN3: Removal of #ifdef blocks

13 files changed, 44 insertions, 706 deletions

diff --git a/engines/glk/alan3/args.h b/engines/glk/alan3/args.h
index f70cf3a753..690f67566b 100644
--- a/engines/glk/alan3/args.h
+++ b/engines/glk/alan3/args.h
@@ -31,11 +31,7 @@ namespace Glk {
 namespace Alan3 {
 
 #ifndef PROGNAME
-#ifdef HAVE_GARGLK
 #define PROGNAME "alan3"
-#else
-#define PROGNAME "arun"
-#endif
 #endif
 
 /* DATA */
diff --git a/engines/glk/alan3/debug.cpp b/engines/glk/alan3/debug.cpp
index 25de184a7b..53895f14e7 100644
--- a/engines/glk/alan3/debug.cpp
+++ b/engines/glk/alan3/debug.cpp
@@ -66,9 +66,7 @@ static void showAttributes(AttributeEntry *attrib)
     i = 1;
     for (at = attrib; !isEndOfArray(at); at++) {
         sprintf(str, "$i$t%s[%d] = %d", (char *) pointerTo(at->id), at->code, (int)at->value);
-#if ISO == 0
-        fromIso(str, str);
-#endif
+
         output(str);
         i++;
     }
@@ -238,47 +236,6 @@ static void showObject(int obj)
 
 }
 
-#ifdef UNDEF_WHEN_NEEDED
-/*----------------------------------------------------------------------*/
-static void showcnts(void)
-{
-    char str[80];
-    int cnt;
-
-    output("Containers:");
-    for (cnt = 1; cnt <= header->containerMax; cnt++) {
-        sprintf(str, "$i%3d: ", cnt);
-        output(str);
-        if (containers[cnt].owner != 0)
-            say(containers[cnt].owner);
-    }
-
-}
-
-/*----------------------------------------------------------------------*/
-static void showContainer(int cnt)
-{
-    char str[80];
-
-    if (cnt < 1 || cnt > header->containerMax) {
-        sprintf(str, "Container number out of range. Between 1 and %d, please.", header->containerMax);
-        output(str);
-        return;
-    }
-
-    sprintf(str, "Container %d :", cnt);
-    output(str);
-    if (containers[cnt].owner != 0) {
-        cnt = containers[cnt].owner;
-        say(cnt);
-        sprintf(str, "$iLocation: %d", where(cnt, TRUE));
-        output(str);
-    }
-    showContents(cnt);
-}
-#endif
-
-
 /*----------------------------------------------------------------------*/
 static int sourceFileNumber(char *fileName) {
     SourceFileEntry *entries = (SourceFileEntry *)pointerTo(header->sourceFileTable);
@@ -437,9 +394,7 @@ static void showEvents(void)
     output("Events:");
     for (event = 1; event <= header->eventMax; event++) {
         sprintf(str, "$i%d [%s]:", event, (char *)pointerTo(events[event].id));
-#if ISO == 0
-        fromIso(str, str);
-#endif
+
         output(str);
         scheduled = FALSE;
         for (i = 0; i < eventQueueTop; i++)
@@ -796,11 +751,7 @@ static void readCommand(char buf[]) {
     do {
         output("adbg> ");
 
-#ifdef USE_READLINE
         if (!readline(buf)) {
-#else
-        if (fgets(buf, 255, stdin) == NULL) {
-#endif
             newline();
             quitGame();
         }
@@ -1042,10 +993,7 @@ void debug(bool calledFromBreakpoint, int line, int fileNumber)
     static bool warned = FALSE;
 
     saveInfo();
-
-#ifdef HAVE_GLK
     g_vm->glk_set_style(style_Preformatted);
-#endif
 
     if (calledFromBreakpoint)
         displaySourceLocation(line, fileNumber);
@@ -1090,10 +1038,7 @@ void debug(bool calledFromBreakpoint, int line, int fileNumber)
     }
 
  exit_debug:
-#ifdef HAVE_GLK
 	g_vm->glk_set_style(style_Normal);
-#endif
-    ;
 }
 
 
diff --git a/engines/glk/alan3/exe.cpp b/engines/glk/alan3/exe.cpp
index f37cc2f661..445b00dc6d 100644
--- a/engines/glk/alan3/exe.cpp
+++ b/engines/glk/alan3/exe.cpp
@@ -68,9 +68,7 @@ Common::SeekableReadStream *textFile;
 
 
 /*======================================================================*/
-void setStyle(int style)
-{
-#ifdef HAVE_GLK
+void setStyle(int style) {
     switch (style) {
     case NORMAL_STYLE: g_vm->glk_set_style(style_Normal); break;
     case EMPHASIZED_STYLE: g_vm->glk_set_style(style_Emphasized); break;
@@ -78,7 +76,6 @@ void setStyle(int style)
     case ALERT_STYLE: g_vm->glk_set_style(style_Alert); break;
     case QUOTE_STYLE: g_vm->glk_set_style(style_BlockQuote); break;
     }
-#endif
 }
 
 /*======================================================================*/
@@ -126,9 +123,7 @@ void print(Aword fpos, Aword len)
                     break;
             }
             str[i] = '\0';
-#if ISO == 0
-            fromIso(str, str);
-#endif
+
             output(str);
         }
 
@@ -243,11 +238,8 @@ void quitGame(void)
         col = 1;
         statusline();
         printMessage(M_QUITACTION);
-#ifdef USE_READLINE
+
         if (!readline(buf)) terminate(0);
-#else
-        if (gets(buf) == NULL) terminate(0);
-#endif
         if (strcasecmp(buf, "restart") == 0)
             longjmp(restartLabel, TRUE);
         else if (strcasecmp(buf, "restore") == 0) {
@@ -558,9 +550,7 @@ int getContainerMember(int container, int index, bool directly) {
 
 
 /*======================================================================*/
-void showImage(int image, int align)
-{
-#ifdef HAVE_GLK
+void showImage(int image, int align) {
     uint ecode;
 
     if ((g_vm->glk_gestalt(gestalt_Graphics, 0) == 1) &&
@@ -570,14 +560,12 @@ void showImage(int image, int align)
         ecode = g_vm->glk_image_draw(glkMainWin, image, imagealign_MarginLeft, 0);
         (void)ecode;
     }
-#endif
 }
 
 
 /*======================================================================*/
 void playSound(int sound)
 {
-#ifdef HAVE_GLK
 #ifdef GLK_MODULE_SOUND
     static schanid_t soundChannel = NULL;
 
@@ -590,11 +578,9 @@ void playSound(int sound)
         }
     }
 #endif
-#endif
 }
 
 
-
 /*======================================================================*/
 void empty(int cnt, int whr)
 {
diff --git a/engines/glk/alan3/glkio.h b/engines/glk/alan3/glkio.h
index 5bcd6e6b63..b77e659cc5 100644
--- a/engines/glk/alan3/glkio.h
+++ b/engines/glk/alan3/glkio.h
@@ -40,15 +40,6 @@ extern winid_t glkStatusWin;
 #define printf glkio_printf
 extern void glkio_printf(const char *, ...);
 
-#ifdef MAP_STDIO_TO_GLK
-#define fgetc(stream) glk_get_char_stream(stream)
-#define rewind(stream) glk_stream_set_position(stream, 0, seekmode_Start);
-#define fwrite(buf, elementSize, count, stream) glk_put_buffer_stream(stream, buf, elementSize*count);
-#define fread(buf, elementSize, count, stream) glk_get_buffer_stream(stream, buf, elementSize*count);
-#define fclose(stream) glk_stream_close(stream, NULL)
-#define fgets(buff, len, stream) glk_get_line_stream(stream, buff, len)
-#endif
-
 } // End of namespace Alan3
 } // End of namespace Glk
 
diff --git a/engines/glk/alan3/glkstart.cpp b/engines/glk/alan3/glkstart.cpp
index da20f0fd66..d4f7dcb88d 100644
--- a/engines/glk/alan3/glkstart.cpp
+++ b/engines/glk/alan3/glkstart.cpp
@@ -21,24 +21,15 @@
  */
 
 #include "glk/alan3/glkstart.h"
+#include "glk/alan3/alan_version.h"
 #include "glk/alan3/alan3.h"
 #include "glk/alan3/args.h"
 #include "glk/alan3/main.h"
 #include "glk/alan3/glkio.h"
 #include "glk/alan3/resources.h"
 #include "glk/alan3/utils.h"
- //#include "glk/alan3/gi_blorb.h"
 #include "glk/streams.h"
 
-#ifdef HAVE_WINGLK
-#include "glk/alan3/WinGlk.h"
-#endif
-
-
-#ifdef HAVE_GARGLK
-#include "glk/alan3/alan_version.h"
-#endif
-
 namespace Glk {
 namespace Alan3 {
 
@@ -64,9 +55,7 @@ static void openGlkWindows() {
             printf("FATAL ERROR: Cannot open initial window");
 			g_vm->glk_exit();
     }
-#ifdef HAVE_GARGLK
-   glk_stylehint_set (wintype_TextGrid, style_User1, stylehint_ReverseColor, 1);
-#endif
+
     glkStatusWin = g_vm->glk_window_open(glkMainWin, winmethod_Above |
                                    winmethod_Fixed, 1, wintype_TextGrid, 0);
 	g_vm->glk_set_window(glkStatusWin);
@@ -107,23 +96,8 @@ int glkunix_startup_code(glkunix_startup_t *data) {
     /* first, open a window for error output */
     openGlkWindows();
 
-#ifdef HAVE_GARGLK
-#if (BUILD+0) != 0
-    {
-        char name[100];
-        sprintf(name, "%s-%d", alan.shortHeader, BUILD);
-        garglk_set_program_name(name);
-    }
-#else
-	garglk_set_program_name(alan.shortHeader);
-#endif
-	char info[80];
-	sprintf(info, "%s Interpreter by Thomas Nilefalk\n", alan.shortHeader);
-	garglk_set_program_info(info);
-#endif
-
     /* now process the command line arguments */
-    args(data->argc, data->argv);
+    //args(data->argc, data->argv);
 
     if (adventureFileName == NULL || strcmp(adventureFileName, "") == 0) {
         printf("You should supply a game file to play.\n");
@@ -137,73 +111,5 @@ int glkunix_startup_code(glkunix_startup_t *data) {
     return TRUE;
 }
 
-
-
-#ifdef HAVE_WINGLK
-static int argCount;
-static char *argumentVector[10];
-
-/*----------------------------------------------------------------------*/
-static void splitArgs(char *commandLine) {
-    unsigned char *cp = (unsigned char *)commandLine;
-
-    while (*cp) {
-        while (*cp && isspace(*cp)) cp++;
-        if (*cp) {
-            argumentVector[argCount++] = (char *)cp;
-            if (*cp == '"') {
-                do {
-                    cp++;
-                } while (*cp != '"');
-                cp++;
-            } else
-                while (*cp && !isspace(*cp))
-                    cp++;
-            if (*cp) {
-                *cp = '\0';
-                cp++;
-            }
-        }
-    }
-}
-
-
-/*======================================================================*/
-int winglk_startup_code(const char* cmdline)
-{
-    char windowTitle[200];
-
-    /* Process the command line arguments */
-    argumentVector[0] = "";
-    argCount = 1;
-
-    splitArgs(strdup(cmdline));
-
-    args(argCount, argumentVector);
-
-
-    if (adventureFileName == NULL || strcmp(adventureFileName, "") == 0) {
-        adventureFileName = (char*)winglk_get_initial_filename(NULL, "Arun : Select an Alan game file",
-                                                               "Alan Game Files (*.a3c)|*.a3c||");
-        if (adventureFileName == NULL) {
-            terminate(0);
-        }
-        adventureName = gameName(adventureFileName);
-    }
-
-    winglk_app_set_name("WinArun");
-    winglk_set_gui(IDR_ARUN);
-
-    sprintf(windowTitle, "WinArun : %s", adventureName);
-    winglk_window_set_title(windowTitle);
-    openGlkWindows();
-
-    /* Open any possible blorb resource file */
-    openResourceFile();
-
-    return TRUE;
-}
-#endif
-
 } // End of namespace Alan3
 } // End of namespace Glk
diff --git a/engines/glk/alan3/main.cpp b/engines/glk/alan3/main.cpp
index 030579f97c..e22c5be942 100644
--- a/engines/glk/alan3/main.cpp
+++ b/engines/glk/alan3/main.cpp
@@ -66,46 +66,6 @@ VerbEntry *vrbs;		/* Verb table pointer */
 /* PRIVATE DATA */
 #define STACKSIZE 100
 
-
-
-#ifdef CHECKOBJ
-/*======================================================================
-
-  checkobj()
-
-  Check that the object given is valid, else print an error message
-  or find out what he wanted.
-
-  This routine is not used any longer, kept for sentimental reasons ;-)
-
-*/
-void checkobj(Aword *obj) {
-    Aword oldobj;
-
-    if (*obj != EOD)
-        return;
-
-    oldobj = EOD;
-    for (cur.obj = OBJMIN; cur.obj <= OBJMAX; cur.obj++) {
-        /* If an object is present and it is possible to perform his action */
-        if (isHere(cur.obj) && possible())
-            if (oldobj == EOD)
-                oldobj = cur.obj;
-            else
-                error(WANT);          /* And we didn't find multiple objects */
-    }
-
-    if (oldobj == EOD)
-        error(WANT);              /* But we found ONE */
-
-    *obj = cur.obj = oldobj;
-    output("($o)");             /* Then he surely meant this object */
-}
-#endif
-
-
-
-
 /*----------------------------------------------------------------------*
  *
  * Event Handling
@@ -232,9 +192,6 @@ static void loadAndCheckMemory(ACodeHeader tmphdr, Aword crc, char err[]) {
         crc += (memory[i]>>8)&0xff;
         crc += (memory[i]>>16)&0xff;
         crc += (memory[i]>>24)&0xff;
-#ifdef CRCLOG
-        printf("%6x\t%6lx\t%6lx\n", i, crc, memory[i]);
-#endif
     }
     if (crc != tmphdr.acdcrc) {
         sprintf(err, "Checksum error in Acode (.a3c) file (0x%lx instead of 0x%lx).",
diff --git a/engines/glk/alan3/output.cpp b/engines/glk/alan3/output.cpp
index be27484b96..16f1c1e65b 100644
--- a/engines/glk/alan3/output.cpp
+++ b/engines/glk/alan3/output.cpp
@@ -56,7 +56,6 @@ strid_t logFile;
 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
 
 
-#if defined(HAVE_GLK) || defined(RUNNING_UNITTESTS)
 /*----------------------------------------------------------------------*/
 static int updateColumn(int currentColumn, const char *string) {
     const char *newlinePosition = strrchr(string, '\n');
@@ -65,46 +64,22 @@ static int updateColumn(int currentColumn, const char *string) {
     else
         return currentColumn + strlen(string);
 }
-#endif
 
 
 /*======================================================================*/
 void setSubHeaderStyle(void) {
-#ifdef HAVE_GLK
     g_vm->glk_set_style(style_Subheader);
-#endif
 }
 
 
 /*======================================================================*/
 void setNormalStyle(void) {
-#ifdef HAVE_GLK
 	g_vm->glk_set_style(style_Normal);
-#endif
 }
 
 /*======================================================================*/
 void newline(void) {
-#ifndef HAVE_GLK
-    char buf[256];
-
-    if (!regressionTestOption && lin == pageLength - 1) {
-		printAndLog("\n");
-        needSpace = FALSE;
-        col = 0;
-        lin = 0;
-        printMessage(M_MORE);
-        statusline();
-        fflush(stdout);
-        fgets(buf, 256, stdin);
-        getPageSize();
-    } else
-        printAndLog("\n");
-
-    lin++;
-#else
     printAndLog("\n");
-#endif
     col = 1;
     needSpace = FALSE;
 }
@@ -114,11 +89,9 @@ void newline(void) {
 void para(void)
 {
     /* Make a new paragraph, i.e one empty line (one or two newlines). */
-
-#ifdef HAVE_GLK
     if (g_vm->glk_gestalt(gestalt_Graphics, 0) == 1)
 		g_vm->glk_window_flow_break(glkMainWin);
-#endif
+
     if (col != 1)
         newline();
     newline();
@@ -127,17 +100,8 @@ void para(void)
 
 
 /*======================================================================*/
-void clear(void)
-{
-#ifdef HAVE_GLK
+void clear(void) {
 	g_vm->glk_window_clear(glkMainWin);
-#else
-#ifdef HAVE_ANSI
-    if (!statusLineOption) return;
-    printf("\x1b[2J");
-    printf("\x1b[%d;1H", pageLength);
-#endif
-#endif
 }
 
 
@@ -156,17 +120,13 @@ static void capitalizeFirst(Common::String &str) {
 
 
 /*======================================================================*/
-void printAndLog(const char *string)
-{
-#ifdef HAVE_GLK
+void printAndLog(const char *string) {
     static int column = 0;
     char *stringCopy;
     char *stringPart;
-#endif
 
     printf("%s", string);
     if (!onStatusLine && transcriptOption) {
-#ifdef HAVE_GLK
         // TODO Is this assuming only 70-char wide windows for GLK?
         if ((int)strlen(string) > 70-column) {
             stringCopy = strdup(string);  /* Make sure we can write NULLs */
@@ -187,9 +147,6 @@ void printAndLog(const char *string)
 			g_vm->glk_put_string_stream(logFile, string);
             column = updateColumn(column, string);
         }
-#else
-        fprintf(logFile, "%s", string);
-#endif
     }
 }
 
@@ -201,37 +158,7 @@ static void justify(const char *str) {
     if (capitalize)
         capitalizeFirst(tempStr);
 
-#ifdef HAVE_GLK
     printAndLog(tempStr.c_str());
-#else
-    int i;
-    char ch;
-
-    if (col >= pageWidth && !skipSpace)
-        newline();
-
-    while (strlen(str) > pageWidth - col) {
-        i = pageWidth - col - 1;
-        while (!isSpace(str[i]) && i > 0) /* First find wrap point */
-            i--;
-        if (i == 0 && col == 1) /* If it doesn't fit at all */
-            /* Wrap immediately after this word */
-            while (!isSpace(str[i]) && str[i] != '\0')
-                i++;
-        if (i > 0) {        /* If it fits ... */
-            ch = str[i];      /* Save space or NULL */
-            str[i] = '\0';        /* Terminate string */
-            printAndLog(str);     /* and print it */
-            skipSpace = FALSE;        /* If skipping, now we're done */
-            str[i] = ch;      /* Restore character */
-            /* Skip white after printed portion */
-            for (str = &str[i]; isSpace(str[0]) && str[0] != '\0'; str++);
-        }
-        newline();          /* Then start a new line */
-        while(isSpace(str[0])) str++; /* Skip any leading space on next part */
-    }
-    printAndLog(str);     /* Print tail */
-#endif
     col = col + tempStr.size();  // Update column
 }
 
@@ -496,11 +423,8 @@ bool confirm(MsgKind msgno)
        it could be affirmative, but for now any input is NOT! */
     printMessage(msgno);
 
-#ifdef USE_READLINE
-    if (!readline(buf)) return TRUE;
-#else
-    if (gets(buf) == NULL) return TRUE;
-#endif
+    if (!readline(buf))
+		return TRUE;
     col = 1;
 
     return (buf[0] == '\0');
diff --git a/engines/glk/alan3/readline.cpp b/engines/glk/alan3/readline.cpp
index fa965bbd76..4fb7a8926a 100644
--- a/engines/glk/alan3/readline.cpp
+++ b/engines/glk/alan3/readline.cpp
@@ -54,10 +54,6 @@ bool readline(char buffer[])
     static bool readingCommands = FALSE;
     static frefid_t commandFileRef;
     static strid_t commandFile;
-#ifdef HAVE_WINGLK
-    static frefid_t logFileRef;
-    INT_PTR e;
-#endif
 
     if (readingCommands) {
         if (g_vm->glk_get_line_stream(commandFile, buffer, 255) == 0) {
@@ -80,73 +76,7 @@ bool readline(char buffer[])
                 case evtype_Arrange:
                     statusline();
                     break;
-#ifdef HAVE_WINGLK
-                case winglk_evtype_GuiInput:
-                    switch (event.val1) {
-                    case ID_MENU_RESTART:
-                        restartGame();
-                        break;
-                    case ID_MENU_SAVE:
-                        glk_set_style(style_Input);
-                        printf("save\n");
-                        glk_set_style(style_Normal);
-                        save();
-                        para();
-                        printf("> ");
-                        break;
-                    case ID_MENU_RESTORE:
-                        glk_set_style(style_Input);
-                        printf("restore\n");
-                        glk_set_style(style_Normal);
-                        restore();
-                        look();
-                        para();
-                        printf("> ");
-                        break;
-                    case ID_MENU_RECORD:
-                        if (transcriptOption || logOption) {
-                            glk_stream_close(logFile, NULL);
-                            transcriptOption = FALSE;
-                            logOption = FALSE;
-                        }
-                        logFileRef = glk_fileref_create_by_prompt(fileusage_InputRecord+fileusage_TextMode, filemode_Write, 0);
-                        if (logFileRef == NULL) break;
-                        logFile = glk_stream_open_file(logFileRef, filemode_Write, 0);
-                        if (logFile != NULL)
-                            logOption = TRUE;
-                        break;
-                    case ID_MENU_PLAYBACK:
-                        commandFileRef = glk_fileref_create_by_prompt(fileusage_InputRecord+fileusage_TextMode, filemode_Read, 0);
-                        if (commandFileRef == NULL) break;
-                        commandFile = glk_stream_open_file(commandFileRef, filemode_Read, 0);
-                        if (commandFile != NULL)
-                            if (glk_get_line_stream(commandFile, buffer, 255) != 0) {
-                                readingCommands = TRUE;
-                                printf(buffer);
-                                return TRUE;
-                            }
-                        break;
-                    case ID_MENU_TRANSCRIPT:
-                        if (transcriptOption || logOption) {
-                            glk_stream_close(logFile, NULL);
-                            transcriptOption = FALSE;
-                            logOption = FALSE;
-                        }
-                        logFileRef = glk_fileref_create_by_prompt(fileusage_Transcript+fileusage_TextMode, filemode_Write, 0);
-                        if (logFileRef == NULL) break;
-                        logFile = glk_stream_open_file(logFileRef, filemode_Write, 0);
-                        if (logFile != NULL) {
-                            transcriptOption = TRUE;
-                            glk_put_string_stream(logFile, "> ");
-                        }
-                        break;
-                    case ID_MENU_ABOUT:
-                        e = DialogBox(myInstance, MAKEINTRESOURCE(IDD_ABOUT), NULL, &AboutDialogProc);
-                        (void)e;
-                        break;
-                    }
-                    break;
-#endif
+
 				default:
 					break;
 				}
diff --git a/engines/glk/alan3/scan.cpp b/engines/glk/alan3/scan.cpp
index 64c0e6234c..9eb40d99a6 100644
--- a/engines/glk/alan3/scan.cpp
+++ b/engines/glk/alan3/scan.cpp
@@ -62,10 +62,7 @@ void forceNewPlayerInput() {
 static void unknown(char tok[]) {
     char *str = strdup(tok);
     Parameter *messageParameters = newParameterArray();
-	
-#if ISO == 0
-    fromIso(str, str);
-#endif
+
     addParameterForString(messageParameters, str);
     printMessageWithParameters(M_UNKNOWN_WORD, messageParameters);
 	deallocate(messageParameters);
@@ -150,12 +147,7 @@ static void getLine(void) {
         } else
             printAndLog("> ");
 
-#ifdef USE_READLINE
         if (!readline(buf)) {
-#else
-        fflush(stdout);
-        if (fgets(buf, LISTLEN, stdin) == NULL) {
-#endif
             newline();
             quitGame();
         }
@@ -177,11 +169,7 @@ static void getLine(void) {
 		::error("TODO: empty command");
 #endif
 		
-#if ISO == 0
-        toIso(isobuf, buf, NATIVECHARSET);
-#else
         strcpy(isobuf, buf);
-#endif
         token = gettoken(isobuf);
         if (token != NULL) {
             if (strcmp("debug", token) == 0 && header->debug) {
diff --git a/engines/glk/alan3/sysdep.cpp b/engines/glk/alan3/sysdep.cpp
index 6b663938d7..0966d54d7b 100644
--- a/engines/glk/alan3/sysdep.cpp
+++ b/engines/glk/alan3/sysdep.cpp
@@ -28,41 +28,6 @@
 namespace Glk {
 namespace Alan3 {
 
-#ifdef __vms__
-
-char *strdup(char str[])                /* IN - String to duplicate */
-{
-  char *new = (char *) malloc(strlen(str)+1);
-
-  if (!new)
-    syserr("Out of memory");
-  strcpy(new, str);
-  return new;
-}
-
-#endif
-
-
-#ifdef __vms__
-
-/* Cheat implementation of strftime */
-size_t strftime (
-		 char *outbuf,
-		 size_t len,
-		 const char *format,
-		 const struct tm *t)
-{
-  char buf[100];
-  time_t ticks;
-
-  time(&ticks);
-  strcpy(buf, ctime(&ticks));
-  buf[strlen(buf)-1] = '\0';
-  strcpy(outbuf, &buf[4]);
-}
-
-#endif
-
 /* Note to Glk maintainers: 'native' characters are used for output, in this
    case, Glk's Latin-1.  ISO characters are Alan's internal representation,
    stored in the .A3C file, and must be converted to native before printing.
@@ -138,86 +103,34 @@ static const byte upperCaseCharacters[] =
 };
 
 
-int isSpace(unsigned int c)              /* IN - Native character to test */
-{
+int isSpace(unsigned int c) {
     return (c != '\0' && strchr((const char *)spaceCharacters, c) != 0);
 }
 
 
-int isLower(unsigned int c)              /* IN - Native character to test */
-{
+int isLower(unsigned int c) {
     return (c != '\0' && strchr((const char *)lowerCaseCharacters, c) != 0);
 }
 
 
-int isUpper(unsigned int c)              /* IN - Native character to test */
-{
+int isUpper(unsigned int c) {
     return (c != '\0' && strchr((const char *)upperCaseCharacters, c) != 0);
 }
 
-int isLetter(unsigned int c)             /* IN - Native character to test */
-{
+int isLetter(unsigned int c) {
   return(c != '\0' && (isLower(c)? !0: isUpper(c)));
 }
 
 
-int toLower(unsigned int c)              /* IN - Native character to convert */
-{
-#ifdef HAVE_GLK
+int toLower(unsigned int c) {
   return g_vm->glk_char_to_lower(c);
-#else
-#ifdef __dos__
-  char *cp;
-
-  if ((cp = strchr(upperCaseCharacters, c)) != 0)
-    return(lowerCaseCharacters[cp-upperCaseCharacters]);
-  else
-    return c;
-#else
-#ifdef __mac__
-  char *cp;
-
-  if ((cp = strchr(upperCaseCharacters, c)) != 0)
-    return(lowerCaseCharacters[cp-upperCaseCharacters]);
-  else
-    return c;
-#else
-  return (isUpper(c)? c + ('a' - 'A'): c);
-#endif
-#endif
-#endif
 }
 
-/* IN - Native character to convert */
-int toUpper(unsigned int c)
-{
-#ifdef HAVE_GLK
+int toUpper(unsigned int c) {
   return g_vm->glk_char_to_upper(c);
-#else
-#ifdef __dos__
-  char *cp;
-
-  if ((cp = strchr(lowerCaseCharacters, c)) != 0)
-    return(upperCaseCharacters[cp-lowerCaseCharacters]);
-  else
-    return c;
-#else
-#ifdef __mac__
-  char *cp;
-
-  if ((cp = strchr(lowerCaseCharacters, c)) != 0)
-    return(upperCaseCharacters[cp-lowerCaseCharacters]);
-  else
-    return c;
-#else
-  return (isLower(c)? c - ('a' - 'A'): c);
-#endif
-#endif
-#endif
 }
 
-char *strlow(char str[])        /* INOUT - Native string to convert */
-{
+char *strlow(char str[]) {
   char *s;
 
   for (s = str; *s; s++)
@@ -226,8 +139,7 @@ char *strlow(char str[])        /* INOUT - Native string to convert */
 }
 
 
-char *strupp(char str[])        /* INOUT - Native string to convert */
-{
+char *strupp(char str[]) {
   char *s;
 
   for (s = str; *s; s++)
@@ -238,8 +150,7 @@ char *strupp(char str[])        /* INOUT - Native string to convert */
 
 /* The following work on ISO characters */
 
-int isLowerCase(unsigned int c)          /* IN - ISO character to test */
-{
+int isLowerCase(unsigned int c) {
   uint i;
   for (i = 0; i < strlen((const char *)lowerCaseCharacters); i++)
     if (((unsigned int)lowerCaseCharacters[i]) == c) return 1;
@@ -247,8 +158,7 @@ int isLowerCase(unsigned int c)          /* IN - ISO character to test */
 }
 
 
-int isUpperCase(unsigned int c)          /* IN - ISO character to test */
-{
+int isUpperCase(unsigned int c) {
   uint i;
   for (i = 0; i < strlen((const char *)upperCaseCharacters); i++)
     if (upperCaseCharacters[i] == c) return 1;
@@ -256,26 +166,22 @@ int isUpperCase(unsigned int c)          /* IN - ISO character to test */
 }
 
 
-int isISOLetter(int c)          /* IN - ISO character to test */
-{
+int isISOLetter(int c) {
   return (isLowerCase(c) || isUpperCase(c));
 }
 
 
-char IsoToLowerCase(int c)         /* IN - ISO character to convert */
-{
+char IsoToLowerCase(int c) {
   return (isUpperCase(c)? c + ('a' - 'A'): c);
 }
 
 
-char IsoToUpperCase(int c)         /* IN - ISO character to convert */
-{
+char IsoToUpperCase(int c) {
   return (isLowerCase(c)? c - ('a' - 'A'): c);
 }
 
 
-char *stringLower(char str[])   /* INOUT - ISO string to convert */
-{
+char *stringLower(char str[]) {
   char *s;
 
   for (s = str; *s; s++)
@@ -284,8 +190,7 @@ char *stringLower(char str[])   /* INOUT - ISO string to convert */
 }
 
 
-char *stringUpper(char str[])   /* INOUT - ISO string to convert */
-{
+char *stringUpper(char str[]) {
   char *s;
 
   for (s = str; *s; s++)
@@ -387,60 +292,9 @@ static const unsigned char dosMap[256]
   interpreter so character set is known at compile time.
 
   */
-void fromIso(char copy[],       /* OUT - Mapped string */
-	     char original[])   /* IN - string to convert */
-{
-#if ISO == 0
-  static const unsigned char map[256]
-#if defined __mac__
-    = {
-      0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0D,0x0B,0x0C,0x0D,0x0E,0x0F,
-      0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
-      0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
-      0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
-      0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
-      0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
-      0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
-      0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
-      0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,
-      0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF,
-      0xCA,0xC1,0xA2,0xA3,0xB0,0xB4,0xBA,0xA4,0xAC,0xA9,0xBB,0xC7,0xC2,0xD0,0xA8,0xD1,
-      0xA1,0xB1,0xAA,0xD5,0xAB,0xB5,0xA6,0xA5,0xD4,0xA0,0xBC,0xC8,0xD9,0xDA,0xDB,0xC0,
-      0xCB,0xDC,0xD7,0xCC,0x80,0x81,0xAE,0x82,0xC5,0x83,0xB7,0xC9,0xB3,0xB2,0xC3,0xC4,
-      0xC6,0x84,0xDD,0xDE,0xBD,0xCD,0x85,0xAD,0xAF,0xD3,0xD2,0xDF,0x86,0xCE,0xB8,0xA7,
-      0x88,0x87,0x89,0x8B,0x8A,0x8C,0xBE,0x8D,0x8F,0x8E,0x90,0x91,0x93,0x92,0x94,0x95,
-      0xB6,0x96,0x98,0x97,0x99,0x9B,0x9A,0xD6,0xBF,0x9D,0x9C,0x9E,0x9F,0xCF,0xB9,0xD8}
-#else
-#if defined __dos__
-  = {
-    0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0D,0x0B,0x0C,0x0D,0x0E,0x0F,
-    0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
-    0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
-    0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
-    0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
-    0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
-    0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
-    0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
-    0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,
-    0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,
-    0xFF,0xD0,0x9B,0x9C,0xE5,0x9D,0x9F,0xD1,0xF7,0xE0,0xA6,0xAE,0xFB,0xD2,0xE7,0xFA,
-    0xF8,0xF1,0xFD,0xD3,0xFE,0xE6,0xE3,0xF9,0xD4,0xD5,0xA7,0xAF,0xAC,0xAB,0xF0,0xA8,
-    0xA9,0xAA,0xEF,0xD6,0x8E,0x8F,0x92,0x80,0xE2,0x90,0xE4,0xEE,0xF5,0xF4,0xD7,0xAD,
-    0xE9,0xA5,0xD8,0xD9,0xEA,0xE8,0x99,0xEC,0xED,0xF2,0xF3,0xDA,0x9A,0xDB,0x9E,0xE1,
-    0x85,0xA0,0x83,0xDC,0x84,0x86,0x91,0x87,0x8A,0x82,0x88,0x89,0x8D,0xA1,0x8C,0x8B,
-    0xEB,0xA4,0x95,0xA2,0x93,0xDD,0x94,0xF6,0xDE,0x97,0xA3,0x96,0x81,0xDF,0xFC,0x98}
-#endif
-    ;
-#endif
-    unsigned char *o, *c;
-
-    for (o = (unsigned char *)original, c = (unsigned char *)copy; *o; o++, c++)
-      *c = map[*o];
-    *c = '\0';
-#else
+void fromIso(char copy[], char original[]) {
     if (copy != original)
       (void)strcpy(copy, original);
-#endif
 }
 
 
@@ -450,12 +304,11 @@ void fromIso(char copy[],       /* OUT - Mapped string */
   Converts the incoming string to the native character set from any of
   the others. The original is in the current character set which in
   the case of the compiler might be other than the native.
-
+  copy - Mapped  string
+  original - string to convert
+  charset - the current character set
   */
-void toNative(char copy[],	/* OUT - Mapped  string */
-	      char original[],	/* IN - string to convert */
-	      int charset)	/* IN - the current character set */
-{
+void toNative(char copy[], char original[], int charset) {
   toIso(copy, original, charset);
   if (NATIVECHARSET != 0)
     fromIso(copy, copy);
diff --git a/engines/glk/alan3/sysdep.h b/engines/glk/alan3/sysdep.h
index 747201c188..a0c2f7ad4f 100644
--- a/engines/glk/alan3/sysdep.h
+++ b/engines/glk/alan3/sysdep.h
@@ -90,71 +90,14 @@ namespace Alan3 {
 #define WRITE_MODE "wb"
 
 
-/****************************/
-/* Allocates cleared bytes? */
-/****************************/
-
-#ifdef __CYGWIN__
-#define NOTCALLOC
-#endif
-
-#ifdef __MINGW32__
-#define NOTCALLOC
-#endif
-
-#ifdef __unix__
-#define NOTCALLOC
-#endif
-
-
-/****************/
-/* Have termio? */
 /****************/
 
-#ifdef HAVE_GLK
-#  undef HAVE_TERMIO   /* don't need TERMIO */
-#else
-#  ifdef __CYGWIN__
-#    define HAVE_TERMIO
-#  endif
-#  ifdef __unix__
-#    define HAVE_TERMIO
-#  endif
-#endif
-
-/*******************************/
-/* Is ANSI control available? */
-/*******************************/
+/* don't need TERMIO */
+#undef HAVE_TERMIO
+/* don't need ANSI */
+#undef HAVE_ANSI
 
-#ifdef HAVE_GLK
-#  undef HAVE_ANSI /* don't need ANSI */
-#else
-#  ifdef __CYGWIN__
-#    define HAVE_ANSI
-#  endif
-#endif
-
-/******************************/
-/* Use the READLINE function? */
-/******************************/
 #define USE_READLINE
-#ifdef SOME_PLATFORM_WHICH_CANT_USE_READLINE
-#  undef USE_READLINE
-#endif
-
-/* Special cases and definition overrides */
-#ifdef __unix__
-#define MULTI
-#endif
-
-
-#ifdef __dos__
-
-/* Return codes */
-#define EXIT_SUCCESS 0
-#define EXIT_FAILURE  1
-
-#endif
 
 
 /* Native character functions */
diff --git a/engines/glk/alan3/term.cpp b/engines/glk/alan3/term.cpp
index 6a6d25691a..24e9a882ac 100644
--- a/engines/glk/alan3/term.cpp
+++ b/engines/glk/alan3/term.cpp
@@ -42,48 +42,13 @@ bool onStatusLine = FALSE; /* To know if where printing the status line or not *
   from the header.
 
  */
-void getPageSize(void)
-{
-#ifdef HAVE_GLK
+void getPageSize(void) {
   pageLength = 0;
   pageWidth = 0;
-
-#else
-#ifdef HAVE_TERMIO
-
-#ifdef __linux__
-extern int ioctl (int __fd, unsigned long int __request, ...) __THROW;
-#else
-extern int ioctl();
-#endif
-  struct winsize win;
-  int ecode;
-
-  ecode = ioctl(1, TIOCGWINSZ, &win);
-
-  if (ecode != 0 || win.ws_row == 0)
-    pageLength = header->pageLength;
-  else
-    pageLength = win.ws_row;
-
-  if (ecode != 0 || win.ws_col == 0)
-    pageWidth = header->pageWidth;
-  else
-    pageWidth = win.ws_col;
-
-#else
-
-  pageLength = header->pageLength;
-  pageWidth = header->pageWidth;
-
-#endif
-#endif
 }
 
 /*======================================================================*/
-void statusline(void)
-{
-#ifdef HAVE_GLK
+void statusline(void) {
   uint32 glkWidth;
   char line[100];
   int pcol = col;
@@ -96,13 +61,6 @@ void statusline(void)
   g_vm->glk_window_clear(glkStatusWin);
   g_vm->glk_window_get_size(glkStatusWin, &glkWidth, NULL);
 
-#ifdef HAVE_GARGLK
-  int i;
-  glk_set_style(style_User1);
-  for (i = 0; i < glkWidth; i++)
-    glk_put_char(' ');
-#endif
-
   onStatusLine = TRUE;
   col = 1;
   g_vm->glk_window_move_cursor(glkStatusWin, 1, 0);
@@ -121,37 +79,6 @@ void statusline(void)
   onStatusLine = FALSE;
 
   g_vm->glk_set_window(glkMainWin);
-#else
-#ifdef HAVE_ANSI
-  char line[100];
-  int i;
-  int pcol = col;
-
-  if (!statusLineOption) return;
-  /* ansi_position(1,1); ansi_bold_on(); */
-  printf("\x1b[1;1H");
-  printf("\x1b[7m");
-
-  onStatusLine = TRUE;
-  col = 1;
-  sayInstance(where(HERO, FALSE));
-
-  if (header->maximumScore > 0)
-    sprintf(line, "Score %d(%d)/%d moves", current.score, header->maximumScore, current.tick);
-  else
-    sprintf(line, "%ld moves", (long)current.tick);
-  for (i=0; i < pageWidth - col - strlen(line); i++) putchar(' ');
-  printf(line);
-  printf("\x1b[m");
-  printf("\x1b[%d;1H", pageLength);
-
-  needSpace = FALSE;
-  capitalize = TRUE;
-
-  onStatusLine = FALSE;
-  col = pcol;
-#endif
-#endif
 }
 
 } // End of namespace Alan3
diff --git a/engines/glk/alan3/utils.cpp b/engines/glk/alan3/utils.cpp
index 9b9b6edbef..4b01b46d68 100644
--- a/engines/glk/alan3/utils.cpp
+++ b/engines/glk/alan3/utils.cpp
@@ -42,8 +42,7 @@ namespace Alan3 {
   return buffers...
 
  */
-void terminate(int code)
-{
+void terminate(int code) {
     newline();
 
     terminateStateStack();
@@ -53,11 +52,7 @@ void terminate(int code)
     if (memory)
         deallocate(memory);
 
-#ifdef HAVE_GLK
     g_vm->glk_exit();
-#else
-    exit(code);
-#endif
 }
 
 /*======================================================================*/
@@ -79,9 +74,8 @@ void usage(const char *programName)
     printf("\n\nUsage:\n\n");
     printf("    %s [<switches>] <adventure>\n\n", programName);
     printf("where the possible optional switches are:\n");
-#ifdef HAVE_GLK
+
     g_vm->glk_set_style(style_Preformatted);
-#endif
     printf("    -v       verbose mode\n");
     printf("    -l       log transcript to a file\n");
     printf("    -c       log player commands to a file\n");
@@ -90,9 +84,7 @@ void usage(const char *programName)
     printf("    -t[<n>]  trace game execution, higher <n> gives more trace\n");
     printf("    -i       ignore version and checksum errors\n");
     printf("    -r       make regression test easier (don't timestamp, page break, randomize...)\n");
-#ifdef HAVE_GLK
     g_vm->glk_set_style(style_Normal);
-#endif
 }