Rename sdl_bitblt_to_texture2 to sdl_bitblt_to_texture_exact to be more descriptive

Use SDL_LowerBlitScaled() rather than SDL_BlitScaled()
Handle pixel scaling when creating the cursors
2026-03-16 14:57:20 +00:00 · 2021-12-20 12:56:11 -08:00 · 2021-12-10 16:35:19 -08:00 · 2021-12-06 19:21:10 -08:00 · 2021-11-26 19:57:40 -08:00 · 2021-11-26 19:53:26 -08:00
36 changed files with 1095 additions and 327 deletions
--- a/.github/workflows/build.yml
+++ b/.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
--- a/CMakeLists.txt
+++ b/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)
--- a/bin/makefile-tail
+++ b/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
--- a/inc/display.h
+++ b/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 */
--- a/inc/lspglob.h
+++ b/inc/lspglob.h
@@ -31,7 +31,6 @@
 #include "lispemul.h" /* for LispPTR, DLword */
 #include "miscstat.h" /* for MISCSTAT */

- extern  DLword *Atomspace; 		/* ATOMSPACE */
 extern  DLword *Stackspace;		/* STACKSPACE*/
 extern  DLword *Plistspace;		/* PLISTSPACE */
 extern  DLword *DTDspace;		/* DTDSPACE */
@@ -41,8 +40,6 @@
 extern  DLword *AtomSpace;		/* New atoms, initial set */
 extern  DLword *Defspace;		/* DEFSPACE */
 extern  DLword *Valspace;		/* VALSPACE */
- extern  DLword *Spospspace;		/* POSITIVE Smallp */
- extern  DLword *Snegspace;		/* NEGATIVE Smallp */
 
 /* For Virtual Mem Management */
 #ifdef BIGVM
@@ -82,7 +79,6 @@ extern DLword *UFNTable ;


 /* FLEX STORAGES */
- extern  DLword *Arrayspace;  /* Start of ARRAYSPACE */
 extern  DLword *MDS_space_bottom;  /* Start of MDS (pre -2) */
 extern  DLword *PnCharspace ;	/* Space for PN char codes (Thin only) */

--- a/inc/maindefs.h
+++ b/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
--- a/inc/mkatomdefs.h
+++ b/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 parse_number(const char *char_base, short int length);
+LispPTR make_atom(const char *char_base, DLword offset, DLword length);
 #endif
--- a/inc/sdldefs.h
+++ b/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
--- a/inc/timeout.h
+++ b/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 */
--- a/inc/tosfns.h
+++ b/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);                     \
-      work = POINTERMASK & swapx(scratch);                                     \
+      nnewframe(CURRENTFX, scratch, TOPOFSTACK & 0xffff);                      \
+      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);                     \
-      work = POINTERMASK & swapx(scratch);                                     \
+      nnewframe(CURRENTFX, scratch, TOPOFSTACK & 0xffff);                      \
+      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);                            \
-        work = POINTERMASK & swapx(scratch);                                   \
+        nnewframe(CURRENTFX, scratch, TOPOFSTACK);                             \
+        work = POINTERMASK & ((GETBASEWORD(scratch,1) << 16) | GETBASEWORD(scratch,0)); \
        lookuped = *((LispPTR *)(Addr68k_from_LADDR(work)));                   \
        if (lookuped == NOBIND_PTR)                                            \
          goto op_ufn;                                                         \
--- a/inc/xinitdefs.h
+++ b/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
--- a/src/bbtsub.c
+++ b/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 */
--- a/src/dir.c
+++ b/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);
--- a/src/draw.c
+++ b/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) &&
-        (start_addr < DisplayRegion68k_end_addr) &&
-        ((int)(temp_e = (DLword *)(dataptr - DisplayRegion68k)) >= 0) &&
-        ((DLword *)dataptr < DisplayRegion68k_end_addr)) {
+    if (in_display_segment(start_addr) && in_display_segment(dataptr)) {
      int start_x, start_y, end_x, end_y, w, h;
+      ptrdiff_t temp_s, temp_e;

-      start_y = (int)temp_s / DisplayRasterWidth;
-      start_x = ((int)temp_s % DisplayRasterWidth) * BITSPER_DLWORD;
+      temp_s = start_addr - DisplayRegion68k;
+      temp_e = dataptr - DisplayRegion68k;

-      end_y = (int)temp_e / DisplayRasterWidth;
-      end_x = ((int)temp_e % DisplayRasterWidth) * BITSPER_DLWORD + (BITSPER_DLWORD - 1);
+      start_y = temp_s / DisplayRasterWidth;
+      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 */
    }
  }
--- a/src/dsk.c
+++ b/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);
--- a/src/dspif.c
+++ b/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
--- a/src/dspsubrs.c
+++ b/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 */
 }
--- a/src/ether.c
+++ b/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 */
--- a/src/initdsp.c
+++ b/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);
--- a/src/initkbd.c
+++ b/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;
--- a/src/initsout.c
+++ b/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 */
--- a/src/keyevent.c
+++ b/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"
--- a/src/ldeboot.c
+++ b/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);
--- a/src/ldeether.c
+++ b/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 */
--- a/src/main.c
+++ b/src/main.c
@@ -75,7 +75,6 @@
 DLword *Lisp_world; /* lispworld */

 /********** 68k address for Lisp Space **********/
-DLword *Atomspace;
 DLword *Stackspace;
 DLword *Plistspace;
 DLword *DTDspace;
@@ -85,8 +84,6 @@ DLword *Pnamespace;
 DLword *AtomSpace;
 DLword *Defspace;
 DLword *Valspace;
-DLword *Spospspace;
-DLword *Snegspace;

 /********** For Virtual Memory Management **********/
 #ifdef BIGVM
@@ -124,7 +121,6 @@ DLword *HTcoll;
 DLword *DisplayRegion;
 int DisplayInitialized = NIL;

-DLword *Arrayspace;
 DLword *MDS_space_bottom;
 DLword *PnCharspace;
 struct dtd *ListpDTD;
@@ -240,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 */

@@ -253,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;
@@ -291,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\
@@ -314,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.");
@@ -340,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))) {
@@ -362,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);
  }
@@ -439,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
@@ -490,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");
-    if (seteuid(getuid()) == -1) {
-      fprintf(stderr, "Unable to reset effective user id to real user id\n");
+    fprintf(stderr, "Effective user is not real user.  Resetting uid\n");
+    if (setuid(getuid()) == -1) {
+      fprintf(stderr, "Unable to reset user id to real user id\n");
      exit(1);
    }
  }
@@ -519,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);

@@ -618,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");
--- a/src/mkatom.c
+++ b/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
-        else create new atom .  Returns the Atom's index.
+        Look up the atom index of an existing atom, or return 0xFFFFFFFF

-        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,10 +264,8 @@ 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)
-/* if it is NIL then these chars are treated as NUMBER */
+LispPTR make_atom(const char *char_base, DLword offset, DLword length)
 {
-  extern DLword *Spospspace;
  extern DLword *AtomHT;
  extern DLword *Pnamespace;
  extern DLword *AtomSpace;
@@ -282,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,
-         length, non_numericp);
+  printf("TRACE: make_atom( %s , offset= %d, len= %d)\n", char_base, offset, length);
 #endif

  first_char = (*(char_base + offset)) & 0xff;
-  if (length != 0) {
-    if (length == 1) /* one char. atoms */
-    {
-      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 {
+  switch (length) {
+  case 0:
+    /* the zero-length atom has hashcode 0 */
    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;
@@ -327,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"));

@@ -338,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 */
--- a/src/sdl.c
+++ b/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;
+}
--- a/src/storage.c
+++ b/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);
--- a/src/subr.c
+++ b/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;

--- a/src/testtool.c
+++ b/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");
  }
--- a/src/ufs.c
+++ b/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);
--- a/src/unixcomm.c
+++ b/src/unixcomm.c
@@ -351,7 +351,7 @@ static int FindAvailablePty(char *Slave) {
 /*		     => byte count (<= 512), NIL (no data), or T (EOF)          */
 /*	   10 Set Window Size, Arg2 = rows, Arg3 = columns                  */
 /*	   11 Fork PTY to Shell (obsoletes command 4)                       */
-/*        Arg1 = termtype, Arg2 = csh command string                    */
+/*        Arg1 = termtype, Arg2 = shell command string                    */
 /*		     => Job # or NIL                                            */
 /*     12 Create Unix Socket                                            */
 /*        Arg1 = pathname to bind socket to (string)                    */
--- a/src/unixfork.c
+++ b/src/unixfork.c
@@ -75,76 +75,78 @@ static inline ssize_t SAFEREAD(int f, char *b, int c)
 /*									*/
 /************************************************************************/

-/* Creates a PTY connection to a csh */
+/* Creates a PTY connection to a shell */

 static int ForkUnixShell(int slot, char *PtySlave, char *termtype, char *shellarg)
 {
  int PID, SlaveFD;
  struct termios tio;
+  char *argvec[4] = {NULL, NULL, NULL, NULL};
+  char *shell = NULL;
+  char *userShell = NULL;

  PID = fork();

-  if (PID == 0) {
-    char *argvec[4];
-
-    if (0 > setsid()) /* create us a new session for tty purposes */
-      perror("setsid");
-
-/* Open the slave side */
-    SlaveFD = open(PtySlave, O_RDWR);
-    if (SlaveFD == -1) {
-      perror("Slave Open");
-      perror(PtySlave);
-      exit(0);
-    }
-
-#ifdef OS5
-    ioctl(SlaveFD, I_PUSH, "ptem");
-    ioctl(SlaveFD, I_PUSH, "ldterm");
-#endif /* OS5 */
-
-    /* Set up as basic display terminal: canonical erase,
-       kill processing, echo, backspace to erase, echo ctrl
-       chars as ^x, kill line by backspacing */
-    tcgetattr(SlaveFD, &tio);
-    tio.c_lflag |= ICANON | ECHO | ECHOE | ECHOCTL | ECHOKE;
-    tcsetattr(SlaveFD, TCSANOW, &tio);
-
-    (void)dup2(SlaveFD, 0);
-    (void)dup2(SlaveFD, 1);
-    (void)dup2(SlaveFD, 2);
-    (void)close(SlaveFD);
-
-    /* set the LDESHELL variable so the underlying .cshrc can see it and
-       configure the shell appropriately, though this may not be so important any more */
-    setenv("LDESHELL", "YES", 1);
-
-    if (termtype[0] != 0) { /* set the TERM environment var */
-      setenv("TERM", termtype, 1);
-    }
-    /* Start up csh */
-    argvec[0] = "csh";
-    if (shellarg[0] != 0) { /* setup to run command */
-      argvec[1] = "-c";     /* read commands from next arg */
-      argvec[2] = shellarg;
-      argvec[3] = (char *)0;
-    } else
-      argvec[1] = (char *)0;
-
-    execv("/bin/csh", argvec);
-
-    /* Should never get here */
-    perror("execv");
-    exit(0);
-  } else { /* not the forked process. */
+  if (PID != 0) {
    if (shellarg != shcom) free(shellarg);
+    return (PID);
  }

-  /* Set the process group so all the kids get the bullet too
-  if (setpgrp(PID, PID) != 0)
-    perror("setpgrp"); */
+  if (0 > setsid()) /* create us a new session for tty purposes */
+    perror("setsid");

-  return (PID);
+  /* Open the slave side */
+  SlaveFD = open(PtySlave, O_RDWR);
+  if (SlaveFD == -1) {
+    perror("Slave Open");
+    perror(PtySlave);
+    exit(0);
+  }
+
+#ifdef OS5
+  ioctl(SlaveFD, I_PUSH, "ptem");
+  ioctl(SlaveFD, I_PUSH, "ldterm");
+#endif /* OS5 */
+
+  /* Set up as basic display terminal: canonical erase,
+     kill processing, echo, backspace to erase, echo ctrl
+     chars as ^x, kill line by backspacing */
+  tcgetattr(SlaveFD, &tio);
+  tio.c_lflag |= ICANON | ECHO | ECHOE | ECHOCTL | ECHOKE;
+  tcsetattr(SlaveFD, TCSANOW, &tio);
+
+  (void)dup2(SlaveFD, 0);
+  (void)dup2(SlaveFD, 1);
+  (void)dup2(SlaveFD, 2);
+  (void)close(SlaveFD);
+
+  /* set the LDESHELL variable so the underlying shell initialization can see it and
+     configure the shell appropriately, though this may not be so important any more */
+  setenv("LDESHELL", "YES", 1);
+
+  if (termtype[0] != 0) { /* set the TERM environment var */
+    setenv("TERM", termtype, 1);
+  }
+  /* Start up shell -- use SHELL environment variable as long as it's in /etc/shells */
+  shell = getenv("SHELL");
+  for (userShell = getusershell(); userShell != NULL && strcmp(shell, userShell) != 0; userShell = getusershell());
+  if (userShell == NULL) {
+    perror("$(SHELL) not found in /etc/shells");
+    exit(0);
+  }
+
+  /* argvec entries initialized to NULL */
+  argvec[0] = strrchr(userShell, '/') + 1;
+  if (shellarg[0] != 0) { /* setup to run command */
+    argvec[1] = "-c";     /* read commands from next arg */
+    argvec[2] = shellarg;
+  }
+
+  execv(userShell, argvec);
+
+  /* Should never get here */
+  perror("execv");
+  exit(0);
 }

 /* fork_Unix is the secondary process spawned right after LISP is
--- a/src/uraid.c
+++ b/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);
--- a/src/xc.c
+++ b/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();
--- a/src/xinit.c
+++ b/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;
Author	SHA1	Message	Date
Nick Briggs	32335d5304	Rename sdl_bitblt_to_texture2 to sdl_bitblt_to_texture_exact to be more descriptive	2021-12-20 12:56:11 -08:00
Nick Briggs	e175a69377	Use SDL_LowerBlitScaled() rather than SDL_BlitScaled()	2021-12-10 16:35:19 -08:00
Nick Briggs	f87b1604e5	Handle pixel scaling when creating the cursors	2021-12-06 19:21:10 -08:00
Nick Briggs	88f5729727	Merge branch 'master' into sdl-texture-direct	2021-11-26 19:57:40 -08:00
Nick Briggs	65bbcb7d9d	Remove makepathname() (#410 ) 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.	2021-11-26 19:53:26 -08:00
Nick Briggs	ceda3d146e	Clean up cursor code Use the Lisp type DLword where referring to data stored by Lisp Access the extern EmCursorBitMap68K directly where appropriate. Use GETBYTE() macro to correct for endian-ness of host system when accessing the cursor bitmaps. Cached cursors can use an ordering strategy that only promotes the found item if it is third or later in the list since in normal operation Medley is highly likely to flip back-and-forth between two cursors.	2021-11-26 18:02:21 -08:00
Nick Briggs	753c7d37a9	Reformat to standard with clang-format	2021-11-23 17:52:37 -08:00
Nick Briggs	ffd86beb52	Cleanup, strip some debug/performance code in display update, minor formatting	2021-11-23 17:45:01 -08:00
Nick Briggs	31a244c0e6	Implement bitblt to texture at bit level rather than word level, some cleanup sdl_bitblt_to_texture2 is an experiment, parallel to sdl_bitblt_to_texture that only moves as many bits as are required, rather than rounding down(up) to the nearest (16-bit) word boundary for the start(end) of the line. Introduces some name changes to make things a little clearer.	2021-11-20 18:26:50 -08:00
Nick Briggs	2eae377e5f	Take pixelscale into account when repositioning cursor	2021-11-17 12:27:13 -08:00
Nick Briggs	00125785be	Some systems require C99 extensions to get sigset utilities.	2021-11-15 18:57:51 -08:00
Nick Briggs	c32233b824	Speedups in texture based display path Instead of checking "do_invert" at each pixel assignment, assign the foreground and background colors appropriately when responding to the (VIDEOCOLOR x) call. Modify sdl_bitblt_to_texture() so that it does less arithmetic in the inner loop, including using a table of masks rather than computing 1<<n on each pixel. Modify sdl_bitblt_to_texture() so that it accesses the Lisp display region 16-bits at a time with the correct ordering for whether we are on a byte-swapped system or not.	2021-11-15 18:38:16 -08:00
Nick Briggs	3091bb2e5a	Minor changes to add missing file for SDL and set no extensions for C compiler Sets CMAKE_C_EXTENSIONS to OFF as we wish to use c99 not gnu99 Adds inc/sdldefs.h to SDL header files list	2021-11-15 18:34:01 -08:00
Nick Briggs	fabfca2486	When updating the window surface directly, at scale 1, avoid the intermediate buffer Adds an sdl_blt_to_window_surface() that goes directly from the Lisp bitmap to the window surface avoiding the intermediate copy. This is only coded for a scale factor of 1. Uses the intermediate buffer if the scale is not 1. Corrects an error where the damage rectangle was not properly reset.	2021-11-09 20:15:00 -08:00
Nick Briggs	e430513d6a	Avoid intermediate buffer and bitblt Lisp screen changes directly into the texture pixels Using SDL_LockTexture/SDL_UnlockTexture we can gain more direct access to the pixels of the texture and update them directly from the Lisp screen bitmap. At the same time, for both the rendering case and the display surface case, update the pixel format used to be either the first (presumably preferred?) format for a texture, or the surface format of the window. Use the SDL routines to pick out the pixel value for Black and White based on the destination it will be placed in.	2021-11-09 13:57:25 -08:00
Nick Briggs	184f02d0c1	Introduce alternative method for updating window from Lisp bitmap If the preprocessor symbol SDLRENDERING is defined the code operates as it previously did. In the absence of that, we process the Lisp bitmap into an intermediate form (as before) but then use SDL bitblt to redraw the intermediate form on the window's surface.	2021-11-08 22:18:08 -08:00
Nick Briggs	0606015793	Move display update into separate procedure	2021-11-08 22:02:43 -08:00
Nick Briggs	d64e1d1b38	Width, but not height, must be multiple of 32	2021-11-08 21:28:06 -08:00
Nick Briggs	f59e4395b8	Bounds check indexing into intermediate screen buffer When building with -DCMAKE_BUILD_TYPE=Debug, we assert() that the index into the intermediate screen buffer is in bounds.	2021-11-08 20:40:30 -08:00
Nick Briggs	f7588b8c8e	Keep damage notification boundaries within the current screen On startup, bitblt calls may be made for the original screen size and if the new screen size is smaller than that, we must ensure that damage notifications are contained within the new screen. Move definition of min() so we can use it in sdl_notify_damage()	2021-11-08 18:21:38 -08:00
Peter	241e5fe9a9	Cache cursors for SDL.	2021-11-08 21:10:23 +01:00
Peter	f9d1e51456	Change Pixelformat to 332 (one byte) instead of 8888 (four bytes).	2021-11-08 20:03:28 +01:00
ecraven	c64f8534df	Merge pull request #408 from Interlisp/sdl-fix-implicit-decls Add proper header for SDL-specific functions with prototypes.	2021-11-08 12:56:47 +01:00
Nick Briggs	ba6e365cc8	Fix "error: implicit declaration of function" from dspsubrs Creates an sdldefs.h, declares a few more functions in sdl.c static, and includes sdldefs.h in dspsubrs.c when necessary.	2021-11-07 11:26:46 -08:00
Peter	37aed57027	Add support for setting the mouse cursor. Not finished! Currently this just allocates a new X cursor each time, should be amended to cache the cursor, just like X does at the moment.	2021-11-07 19:37:33 +01:00
Peter	ecfd4048e0	Add support for inverting video and setting mouse position. Use (IL:VIDEOCOLOR T/NIL) to change inversion.	2021-11-07 19:37:33 +01:00
Peter	a3fdf18edc	Add mouse wheel diagnostics.	2021-11-07 19:37:33 +01:00
Peter	8a872d7d85	Only update texture on damage.	2021-11-07 19:37:33 +01:00
Peter	5413934525	Add support for key repeating.	2021-11-07 19:37:33 +01:00
Peter	784d9f61cb	For now, some more extern functions declarations.	2021-11-07 19:37:33 +01:00
Peter	00c4d65aff	Maybe fix cmake for SDL2.	2021-11-07 19:37:33 +01:00
Peter	bab9213120	Remove SDL2 directory from include SDL2/SDL.h.	2021-11-07 19:37:33 +01:00
Peter	9bb7fab4a4	Fix Caso.	2021-11-07 19:37:33 +01:00
Peter	bab54bca6a	Try to unify cmake file for different versions of SDL2.	2021-11-07 19:37:33 +01:00
Peter	572b94d4a7	Try SDL2::SDL2 instead of SDL2 in CMakeLists.txt.	2021-11-07 19:37:33 +01:00
Peter	e9968a211b	Try to placate the macos build.	2021-11-07 19:37:33 +01:00
Peter	e346db4b99	Apparently there is no sdl2 cask for macos :-/	2021-11-07 19:37:33 +01:00
Peter	f769dbadeb	Add SDL2 dependency to macos build.	2021-11-07 19:37:33 +01:00
Peter	56d563983e	Show cmake version before building.	2021-11-07 19:37:33 +01:00
Peter	ccfacb23a7	Try to make builds pass again.	2021-11-07 19:37:33 +01:00
Peter	4ee904fd1d	Run apt-get update before trying to install.	2021-11-07 19:37:33 +01:00
Peter	ab94538d0c	Add support for -t / -title.	2021-11-07 19:37:33 +01:00
Peter	f8fea0b8d8	Revert CMakeLists.txt change until better understanding.	2021-11-07 19:37:33 +01:00
Peter	0d4703086e	Also correctly install SDL2 on ubuntu runners.	2021-11-07 19:37:33 +01:00
Peter	5c225467ab	Also install SDL2 on ubuntu runners.	2021-11-07 19:37:33 +01:00
Peter	8f7067943f	Try to get CI running again ;)	2021-11-07 19:37:33 +01:00
Peter	2092a74869	Add command line parameters -sc WxH and -pixelscale n for SDL.	2021-11-07 19:37:33 +01:00
Peter	f198204bca	Update CMakeLists.txt for cross-compiling.	2021-11-07 19:37:33 +01:00
Peter	4821dac4c0	Add more #ifdef XWINDOW	2021-11-07 19:37:33 +01:00
Peter	28931acd36	Remove extra directory from includes for SDL.	2021-11-07 19:37:33 +01:00
Peter	7b7db9aac5	Refactor, only bitblt once per "frame".	2021-11-07 19:37:33 +01:00
Peter	333c132e40	Refactor, don't update texture on every bitblt.	2021-11-07 19:37:33 +01:00
Peter	87ede7cee1	Only bitblt on damage. Also add an alternative for key handling, which does not work any better...	2021-11-07 19:37:33 +01:00
Peter	78e42b7217	Change SDL backend to accelerated renderer, support pixel scaling. Edit main.c, init_SDL(1600, 1024, 1) means lisp display size 1600x1024, pixel scaling 1. Try init_SDL(800, 512, 2) or even init_SDL(608, 1023, 3).	2021-11-07 19:37:33 +01:00
Peter	f73b4d1ff5	Merge remote-tracking branch 'upstream/master'	2021-11-07 19:37:24 +01:00
Nick Briggs	987cf4c7c6	Correct error for missing byteswap macros in tosfns.h EVAL implementation (#407 ) Commit `c46fcce307` fixed a warning for incompatible pointers to nnewframe() but did not consider that the order of the DLwords is swapped depending on the endianness of the system it is running on. Add the necessary GETBASEWORD() macros to access the items when constructing the pointer.	2021-11-06 18:36:25 -07:00
Nick Briggs	c46fcce307	Fix "warning: incompatible pointer types" in EVAL implementation (#406 ) nnewframe() as called from the EVAL implementation expects to be passed the address of an array of two DLwords. Do that, and compose the 32-bit result correctly rather than passing the address of a (32-bit) LispPTR and then having to swapx() that result to get the expected value.	2021-11-04 20:18:27 -07:00
Nick Briggs	de5ea2110f	Correct integer type warnings (#405 ) * Correct warning: cast to smaller integer type -- X_init/lispbitmap * Fixes to INTRSAFE, INTRSAFE0 and ensure TIMEOUT, TIMEOUT0 used appropriately INTRSAFE and INTRSAFE0 must clear errno before executing the library or system call because not all library calls set errno on success. Avoid casting pointers or larger integer values down to smaller ints before comparing to 0 or -1, and use NULL (a pointer) rather than 0. Fix cases where the result of the library call is a pointer rather than an int to use TIMEOUT0 instead of TIMEOUT, testing for NULL rather than -1 on timeout (errno == EINTR) * Remove useless validity check of LASTVMEMFILEPAGE_word pointer * Convert pointer arithmetic type in drawline from int to ptrdiff_t * Add NOTE warning about a 32-bit vs 64-bit issue affecting currently unused GET_NATIVE_ADDR_FROM_LISP_PTR	2021-11-04 09:08:55 -07:00
Nick Briggs	6c241f1eaa	Make opcode_table (names of opcodes) visible as useful debug aid.	2021-10-29 10:02:47 -07:00
Nick Briggs	19688bc314	Drop setuid privilege correctly. (#401 )	2021-10-29 09:52:51 -07:00
Nick Briggs	c39b751f42	Rework make_atom() to allow removal of parse_number() (#404 ) No calls to make_atom() depend on the ability to parse the atom's pname as a number. Additionally, the parse_number() implementation used here was non-functional. We remove parse_number() and adjust the parameter list of make_atom() to remove the non_numericp flag.	2021-10-29 09:51:32 -07:00
Peter	f58abe36ee	Add prototypical SDL support. Build with cmake. This will create a new backend (ldesdl). - Resolution can only be set by editing the variables in sdl.c. - Key repeat does not work. - Still problems with keysyms that implicitly contain modifiers. - The entire screen is bitblted onto the SDL display every frame. Support keyboard, and work on mouse. Kind of working... Fix display resolution problems.	2021-10-20 10:12:04 +02:00
Nick Briggs	75c668f1cd	The pointers Atomspace, Spospspace, Snegspace, Arrayspace can be removed (#402 ) These pointers are neither initialized nor referenced anywhere in the code.	2021-10-10 16:55:33 -07:00
Nick Briggs	a25368714f	Use SHELL rather than /bin/csh when forking shells. Issue Interlisp/medley#384 (#400 ) As long as $(SHELL) names an executable that appears in /etc/shells (as determined by the getusershell() function) use that. It used to always use /bin/csh, but some modern distros do not ship with csh installed. Using the user's preferred shell seems like a better choice, while allowing the choice from /etc/shells gives some additional flexibility.	2021-10-08 17:58:29 -07:00