Rename sdl_bitblt_to_texture2 to sdl_bitblt_to_texture_exact to be more descriptive

makepathname() is only ever called with one of two constant string
arguments, in one case (DOS) such that it only does a strncpy(...),
and the other case (non-DOS) expanding "~" to the current user's home
directory. Additional code duplicates realpath() functionality but is
never used.

.github/workflows/build.yml

@@ -42,9 +42,17 @@ jobs:
       BUILD_TYPE: Release
     steps:
     - uses: actions/checkout@v2
+    - name: Show CMake version
+      run: cmake --version
     - name: Install X11 dependencies on MacOS
       if: ${{ runner.os == 'macOS'}}
       run: brew install --cask xquartz
+    - name: Install SDL2 dependencies on MacOS
+      if: ${{ runner.os == 'macOS'}}
+      run: brew install sdl2
+    - name: Install SDL dependency on Ubuntu
+      if: ${{ runner.os == 'Linux'}}
+      run: sudo apt-get update && sudo apt-get install -y libsdl2-dev
     - name: Create Build Environment
       run: cmake -E make_directory ${{github.workspace}}/build
     - name: Configure CMake

CMakeLists.txt

@@ -23,10 +23,12 @@ find_program(
 )
 
 IF (CLANG_TIDY_EXE)
+   IF (NOT CMAKE_CROSSCOMPILING)
 # There are many many warnings for strcpy instances to deal with,
 # but suppress it for now so that other issues are more obvious
 #
-   SET(CMAKE_C_CLANG_TIDY ${CLANG_TIDY_EXE} -checks=-*,cert-*,clang-analyzer-security.*,-clang-analyzer-security.insecureAPI.strcpy,-clang-analyzer-security.insecureAPI.bzero -header-filter=.*)
+        SET(CMAKE_C_CLANG_TIDY ${CLANG_TIDY_EXE} -checks=-*,cert-*,clang-analyzer-security.*,-clang-analyzer-security.insecureAPI.strcpy,-clang-analyzer-security.insecureAPI.bzero -header-filter=.*)
+   ENDIF()
 ENDIF()
 
 INCLUDE(CheckLibraryExists)
@@ -39,7 +41,7 @@ SET(MAIKO_DEFINITIONS
     "-DRELEASE=351"
 )
 
-OPTION(MAIKO_DISPLAY_X11 "Use X11 for display." ON)
+OPTION(MAIKO_DISPLAY_X11 "Use X11 for display." OFF)
 IF(MAIKO_DISPLAY_X11)
   FIND_PACKAGE(X11 REQUIRED)
   SET(MAIKO_DISPLAY_X11_DEFINITIONS
@@ -72,6 +74,21 @@ IF(MAIKO_DISPLAY_X11)
   )
 ENDIF()
 
+OPTION(MAIKO_DISPLAY_SDL "Use SDL for display." ON)
+IF(MAIKO_DISPLAY_SDL)
+  FIND_PACKAGE(SDL2 REQUIRED)
+  SET(MAIKO_DISPLAY_SDL_DEFINITIONS
+    "-DSDL"
+  )
+  SET(MAIKO_DISPLAY_SDL_LIBRARIES ${SDL2_LIBRARIES})
+  SET(MAIKO_DISPLAY_SDL_SRCS
+    src/sdl.c
+  )
+  SET(MAIKO_DISPLAY_SDL_HDRS
+    inc/sdldefs.h
+  )
+ENDIF()
+
 IF(CMAKE_SYSTEM_NAME STREQUAL "SunOS")
   LIST(APPEND MAIKO_DEFINITIONS
     "-DOS5"
@@ -404,6 +421,11 @@ IF(MAIKO_DISPLAY_X11)
   TARGET_LINK_LIBRARIES(lde X11::X11)
 ENDIF()
 
+IF(MAIKO_DISPLAY_SDL)
+  # Tell it that the SDL launcher is available.
+  TARGET_COMPILE_DEFINITIONS(lde PUBLIC ${MAIKO_DISPLAY_SDL_DEFINITIONS})
+ENDIF()
+
 ADD_EXECUTABLE(ldeether src/ldeether.c src/dlpi.c)
 TARGET_COMPILE_DEFINITIONS(ldeether PUBLIC ${MAIKO_DEFINITIONS})
 TARGET_INCLUDE_DIRECTORIES(ldeether PUBLIC inc)
@@ -422,6 +444,21 @@ IF(MAIKO_DISPLAY_X11)
   TARGET_LINK_LIBRARIES(ldex ${MAIKO_LIBRARIES} ${MAIKO_DISPLAY_X11_LIBRARIES})
 ENDIF()
 
+IF(MAIKO_DISPLAY_SDL)
+  ADD_EXECUTABLE(ldesdl
+    src/main.c
+    vdate.c
+    ${MAIKO_SRCS}
+    ${MAIKO_HDRS}
+    ${MAIKO_DISPLAY_SDL_SRCS}
+    ${MAIKO_DISPLAY_SDL_HDRS}
+  )
+  TARGET_COMPILE_DEFINITIONS(ldesdl PUBLIC ${MAIKO_DEFINITIONS} ${MAIKO_DISPLAY_SDL_DEFINITIONS})
+  TARGET_INCLUDE_DIRECTORIES(ldesdl PUBLIC inc)
+  TARGET_INCLUDE_DIRECTORIES(ldesdl PRIVATE ${SDL2_INCLUDE_DIRS})
+  TARGET_LINK_LIBRARIES(ldesdl ${MAIKO_LIBRARIES} ${MAIKO_DISPLAY_SDL_LIBRARIES})
+ENDIF()
+
 ADD_EXECUTABLE(mkvdate src/mkvdate.c)
 TARGET_COMPILE_DEFINITIONS(mkvdate PUBLIC ${MAIKO_DEFINITIONS})
 TARGET_INCLUDE_DIRECTORIES(mkvdate PUBLIC inc)

bin/makefile-tail

@@ -1026,6 +1026,9 @@ $(OBJECTDIR)xwinman.o: $(SRCDIR)xwinman.c $(REQUIRED-INCS) \
 	$(INCDIR)xlspwindefs.h $(INCDIR)xscrolldefs.h
 	$(CC) $(RFLAGS) $(SRCDIR)xwinman.c -o $(OBJECTDIR)xwinman.o
 
+$(OBJECTDIR)sdl.o: $(SRCDIR)sdl.c $(REQUIRED-INCS)
+	$(CC) $(RFLAGS) $(SRCDIR)sdl.c -o $(OBJECTDIR)sdl.o
+
 $(OBJECTDIR)foreign.o: $(SRCDIR)foreign.c $(REQUIRED-INCS) \
 	$(INCDIR)/foreigndefs.h
 	$(CC) $(RFLAGS) $(SRCDIR)foreign.c -o $(OBJECTDIR)foreign.o

inc/display.h

@@ -44,6 +44,10 @@ extern DLword *DISP_MAX_Address;
 #define DISPLAYBUFFER
 #endif /* XWINDOW */
 
+#ifdef SDL
+#define DISPLAYBUFFER
+#endif /* SDL */
+
 #ifdef DOS
 #define DISPLAYBUFFER
 #endif /* DOS */

inc/maindefs.h

@@ -1,6 +1,5 @@
 #ifndef MAINDEFS_H
 #define MAINDEFS_H 1
-int makepathname(char *src, char *dst);
 void start_lisp(void);
 void print_info_lines(void);
 #endif

inc/mkatomdefs.h

@@ -5,6 +5,5 @@ DLword compute_hash(const char *char_base, DLword offset, DLword length);
 DLword compute_lisp_hash(const char *char_base, DLword offset, DLword length, DLword fatp);
 LispPTR compare_chars(register const char *char1, register const char *char2, register DLword length);
 LispPTR compare_lisp_chars(register const char *char1, register const char *char2, register DLword length, DLword fat1, DLword fat2);
-LispPTR make_atom(const char *char_base, DLword offset, DLword length, short int non_numericp);
+LispPTR make_atom(const char *char_base, DLword offset, DLword length);
-LispPTR parse_number(const char *char_base, short int length);
 #endif

inc/sdldefs.h

@@ -0,0 +1,11 @@
+#ifndef SDLDEFS_H
+#define SDLDEFS_H 1
+
+void sdl_notify_damage(int x, int y, int w, int h);
+void sdl_setCursor(int hot_x, int hot_y);
+void sdl_bitblt_to_screen(int x, int y, int w, int h);
+void sdl_set_invert(int flag);
+void sdl_setMousePosition(int x, int y);
+void process_SDLevents();
+int init_SDL(char *windowtitle, int w, int h, int s);
+#endif

inc/timeout.h

@@ -61,8 +61,8 @@ extern	int	TIMEOUT_TIME;
 /************************************************************************/
 
 #define INTRSAFE(exp)				\
-  do {} while ((int)(exp) == -1 && errno == EINTR)
+  do {errno = 0; } while ((exp) == -1 && errno == EINTR)
 
 #define INTRSAFE0(exp)				\
-  do {} while ((int)(exp) == 0 && errno == EINTR)
+  do {errno = 0; } while ((exp) == NULL && errno == EINTR)
 #endif /* TIMEOUT_H */

inc/tosfns.h

@@ -513,7 +513,8 @@
 #ifndef BIGATOMS
 #define EVAL                                                                   \
   do {                                                                         \
-    LispPTR scratch, work, lookuped;                                           \
+    LispPTR work, lookuped;                                                    \
+    DLword scratch[2];                                                         \
     switch (TOPOFSTACK & SEGMASK) {                                            \
     case S_POSITIVE:                                                           \
     case S_NEGATIVE:                                                           \
@@ -521,8 +522,8 @@
     case ATOM_OFFSET:                                                          \
       if ((TOPOFSTACK == NIL_PTR) || (TOPOFSTACK == ATOM_T))                   \
         goto Hack_Label;                                                       \
-      nnewframe(CURRENTFX, &scratch, TOPOFSTACK & 0xffff);                     \
+      nnewframe(CURRENTFX, scratch, TOPOFSTACK & 0xffff);                      \
-      work = POINTERMASK & swapx(scratch);                                     \
+      work = POINTERMASK & ((GETBASEWORD(scratch,1) << 16) | GETBASEWORD(scratch,0)); \
       lookuped = *((LispPTR *)(Addr68k_from_LADDR(work)));                     \
       if (lookuped == NOBIND_PTR)                                              \
         goto op_ufn;                                                           \
@@ -552,7 +553,8 @@
 #else
 #define EVAL                                                                   \
   do {                                                                         \
-    LispPTR scratch, work, lookuped;                                           \
+    LispPTR work, lookuped;                                                    \
+    DLword scratch[2];                                                         \
     switch (TOPOFSTACK & SEGMASK) {                                            \
     case S_POSITIVE:                                                           \
     case S_NEGATIVE:                                                           \
@@ -560,8 +562,8 @@
     case ATOM_OFFSET:                                                          \
       if ((TOPOFSTACK == NIL_PTR) || (TOPOFSTACK == ATOM_T))                   \
         goto Hack_Label;                                                       \
-      nnewframe(CURRENTFX, &scratch, TOPOFSTACK & 0xffff);                     \
+      nnewframe(CURRENTFX, scratch, TOPOFSTACK & 0xffff);                      \
-      work = POINTERMASK & swapx(scratch);                                     \
+      work = POINTERMASK & ((GETBASEWORD(scratch,1) << 16) | GETBASEWORD(scratch,0)); \
       lookuped = *((LispPTR *)(Addr68k_from_LADDR(work)));                     \
       if (lookuped == NOBIND_PTR)                                              \
         goto op_ufn;                                                           \
@@ -584,8 +586,8 @@
         fn_apply = 0;                                                          \
         goto op_fn_common;                                                     \
       case TYPE_NEWATOM:                                                       \
-        nnewframe(CURRENTFX, &scratch, TOPOFSTACK);                            \
+        nnewframe(CURRENTFX, scratch, TOPOFSTACK);                             \
-        work = POINTERMASK & swapx(scratch);                                   \
+        work = POINTERMASK & ((GETBASEWORD(scratch,1) << 16) | GETBASEWORD(scratch,0)); \
         lookuped = *((LispPTR *)(Addr68k_from_LADDR(work)));                   \
         if (lookuped == NOBIND_PTR)                                            \
           goto op_ufn;                                                         \

inc/xinitdefs.h

@@ -6,5 +6,5 @@ void lisp_Xexit(DspInterface dsp);
 void Xevent_before_raid(DspInterface dsp);
 void Xevent_after_raid(DspInterface dsp);
 void Open_Display(DspInterface dsp);
-DspInterface X_init(DspInterface dsp, char *lispbitmap, int width_hint, int height_hint, int depth_hint);
+DspInterface X_init(DspInterface dsp, LispPTR lispbitmap, int width_hint, int height_hint, int depth_hint);
 #endif

src/bbtsub.c

@@ -479,6 +479,10 @@ do_it_now:
   if (in_display_segment(dstbase)) flush_display_region(dx, dty, w, h);
 #endif /* XWINDOW */
 
+#ifdef SDL
+  if (in_display_segment(dstbase)) flush_display_region(dx, dty, w, h);
+#endif /* XWINDOW */
+
 #ifdef DOS
   /* Copy the changed section of display bank to the frame buffer */
   if (in_display_segment(dstbase)) {
@@ -834,6 +838,10 @@ do_it_now:
   if (in_display_segment(dstbase)) flush_display_region(dlx, dty, width, height);
 #endif /* XWINDOW */
 
+#ifdef SDL
+  if (in_display_segment(dstbase)) flush_display_region(dlx, dty, width, height);
+#endif /* SDL */
+
 #ifdef DOS
   /* Copy the changed section of display bank to the frame buffer */
   if (in_display_segment(dstbase)) {
@@ -1081,6 +1089,10 @@ do_it_now:
   if (in_display_segment(dstbase)) flush_display_region(left, dty, width, height);
 #endif /* XWINDOW */
 
+#ifdef SDL
+  if (in_display_segment(dstbase)) flush_display_region(left, dty, width, height);
+#endif /* SDL */
+
 #ifdef DOS
   /* Copy the changed section of display bank to the frame buffer */
   if (in_display_segment(dstbase)) {
@@ -1210,6 +1222,10 @@ void bltchar(LispPTR *args)
   if (in_display_segment(dstbase)) flush_display_lineregion(dx, dstbase, w, h);
 #endif /* XWINDOW */
 
+#ifdef SDL
+  if (in_display_segment(dstbase)) flush_display_lineregion(dx, dstbase, w, h);
+#endif /* SDL */
+
 #ifdef DOS
   if (in_display_segment(dstbase)) flush_display_lineregion(dx, dstbase, w, h);
 #endif /* DOS */
@@ -1423,6 +1439,9 @@ void newbltchar(LispPTR *args) {
 #ifdef XWINDOW
   if (in_display_segment(dstbase)) flush_display_lineregion(dx, dstbase, w, h);
 #endif /* XWINDOW */
+#ifdef SDL
+  if (in_display_segment(dstbase)) flush_display_lineregion(dx, dstbase, w, h);
+#endif /* SDL */
 #ifdef DOS
   if (in_display_segment(dstbase)) flush_display_lineregion(dx, dstbase, w, h);
 #endif /* DOS */

src/dir.c

@@ -691,7 +691,7 @@ static int enum_dsk_prop(char *dir, char *name, char *ver, FINFO **finfo_buf)
       nextp->prop->wdate = (unsigned)ToLispTime(sbuf.st_mtime);
       nextp->prop->rdate = (unsigned)ToLispTime(sbuf.st_atime);
       nextp->prop->protect = (unsigned)sbuf.st_mode;
-      TIMEOUT(pwd = getpwuid(sbuf.st_uid));
+      TIMEOUT0(pwd = getpwuid(sbuf.st_uid));
       if (pwd == (struct passwd *)NULL) {
         nextp->prop->au_len = 0;
       } else {
@@ -1080,7 +1080,7 @@ static int enum_ufs_prop(char *dir, char *name, char *ver, FINFO **finfo_buf)
   char namebuf[MAXPATHLEN];
 
   errno = 0;
-  TIMEOUT(dirp = opendir(dir));
+  TIMEOUT0(dirp = opendir(dir));
   if (dirp == NULL) {
     *Lisp_errno = errno;
     return (-1);
@@ -1263,7 +1263,7 @@ static int enum_ufs(char *dir, char *name, char *ver, FINFO **finfo_buf)
   char namebuf[MAXPATHLEN];
 
   errno = 0;
-  TIMEOUT(dirp = opendir(dir));
+  TIMEOUT0(dirp = opendir(dir));
   if (dirp == NULL) {
     *Lisp_errno = errno;
     return (-1);

src/draw.c

@@ -17,10 +17,10 @@
 
 #include "version.h"
 
+#include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 
-
 #include "lispemul.h"
 #include "lspglob.h"
 #include "lispmap.h"
@@ -268,21 +268,21 @@ int N_OP_drawline(LispPTR ptr, int curbit, int xsize, int width, int ysize, int
 #endif /* COLOR */
 
   {
-    DLword *start_addr, *temp_s, *temp_e;
+    DLword *start_addr;
-
     start_addr = (DLword *)Addr68k_from_LADDR(ptr);
 
-    if (((int)(temp_s = (DLword *)(start_addr - DisplayRegion68k)) >= 0) &&
+    if (in_display_segment(start_addr) && in_display_segment(dataptr)) {
-        (start_addr < DisplayRegion68k_end_addr) &&
-        ((int)(temp_e = (DLword *)(dataptr - DisplayRegion68k)) >= 0) &&
-        ((DLword *)dataptr < DisplayRegion68k_end_addr)) {
       int start_x, start_y, end_x, end_y, w, h;
+      ptrdiff_t temp_s, temp_e;
 
-      start_y = (int)temp_s / DisplayRasterWidth;
+      temp_s = start_addr - DisplayRegion68k;
-      start_x = ((int)temp_s % DisplayRasterWidth) * BITSPER_DLWORD;
+      temp_e = dataptr - DisplayRegion68k;
 
-      end_y = (int)temp_e / DisplayRasterWidth;
+      start_y = temp_s / DisplayRasterWidth;
-      end_x = ((int)temp_e % DisplayRasterWidth) * BITSPER_DLWORD + (BITSPER_DLWORD - 1);
+      start_x = (temp_s % DisplayRasterWidth) * BITSPER_DLWORD;
+
+      end_y = temp_e / DisplayRasterWidth;
+      end_x = (temp_e % DisplayRasterWidth) * BITSPER_DLWORD + (BITSPER_DLWORD - 1);
 
       w = abs(start_x - end_x) + 1;
       h = abs(start_y - end_y) + 1;
@@ -290,10 +290,8 @@ int N_OP_drawline(LispPTR ptr, int curbit, int xsize, int width, int ysize, int
       if (start_x > end_x) start_x = end_x;
       if (start_y > end_y) start_y = end_y;
 
-
 #if defined(XWINDOW) || defined(BYTESWAP)
       flush_display_region(start_x, start_y, w, h);
-
 #endif /* XWINDOW */
     }
   }

src/dsk.c

@@ -1702,7 +1702,7 @@ LispPTR COM_getfileinfo(register LispPTR *args)
     case AUTHOR: {
       size_t rval;
 #ifndef DOS
-      TIMEOUT(pwd = getpwuid(sbuf.st_uid));
+      TIMEOUT0(pwd = getpwuid(sbuf.st_uid));
       if (pwd == (struct passwd *)NULL) {
         /*
          * Returns Lisp 0.  Lisp code handles this case as author
@@ -1748,7 +1748,7 @@ LispPTR COM_getfileinfo(register LispPTR *args)
       bufp = (unsigned *)(Addr68k_from_LADDR(laddr));
       *bufp = sbuf.st_mode;
 #ifndef DOS
-      TIMEOUT(pwd = getpwuid(sbuf.st_uid));
+      TIMEOUT0(pwd = getpwuid(sbuf.st_uid));
       if (pwd == (struct passwd *)NULL) { return (GetSmallp(0)); }
       laddr = cdr(car(cdr(cdr(cdr(cdr(args[2]))))));
       STRING_BASE(laddr, base);

src/dspif.c

@@ -27,9 +27,6 @@ DspInterface currentdsp = &curdsp;
 #ifdef XWINDOW
 extern int LispDisplayRequestedWidth;
 extern int LispDisplayRequestedHeight;
-
-extern DspInterface X_init(DspInterface dsp, char *lispbitmap, int width_hint, int height_hint,
-                           int depth_hint);
 #endif /* XWINDOW */
 
 #ifdef DOS

src/dspsubrs.c

@@ -21,9 +21,11 @@
 
 #include "dspsubrsdefs.h"
 #include "commondefs.h"
-#ifdef XWINDOW
+#if defined(XWINDOW)
 #include "xcursordefs.h"
 #include "xlspwindefs.h"
+#elif defined(SDL)
+#include "sdldefs.h"
 #endif
 
 extern int DebugDSP;
@@ -72,6 +74,13 @@ LispPTR DSP_VideoColor(LispPTR *args) /* args[0] :	black flag	*/
     return ATOM_T;
   else
     return NIL;
+#elif defined(SDL)
+  invert = args[0] & 0xFFFF;
+  sdl_set_invert(invert);
+  if (invert)
+    return ATOM_T;
+  else
+    return NIL;
 #else
   return NIL;
 #endif
@@ -96,9 +105,11 @@ void DSP_Cursor(LispPTR *args, int argnum)
   extern int LastCursorX, LastCursorY;
 
 
-#ifdef XWINDOW
+#if defined(XWINDOW)
   /* For X-Windows, set the cursor to the given location. */
   Set_XCursor((int)(args[0] & 0xFFFF), (int)(args[1] & 0xFFFF));
+#elif defined(SDL)
+  sdl_setCursor((int)(args[0] & 0xFFFF), (int)(args[1] & 0xFFFF));
 #endif /* XWINDOW */
 }
 
@@ -118,6 +129,11 @@ void DSP_SetMousePos(register LispPTR *args)
   if (Mouse_Included)
     set_Xmouseposition((int)(GetSmalldata(args[0])), (int)(GetSmalldata(args[1])));
 #endif /* XWINDOW */
+#ifdef SDL
+  int x = (int)(GetSmalldata(args[0]));
+  int y = (int)(GetSmalldata(args[1]));
+  sdl_setMousePosition(x, y);
+#endif /* SDL */
 }
 
 /****************************************************
@@ -178,8 +194,10 @@ void flip_cursor() {
 #endif
 
 
-#ifdef XWINDOW
+#if defined(XWINDOW)
   /* JDS 011213: 15- cur y, as function does same! */
   Set_XCursor(Current_Hot_X, 15 - Current_Hot_Y);
+#elif defined(SDL)
+  sdl_setCursor(0, 0); // TODO: keep track of the current hot_x and hot_y
 #endif /* XWINDOW */
 }

src/ether.c

@@ -742,7 +742,7 @@ static int check_filter(u_char *buffer)
 static void init_uid() {
   int rid;
   rid = getuid();
-  seteuid(rid);
+  setuid(rid);
 }
 #endif /* MAIKO_ENABLE_ETHERNET */
 
@@ -830,7 +830,7 @@ void init_ether() {
         /* JDS 991228 remove	perror("Can't open network; XNS unavailable.\n"); */
         ether_fd = -1;
       }
-      seteuid(getuid());
+      setuid(getuid());
     }
 #elif defined(USE_NIT)
 #ifndef OS4
@@ -952,7 +952,7 @@ void init_ether() {
     perror("Can't open network; XNS unavailable.\n");
     ether_fd = -1;
   }
-  seteuid(getuid());
+  setuid(getuid());
 }
 
 #endif /* OS4 */

src/initdsp.c

@@ -66,6 +66,7 @@ extern DspInterface currentdsp;
 int LispWindowFd = -1;
 int FrameBufferFd = -1;
 
+extern int sdl_displaywidth, sdl_displayheight, sdl_pixelscale;
 int displaywidth, displayheight, DisplayRasterWidth, DisplayType;
 int DisplayByteSize;
 DLword *DisplayRegion68k; /* 68k addr of #{}22,0 */
@@ -89,6 +90,10 @@ extern DLword *ColorDisplayRegion68k;
 extern int MonoOrColor;
 #endif /* COLOR */
 
+#ifdef SDL
+extern void sdl_notify_damage(int, int, int, int);
+#endif /* SDL */
+
 #ifdef XWINDOW
 DLword *DisplayRegion68k_end_addr;
 extern int *Xdisplay; /* DAANGER -jarl nilsson 27-apr-92 */
@@ -180,7 +185,10 @@ void init_display2(DLword *display_addr, int display_max)
   displaywidth = currentdsp->Display.width;
   displayheight = currentdsp->Display.height;
 #endif /* XWINDOW */
-
+#if (defined(SDL))
+  displaywidth = sdl_displaywidth;
+  displayheight = sdl_displayheight;
+#endif /* SDL */
   DisplayRasterWidth = displaywidth / BITSPER_DLWORD;
 
   if ((displaywidth * displayheight) > display_max) { displayheight = display_max / displaywidth; }
@@ -194,7 +202,9 @@ void init_display2(DLword *display_addr, int display_max)
   DisplayType = SUN2BW;
   DisplayRegion68k_end_addr = DisplayRegion68k + DisplayRasterWidth * displayheight;
 #endif /* XWINDOW */
-
+#ifdef SDL
+  DisplayType = SUN2BW;
+#endif /* SDL */
   init_cursor();
   DisplayByteSize = ((displaywidth * displayheight / 8 + (getpagesize() - 1)) & -getpagesize());
 
@@ -266,7 +276,10 @@ in_display_segment(baseaddr)
 /************************************************************************/
 
 void flush_display_buffer() {
-
+  //  printf("flush_display_buffer\n");
+#ifdef SDL
+  sdl_notify_damage(0, 0, sdl_displaywidth, sdl_displayheight);
+#endif
 #ifdef XWINDOW
   (currentdsp->bitblt_to_screen)(currentdsp, DisplayRegion68k, currentdsp->Visible.x,
                                  currentdsp->Visible.y, currentdsp->Visible.width,
@@ -297,7 +310,10 @@ void flush_display_buffer() {
 
 void flush_display_region(int x, int y, int w, int h)
 {
-
+  //  printf("flush_display_region %d %d %d %d\n", x, y, w, h);
+#ifdef SDL
+  sdl_notify_damage(x, y, w, h);
+#endif
 #if (defined(XWINDOW) || defined(DOS))
   TPRINT(("Enter flush_display_region x=%d, y=%d, w=%d, h=%d\n", x, y, w, h));
   (currentdsp->bitblt_to_screen)(currentdsp, DisplayRegion68k, x, y, w, h);
@@ -340,7 +356,10 @@ void flush_display_lineregion(UNSIGNED x, DLword *ybase, UNSIGNED w, UNSIGNED h)
 {
   int y;
   y = ((DLword *)ybase - DisplayRegion68k) / DLWORD_PERLINE;
-
+  //  printf("flush_display_lineregion %d %d %d %d\n", x, y, w, h);
+#ifdef SDL
+  sdl_notify_damage(x, y, w, h);
+#endif
 #if (defined(XWINDOW) || defined(DOS))
   TPRINT(("Enter flush_display_lineregion x=%d, y=%d, w=%d, h=%d\n", x, y, w, h));
   (currentdsp->bitblt_to_screen)(currentdsp, DisplayRegion68k, x, y, w, h);
@@ -371,7 +390,10 @@ void flush_display_ptrregion(DLword *ybase, UNSIGNED bitoffset, UNSIGNED w, UNSI
   baseoffset = (((DLword *)ybase) - DisplayRegion68k);
   y = baseoffset / DLWORD_PERLINE;
   x = bitoffset + (BITSPERWORD * (baseoffset - (DLWORD_PERLINE * y)));
-
+  //  printf("flush_display_ptrregion %d %d %d %d\n", x, y, w, h);
+#ifdef SDL
+  sdl_notify_damage(x, y, w, h);
+#endif
 #if   (defined(XWINDOW) || defined(DOS))
   TPRINT(("Enter flush_display_ptrregion\n x=%d, y=%d, w=%d, h=%d\n", x, y, w, h));
   (currentdsp->bitblt_to_screen)(currentdsp, DisplayRegion68k, x, y, w, h);

src/initkbd.c

@@ -273,6 +273,7 @@ void set_kbd_iopointers() {
 #define KB_HP9000 (10 + MIN_KEYTYPE)  /* TODO: Can we remove this? */
 #define KB_X (11 + MIN_KEYTYPE)
 #define KB_DOS (12 + MIN_KEYTYPE)
+#define KB_SDL (13 + MIN_KEYTYPE)
 
 /* KB_SUN4 not defined in older OS versions */
 #ifndef KB_SUN4
@@ -432,6 +433,8 @@ void keyboardtype(int fd)
     type = KB_X;
 #elif DOS
     type = KB_DOS;
+#elif SDL
+    type = KB_SDL;
 #endif /* XWINDOW */
   } /* if end */
   else {
@@ -447,6 +450,8 @@ void keyboardtype(int fd)
       type = KB_X;
     else if (strcmp("x", key) == 0)
       type = KB_X;
+    else if (strcmp("sdl", key) == 0)
+      type = KB_SDL;
     else
       type = KB_SUN3; /* default */
   }
@@ -483,7 +488,11 @@ void keyboardtype(int fd)
       InterfacePage->devconfig |= KB_SUN3 - MIN_KEYTYPE; /* 10 */
       break;
 #endif /* XWINDOW */
-
+#ifdef SDL
+  case KB_SDL:
+    InterfacePage->devconfig |= KB_SUN3 - MIN_KEYTYPE; /* 10 */
+    break;
+#endif /* SDL */
 #ifdef DOS
     case KB_DOS:
       SUNLispKeyMap = DOSLispKeyMap_101;

src/initsout.c

@@ -139,8 +139,7 @@ void init_ifpage(int sysout_size) {
 
 #ifdef BIGVM
   /* For BIGVM system, save the value in \LASTVMEMFILEPAGE for lisp's use */
-  if ((LispPTR)LASTVMEMFILEPAGE_word != 0xFFFFFFFF)
+  *LASTVMEMFILEPAGE_word = InterfacePage->dllastvmempage;
-    *LASTVMEMFILEPAGE_word = InterfacePage->dllastvmempage;
 #endif /* BIGVM */
 
   /* unfortunately, Lisp only looks at a 16 bit serial number */

src/keyevent.c

@@ -58,7 +58,9 @@ void Mouse_hndlr(void); /* Fields mouse events from driver        */
 
 #include "keyeventdefs.h"
 #include "osmsgdefs.h"
+#ifdef XWINDOW
 #include "xwinmandefs.h"
+#endif
 
 #ifdef MAIKO_ENABLE_ETHERNET
 #include "etherdefs.h"

src/ldeboot.c

@@ -35,7 +35,9 @@
 #include <X11/Xutil.h>
 #define LDEX "ldex"
 #endif /* XWINDOW */
-
+#ifdef SDL
+#define LDESDL "ldesdl"
+#endif
 #define LDEMONO "ldesingle"
 #define LDECOLOR "ldemulti"
 #define LDETRUECOLOR "ldetruecolor"
@@ -133,7 +135,9 @@ int main(int argc, char *argv[])
     }   /* end if */
   }
 #endif /* XWINDOW */
-
+#ifdef SDL
+  strcpy(filetorun,LDESDL);
+#endif /* SDL */
 #ifdef USESUNSCREEN
   if ((FrameBufferFd = open("/dev/fb", O_RDWR)) < 0) {
     fprintf(stderr, "ldeboot: can't open FrameBuffer\n");
@@ -187,7 +191,6 @@ int main(int argc, char *argv[])
     fork_Unix();
 
   /* start ldemono or ldecolor */
-
   if (filetorun[0] == '\0') {
     fprintf(stderr, "Unable to determine what display program to run.\n");
     exit(1);

src/ldeether.c

@@ -214,7 +214,7 @@ int main(int argc, char *argv[]) {
       ether_fd = -1;
       /*	exit();	*/
     }
-    seteuid(getuid());
+    setuid(getuid());
   }
 
   /* OK, right here do other stuff like scan args */

src/main.c

@@ -236,10 +236,6 @@ int display_max = 65536 * 16 * 2;
 /* diagnostic flag for sysout dumping */
 extern int maxpages;
 
-/** For call makepathname inside main() **/
-extern int *Lisp_errno;
-extern int Dummy_errno; /* If errno cell is not provided by Lisp, dummy_errno is used. */
-
 char sysout_name[MAXPATHLEN]; /* Set by read_Xoption, in the X version. */
 int sysout_size = 0;    /* ditto */
 
@@ -249,7 +245,9 @@ int flushing = FALSE; /* see dbprint.h if set, all debug/trace printing will cal
 #include "devif.h"
 extern DspInterface currentdsp;
 #endif /* DOS || XWINDOW */
-
+#ifdef SDL
+extern int init_SDL(char*, int, int, int);
+#endif
 extern time_t MDate;
 extern int nokbdflag;
 extern int nomouseflag;
@@ -287,7 +285,18 @@ const char *helpstring =
  -bw <pixels>             The Medley screen borderwidth\n\
  -g[eometry] <geom>]      The Medley screen geometry\n\
  -sc[reen] <w>x<h>]       The Medley screen geometry\n";
-#else  /* not DOS, not XWINDOW */
+#elif SDL
+const char *helpstring =
+    "\n\
+ either setenv LDESRCESYSOUT or do:\n\
+ medley [<sysout-name>] [<options>]\n\
+ -info                    Print general info about the system\n\
+ -help                    Print this message\n\
+ -pixelscale <n>          The amount of pixels to show for one Medley screen pixel.\n\
+ -sc[reen] <w>x<h>]       The Medley screen geometry\n\
+ -t <title>               The window title\n\
+ -title <title>           The window title\n";
+#else  /* not DOS, not XWINDOW, not SDL */
 const char *helpstring =
     "\n\
  either setenv LDESRCESYSOUT or do:\n\
@@ -310,6 +319,9 @@ int main(int argc, char *argv[])
   extern int TIMER_INTERVAL;
   extern fd_set LispReadFds;
   int tmpint;
+  int width = 1024, height = 768;
+  int pixelscale = 1;
+  char *windowtitle = "Medley";
 #ifdef MAIKO_ENABLE_FOREIGN_FUNCTION_INTERFACE
   if (dld_find_executable(argv[0]) == 0) {
     perror("Name of executable not found.");
@@ -336,9 +348,6 @@ int main(int argc, char *argv[])
         Barf and print the command line if tha fails
 */
 
-  /* For call makepathname */
-  Lisp_errno = &Dummy_errno;
-
   i = 1;
 
   if (argv[i] && ((strcmp(argv[i], "-info") == 0) || (strcmp(argv[i], "-INFO") == 0))) {
@@ -358,13 +367,18 @@ int main(int argc, char *argv[])
     strncpy(sysout_name, envname, MAXPATHLEN);
   } else if ((envname = getenv("LDESOURCESYSOUT")) != NULL)
     strncpy(sysout_name, envname, MAXPATHLEN);
+  else {
 #ifdef DOS
-  else if (!makepathname("lisp.vm", sysout_name)
+    strncpy(sysout_name, "lisp.vm", MAXPATHLEN);
 #else
-  else if (!makepathname("~/lisp.virtualmem", sysout_name)
+    if ((envname = getenv("HOME")) != NULL) {
+      strncpy(sysout_name, envname, MAXPATHLEN);
+      strncat(sysout_name, "/lisp.virtualmem", MAXPATHLEN - 17);
+    }
 #endif /* DOS */
-           || access(sysout_name, R_OK)) {
+  }
-    fprintf(stderr, "Couldn't find a sysout to run;\n");
+  if (access(sysout_name, R_OK)) {
+    perror("Couldn't find a sysout to run");
     fprintf(stderr, "%s", helpstring);
     exit(1);
   }
@@ -435,7 +449,40 @@ int main(int argc, char *argv[])
     }
 
 #endif /* DOS */
+#ifdef SDL
+    else if ((strcmp(argv[i], "-sc") == 0) || (strcmp(argv[i], "-SC") == 0)) {
+      if (argc > ++i) {
+        int read = sscanf(argv[i], "%dx%d", &width, &height);
+        if(read != 2) {
+          fprintf(stderr, "Could not parse -sc argument %s\n", argv[i]);
+          exit(1);
+        }
+      } else {
+        fprintf(stderr, "Missing argument after -sc\n");
+        exit(1);
+      }
+    } else if ((strcmp(argv[i], "-pixelscale") == 0) || (strcmp(argv[i], "-PIXELSCALE") == 0)) {
+      if (argc > ++i) {
+        int read = sscanf(argv[i], "%d", &pixelscale);
+        if(read != 1) {
+          fprintf(stderr, "Could not parse -pixelscale argument %s\n", argv[i]);
+          exit(1);
+        }
+      } else {
+        fprintf(stderr, "Missing argument after -pixelscale\n");
+        exit(1);
+      }
+    } else if ((strcmp(argv[i], "-t") == 0) || (strcmp(argv[i], "-T") == 0)
+               || (strcmp(argv[i], "-title") == 0) || (strcmp(argv[i], "-TITLE") == 0)) {
+      if (argc > ++i) {
+        windowtitle = argv[i];
+      } else {
+        fprintf(stderr, "Missing argument after -title\n");
+        exit(1);
+      }
+    }
 
+#endif /* SDL */
     /* Can only do this under SUNOs, for now */
     else if (!strcmp(argv[i], "-E")) { /**** ethernet info	****/
 #ifdef MAIKO_ENABLE_ETHERNET
@@ -486,9 +533,9 @@ int main(int argc, char *argv[])
   probemouse(); /* See if the mouse is connected. */
 #else
   if (getuid() != geteuid()) {
-    fprintf(stderr, "Effective user is not real user.  Setting euid to uid.\n");
+    fprintf(stderr, "Effective user is not real user.  Resetting uid\n");
-    if (seteuid(getuid()) == -1) {
+    if (setuid(getuid()) == -1) {
-      fprintf(stderr, "Unable to reset effective user id to real user id\n");
+      fprintf(stderr, "Unable to reset user id to real user id\n");
       exit(1);
     }
   }
@@ -515,7 +562,9 @@ int main(int argc, char *argv[])
 #if defined(DOS) || defined(XWINDOW)
   make_dsp_instance(currentdsp, 0, 0, 0, 1); /* All defaults the first time */
 #endif                                       /* DOS || XWINDOW */
-
+#if defined(SDL)
+  init_SDL(windowtitle, width, height, pixelscale);
+#endif /* SDL */
   /* Load sysout to VM space and returns real sysout_size(not 0) */
   sysout_size = sysout_loader(sysout_name, sysout_size);
 
@@ -614,86 +663,6 @@ void start_lisp() {
   dispatch();
 }
 
-/************************************************************************/
-/*									*/
-/*			m a k e p a t h n a m e				*/
-/*									*/
-/*									*/
-/*									*/
-/************************************************************************/
-
-int makepathname(char *src, char *dst)
-{
-  register char *base, *cp;
-  register struct passwd *pwd;
-  char name[MAXPATHLEN];
-
-  base = src;
-  switch (*base) {
-    case '.':
-      if (getcwd(dst, MAXPATHLEN) == 0)
-      { /* set working directory */
-        *Lisp_errno = errno;
-        return (0);
-      }
-      switch (*(base + 1)) {
-        case '.':
-          if (*(base + 2) == '/') { /* Now, base == "../xxxx" */
-            cp = (char *)strrchr(dst, '/');
-            if (cp == 0) return (0);
-            *cp = '\0';
-            strcat(dst, base + 2);
-            return (1);
-          } else
-            return (0);
-        case '/':
-          /* Now, base == "./xxx" */
-          strcat(dst, base + 1);
-          return (1);
-        default: return (0);
-      }
-    case '~':
-      ERRSETJMP(0);
-      if (*(base + 1) == '/') {
-/* path is "~/foo" */
-#ifdef DOS
-        pwd = 0;
-#else
-        TIMEOUT(pwd = getpwuid(getuid()));
-#endif /* DOS */
-        if (pwd == NULL) {
-          *Lisp_errno = errno;
-          return (0);
-        }
-#ifndef DOS
-        sprintf(dst, "%s%s", pwd->pw_dir, base + 1);
-#endif
-        return (1);
-      } else {
-        /* path is "~foo/" */
-        if ((cp = (char *)strchr(base + 1, '/')) == 0)
-          return (0);
-        else {
-          size_t len = cp - base - 1;
-          strncpy(name, base + 1, len);
-          name[len] = '\0';
-#ifndef DOS
-          TIMEOUT(pwd = getpwnam(name));
-#endif /* DOS */
-          if (pwd == NULL) {
-            *Lisp_errno = errno;
-            return (0);
-          }
-#ifndef DOS
-          sprintf(dst, "%s%s", pwd->pw_dir, cp);
-#endif /* DOS */
-          return (1);
-        }
-      }
-    default: strcpy(dst, src); return (1);
-  }
-}
-
 void print_info_lines() {
 #if (RELEASE == 200)
   printf("Emulator for Medley release 2.0\n");

src/mkatom.c

@@ -27,7 +27,6 @@
                         compute_hash
                         create_symbol
                         compare_chars
-                        parse_number
 */
 /**********************************************************************/
 
@@ -248,10 +247,11 @@ LispPTR compare_lisp_chars(register const char *char1, register const char *char
 /*
         Func name :	make_atom
 
-        If the atom already existed then return
+        Look up the atom index of an existing atom, or return 0xFFFFFFFF
-        else create new atom .  Returns the Atom's index.
 
-        This function does not handle FAT pname's.
+        This function is a subset of \MKATOM (in LLBASIC), but only handles
+        thin text atom names (no numbers, no 2-byte pnames).
+        It MUST return the same atom index number as \MKATOM
 
         Date :		January 29, 1987
         Edited by :	Takeshi Shimizu
@@ -264,8 +264,7 @@ LispPTR compare_lisp_chars(register const char *char1, register const char *char
 */
 /**********************************************************************/
 
-LispPTR make_atom(const char *char_base, DLword offset, DLword length, short int non_numericp)
+LispPTR make_atom(const char *char_base, DLword offset, DLword length)
-/* if it is NIL then these chars are treated as NUMBER */
 {
   extern DLword *AtomHT;
   extern DLword *Pnamespace;
@@ -281,41 +280,34 @@ LispPTR make_atom(const char *char_base, DLword offset, DLword length, short int
   unsigned short first_char;
 
 #ifdef TRACE2
-  printf("TRACE: make_atom( %s , offset= %d, len= %d, non_numericp = %d)\n", char_base, offset,
+  printf("TRACE: make_atom( %s , offset= %d, len= %d)\n", char_base, offset, length);
-         length, non_numericp);
 #endif
 
   first_char = (*(char_base + offset)) & 0xff;
-  if (length != 0) {
+  switch (length) {
-    if (length == 1) /* one char. atoms */
+  case 0:
-    {
+    /* the zero-length atom has hashcode 0 */
-      if (first_char > 57) /* greater than '9 */
-        return ((LispPTR)(ATOMoffset + (first_char - 10)));
-      else if (first_char > 47) /* between '0 to '9 */
-        return ((LispPTR)(S_POSITIVE + (first_char - 48)));
-      /* fixed S_... mar-27-87 take */
-      else /* other one char. atoms */
-        return ((LispPTR)(ATOMoffset + first_char));
-    } /* if(length==1.. end */
-    else if ((non_numericp == NIL) && (first_char <= '9'))
-    /* more than 10 arithmetic  aon + - mixed atom process */
-    {
-      if ((hash_entry = parse_number(char_base + offset, length)) != 0)
-        return ((LispPTR)hash_entry); /* if NIL that means THE ATOM is +- mixed litatom */
-                                      /* 15 may 87 take */
-    }
-
-    hash = compute_hash(char_base, offset, length);
-
-  } /* if(lengt.. end */
-  else {
     hash = 0;
     first_char = 255;
+    break;
+
+  case 1:
+    /* One-character atoms live in well known places, no need to hash */
+    if (first_char > '9')
+      return ((LispPTR)(ATOMoffset + (first_char - 10)));
+    if (first_char >= '0' ) /* 0..9 */
+      return ((LispPTR)(S_POSITIVE + (first_char - '0')));
+    /* other one character atoms */
+    return ((LispPTR)(ATOMoffset + first_char));
+
+  default:
+    hash = compute_hash(char_base, offset, length);
+    break;
   }
 
   /* This point corresponds with LP in Lisp source */
 
-  /* following for loop never exits until it finds new hash entry or same atom */
+  /* following for loop does not exit until it finds new hash entry or same atom */
   for (reprobe = Atom_reprobe(hash, first_char); (hash_entry = GETWORD(AtomHT + hash)) != 0;
        hash = ((hash + reprobe) & 0xffff)) {
     atom_index = hash_entry - 1;
@@ -326,7 +318,7 @@ LispPTR make_atom(const char *char_base, DLword offset, DLword length, short int
     if ((length == GETBYTE(pname_base)) &&
         (compare_chars(++pname_base, char_base + offset, length) == T)) {
       DBPRINT(("FOUND the atom. \n"));
-      return (atom_index); /* find already existed atom */
+      return (atom_index); /* found existing atom */
     }
     DBPRINT(("HASH doesn't hit. reprobe!\n"));
 
@@ -337,65 +329,3 @@ LispPTR make_atom(const char *char_base, DLword offset, DLword length, short int
   return (0xffffffff);
   /** Don't create newatom now **/
 } /* make_atom end */
-
-/*********************************************************************/
-/*
-        Func name :	parse_number
-
-        Desc	:	It can treat -65534 to 65535 integer
-                        Returns SMALLP PTR
-        Date :		1,May 1987 Take
-                        15 May 87 take
-*/
-/*********************************************************************/
-
-/* Assume this func. should be called with C string in "char_base" */
-LispPTR parse_number(const char *char_base, short int length) {
-  register LispPTR sign_mask;
-  register LispPTR val;
-  register int radix;
-  register int *cell68k;
-
-#ifdef TRACE2
-  printf("TRACE: parse_number()\n");
-#endif
-
-  /* Check for Radix 8(Q) postfixed ?? */
-  if ((*(char_base + (length - 1))) == 'Q') {
-    radix = 8;
-    length--;
-  } else
-    radix = 10;
-
-  /* Check for Sign */
-  sign_mask = S_POSITIVE;
-
-  if ((*(char_base) == '+') || (*(char_base) == '-')) {
-    sign_mask = ((*char_base++) == '+') ? S_POSITIVE : S_NEGATIVE;
-    length--;
-  }
-
-  for (val = 0; length > 0; length--) {
-    if ((((*char_base)) < '0') || ('9' < ((*char_base)))) return (NIL);
-    val = radix * val + (*char_base++) - '0';
-  }
-
-  if (val > 0xffffffff) error("parse_number : Overflow ...exceeded range of FIXP");
-
-  if ((sign_mask == S_POSITIVE) && (val > 0xffff)) {
-    cell68k = (int *)createcell68k(TYPE_FIXP);
-    *cell68k = val;
-    return (LADDR_from_68k(cell68k));
-  } else if ((sign_mask == S_NEGATIVE) && (val > 0xffff)) {
-    cell68k = (int *)createcell68k(TYPE_FIXP);
-    *cell68k = ~val + 1;
-    return (LADDR_from_68k(cell68k));
-  }
-
-  else if (sign_mask == S_NEGATIVE)
-    return (sign_mask | (~((DLword)val) + 1));
-  else {
-    return (sign_mask | val);
-  }
-}
-/* end parse_number */

src/sdl.c

@@ -0,0 +1,735 @@
+#include <SDL.h>
+#include <SDL_keycode.h>
+#include <assert.h>
+#include <limits.h>
+#include "sdldefs.h"
+#include "byteswapdefs.h"
+#include "lispemul.h"
+#include "lsptypes.h"
+#include "miscstat.h"
+#include "keyboard.h"
+#include "lspglob.h"  // for IOPage
+#include "display.h"  // for CURSORHEIGHT, DisplayRegion68k
+
+/* if SDLRENDERING is defined, render to a texture rather than
+ * using the window surface
+ */
+
+#define  SDLRENDERING 1
+
+static SDL_Window *sdl_window = NULL;
+#if defined(SDLRENDERING)
+static SDL_Renderer *sdl_renderer = NULL;
+static SDL_RendererInfo sdl_rendererinfo = {0};
+static SDL_Texture *sdl_texture = NULL;
+#else
+static SDL_Surface *sdl_windowsurface = NULL;
+static SDL_Surface *sdl_buffersurface = NULL;
+static int buffer_size = 0;
+static void *buffer = NULL;
+#endif
+static Uint32 sdl_white;
+static Uint32 sdl_black;
+static Uint32 sdl_foreground;
+static Uint32 sdl_background;
+static int sdl_bytesperpixel;
+static SDL_PixelFormat *sdl_pixelformat;
+
+extern void kb_trans(u_short keycode, u_short upflg);
+extern int error(const char *s);
+
+extern int KBDEventFlg;
+/* clang-format off */
+int keymap[] = {
+  0, SDLK_5,
+  1, SDLK_4,
+  2, SDLK_6,
+  3, SDLK_e,
+  4, SDLK_7,
+  5, SDLK_d,
+  6, SDLK_u,
+  7, SDLK_v,
+  8, SDLK_RIGHTPAREN,
+  8, SDLK_0,
+  9, SDLK_k,
+  10, SDLK_MINUS,
+  11, SDLK_p,
+  12, SDLK_SLASH,
+  13, SDLK_KP_PERIOD,
+  14, SDLK_SCROLLLOCK,
+  15, SDLK_BACKSPACE,
+  16, SDLK_3,
+  17, SDLK_2,
+  18, SDLK_w,
+  19, SDLK_q,
+  20, SDLK_s,
+  21, SDLK_a,
+  22, SDLK_LEFTPAREN,
+  22, SDLK_9,
+  23, SDLK_i,
+  24, SDLK_x,
+  25, SDLK_o,
+  26, SDLK_l,
+  27, SDLK_COMMA,
+  28, SDLK_QUOTE,
+  29, SDLK_RIGHTBRACKET,
+  31, SDLK_LALT, /* Meta, Sun-4 usual key */
+  32, SDLK_1,
+  33, SDLK_ESCAPE,
+  34, SDLK_TAB,
+  35, SDLK_f,
+  36, SDLK_LCTRL,
+  37, SDLK_c,
+  38, SDLK_j,
+  39, SDLK_b,
+  40, SDLK_z,
+  41, SDLK_LSHIFT,
+  42, SDLK_PERIOD,
+  43, SDLK_SEMICOLON,
+  43, SDLK_COLON,
+  44, SDLK_RETURN,
+  45, SDLK_BACKQUOTE,
+  47, SDLK_RCTRL,
+  48, SDLK_r,
+  49, SDLK_t,
+  50, SDLK_g,
+  51, SDLK_y,
+  52, SDLK_h,
+  53, SDLK_8,
+  54, SDLK_n,
+  55, SDLK_m,
+  56, SDLK_CAPSLOCK,
+  57, SDLK_SPACE,
+  58, SDLK_LEFTBRACKET,
+  59, SDLK_EQUALS,
+  60, SDLK_RSHIFT,
+  61, SDLK_F11,
+  61, SDLK_PAUSE,
+  62, SDLK_HOME,
+  63, SDLK_PAGEUP,
+  64, SDLK_KP_EQUALS,
+  65, SDLK_KP_DIVIDE,
+  66, SDLK_F7,
+  67, SDLK_F4,
+  68, SDLK_F5,
+  69, SDLK_KP_2,
+  70, SDLK_KP_3,
+  // 71, XK_Linefeed,
+  // 73, XK_Numlock,
+  76, SDLK_KP_ENTER,
+  80, SDLK_F9,
+  81, SDLK_KP_7,
+  82, SDLK_KP_8,
+  83, SDLK_KP_9,
+  84, SDLK_KP_4,
+  85, SDLK_KP_5,
+  86, SDLK_LALT, /* (sun left-diamond key) */
+  87, SDLK_KP_6,
+  89, SDLK_INSERT,
+  90, SDLK_END,
+  91, SDLK_F12,
+  92, SDLK_PRINTSCREEN, // is this XK_Print??
+  93, SDLK_MODE, // is this XK_Mode_switch
+  94, SDLK_KP_1,
+  95, SDLK_KP_MULTIPLY,
+  96, SDLK_KP_MINUS,
+  97, SDLK_HELP,
+  98, SDLK_KP_0,
+  99, SDLK_F2,
+  100, SDLK_F3,
+  101, SDLK_F6,
+  102, SDLK_KP_PLUS,
+  104, SDLK_F8,
+  105, SDLK_BACKSLASH,
+  106, SDLK_F10,
+  107, SDLK_F11,
+  108, SDLK_F12,
+  -1, -1
+};
+/* clang-format on */
+static const DLword bitmask[16] = {1 << 15, 1 << 14, 1 << 13, 1 << 12, 1 << 11, 1 << 10,
+                                   1 << 9,  1 << 8,  1 << 7,  1 << 6,  1 << 5,  1 << 4,
+                                   1 << 3,  1 << 2,  1 << 1,  1 << 0};
+// all of the following are overwritten, the values here are irrelevant defaults!
+// actual size of the lisp display in pixels.
+int sdl_displaywidth = 0;
+int sdl_displayheight = 0;
+// current size of the window, in pixels
+int sdl_windowwidth = 0;
+int sdl_windowheight = 0;
+// each pixel is shown as this many pixels
+int sdl_pixelscale = 0;
+extern DLword *EmKbdAd068K, *EmKbdAd168K, *EmKbdAd268K, *EmKbdAd368K, *EmKbdAd468K, *EmKbdAd568K,
+    *EmRealUtilin68K;
+extern DLword *EmCursorBitMap68K;
+extern DLword *CTopKeyevent;
+extern int URaid_req;
+extern LispPTR *KEYBUFFERING68k;
+
+void DoRing() {
+  DLword w, r;
+  KBEVENT *kbevent;
+
+do_ring:
+  /* DEL is not generally present on a Mac X keyboard, Ctrl-shift-ESC would be 18496 */
+  if (((*EmKbdAd268K) & 2113) == 0) { /*Ctrl-shift-NEXT*/
+    error("******  EMERGENCY Interrupt ******");
+    *EmKbdAd268K = KB_ALLUP;          /*reset*/
+    ((RING *)CTopKeyevent)->read = 0; /* reset queue */
+    ((RING *)CTopKeyevent)->write = MINKEYEVENT;
+    /*return(0);*/
+  } else if (((*EmKbdAd268K) & 2114) == 0) { /* Ctrl-Shift-DEL */
+    *EmKbdAd268K = KB_ALLUP;                 /*reset*/
+    URaid_req = T;
+    ((RING *)CTopKeyevent)->read = 0; /* reset queue */
+    ((RING *)CTopKeyevent)->write = MINKEYEVENT;
+    /*return(0);*/
+  }
+
+#ifdef OS4_TYPE4BUG
+  else if (((*EmKbdAd268K) & 2120) == 0) { /* Ctrl-Shift-Return */
+    *EmKbdAd268K = KB_ALLUP;               /*reset*/
+    URaid_req = T;
+    ((RING *)CTopKeyevent)->read = 0; /* reset queue */
+    ((RING *)CTopKeyevent)->write = MINKEYEVENT;
+  }
+#endif
+
+  r = RING_READ(CTopKeyevent);
+  w = RING_WRITE(CTopKeyevent);
+
+  if (r == w) /* event queue FULL */
+    goto KBnext;
+
+  kbevent = (KBEVENT *)(CTopKeyevent + w);
+  /*    RCLK(kbevent->time); */
+  kbevent->W0 = *EmKbdAd068K;
+  kbevent->W1 = *EmKbdAd168K;
+  kbevent->W2 = *EmKbdAd268K;
+  kbevent->W3 = *EmKbdAd368K;
+  kbevent->W4 = *EmKbdAd468K;
+  kbevent->W5 = *EmKbdAd568K;
+  kbevent->WU = *EmRealUtilin68K;
+
+  if (r == 0) /* Queue was empty */
+    ((RING *)CTopKeyevent)->read = w;
+  if (w >= MAXKEYEVENT)
+    ((RING *)CTopKeyevent)->write = MINKEYEVENT;
+  else
+    ((RING *)CTopKeyevent)->write = w + KEYEVENTSIZE;
+
+KBnext:
+  if (*KEYBUFFERING68k == NIL) *KEYBUFFERING68k = ATOM_T;
+}
+
+static int min(int a, int b) {
+  if (a < b) return a;
+  return b;
+}
+
+static int display_update_needed = 0;
+
+static int min_x = INT_MAX;
+static int min_y = INT_MAX;
+static int max_x = 0;
+static int max_y = 0;
+void sdl_notify_damage(int x, int y, int w, int h) {
+  if (x < min_x) min_x = x;
+  if (y < min_y) min_y = y;
+  if (x + w > max_x) max_x = min(x + w, sdl_displaywidth - 1);
+  if (y + h > max_y) max_y = min(y + h, sdl_displayheight - 1);
+  display_update_needed = 1;
+}
+
+/* a simple linked list to remember generated cursors
+ * because cursors don't have any identifying information
+ * except for the actual bitmap in Lisp, just cache that.
+ * 16 DLwords, to give a 16x16 bitmap cursor.
+ */
+struct CachedCursor {
+  struct CachedCursor *next;
+  DLword EmCursorBitMap[CURSORHEIGHT];
+  SDL_Cursor *cursor;
+} *sdl_cursorlist = NULL;
+
+/*
+ * given a 16-bit value and a repeat count modify an array
+ * of bytes to contain the same bit pattern with each bit
+ * repeated "reps" times consecutively in the output
+ */
+static void replicate_bits(int bits, int reps, Uint8 *out) {
+  int dbyte = 0;
+  int dbit = 7;
+  for (int ibit = 15; ibit >= 0; --ibit) {
+    for (int r = 0; r < reps; r++) {
+      if (bits & (1 << ibit))
+        out[dbyte] |= 1 << dbit;
+      if (--dbit < 0) {
+        dbyte++;
+        dbit = 7;
+      }
+    }
+  }
+}
+
+static int cursor_equal_p(DLword *a, DLword *b) {
+  for (int i = 0; i < CURSORHEIGHT; i++)
+    if (a[i] != b[i]) return FALSE;
+  return TRUE;
+}
+
+/*
+ * Try to find cursor CURSOR on the sdl_cursorlist, if it isn't there, add it.
+ * Return an SDL_Cursor that can be used directly.
+ */
+static SDL_Cursor *sdl_getOrAllocateCursor(DLword cursor[16], int hot_x, int hot_y) {
+  hot_x = 0;
+  hot_y = 0;
+  /* try to find the cursor by checking the full bitmap */
+  struct CachedCursor *pclp = NULL;
+  struct CachedCursor *clp = sdl_cursorlist;
+  SDL_Cursor *c;
+  while (clp != NULL) {
+    if (cursor_equal_p(clp->EmCursorBitMap, cursor) == TRUE) {
+      /* if it's in the first two elements of the list, leave the order alone.
+       * There is a high probability of flipping back and forth between two
+       */
+      if (clp == sdl_cursorlist || pclp == sdl_cursorlist) {
+        return clp->cursor;
+      }
+      /* otherwise unlink the found item and reinsert at the front */
+      pclp->next = clp->next;
+      clp->next = sdl_cursorlist;
+      sdl_cursorlist = clp;
+      return clp->cursor;
+    }
+    pclp = clp;
+    clp = clp->next;
+  }
+  /* It isn't there, so build a new one */
+  clp = (struct CachedCursor *)malloc(sizeof(struct CachedCursor));
+  memcpy(clp->EmCursorBitMap, cursor, sizeof(clp->EmCursorBitMap));
+  /* no scaling is an easy case, scale > 1 is harder */
+  if (sdl_pixelscale == 1) {
+    Uint8 sdl_cursor_data[32];
+    for (int i = 0; i < 32; i++) sdl_cursor_data[i] = GETBYTE(((Uint8 *)cursor) + i);
+    c = SDL_CreateCursor(sdl_cursor_data, sdl_cursor_data, 16, 16, hot_x, hot_y);
+  } else {
+    Uint8 *sdl_cursor_data = calloc(sdl_pixelscale * sdl_pixelscale, 32);
+    /* fill in the cursor data expanded */
+    for (int i = 0; i < 32; i += 2) {
+      int v = GETBYTE(((Uint8 *)cursor) + i) << 8 | GETBYTE(((Uint8 *)cursor) + i + 1);
+      int db = i * sdl_pixelscale * sdl_pixelscale;
+      /* spread the bits out for the first copy of the row */
+      replicate_bits(v, sdl_pixelscale, &sdl_cursor_data[db]);
+      /* and then copy the replicated bits for the copies of the row */
+      for (int j = 1; j < sdl_pixelscale; j++) {
+        memcpy(&sdl_cursor_data[db + (j * 2 * sdl_pixelscale)], &sdl_cursor_data[db], 2 * sdl_pixelscale);
+      }
+    }
+    c = SDL_CreateCursor(sdl_cursor_data, sdl_cursor_data, 16 * sdl_pixelscale, 16 * sdl_pixelscale, hot_x, hot_y);
+  }
+  if (c == NULL) printf("ERROR creating cursor: %s\n", SDL_GetError());
+  clp->cursor = c;
+  clp->next = sdl_cursorlist;
+  sdl_cursorlist = clp;
+  return clp->cursor;
+}
+
+/*
+ * Read a cursor bitmap from lisp. Try to find a cached cursor, then use that.
+ * Use HOT_X and HOT_Y as the cursor hotspot.
+ * XXX: needs to deal with sdl_pixelscale > 1, and where is the hotspot?
+ */
+void sdl_setCursor(int hot_x, int hot_y) {
+  SDL_Cursor *c = sdl_getOrAllocateCursor(EmCursorBitMap68K, hot_x, hot_y);
+  SDL_SetCursor(c);
+}
+#if defined(SDLRENDERING)
+void sdl_bitblt_to_texture(int _x, int _y, int _w, int _h) {
+  DLword *src = DisplayRegion68k;
+  void *dst;
+  int dstpitchbytes;
+  int dstpitchpixels;
+  const int bitsperword = 8 * sizeof(DLword);
+  int sourcepitchwords = sdl_displaywidth / bitsperword;
+  int xstart = _x / bitsperword;
+  int xlimit = (_x + _w + bitsperword - 1) / bitsperword;
+  int ystart = _y * sourcepitchwords;
+  int ylimit = (_y + _h) * sourcepitchwords;
+  SDL_Rect dstrect;
+  // Avoid dealing with partial words in the update by stretching the source rectangle
+  // left and right to cover complete units and lock the corresponding
+  // region in the texture
+  dstrect.x = xstart * bitsperword;
+  dstrect.w = (xlimit * bitsperword) - dstrect.x;
+  dstrect.y = _y;
+  dstrect.h = _h;
+  SDL_LockTexture(sdl_texture, &dstrect, &dst, &dstpitchbytes);
+  dstpitchpixels = dstpitchbytes / sdl_bytesperpixel;
+  int dy = 0;
+  // for each line in the source image
+  for (int sy = ystart; sy < ylimit; sy += sourcepitchwords, dy += dstpitchpixels) {
+    // for each word in the line
+    int dx = 0;
+    for (int sx = xstart; sx < xlimit; sx++, dx += bitsperword) {
+      int srcw = GETBASEWORD(src, sy + sx);
+      // for each bit in the word
+      for (int b = 0; b < bitsperword; b++) {
+        ((Uint32 *)dst)[dy + dx + b] = (srcw & bitmask[b]) ? sdl_foreground : sdl_background;
+      }
+    }
+  }
+  SDL_UnlockTexture(sdl_texture);
+}
+void sdl_bitblt_to_texture_exact(int _x, int _y, int _w, int _h) {
+  DLword *src = DisplayRegion68k;
+  void *dst;
+  int dstpitchbytes;
+  int dstpitchpixels;
+  const int bitsperword = 8 * sizeof(DLword);
+  int sourcepitchwords = sdl_displaywidth / bitsperword;
+  int xstart = _x / bitsperword;   // "word" index of first accessed word in line
+  int xstartb = _x % bitsperword;  // bit within word
+  int xlimit = (_x + _w + bitsperword - 1) / bitsperword;  // word index
+  int ystart = _y * sourcepitchwords;
+  int ylimit = (_y + _h) * sourcepitchwords;
+  SDL_Rect dstrect = {.x = _x, .y = _y, .w = _w, .h = _h};
+  SDL_LockTexture(sdl_texture, &dstrect, &dst, &dstpitchbytes);
+  dstpitchpixels = dstpitchbytes / sdl_bytesperpixel;
+  int dy = 0;
+  // for each line in the source image
+  for (int sy = ystart; sy < ylimit; sy += sourcepitchwords, dy += dstpitchpixels) {
+    int dx = 0;
+    int sx = xstart;
+    int b = xstartb;
+    int srcw = GETBASEWORD(src, sy + sx);
+    // for each pixel within the dstination region line
+    for (int dx = 0; dx < _w; dx++) {
+      ((Uint32 *)dst)[dy + dx] = (srcw & bitmask[b]) ? sdl_foreground : sdl_background;
+      if (++b == bitsperword) {
+        b = 0;
+        sx++;
+        srcw = GETBASEWORD(src, sy + sx);
+      }
+    }
+  }
+  SDL_UnlockTexture(sdl_texture);
+}
+#else
+void sdl_bitblt_to_buffer(int _x, int _y, int _w, int _h) {
+  Uint32 *src = (Uint32 *)DisplayRegion68k;
+  int width = sdl_displaywidth;
+  int height = sdl_displayheight;
+  int bpw = 8 * sizeof(Uint32);
+  int pitch = sdl_displaywidth / bpw;
+  int xlimit = (_x + _w + bpw - 1) / bpw;
+  int ylimit = _y + _h;
+  for (int y = _y; y < ylimit; y++) {
+    int they = y * sdl_displaywidth;
+    for (int x = _x / bpw; x < xlimit; x++) {
+      int srcw = src[y * pitch + x];
+      int thex = x * bpw;
+      for (int b = 0; b < bpw; b++) {
+        uint32_t px = 0;
+        if (srcw & (1 << (bpw - 1 - b))) {
+          px = sdl_foreground;
+        } else {
+          px = sdl_background;
+        }
+        int pxindex = they + thex + b;
+        assert(pxindex >= 0 && pxindex < buffer_size);
+        ((Uint32 *)buffer)[pxindex] = px;
+      }
+    }
+  }
+}
+void sdl_bitblt_to_window_surface(int _x, int _y, int _w, int _h) {
+  DLword *src = DisplayRegion68k;
+  Uint32 *dst = (Uint32 *)sdl_windowsurface->pixels;
+  int dstpitchbytes = sdl_windowsurface->pitch;
+  int dstpitchpixels = dstpitchbytes / sdl_bytesperpixel;
+  const int bitsperword = 8 * sizeof(DLword);
+  int sourcepitchwords = sdl_displaywidth / bitsperword;
+  int xstart = _x / bitsperword;
+  int xlimit = (_x + _w + bitsperword - 1) / bitsperword;
+  int ystart = _y * sourcepitchwords;
+  int ylimit = (_y + _h) * sourcepitchwords;
+  int dy = _y * dstpitchpixels;
+  // for each line in the source image
+  for (int sy = ystart; sy < ylimit; sy += sourcepitchwords, dy += dstpitchpixels) {
+    // for each word in the line
+    int dx = (_x / bitsperword) * bitsperword;
+    for (int sx = xstart; sx < xlimit; sx++, dx += bitsperword) {
+      int srcw = GETBASEWORD(src, sy + sx);
+      // for each bit in the word
+      for (int b = 0; b < bitsperword; b++) {
+        ((Uint32 *)dst)[dy + dx + b] = (srcw & bitmask[b]) ? sdl_foreground : sdl_background;
+      }
+    }
+  }
+}
+#endif
+static int map_key(SDL_Keycode k) {
+  for (int i = 0; keymap[i] != -1; i += 2) {
+    if (keymap[i + 1] == k) return keymap[i];
+  }
+  return -1;
+}
+#define KEYCODE_OFFSET 0
+static void handle_keydown(SDL_Keycode k, unsigned short mod) {
+  int lk = map_key(k);
+  if (lk == -1) {
+    printf("No mapping for key %s\n", SDL_GetKeyName(k));
+  } else {
+    printf("dn %s -> lisp keycode %d (0x%x)\n", SDL_GetKeyName(k), lk, mod);
+    kb_trans(lk - KEYCODE_OFFSET, FALSE);
+    DoRing();
+    if ((KBDEventFlg += 1) > 0) Irq_Stk_End = Irq_Stk_Check = 0;
+  }
+}
+static void handle_keyup(SDL_Keycode k, unsigned short mod) {
+  int lk = map_key(k);
+  if (lk == -1) {
+    printf("No mapping for key %s\n", SDL_GetKeyName(k));
+  } else {
+    printf("up %s -> lisp keycode %d (0x%x)\n", SDL_GetKeyName(k), lk, mod);
+    kb_trans(lk - KEYCODE_OFFSET, TRUE);
+    DoRing();
+    if ((KBDEventFlg += 1) > 0) Irq_Stk_End = Irq_Stk_Check = 0;
+  }
+}
+extern DLword *EmCursorX68K, *EmCursorY68K;
+extern DLword *EmMouseX68K, *EmMouseY68K, *EmKbdAd068K, *EmRealUtilin68K;
+extern LispPTR *CLastUserActionCell68k;
+extern MISCSTATS *MiscStats;
+
+/* bits within the EmRealUtilin word */
+#define KEYSET_LEFT 8
+#define KEYSET_LEFTMIDDLE 9
+#define KEYSET_MIDDLE 10
+#define KEYSET_RIGHTMIDDLE 11
+#define KEYSET_RIGHT 12
+/* Mouse buttons */
+#define MOUSE_LEFT 13
+#define MOUSE_RIGHT 14
+#define MOUSE_MIDDLE 15
+static void sdl_update_viewport(int width, int height) {
+  /* XXX: needs work */
+  int w = width / 32 * 32;
+  if (w > sdl_displaywidth * sdl_pixelscale) w = sdl_displaywidth * sdl_pixelscale;
+  int h = height / 32 * 32;
+  if (h > sdl_displayheight * sdl_pixelscale) h = sdl_displayheight * sdl_pixelscale;
+  SDL_Rect r;
+  r.x = 0;
+  r.y = 0;
+  r.w = w;
+  r.h = h;
+#if defined(SDLRENDERING)
+  SDL_RenderSetViewport(sdl_renderer, &r);
+#endif
+  printf("new viewport: %d / %d\n", w, h);
+}
+static int last_keystate[512] = {0};
+void sdl_set_invert(int flag) {
+  if (flag) {
+    sdl_foreground = sdl_white;
+    sdl_background = sdl_black;
+  } else {
+    sdl_foreground = sdl_black;
+    sdl_background = sdl_white;
+  }
+  sdl_notify_damage(0, 0, sdl_displaywidth, sdl_displayheight);
+}
+void sdl_setMousePosition(int x, int y) {
+  SDL_WarpMouseInWindow(sdl_window, x * sdl_pixelscale, y * sdl_pixelscale);
+}
+#if defined(SDLRENDERING)
+void sdl_update_display() {
+  sdl_bitblt_to_texture(min_x, min_y, max_x - min_x, max_y - min_y);
+  SDL_RenderCopy(sdl_renderer, sdl_texture, NULL, NULL);
+  SDL_RenderPresent(sdl_renderer);
+}
+#else
+void sdl_update_display() {
+  SDL_Rect r, s;
+
+  r.x = min_x;
+  r.y = min_y;
+  r.w = max_x - min_x;
+  r.h = max_y - min_y;
+  if (sdl_pixelscale == 1) {
+    sdl_bitblt_to_window_surface(r.x, r.y, r.w, r.h);
+    SDL_UpdateWindowSurfaceRects(sdl_window, &r, 1);
+  } else {
+    s.x = r.x * sdl_pixelscale;
+    s.y = r.y * sdl_pixelscale;
+    s.w = r.w * sdl_pixelscale;
+    s.h = r.h * sdl_pixelscale;
+    sdl_bitblt_to_buffer(r.x, r.y, r.w, r.h);
+    SDL_LowerBlitScaled(sdl_buffersurface, &r, sdl_windowsurface, &s);
+    SDL_UpdateWindowSurfaceRects(sdl_window, &s, 1);
+  }
+}
+#endif
+int process_events_time = 0;
+void process_SDLevents() {
+  SDL_Event event;
+  while (SDL_PollEvent(&event)) {
+    switch (event.type) {
+      case SDL_QUIT:
+        printf("quitting\n");
+        exit(0);
+        break;
+      case SDL_WINDOWEVENT:
+        switch (event.window.event) {
+          case SDL_WINDOWEVENT_RESIZED:
+            /* XXX: what about integer multiple of 32 requirements here? */
+            sdl_windowwidth = event.window.data1;
+            sdl_windowheight = event.window.data2;
+            sdl_update_viewport(sdl_windowwidth, sdl_windowheight);
+            break;
+        }
+        break;
+      case SDL_KEYDOWN:
+        printf("dn ts: %x, type: %x, state: %x, repeat: %x, scancode: %x, sym: %x <%s>, mod: %x\n",
+               event.key.timestamp, event.key.type, event.key.state, event.key.repeat,
+               event.key.keysym.scancode, event.key.keysym.sym,
+               SDL_GetKeyName(event.key.keysym.sym), event.key.keysym.mod);
+        if (event.key.repeat) {
+          /* Lisp needs to see the UP transition before the DOWN transition */
+          handle_keyup(event.key.keysym.sym, event.key.keysym.mod);
+        }
+        handle_keydown(event.key.keysym.sym, event.key.keysym.mod);
+        break;
+      case SDL_KEYUP:
+        printf("up ts: %x, type: %x, state: %x, repeat: %x, scancode: %x, sym: %x <%s>, mod: %x\n",
+               event.key.timestamp, event.key.type, event.key.state, event.key.repeat,
+               event.key.keysym.scancode, event.key.keysym.sym,
+               SDL_GetKeyName(event.key.keysym.sym), event.key.keysym.mod);
+        handle_keyup(event.key.keysym.sym, event.key.keysym.mod);
+        break;
+      case SDL_MOUSEMOTION: {
+        int x, y;
+        SDL_GetMouseState(&x, &y);
+        x /= sdl_pixelscale;
+        y /= sdl_pixelscale;
+        *CLastUserActionCell68k = MiscStats->secondstmp;
+        *EmCursorX68K = (*((DLword *)EmMouseX68K)) = (short)(x & 0xFFFF);
+        *EmCursorY68K = (*((DLword *)EmMouseY68K)) = (short)(y & 0xFFFF);
+        DoRing();
+        if ((KBDEventFlg += 1) > 0) Irq_Stk_End = Irq_Stk_Check = 0;
+        break;
+      }
+      case SDL_MOUSEBUTTONDOWN: {
+        int button = event.button.button;
+        switch (button) {
+          case 1: PUTBASEBIT68K(EmRealUtilin68K, MOUSE_LEFT, FALSE); break;
+          case 2: PUTBASEBIT68K(EmRealUtilin68K, MOUSE_MIDDLE, FALSE); break;
+          case 3: PUTBASEBIT68K(EmRealUtilin68K, MOUSE_RIGHT, FALSE); break;
+          case 4: PUTBASEBIT68K(EmRealUtilin68K, KEYSET_LEFT, FALSE); break;
+          case 5: PUTBASEBIT68K(EmRealUtilin68K, KEYSET_LEFTMIDDLE, FALSE); break;
+          case 6: PUTBASEBIT68K(EmRealUtilin68K, KEYSET_RIGHT, FALSE); break;
+          case 7: PUTBASEBIT68K(EmRealUtilin68K, KEYSET_RIGHTMIDDLE, FALSE); break;
+        }
+        DoRing();
+        if ((KBDEventFlg += 1) > 0) Irq_Stk_End = Irq_Stk_Check = 0;
+        break;
+      }
+      case SDL_MOUSEBUTTONUP: {
+        int button = event.button.button;
+        switch (button) {
+          case 1: PUTBASEBIT68K(EmRealUtilin68K, MOUSE_LEFT, TRUE); break;
+          case 2: PUTBASEBIT68K(EmRealUtilin68K, MOUSE_MIDDLE, TRUE); break;
+          case 3: PUTBASEBIT68K(EmRealUtilin68K, MOUSE_RIGHT, TRUE); break;
+          case 4: PUTBASEBIT68K(EmRealUtilin68K, KEYSET_LEFT, TRUE); break;
+          case 5: PUTBASEBIT68K(EmRealUtilin68K, KEYSET_LEFTMIDDLE, TRUE); break;
+          case 6: PUTBASEBIT68K(EmRealUtilin68K, KEYSET_RIGHT, TRUE); break;
+          case 7: PUTBASEBIT68K(EmRealUtilin68K, KEYSET_RIGHTMIDDLE, TRUE); break;
+        }
+        DoRing();
+        if ((KBDEventFlg += 1) > 0) Irq_Stk_End = Irq_Stk_Check = 0;
+        break;
+      }
+      case SDL_MOUSEWHEEL:
+        printf("mousewheel mouse %d x %d y %d direction %s\n", event.wheel.which, event.wheel.x,
+               event.wheel.y,
+               event.wheel.direction == SDL_MOUSEWHEEL_NORMAL ? "normal" : "flipped");
+        break;
+        /* case SDL_KEYMAPCHANGED: */
+        /*   printf("SDL_KEYMAPCHANGED\n"); break; */
+        /* case SDL_TEXTINPUT: */
+        /*   printf("SDL_TEXTINPUT\n"); break; */
+      default: printf("other event type: %d\n", event.type);
+    }
+  }
+  if (display_update_needed) {
+    sdl_update_display();
+    display_update_needed = 0;
+    min_x = min_y = INT_MAX;
+    max_x = max_y = 0;
+  }
+}
+
+int init_SDL(char *windowtitle, int w, int h, int s) {
+  sdl_pixelscale = s;
+  // width must be multiple of 32
+  w = (w + 31) / 32 * 32;
+  sdl_displaywidth = w;
+  sdl_displayheight = h;
+  sdl_windowwidth = w * s;
+  sdl_windowheight = h * s;
+  int width = sdl_displaywidth;
+  int height = sdl_displayheight;
+  printf("requested width: %d, height: %d\n", width, height);
+  if (SDL_Init(SDL_INIT_VIDEO) < 0) {
+    printf("SDL could not be initialized. SDL_Error: %s\n", SDL_GetError());
+    return 1;
+  }
+  printf("initialised\n");
+  sdl_window = SDL_CreateWindow(windowtitle, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
+                                sdl_windowwidth, sdl_windowheight, 0);
+  printf("Window created\n");
+  if (sdl_window == NULL) {
+    printf("Window could not be created. SDL_Error: %s\n", SDL_GetError());
+    return 2;
+  }
+#if defined(SDLRENDERING)
+  printf("Creating renderer...\n");
+  sdl_renderer = SDL_CreateRenderer(sdl_window, -1, SDL_RENDERER_ACCELERATED);
+  if (NULL == sdl_renderer) {
+    printf("SDL Error: %s\n", SDL_GetError());
+    return 3;
+  }
+  SDL_GetRendererInfo(sdl_renderer, &sdl_rendererinfo);
+  SDL_SetRenderDrawColor(sdl_renderer, 127, 127, 127, 255);
+  SDL_RenderClear(sdl_renderer);
+  SDL_RenderPresent(sdl_renderer);
+  SDL_RenderSetScale(sdl_renderer, 1.0, 1.0);
+  printf("Creating texture...\n");
+  sdl_pixelformat = SDL_AllocFormat(sdl_rendererinfo.texture_formats[0]);
+  sdl_texture = SDL_CreateTexture(sdl_renderer, sdl_pixelformat->format,
+                                  SDL_TEXTUREACCESS_STREAMING, width, height);
+  sdl_black = SDL_MapRGB(sdl_pixelformat, 0, 0, 0);
+  sdl_white = SDL_MapRGB(sdl_pixelformat, 255, 255, 255);
+  sdl_foreground = sdl_black;
+  sdl_background = sdl_white;
+  sdl_bytesperpixel = sdl_pixelformat->BytesPerPixel;
+#else
+  printf("Creating window surface and buffer surface\n");
+  sdl_windowsurface = SDL_GetWindowSurface(sdl_window);
+  sdl_pixelformat = sdl_windowsurface->format;
+  sdl_black = SDL_MapRGB(sdl_pixelformat, 0, 0, 0);
+  sdl_white = SDL_MapRGB(sdl_pixelformat, 255, 255, 255);
+  sdl_foreground = sdl_black;
+  sdl_background = sdl_white;
+  sdl_bytesperpixel = sdl_pixelformat->BytesPerPixel;
+  buffer_size = width * height * sdl_bytesperpixel;
+  buffer = malloc(buffer_size);
+  sdl_buffersurface = SDL_CreateRGBSurfaceWithFormatFrom(
+      buffer, sdl_displaywidth, sdl_displayheight, sdl_bytesperpixel * 8,
+      sdl_displaywidth * sdl_bytesperpixel, sdl_pixelformat->format);
+#endif
+  printf("SDL initialised\n");
+  return 0;
+}

src/storage.c

@@ -35,7 +35,7 @@
 #include "conspagedefs.h"
 #include "gcfinaldefs.h"
 #include "gchtfinddefs.h"
-#include "mkatomdefs.h"
+#include "testtooldefs.h"
 
 #define MINARRAYBLOCKSIZE 4
 #define GUARDVMEMFULL 500
@@ -374,7 +374,7 @@ LispPTR newpage(LispPTR base) {
     } else if (InterfacePage->key == IFPVALID_KEY) {
       *VMEM_FULL_STATE_word = ATOM_T;
     } else
-      *VMEM_FULL_STATE_word = make_atom("DIRTY", 0, 5, 0);
+      *VMEM_FULL_STATE_word = MAKEATOM("DIRTY");
   }
 
   return (base);

src/subr.c

@@ -484,6 +484,7 @@ void OP_subrcall(int subr_no, int argnum) {
 
     case sb_GET_NATIVE_ADDR_FROM_LISP_PTR:
       POP_SUBR_ARGS;
+      /* XXX: this WILL NOT WORK if Lisp memory is allocated outside the low 4GB */
       ARITH_SWITCH(Addr68k_from_LADDR(args[0]), TopOfStack);
       break;
 

src/testtool.c

@@ -424,7 +424,7 @@ void dump_fnobj(LispPTR index)
 /************************************************************************/
 
 /* Opcode names, by opcode */
-static const char *opcode_table[256] = {
+const char *opcode_table[256] = {
                            "-X-",
                            "CAR",
                            "CDR",
@@ -1018,7 +1018,7 @@ FX *get_nextFX(FX *fx) {
 } /* get_nextFX end */
 
 LispPTR MAKEATOM(char *string) {
-    return (make_atom(string, 0, strlen(string), 0));
+    return (make_atom(string, 0, strlen(string)));
 }
 
 /************************************************************************/
@@ -1032,7 +1032,7 @@ LispPTR MAKEATOM(char *string) {
 
 LispPTR *MakeAtom68k(char *string) {
   LispPTR index;
-  index = make_atom(string, 0, strlen(string), 0);
+  index = make_atom(string, 0, strlen(string));
   if (index == 0xffffffff) {
       error("MakeAtom68k: no such atom found");
   }

src/ufs.c

@@ -566,7 +566,7 @@ int unixpathname(char *src, char *dst, int versionp, int genp)
     case '~':
       if (*(cp + 1) == '>' || *(cp + 1) == '\0') {
         /* "~>" or "~" means the user's home directory. */
-        TIMEOUT(pwd = getpwuid(getuid()));
+        TIMEOUT0(pwd = getpwuid(getuid()));
         if (pwd == NULL) return (0);
 
         strcpy(dst, pwd->pw_dir);
@@ -590,7 +590,7 @@ int unixpathname(char *src, char *dst, int versionp, int genp)
          */
         for (++cp, np = name; *cp != '\0' && *cp != '>';) *np++ = *cp++;
         *np = '\0';
-        TIMEOUT(pwd = getpwnam(name));
+        TIMEOUT0(pwd = getpwnam(name));
         if (pwd == NULL) return (0);
 
         strcpy(dst, pwd->pw_dir);

src/uraid.c

@@ -286,7 +286,7 @@ LispPTR parse_atomstring(char *string)
     namelen = cnt - 1;
 
   if ((packagelen == 0) || (strncmp(packageptr, "IL", packagelen) == 0)) { /* default IL: */
-    aindex = make_atom(nameptr, 0, namelen, T);
+    aindex = make_atom(nameptr, 0, namelen);
     if (aindex == 0xffffffff) {
       printf("trying IL:\n");
       aindex = get_package_atom(nameptr, namelen, "INTERLISP", 9, 0);

src/xc.c

@@ -99,7 +99,9 @@
 #include "ubf3defs.h"
 #include "unwinddefs.h"
 #include "vars3defs.h"
+#ifdef XWINDOW
 #include "xwinmandefs.h"
+#endif
 #include "z2defs.h"
 
 #ifdef DOS
@@ -109,10 +111,14 @@ extern IOPAGE *IOPage68K;
 extern KbdInterface currentkbd;
 extern DspInterface currentdsp;
 extern MouseInterface currentmouse;
-#else
+#elif defined(XWINDOW)
 extern DspInterface currentdsp;
 #endif /* DOS */
 
+#ifdef SDL
+extern void process_SDLevents();
+#endif
+
 typedef struct conspage ConsPage;
 typedef ByteCode *InstPtr;
 
@@ -1118,8 +1124,12 @@ check_interrupt:
      * If the system is configured with SIGIO handling we have a hint
      * that allows us to cheaply skip if there's nothing to do
      */
+#ifdef XWINDOW
     process_Xevents(currentdsp);
-
+#endif
+#ifdef SDL
+    process_SDLevents();
+#endif
     if (IO_Signalled) {
       IO_Signalled = FALSE;
       process_io_events();

src/xinit.c

@@ -222,7 +222,7 @@ void Open_Display(DspInterface dsp)
 /*                                                                   */
 /*********************************************************************/
 
-DspInterface X_init(DspInterface dsp, char *lispbitmap, int width_hint, int height_hint,
+DspInterface X_init(DspInterface dsp, LispPTR lispbitmap, int width_hint, int height_hint,
                     int depth_hint)
 {
   Screen *Xscreen;