Scratch branch for (trying to) build old release 2.01

Addr68k_from_LADDR always produced a 2-byte aligned pointer which
  was frequently cast to a type requiring 4-byte alignment.
  This commit changes Addr68k_from_LADDR uses to one of two new
  inline procedures, NativeAligned2FromLAddr or NativeAligned4FromLAddr,
  which produce a result with the appropriate alignment for the context.
  This permits checking for cases where the Lisp address is not
  appropriately aligned for the usage context, and localizes compiler
  warnings to these two procedures.

  Similarly, the Addr68k_from_StkOffset macros are replaced by
  NativeAligned2FromStackOffset and NativeAligned4FromStackOffset.

  NativeAligned4FromLPage replaces Addr68k_from_LPAGE as page address
  will always be at least 4-byte aligned.

  LAddrFromNative, LPageFromNative, and StackOffsetFromNative complete
  the set, replacing LADDR_from_68k, LPAGE_from_68k, and
  StkOffset_from_68K (note K not k) respectively.

.github/workflows/build.yml

@@ -11,7 +11,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [macos-10.15, ubuntu-18.04]
+        os: [macos-11, ubuntu-22.04, ubuntu-18.04]
     steps:
       - uses: actions/checkout@v2
       - name: Install X11 dependencies on MacOS
@@ -37,7 +37,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [macos-10.15, ubuntu-20.04, ubuntu-18.04]
+        os: [macos-11, ubuntu-22.04, ubuntu-20.04, ubuntu-18.04]
     env:
       BUILD_TYPE: Release
     steps:

.github/workflows/buildDocker.yml

@@ -1,84 +0,0 @@
-#  based on https://blog.oddbit.com/post/2020-09-25-building-multi-architecture-im/
----
-# Interlisp workflow to build a Docker Image that supports multiple architectures
-name: 'Build Maiko Docker image'
-
-# Run this workflow on push to master
-# Other branches can be added it needed. 
-on:
-  push:
-    branches:
-      - master
-
-#  Jobs that are run as part of this workflow.
-jobs:
-  # Job to build the docker image
-  # see: https://github.com/docker/build-push-action
-  docker:
-    runs-on: ubuntu-latest
-    steps:
-      # Checkout the branch  
-      - name: Checkout
-        uses: actions/checkout@v2
-
-      # Setup some environment variables
-      - name: Prepare
-        id: prep
-        run: |
-          # Name of the Docker Image. 
-          DOCKER_IMAGE=interlisp/${GITHUB_REPOSITORY#*/}
-          VERSION=latest
-          SHORTREF=${GITHUB_SHA::8}
-          ## Do we want to use tags and or versions 
-          # If this is git tag, use the tag name as a docker tag
-          if [[ $GITHUB_REF == refs/tags/* ]]; then
-            VERSION=${GITHUB_REF#refs/tags/v}
-          fi
-          TAGS="${DOCKER_IMAGE}:${VERSION},${DOCKER_IMAGE}:${SHORTREF}"
-          # If the VERSION looks like a version number, assume that
-          # this is the most recent version of the image and also
-          # tag it 'latest'.
-          if [[ $VERSION =~ ^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$ ]]; then
-            TAGS="$TAGS,${DOCKER_IMAGE}:latest"
-          fi
-          # Set output parameters.
-          echo ::set-output name=tags::${TAGS}
-          echo ::set-output name=docker_image::${DOCKER_IMAGE}
-          echo ::set-output name=build_time::$(date -u +'%Y-%m-%dT%H:%M:%SZ')
-      # Setup the Docker Machine Emulation environment.  
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@master
-        with:
-          platforms: all
-
-      # Setup the Docker Buildx funtion
-      - name: Set up Docker Buildx
-        id: buildx
-        uses: docker/setup-buildx-action@master
-
-      # Login into DockerHub - required to store the created image
-      - name: Login to DockerHub
-        if: github.event_name != 'pull_request'
-        uses: docker/login-action@v1
-        with:
-          username: ${{ secrets.DOCKER_USERNAME }}
-          password: ${{ secrets.DOCKER_PASSWORD }}
-
-      # Start the Docker Build using the Dockerfile in the repository we
-      # checked out.  
-      - name: Build
-        uses: docker/build-push-action@v2
-        with:
-          builder: ${{ steps.buildx.outputs.name }}
-          build-args: BUILD_DATE=${{ steps.prep.outputs.build_time }}
-          context: .
-          file: ./Dockerfile
-          # Platforms - Sepecify the platforms to include in the build
-          #  linux/amd64 -- Standard x86_64
-          #  linux/arm64 -- Apple M1
-          #  linux/arm/v7 -- Raspberry pi
-          platforms: linux/amd64,linux/arm64,linux/arm/v7
-          # Push the result to DockerHub
-          push: true
-          # tags to assign to the Docker image
-          tags: ${{ steps.prep.outputs.tags }}

.github/workflows/buildReleaseInclDocker.yml

@@ -0,0 +1,357 @@
+#*******************************************************************************
+# buidReleaseInclDocker.yml
+#
+# Workflow to build a Maiko release that is pushed to github as well as
+# Docker images incorporating the release, which are pushed to Docker Hub.
+# For linux:  release assets are built/pushed for X86_64, aarch64 and arm7vl and 
+#     a multiplatform Docker image is pushed.
+# For macOS:  release assets are built/pushed for X86_64. (No aarch64 as yet.)
+# For Windows:  not supported
+#
+# Note release pushed to github automatically includes source code assets
+# in tar and zip formats.
+#
+# 2022-01-16 by Frank Halasz based on earlier workflow called buildDocker.yml
+#
+# Copyright 2022 by Interlisp.org
+#
+#
+# ******************************************************************************
+
+name: 'Build/Push Release & Docker Image'
+
+env:
+  workflow: 'buildReleaseInclDocker.yml'
+
+# Run this workflow on ...
+on: 
+    workflow_dispatch:
+      inputs:
+        force:
+          description: "Force build even if build already successfully completed for this commit"
+          type: choice
+          options:
+          - 'false'
+          - 'true'
+
+    workflow_call:
+      secrets:
+        DOCKER_USERNAME:
+          required: true
+        DOCKER_PASSWORD:
+          required: true
+      outputs:
+        successful:
+          description: "'True' if maiko build completed successully"
+          value: ${{ jobs.complete.outputs.build_successful }}
+      inputs:
+        force:
+          description: "Force build even if build already successfully completed for this commit"
+          required: false
+          type: string
+          default: 'false'
+
+defaults:
+  run:
+    shell: bash
+
+#  2 separate jobs here that can run in parallel
+#
+#  1.  Linux: Build/push a multiplatform Linux Docker image and use results to
+#      build/push Linux release assets.
+#
+#  2.  MacOs_x86_64:  Build maiko for MacOS on X86_64 then create and push release assets.
+#
+
+jobs:
+
+######################################################################################
+
+  # Regularize the inputs so they can be referenced the same way whether they are
+  # the result of a workflow_dispatch or a workflow_call
+
+  inputs:
+    runs-on: ubuntu-latest
+    outputs:
+      force: ${{ steps.force.outputs.force }}
+    steps:
+      - id: force
+        run: >
+          if [ '${{ toJSON(inputs) }}' = 'null'  ];
+          then echo ::set-output name=force::'${{ github.event.inputs.force }}'; echo "workflow_dispatch";
+          else echo ::set-output name=force::'${{ inputs.force }}'; echo "workflow_call";
+          fi
+        
+
+
+######################################################################################
+
+  # Use sentry-action to determine if this release has already been built
+  # based on the latest commit to the repo
+
+  sentry:
+    needs: inputs
+    runs-on: ubuntu-latest
+    outputs:
+      release_not_built: ${{ steps.check.outputs.release_not_built }}
+
+    steps: 
+      # Checkout the actions for this repo owner
+      - name: Checkout Actions
+        uses: actions/checkout@v2
+        with:
+          repository: ${{ github.repository_owner }}/.github
+          path: ./Actions_${{ github.sha }}
+      - run: mv ./Actions_${{ github.sha }}/actions ../actions && rm -rf ./Actions_${{ github.sha }}
+
+      # Check if build already run for this commit
+      - name: Build already completed? 
+        id: check
+        continue-on-error: true
+        uses: ./../actions/check-sentry-action
+        with:
+          tag: "release_docker"
+
+######################################################################################
+
+  # Linux: build and push multi-platform docker image for Linux
+  # Use docker images to create and push release assets to github
+
+  linux:
+  
+    needs: [inputs, sentry]
+    if: |
+      needs.sentry.outputs.release_not_built == 'true'
+      || needs.inputs.outputs.force == 'true'
+    
+    runs-on: ubuntu-latest
+
+    steps:
+      # Checkout the actions for this repo owner
+      - name: Checkout Actions
+        uses: actions/checkout@v2
+        with:
+          repository: ${{ github.repository_owner }}/.github
+          path: ./Actions_${{ github.sha }}
+      - run: mv ./Actions_${{ github.sha }}/actions ../actions && rm -rf ./Actions_${{ github.sha }}
+
+      # Checkout the branch  
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      # Setup release tag
+      - name: Setup Release Tag
+        id: tag
+        uses: ./../actions/release-tag-action
+
+      # Setup docker environment variables
+      - name: Setup Docker Environment Variables
+        id: docker_env
+        run: |
+          DOCKER_NAMESPACE=$(echo "${{ github.repository_owner }}" | tr '[:upper:]' '[:lower:]')
+          echo "DOCKER_NAMESPACE=${DOCKER_NAMESPACE}" >> ${GITHUB_ENV}
+          DOCKER_IMAGE=${DOCKER_NAMESPACE}/${{ steps.tag.outputs.repo_name }}
+          DOCKER_TAGS="${DOCKER_IMAGE}:latest,${DOCKER_IMAGE}:${RELEASE_TAG#*-}"
+          echo ::set-output name=build_time::$(date -u +'%Y-%m-%dT%H:%M:%SZ')
+          echo ::set-output name=docker_tags::${DOCKER_TAGS}
+
+      # Setup the Docker Machine Emulation environment.  
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@master
+        with:
+          platforms: linux/amd64,linux/arm64,linux/arm/v7
+
+      # Setup the Docker Buildx funtion
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@master
+
+      # Login into DockerHub - required to store the created image
+      - name: Login to DockerHub
+        uses: docker/login-action@v1
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+
+      # Do the Docker Build using the Dockerfile in the repository we
+      # checked out.  Push the result to Docker Hub.
+      #
+      # NOTE: THE ACTUAL MAIKO BUILD (FOR LINUX) HAPPENS HERE - I.E., IN THE
+      #       DOCKER BUILD CALL.  BUILD COMMANDS ARE SPECIFIED IN THE
+      #       Dockerfile, NOT HERE IN THE WORKFLOW.
+      #
+      - name: Build Docker Image for Push to Docker Hub
+        if: ${{ true }}
+        uses: docker/build-push-action@v2
+        with:
+          builder: ${{ steps.buildx.outputs.name }}
+          build-args: |
+            BUILD_DATE=${{ steps.docker_env.outputs.build_time }}
+            RELEASE_TAG=${{ steps.tag.outputs.release_tag }}
+          context: .
+          file: ./Dockerfile
+          platforms: linux/amd64,linux/arm64,linux/arm/v7
+          # Push the result to DockerHub
+          push: true
+          tags: ${{ steps.docker_env.outputs.docker_tags }}
+
+      # Redo the Docker Build (hopefully mostly using the cache from the previous build).
+      # But save the results in a directory under /tmp to be used for creating release tars.
+      - name: Rebuild Docker Image For Saving Locally
+        uses: docker/build-push-action@v2
+        with:
+          builder: ${{ steps.buildx.outputs.name }}
+          build-args: |
+            BUILD_DATE=${{ steps.docker_env.outputs.build_time }}
+            RELEASE_TAG=${{ steps.tag.outputs.release_tag }}
+          context: .
+          file: ./Dockerfile
+          platforms: linux/amd64,linux/arm64,linux/arm/v7
+          # Put the results out to the local file system
+          outputs: type=local,dest=/tmp/docker_images
+          tags: ${{ steps.docker_env.outputs.docker_tags }}
+
+      # Use docker results to create releases for github.
+      # Docker results are in /tmp/docker_images. One subdir for each platform.
+      - name: Make release tars for each platform
+        env:
+          RELEASE_TAG: ${{ steps.tag.outputs.release_tag }}
+        run: |
+          mkdir -p /tmp/release_tars
+          for OSARCH in "linux.x86_64:linux_amd64" "linux.aarch64:linux_arm64" "linux.armv7l:linux_arm_v7" ;    \
+            do                                                                         \
+              pushd /tmp/docker_images/${OSARCH##*:}/usr/local/interlisp >/dev/null ;  \
+              /usr/bin/tar -c -z                                                       \
+                -f /tmp/release_tars/${RELEASE_TAG}-${OSARCH%%:*}.tgz                  \
+                maiko/bin/osversion                                                    \
+                maiko/bin/machinetype                                                  \
+                maiko/bin/config.guess                                                 \
+                maiko/bin/config.sub                                                   \
+                maiko/${OSARCH%%:*}/lde*                                               \
+              ;                                                                        \
+              popd >/dev/null ;                                                        \
+            done
+
+      # Push Release to github
+      - name: Push the release
+        uses: ncipollo/release-action@v1.8.10
+        with: 
+          allowUpdates: true
+          artifacts:
+            /tmp/release_tars/${{ steps.tag.outputs.release_tag }}-linux.x86_64.tgz,
+            /tmp/release_tars/${{ steps.tag.outputs.release_tag }}-linux.aarch64.tgz,
+            /tmp/release_tars/${{ steps.tag.outputs.release_tag }}-linux.armv7l.tgz
+          tag: ${{ steps.tag.outputs.release_tag }}
+          draft: true
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+
+######################################################################################
+
+  # MacOS: build for MacOS (X86_64) and use results to
+  # create and push release assets to github
+  macos_x86_64:
+
+    needs: [inputs, sentry]
+    if: |
+      needs.sentry.outputs.release_not_built == 'true'
+      || needs.inputs.outputs.force == 'true'
+
+    runs-on: macos-10.15
+
+    steps:
+
+      # Checkout the branch  
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      # Checkout the actions for this repo owner
+      - name: Checkout Actions
+        uses: actions/checkout@v2
+        with:
+          repository: ${{ github.repository_owner }}/.github
+          path: ./Actions_${{ github.sha }}
+      - run: mv ./Actions_${{ github.sha }}/actions ../actions && rm -rf ./Actions_${{ github.sha }}
+
+      # Setup release tag
+      - name: Setup Release Tag
+        id: tag
+        uses: ./../actions/release-tag-action
+
+      # Install X11 dependencies
+      - name: Install X11 dependencies on MacOS
+        if: ${{ runner.os == 'macOS'}}
+        run: brew install --cask xquartz
+
+      # Build maiko   
+      - name: Build
+        working-directory: ./bin
+        run: |
+          ./makeright x
+          ./makeright init
+
+      # Create release tar for github.
+      - name: Make release tar(s)
+        env:
+          RELEASE_TAG: ${{ steps.tag.outputs.release_tag }}
+        run: |
+          mkdir -p /tmp/release_tars
+          pushd ${GITHUB_WORKSPACE}/../ >/dev/null
+          tar -c -z                                                       \
+            -f /tmp/release_tars/${RELEASE_TAG}-darwin.x86_64.tgz                  \
+            maiko/bin/osversion                                                    \
+            maiko/bin/machinetype                                                  \
+            maiko/bin/config.guess                                                 \
+            maiko/bin/config.sub                                                   \
+            maiko/darwin.x86_64/lde*
+          popd >/dev/null
+
+      # Push Release
+      - name: Push the release
+        uses: ncipollo/release-action@v1.8.10
+        with: 
+          allowUpdates: true
+          artifacts:
+            /tmp/release_tars/${{ steps.tag.outputs.release_tag }}-darwin.x86_64.tgz
+          tag: ${{ steps.tag.outputs.release_tag }}
+          draft: true
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+
+
+######################################################################################
+
+  # Use set-sentry-action to determine set the sentry that says this release has
+  # been successfully built
+
+  complete:
+
+    runs-on: ubuntu-latest
+
+    outputs:
+      build_successful: ${{ steps.output.outputs.build_successful }}
+
+    needs: [inputs, sentry, linux, macos_x86_64]
+
+    steps: 
+      # Checkout the actions for this repo owner
+      - name: Checkout Actions
+        uses: actions/checkout@v2
+        with:
+          repository: ${{ github.repository_owner }}/.github
+          path: ./Actions_${{ github.sha }}
+      - run: mv ./Actions_${{ github.sha }}/actions ../actions && rm -rf ./Actions_${{ github.sha }}
+
+      # Set sentry
+      - name: Is build for this commit already completed? 
+        id: set
+        uses: ./../actions/set-sentry-action
+        with:
+          tag: "release_docker"
+     
+      - name: Output
+        id: output
+        run: |
+          echo ::set-output name=build_successful::'true'
+          
+######################################################################################

CMakeLists.txt

@@ -18,7 +18,7 @@ ENDIF()
 
 find_program(
     CLANG_TIDY_EXE
-    NAMES "clang-tidy" "clang-tidy12" "clang-tidy11" "clang-tidy10"
+    NAMES "clang-tidy" "clang-tidy13" "clang-tidy12" "clang-tidy11" "clang-tidy10"
     DOC "Path to clang-tidy executable"
 )
 
@@ -121,15 +121,8 @@ SET(BAD_SRCS
 
 SET(MAIKO_SRCS
     src/allocmds.c
-    src/arith2.c
-    src/arith3.c
-    src/arith4.c
-    src/array2.c
-    src/array3.c
-    src/array4.c
-    src/array5.c
-    src/array6.c
-    src/array.c
+    src/arithops.c
+    src/arrayops.c
     src/asmbbt.c
     src/bbtsub.c
     src/bin.c
@@ -223,16 +216,9 @@ SET(MAIKO_HDRS
     inc/address.h
     inc/adr68k.h
     inc/allocmdsdefs.h
-    inc/arith2defs.h
-    inc/arith3defs.h
-    inc/arith4defs.h
+    inc/arithopsdefs.h
     inc/arith.h
-    inc/array2defs.h
-    inc/array3defs.h
-    inc/array4defs.h
-    inc/array5defs.h
-    inc/array6defs.h
-    inc/arraydefs.h
+    inc/arrayopsdefs.h
     inc/array.h
     inc/bb.h
     inc/bbtsubdefs.h
@@ -379,6 +365,7 @@ SET(MAIKO_HDRS
     inc/unixfork.h
     inc/unwinddefs.h
     inc/uraiddefs.h
+    inc/uraidextdefs.h
     inc/usrsubrdefs.h
     inc/uutilsdefs.h
     inc/vars3defs.h
@@ -390,7 +377,7 @@ SET(MAIKO_HDRS
 )
 
 ADD_CUSTOM_TARGET(gen-vdate
-  COMMAND ../bin/mkvdate > vdate.c
+  COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/bin/mkvdate > vdate.c
   BYPRODUCTS vdate.c
 )
 

Dockerfile

@@ -1,18 +1,55 @@
+#*******************************************************************************
+#
+#  Dockerfile to build Maiko (Stage 1) and create a Docker image and push it
+#  to DockerHub (stage 2).
+#
+#  Copyright 2022 by Interlisp.org
+#
+# ******************************************************************************
+
+#
+#  Build Maiko Stage
+#
+FROM ubuntu:focal AS builder
+SHELL ["/bin/bash", "-c"]
+USER root:root
+# Install build tools
+RUN apt-get update && apt-get install -y make clang libx11-dev gcc x11vnc xvfb
+# Copy over / clean maiko repo
+COPY . /app/maiko
+RUN rm -rf /app/maiko/linux*
+# Build maiko
+WORKDIR /app/maiko/bin
+RUN ./makeright x
+RUN if [ "$(./osversion)" = "linux" ] && [ "$(./machinetype)" = "x86_64" ]; then ./makeright init; fi
+# Prep for Install Stage
+RUN mv ../$(./osversion).$(./machinetype) ../TRANSFER
+#
+#  Install Maiko Stage
+#
 FROM ubuntu:focal
-ARG BUILD_DATE
+ARG BUILD_DATE="not_available"
+ARG RELEASE_TAG="not_available"
 LABEL name="Maiko"
 LABEL description="Virtual machine for Interlisp Medley"
 LABEL url="https://github.com/Interlisp/maiko"
 LABEL build-time=$BUILD_DATE
-
-ARG TARGETPLATFORM
-
-RUN apt-get update && apt-get install -y make clang libx11-dev gcc x11vnc xvfb
-
-COPY --chown=nonroot:nonroot . /app/maiko
-RUN rm -rf /app/maiko/linux*
-
-WORKDIR /app/maiko/bin
-RUN ./makeright x
-
-RUN rm -rf /app/maiko/inc /app/maiko/include /app/maiko/src
+LABEL release_tag=$RELEASE_TAG
+ENV MAIKO_RELEASE=$RELEASE_TAG
+ENV MAIKO_BUILD_DATE=$BUILD_DATE
+ARG BUILD_LOCATION=/app/maiko
+ARG INSTALL_LOCATION=/usr/local/interlisp/maiko
+#
+SHELL ["/bin/bash", "-c"]
+USER root:root
+# Copy release files into /usr/local/directories
+COPY --from=builder ${BUILD_LOCATION}/bin/osversion    ${INSTALL_LOCATION}/bin/
+COPY --from=builder ${BUILD_LOCATION}/bin/machinetype  ${INSTALL_LOCATION}/bin/
+COPY --from=builder ${BUILD_LOCATION}/bin/config.guess ${INSTALL_LOCATION}/bin/
+COPY --from=builder ${BUILD_LOCATION}/bin/config.sub   ${INSTALL_LOCATION}/bin/
+COPY --from=builder ${BUILD_LOCATION}/TRANSFER/lde*    ${INSTALL_LOCATION}/TRANSFER/
+RUN  cd ${INSTALL_LOCATION} && mv TRANSFER "$(cd bin && ./osversion).$(cd bin/ && ./machinetype)"
+# Some niceties
+USER root
+WORKDIR /root
+ENTRYPOINT /bin/bash

bin/makefile-darwin.x86_64-x

@@ -18,7 +18,7 @@ XFLAGS = -I/opt/X11/include -DXWINDOW
 # OPTFLAGS is normally -O2.
 OPTFLAGS =  -O1 -g
 DEBUGFLAGS = # -DDEBUG -DOPTRACE
-DFLAGS = $(DEBUGFLAGS) $(XFLAGS) -DRELEASE=351
+DFLAGS = $(DEBUGFLAGS) $(XFLAGS) -DRELEASE=201 # was 351
 
 LDFLAGS = -L/opt/X11/lib -lX11 -lm
 LDELDFLAGS =  -L/opt/X11/lib -lX11 -lm

bin/makefile-dos

@@ -13,12 +13,12 @@ LDFLAGS = -g graphics.lib binmode.lib mouse.lib
 
 RM = del
 
-SRCFILES = conspage.c gcoflow.c shift.c dbgtool.c gcr.c         gcrcell.c llstk.c gcscan.c loopsops.c   storage.c allocmds.c dir.c gvar2.c lowlev1.c    subr.c arith2.c lowlev2.c subr0374.c    arith3.c doscomm.c hardrtn.c lsthandl.c sxhash.c        arith4.c draw.c main.c testtool.c array.c dsk.c         inet.c misc7.c timer.c array2.c dspif.c initdsp.c       miscn.c typeof.c array3.c initkbd.c ubf1.c      array4.c dspsubrs.c initsout.c mkatom.c ubf2.c  array5.c eqf.c intcall.c mkcell.c ubf3.c array6.c       ether.c mkvdate.c ufn.c atom.c findkey.c        kbdsubrs.c mouseif.c ufs.c bbtsub.c foreign.c   keyevent.c unixcomm.c bin.c fp.c binds.c       asmbbt.c fvar.c mvs.c unwind.c bitblt.c gc.c    uraid.c blt.c gc2.c kprint.c osmsg.c usrsubr.c byteswap.c gcarray.c  perrno.c ldeboot.c ldeether.c uutils.c carcdr.c gccode.c        rawcolor.c vars3.c gcfinal.c ldsout.c return.c  vmemsave.c chardev.c gchtfind.c lineblt8.c rpc.c        xc.c common.c gcmain3.c lisp2c.c rplcons.c z2.c xmkicon.c xbbt.c xinit.c xscroll.c xcursor.c xlspwin.c  xrdopt.c xwinman.c      dosmouse.c vesafns.asm vesainit.c vgainit.c kbdif.c     dspsparc.il copyright launch.asm lpread.c lpsolve.c lpmain.c lpwrite.c lpdual.c lptran.c
+SRCFILES = conspage.c gcoflow.c shift.c dbgtool.c gcr.c         gcrcell.c llstk.c gcscan.c loopsops.c   storage.c allocmds.c dir.c gvar2.c lowlev1.c    subr.c arithops.c lowlev2.c subr0374.c doscomm.c hardrtn.c lsthandl.c sxhash.c draw.c main.c testtool.c array.c dsk.c         inet.c misc7.c timer.c array2.c dspif.c initdsp.c       miscn.c typeof.c array3.c initkbd.c ubf1.c      array4.c dspsubrs.c initsout.c mkatom.c ubf2.c  array5.c eqf.c intcall.c mkcell.c ubf3.c array6.c       ether.c mkvdate.c ufn.c atom.c findkey.c        kbdsubrs.c mouseif.c ufs.c bbtsub.c foreign.c   keyevent.c unixcomm.c bin.c fp.c binds.c       asmbbt.c fvar.c mvs.c unwind.c bitblt.c gc.c    uraid.c blt.c gc2.c kprint.c osmsg.c usrsubr.c byteswap.c gcarray.c  perrno.c ldeboot.c ldeether.c uutils.c carcdr.c gccode.c        rawcolor.c vars3.c gcfinal.c ldsout.c return.c  vmemsave.c chardev.c gchtfind.c lineblt8.c rpc.c        xc.c common.c gcmain3.c lisp2c.c rplcons.c z2.c xmkicon.c xbbt.c xinit.c xscroll.c xcursor.c xlspwin.c  xrdopt.c xwinman.c      dosmouse.c vesafns.asm vesainit.c vgainit.c kbdif.c     dspsparc.il copyright launch.asm lpread.c lpsolve.c lpmain.c lpwrite.c lpdual.c lptran.c
 
-OFILES = conspage.obj gcoflow.obj shift.obj dbgtool.obj         gcr.obj  gcrcell.obj llstk.obj  gcscan.obj loopsops.obj storage.obj     allocmds.obj dir.obj gvar2.obj lowlev1.obj      subr.obj arith2.obj lowlev2.obj       subr0374.obj arith3.obj doscomm.obj     hardrtn.obj lsthandl.obj sxhash.obj arith4.obj  draw.obj main.obj testtool.obj array.obj        dsk.obj inet.obj misc7.obj timer.obj    array2.obj dspif.obj initdsp.obj miscn.obj      typeof.obj array3.obj initkbd.obj ubf1.obj      array4.obj dspsubrs.obj initsout.obj    mkatom.obj ubf2.obj array5.obj eqf.obj  intcall.obj mkcell.obj ubf3.obj array6.obj      ether.obj ufn.obj atom.obj      findkey.obj kbdsubrs.obj mouseif.obj ufs.obj    bbtsub.obj foreign.obj keyevent.obj     unixcomm.obj bin.obj fp.obj binds.obj fvar.obj mvs.obj      unwind.obj bitblt.obj gc.obj    uraid.obj blt.obj gc2.obj       kprint.obj osmsg.obj usrsubr.obj byteswap.obj   gcarray.obj perrno.obj uutils.obj       carcdr.obj asmbbt.obj gccode.obj        vars3.obj gcfinal.obj ldsout.obj        return.obj vmemsave.obj chardev.obj     gchtfind.obj lineblt8.obj rpc.obj xc.obj        common.obj gcmain3.obj lisp2c.obj rplcons.obj   z2.obj  vdate.obj $(COLORFILES) $(ARCHFILES) $(LPFILES)
+OFILES = conspage.obj gcoflow.obj shift.obj dbgtool.obj         gcr.obj  gcrcell.obj llstk.obj  gcscan.obj loopsops.obj storage.obj     allocmds.obj dir.obj gvar2.obj lowlev1.obj      subr.obj arithops.obj lowlev2.obj       subr0374.obj doscomm.obj     hardrtn.obj lsthandl.obj sxhash.obj draw.obj main.obj testtool.obj array.obj        dsk.obj inet.obj misc7.obj timer.obj    array2.obj dspif.obj initdsp.obj miscn.obj      typeof.obj array3.obj initkbd.obj ubf1.obj      array4.obj dspsubrs.obj initsout.obj    mkatom.obj ubf2.obj array5.obj eqf.obj  intcall.obj mkcell.obj ubf3.obj array6.obj      ether.obj ufn.obj atom.obj      findkey.obj kbdsubrs.obj mouseif.obj ufs.obj    bbtsub.obj foreign.obj keyevent.obj     unixcomm.obj bin.obj fp.obj binds.obj fvar.obj mvs.obj      unwind.obj bitblt.obj gc.obj    uraid.obj blt.obj gc2.obj       kprint.obj osmsg.obj usrsubr.obj byteswap.obj   gcarray.obj perrno.obj uutils.obj       carcdr.obj asmbbt.obj gccode.obj        vars3.obj gcfinal.obj ldsout.obj        return.obj vmemsave.obj chardev.obj     gchtfind.obj lineblt8.obj rpc.obj xc.obj        common.obj gcmain3.obj lisp2c.obj rplcons.obj   z2.obj  vdate.obj $(COLORFILES) $(ARCHFILES) $(LPFILES)
 
 
-HFILES = address.h adr68k.h arith.h cell.h dbprint.h display.h  dspif.h ifpage.h iopage.h lispemul.h lispmap.h  lsptypes.h miscstat.h lspglob.h array.h bb.h    bitblt.h debug.h devconf.h dspdata.h ether.h    fast_dsp.h gcdata.h hdw_conf.h initatms.h inlinec.h keyboard.h         lispver1.h lispver2.h lldsp.h locfile.h medleyfp.h mouseif.h my.h  opcodes.h osmsg.h pilotbbt.h print.h return.h stack.h stream.h subrs.h timeout.h   tos1defs.h tosfns.h tosret.h vmemsave.h         xdefs.h xbitmaps.h xkeymap.h
+HFILES = address.h adr68k.h arithopsdefs.h arith.h cell.h dbprint.h display.h  dspif.h ifpage.h iopage.h lispemul.h lispmap.h  lsptypes.h miscstat.h lspglob.h array.h bb.h    bitblt.h debug.h devconf.h dspdata.h ether.h    fast_dsp.h gcdata.h hdw_conf.h initatms.h inlinec.h keyboard.h         lispver1.h lispver2.h lldsp.h locfile.h medleyfp.h mouseif.h my.h  opcodes.h osmsg.h pilotbbt.h print.h return.h stack.h stream.h subrs.h timeout.h   tos1defs.h tosfns.h tosret.h vmemsave.h         xdefs.h xbitmaps.h xkeymap.h
 
 
 
@@ -202,9 +202,9 @@ subr.obj : ../src/subr.c
 	$(CC) @copts ../src/subr.c -I ../inc -c $@
 	del copts
 
-arith2.obj : ../src/arith2.c
+arithops.obj : ../src/arithops.c
 	@ echo  $(CFLAGS) > copts
-	$(CC) @copts ../src/arith2.c -I ../inc -c $@
+	$(CC) @copts ../src/arithops.c -I ../inc -c $@
 	del copts
 
 lowlev2.obj : ../src/lowlev2.c
@@ -217,11 +217,6 @@ subr0374.obj : ../src/subr0374.c
 	$(CC) @copts ../src/subr0374.c -I ../inc -c $@
 	del copts
 
-arith3.obj : ../src/arith3.c
-	@ echo  $(CFLAGS) > copts
-	$(CC) @copts ../src/arith3.c -I ../inc -c $@
-	del copts
-
 doscomm.obj : ../src/doscomm.c
 	@ echo  $(CFLAGS) > copts
 	$(CC) @copts ../src/doscomm.c -I ../inc -c $@
@@ -242,11 +237,6 @@ sxhash.obj : ../src/sxhash.c
 	$(CC) @copts ../src/sxhash.c -I ../inc -c $@
 	del copts
 
-arith4.obj : ../src/arith4.c
-	@ echo  $(CFLAGS) > copts
-	$(CC) @copts ../src/arith4.c -I ../inc -c $@
-	del copts
-
 draw.obj : ../src/draw.c
 	@ echo  $(CFLAGS) > copts
 	$(CC) @copts ../src/draw.c -I ../inc -c $@

bin/makefile-init-darwin.x86_64

@@ -18,7 +18,7 @@ XFLAGS = -I/opt/X11/include -DXWINDOW
 # OPTFLAGS is normally -O2.
 OPTFLAGS =  -O0 -g
 DEBUGFLAGS = # -DDEBUG -DOPTRACE
-DFLAGS = $(DEBUGFLAGS) $(XFLAGS) -DRELEASE=351 -DNOVERSION -DINIT
+DFLAGS = $(DEBUGFLAGS) $(XFLAGS) -DRELEASE=201 -DNOVERSION -DINIT
 
 LDFLAGS = -L/opt/X11/lib -lX11 -lm
 LDELDFLAGS =  -L/opt/X11/lib -lX11 -lm

bin/makefile-tail

@@ -38,15 +38,8 @@ REQUIRED-INCS = $(INCDIR)version.h $(INCDIR)maiko/platform.h
 CFLAGS = $(OPTFLAGS) $(DFLAGS)
 RFLAGS = -c $(CFLAGS) -I$(INCDIR) -I$(INCLUDEDIR)
 
-OFILES = $(OBJECTDIR)arith2.o \
-	$(OBJECTDIR)arith3.o \
-	$(OBJECTDIR)arith4.o \
-	$(OBJECTDIR)array.o \
-	$(OBJECTDIR)array2.o \
-	$(OBJECTDIR)array3.o \
-	$(OBJECTDIR)array4.o \
-	$(OBJECTDIR)array5.o \
-	$(OBJECTDIR)array6.o \
+OFILES = $(OBJECTDIR)arithops.o \
+	$(OBJECTDIR)arrayops.o \
 	$(OBJECTDIR)bin.o \
 	$(OBJECTDIR)binds.o \
 	$(OBJECTDIR)bitblt.o \
@@ -212,7 +205,7 @@ $(OBJECTDIR)dbgtool.o: $(SRCDIR)dbgtool.c $(REQUIRED-INCS) \
 	$(INCDIR)adr68k.h $(INCDIR)lsptypes.h $(INCDIR)lspglob.h $(INCDIR)ifpage.h \
 	$(INCDIR)iopage.h $(INCDIR)miscstat.h $(INCDIR)emlglob.h $(INCDIR)cell.h \
 	$(INCDIR)stack.h $(INCDIR)dbgtooldefs.h $(INCDIR)kprintdefs.h \
-	$(INCDIR)testtooldefs.h
+	$(INCDIR)testtooldefs.h $(INCDIR)uraidextdefs.h
 	$(CC) $(RFLAGS) $(SRCDIR)dbgtool.c -o $(OBJECTDIR)dbgtool.o
 
 $(OBJECTDIR)dlpi.o: $(SRCDIR)dlpi.c \
@@ -233,7 +226,7 @@ $(OBJECTDIR)testtool.o: $(SRCDIR)testtool.c $(REQUIRED-INCS) \
 	$(INCDIR)iopage.h $(INCDIR)miscstat.h $(INCDIR)emlglob.h $(INCDIR)cell.h \
 	$(INCDIR)debug.h $(INCDIR)dbprint.h $(INCDIR)tosfns.h $(INCDIR)testtooldefs.h \
 	$(INCDIR)stack.h $(INCDIR)dbgtooldefs.h $(INCDIR)gcarraydefs.h \
-	$(INCDIR)kprintdefs.h $(INCDIR)mkatomdefs.h
+	$(INCDIR)kprintdefs.h $(INCDIR)mkatomdefs.h $(INCDIR)uraidextdefs.h
 	$(CC) $(RFLAGS) $(SRCDIR)testtool.c -o $(OBJECTDIR)testtool.o
 
 $(OBJECTDIR)allocmds.o: $(SRCDIR)allocmds.c $(REQUIRED-INCS) \
@@ -245,48 +238,40 @@ $(OBJECTDIR)allocmds.o: $(SRCDIR)allocmds.c $(REQUIRED-INCS) \
 	$(INCDIR)timerdefs.h
 	$(CC) $(RFLAGS) $(SRCDIR)allocmds.c -o $(OBJECTDIR)allocmds.o
 
-$(OBJECTDIR)arith2.o: $(SRCDIR)arith2.c $(REQUIRED-INCS) \
-	$(INCDIR)lispemul.h $(INCDIR)lspglob.h \
-	$(INCDIR)ifpage.h $(INCDIR)iopage.h $(INCDIR)miscstat.h $(INCDIR)adr68k.h \
-	$(INCDIR)lispmap.h $(INCDIR)lsptypes.h $(INCDIR)medleyfp.h $(INCDIR)arith.h \
-	$(INCDIR)arith2defs.h $(INCDIR)fpdefs.h $(INCDIR)mkcelldefs.h
-	$(CC) $(RFLAGS) $(SRCDIR)arith2.c -o $(OBJECTDIR)arith2.o
+$(OBJECTDIR)arithops.o: $(SRCDIR)arithops.c $(REQUIRED-INCS) \
+	$(INCDIR)adr68k.h \
+	$(INCDIR)arith.h \
+	$(INCDIR)commondefs.h \
+	$(INCDIR)lispemul.h \
+	$(INCDIR)lispmap.h \
+	$(INCDIR)lsptypes.h \
+	$(INCDIR)mkcelldefs.h \
+	$(INCDIR)arithopsdefs.h \
+	$(INCDIR)fpdefs.h \
+	$(INCDIR)lspglob.h \
+	$(INCDIR)ifpage.h \
+	$(INCDIR)iopage.h \
+	$(INCDIR)miscstat.h
+	$(CC) $(RFLAGS) $(SRCDIR)arithops.c -o $(OBJECTDIR)arithops.o
 
-$(OBJECTDIR)arith3.o: $(SRCDIR)arith3.c $(REQUIRED-INCS) \
-	$(INCDIR)lispemul.h $(INCDIR)lispmap.h \
-	$(INCDIR)lspglob.h $(INCDIR)ifpage.h $(INCDIR)iopage.h $(INCDIR)miscstat.h \
-	$(INCDIR)lsptypes.h $(INCDIR)address.h $(INCDIR)adr68k.h $(INCDIR)cell.h \
-	$(INCDIR)arith.h $(INCDIR)arith3defs.h $(INCDIR)mkcelldefs.h
-	$(CC) $(RFLAGS) $(SRCDIR)arith3.c -o $(OBJECTDIR)arith3.o
-
-$(OBJECTDIR)arith4.o: $(SRCDIR)arith4.c $(REQUIRED-INCS) \
-	$(INCDIR)lispemul.h $(INCDIR)lispmap.h \
-	$(INCDIR)lspglob.h $(INCDIR)ifpage.h $(INCDIR)iopage.h $(INCDIR)miscstat.h \
-	$(INCDIR)lsptypes.h $(INCDIR)address.h $(INCDIR)adr68k.h $(INCDIR)cell.h \
-	$(INCDIR)medleyfp.h $(INCDIR)arith.h $(INCDIR)arith4defs.h $(INCDIR)fpdefs.h \
-	$(INCDIR)mkcelldefs.h
-	$(CC) $(RFLAGS) $(SRCDIR)arith4.c -o $(OBJECTDIR)arith4.o
-
-$(OBJECTDIR)array.o: $(SRCDIR)array.c $(REQUIRED-INCS) \
-	$(INCDIR)lispemul.h $(INCDIR)lspglob.h \
-	$(INCDIR)ifpage.h $(INCDIR)iopage.h $(INCDIR)miscstat.h $(INCDIR)adr68k.h \
-	$(INCDIR)lispmap.h $(INCDIR)lsptypes.h $(INCDIR)emlglob.h $(INCDIR)arraydefs.h \
-	$(INCDIR)mkcelldefs.h $(INCDIR)arith.h $(INCDIR)my.h
-	$(CC) $(RFLAGS) $(SRCDIR)array.c -o $(OBJECTDIR)array.o
-
-$(OBJECTDIR)array3.o: $(SRCDIR)array3.c $(REQUIRED-INCS) \
-	$(INCDIR)lispemul.h $(INCDIR)lspglob.h \
-	$(INCDIR)ifpage.h $(INCDIR)iopage.h $(INCDIR)miscstat.h $(INCDIR)adr68k.h \
-	$(INCDIR)lispmap.h $(INCDIR)lsptypes.h $(INCDIR)emlglob.h \
-	$(INCDIR)array3defs.h $(INCDIR)mkcelldefs.h $(INCDIR)arith.h $(INCDIR)my.h
-	$(CC) $(RFLAGS) $(SRCDIR)array3.c -o $(OBJECTDIR)array3.o
-
-$(OBJECTDIR)array5.o: $(SRCDIR)array5.c $(REQUIRED-INCS) \
-	$(INCDIR)lispemul.h $(INCDIR)lspglob.h \
-	$(INCDIR)ifpage.h $(INCDIR)iopage.h $(INCDIR)miscstat.h $(INCDIR)adr68k.h \
-	$(INCDIR)lispmap.h $(INCDIR)lsptypes.h $(INCDIR)emlglob.h \
-	$(INCDIR)array5defs.h $(INCDIR)mkcelldefs.h $(INCDIR)arith.h $(INCDIR)my.h
-	$(CC) $(RFLAGS) $(SRCDIR)array5.c -o $(OBJECTDIR)array5.o
+$(OBJECTDIR)arrayops.o: $(SRCDIR)arrayops.c $(REQUIRED-INCS) \
+	$(INCDIR)adr68k.h \
+	$(INCDIR)arrayopsdefs.h \
+	$(INCDIR)lispemul.h \
+	$(INCDIR)lispmap.h \
+	$(INCDIR)emlglob.h \
+	$(INCDIR)lspglob.h \
+	$(INCDIR)ifpage.h \
+	$(INCDIR)iopage.h \
+	$(INCDIR)miscstat.h \
+	$(INCDIR)lsptypes.h \
+	$(INCDIR)my.h \
+	$(INCDIR)arith.h \
+	$(INCDIR)commondefs.h \
+	$(INCDIR)mkcelldefs.h \
+	$(INCDIR)gcdata.h \
+	$(INCDIR)gchtfinddefs.h
+	$(CC) $(RFLAGS) $(SRCDIR)arrayops.c -o $(OBJECTDIR)arrayops.o
 
 $(OBJECTDIR)bin.o: $(SRCDIR)bin.c $(REQUIRED-INCS) \
 	$(INCDIR)lispemul.h $(INCDIR)lispmap.h \
@@ -382,7 +367,7 @@ $(OBJECTDIR)common.o: $(SRCDIR)common.c $(REQUIRED-INCS) \
 	$(INCDIR)lispemul.h $(INCDIR)lispmap.h \
 	$(INCDIR)adr68k.h $(INCDIR)lspglob.h $(INCDIR)ifpage.h $(INCDIR)iopage.h \
 	$(INCDIR)miscstat.h $(INCDIR)emlglob.h $(INCDIR)stack.h $(INCDIR)dbprint.h \
-	$(INCDIR)commondefs.h $(INCDIR)kprintdefs.h $(INCDIR)uraiddefs.h
+	$(INCDIR)commondefs.h $(INCDIR)kprintdefs.h $(INCDIR)uraiddefs.h $(INCDIR)uraidextdefs.h
 	$(CC) $(RFLAGS) $(SRCDIR)common.c -o $(OBJECTDIR)common.o
 
 $(OBJECTDIR)conspage.o: $(SRCDIR)conspage.c $(REQUIRED-INCS) \
@@ -807,7 +792,7 @@ $(OBJECTDIR)subr.o: $(SRCDIR)subr.c $(REQUIRED-INCS) \
 	$(INCDIR)gcrdefs.h $(INCDIR)inetdefs.h $(INCDIR)kbdsubrsdefs.h \
 	$(INCDIR)mkcelldefs.h $(INCDIR)osmsgdefs.h $(INCDIR)rpcdefs.h \
 	$(INCDIR)storagedefs.h $(INCDIR)timerdefs.h $(INCDIR)ufsdefs.h \
-	$(INCDIR)unixcommdefs.h $(INCDIR)uutilsdefs.h $(INCDIR)vmemsavedefs.h
+	$(INCDIR)unixcommdefs.h $(INCDIR)uraidextdefs.h $(INCDIR)uutilsdefs.h $(INCDIR)vmemsavedefs.h
 	$(CC) $(RFLAGS) $(SRCDIR)subr.c -o $(OBJECTDIR)subr.o
 
 $(OBJECTDIR)miscn.o: $(SRCDIR)miscn.c $(REQUIRED-INCS) \
@@ -880,7 +865,7 @@ $(OBJECTDIR)uraid.o: $(SRCDIR)uraid.c $(REQUIRED-INCS) \
 	$(INCDIR)gcarraydefs.h $(INCDIR)initdspdefs.h $(INCDIR)initkbddefs.h \
 	$(INCDIR)kprintdefs.h $(INCDIR)llstkdefs.h $(INCDIR)mkatomdefs.h \
 	$(INCDIR)returndefs.h $(INCDIR)testtooldefs.h $(INCDIR)timerdefs.h \
-	$(INCDIR)vmemsavedefs.h $(INCDIR)devif.h
+	$(INCDIR)uraidextdefs.h $(INCDIR)vmemsavedefs.h $(INCDIR)devif.h
 	$(CC) $(RFLAGS) $(SRCDIR)uraid.c -o $(OBJECTDIR)uraid.o
 
 $(OBJECTDIR)rpc.o: $(SRCDIR)rpc.c $(REQUIRED-INCS) \
@@ -914,29 +899,6 @@ $(OBJECTDIR)vmemsave.o: $(SRCDIR)vmemsave.c $(REQUIRED-INCS) \
 	$(INCDIR)ufsdefs.h
 	$(CC) $(RFLAGS) $(SRCDIR)vmemsave.c -o $(OBJECTDIR)vmemsave.o
 
-$(OBJECTDIR)array2.o: $(SRCDIR)array2.c $(REQUIRED-INCS) \
-	$(INCDIR)lispemul.h $(INCDIR)lspglob.h \
-	$(INCDIR)ifpage.h $(INCDIR)iopage.h $(INCDIR)miscstat.h $(INCDIR)adr68k.h \
-	$(INCDIR)lispmap.h $(INCDIR)lsptypes.h $(INCDIR)emlglob.h $(INCDIR)gcdata.h \
-	$(INCDIR)mkcelldefs.h $(INCDIR)arith.h $(INCDIR)my.h $(INCDIR)array2defs.h \
-	$(INCDIR)gchtfinddefs.h
-	$(CC) $(RFLAGS) $(SRCDIR)array2.c -o $(OBJECTDIR)array2.o
-
-$(OBJECTDIR)array4.o: $(SRCDIR)array4.c $(REQUIRED-INCS) \
-	$(INCDIR)lispemul.h $(INCDIR)lspglob.h \
-	$(INCDIR)ifpage.h $(INCDIR)iopage.h $(INCDIR)miscstat.h $(INCDIR)adr68k.h \
-	$(INCDIR)lispmap.h $(INCDIR)lsptypes.h $(INCDIR)mkcelldefs.h $(INCDIR)arith.h \
-	$(INCDIR)gcdata.h $(INCDIR)my.h $(INCDIR)array4defs.h $(INCDIR)gchtfinddefs.h
-	$(CC) $(RFLAGS) $(SRCDIR)array4.c -o $(OBJECTDIR)array4.o
-
-$(OBJECTDIR)array6.o: $(SRCDIR)array6.c $(REQUIRED-INCS) \
-	$(INCDIR)lispemul.h $(INCDIR)lspglob.h \
-	$(INCDIR)ifpage.h $(INCDIR)iopage.h $(INCDIR)miscstat.h $(INCDIR)adr68k.h \
-	$(INCDIR)lispmap.h $(INCDIR)lsptypes.h $(INCDIR)emlglob.h $(INCDIR)gcdata.h \
-	$(INCDIR)mkcelldefs.h $(INCDIR)arith.h $(INCDIR)my.h $(INCDIR)array6defs.h \
-	$(INCDIR)gchtfinddefs.h
-	$(CC) $(RFLAGS) $(SRCDIR)array6.c -o $(OBJECTDIR)array6.o
-
 $(OBJECTDIR)sxhash.o: $(SRCDIR)sxhash.c $(REQUIRED-INCS) \
 	$(INCDIR)lispemul.h $(INCDIR)lspglob.h \
 	$(INCDIR)ifpage.h $(INCDIR)iopage.h $(INCDIR)miscstat.h $(INCDIR)lispmap.h \
@@ -956,10 +918,8 @@ $(OBJECTDIR)xc.o: $(SRCDIR)xc.c $(REQUIRED-INCS) \
 	$(INCDIR)miscstat.h $(INCDIR)lsptypes.h $(INCDIR)lispmap.h $(INCDIR)cell.h \
 	$(INCDIR)initatms.h $(INCDIR)gcdata.h $(INCDIR)arith.h $(INCDIR)stream.h \
 	$(INCDIR)tos1defs.h $(INCDIR)tosret.h $(INCDIR)tosfns.h $(INCDIR)inlineC.h \
-	$(INCDIR)xcdefs.h $(INCDIR)arith2defs.h $(INCDIR)arith3defs.h \
-	$(INCDIR)arith4defs.h $(INCDIR)arraydefs.h $(INCDIR)array2defs.h \
-	$(INCDIR)array3defs.h $(INCDIR)array4defs.h $(INCDIR)array5defs.h \
-	$(INCDIR)array6defs.h $(INCDIR)bitbltdefs.h $(INCDIR)bltdefs.h \
+	$(INCDIR)xcdefs.h $(INCDIR)arithopsdefs.h $(INCDIR)arrayopsdefs.h  \
+	$(INCDIR)bitbltdefs.h $(INCDIR)bltdefs.h \
 	$(INCDIR)byteswapdefs.h $(INCDIR)car-cdrdefs.h $(INCDIR)commondefs.h \
 	$(INCDIR)conspagedefs.h $(INCDIR)drawdefs.h $(INCDIR)eqfdefs.h \
 	$(INCDIR)findkeydefs.h $(INCDIR)fpdefs.h $(INCDIR)fvardefs.h \

bin/mkvdate

@@ -1,5 +1,6 @@
 #!/bin/sh
 cat <<EOF
 #include <time.h>
-time_t MDate = $(date +%s);
+extern const time_t MDate;
+const time_t MDate = $(date +%s);
 EOF

inc/MyWindow.h

@@ -24,7 +24,6 @@
 #define VERTICAL   0
 #define HORIZONTAL 1
 
-#define PERCENT_OF_SCREEN 95
 #define SCROLL_PITCH      30
 
 typedef struct _MyEvent

inc/adr68k.h

@@ -9,8 +9,6 @@
  *			Hiroshi Hayata
  */
 
-
-
 /************************************************************************/
 /*									*/
 /*	Copyright 1989, 1990 Venue, Fuji Xerox Co., Ltd, Xerox Corp.	*/
@@ -20,8 +18,6 @@
 /*									*/
 /************************************************************************/
 
-
-
 /**********************************************************************/
 /*
 		Func name :	adr68k.h
@@ -32,8 +28,64 @@
 */
 /**********************************************************************/
 
+#include <stddef.h>
+#include <stdio.h>
+#include "lispemul.h"
+#include "lspglob.h"
 
+static inline LispPTR LAddrFromNative(void *NAddr)
+{
+  if ((uintptr_t)NAddr & 1) {
+    printf("Misaligned pointer in LAddrFromNative %p\n", NAddr);
+  }
+  return ((DLword *)NAddr) - Lisp_world;
+}
 
+static inline DLword *NativeAligned2FromLAddr(LispPTR LAddr)
+{
+  return (Lisp_world + LAddr);
+}
+
+static inline LispPTR *NativeAligned4FromLAddr(LispPTR LAddr)
+{
+  if (LAddr & 1) {
+    printf("Misaligned pointer in NativeAligned4FromLAddr 0x%x\n", LAddr);
+  }
+  return (LispPTR *)(Lisp_world + LAddr);
+}
+
+static inline LispPTR *NativeAligned4FromLPage(LispPTR LPage)
+{
+  return (LispPTR *)(Lisp_world + (LPage << 8));
+}
+
+static inline DLword StackOffsetFromNative(void *SAddr)
+{
+  /* Stack offsets are expressed as an offset in DLwords from the stack base */
+  ptrdiff_t hoffset = (DLword *)SAddr - Stackspace;
+  if (hoffset > 0xffff) {
+    printf("Stack offset is too large: 0x%tx\n", hoffset);
+  }
+  return (DLword)hoffset;
+}
+
+static inline DLword *NativeAligned2FromStackOffset(DLword StackOffset)
+{
+  return Stackspace + StackOffset;
+}
+
+static inline LispPTR *NativeAligned4FromStackOffset(DLword StackOffset)
+{
+  return (LispPTR *)(Stackspace + StackOffset);
+}
+
+static inline LispPTR LPageFromNative(void *NAddr)
+{
+  if ((uintptr_t)NAddr & 1) {
+    printf("Misaligned pointer in LPageFromNative %p\n", NAddr);
+  }
+  return (((DLword *)NAddr) - Lisp_world) >> 8;
+}
 /*  translate 68k ptr to Lisp DLword address */
 #define LADDR_from_68k(ptr68k)	((LispPTR)(((UNSIGNED)(ptr68k) - (UNSIGNED)Lisp_world) >>1))
 
@@ -49,10 +101,6 @@
 
 /* translate LispPage to 68k address */
 #define Addr68k_from_LPAGE(Lisp_page)	(Addr68k_from_LADDR(((Lisp_page) << 8) ))
-
-
-
-
 /* Stack Offset Macros */
 
 #define StkOffset_from_68K(ptr68k)\

inc/allocmdsdefs.h

@@ -1,6 +1,6 @@
 #ifndef ALLOCMDSDEFS_H
 #define ALLOCMDSDEFS_H 1
 #include "lispemul.h" /* for LispPTR, DLword */
-LispPTR initmdspage(register LispPTR *base, register DLword size, register LispPTR prev);
-LispPTR *alloc_mdspage(register short int type);
+LispPTR initmdspage(LispPTR *base, DLword size, LispPTR prev);
+LispPTR *alloc_mdspage(short int type);
 #endif

inc/arith.h

@@ -9,51 +9,79 @@
 /*									*/
 /************************************************************************/
 
+#include "adr68k.h"    // for NativeAligned4FromLAddr, LAddrFromNative
+#include "commondefs.h" // for error
+#include "lispemul.h"  // for SEGMASK, ERROR_EXIT
+#include "lispmap.h"   // for S_NEGATIVE, S_POSITIVE
+#include "lsptypes.h"  // for TYPE_FIXP, GetTypeNumber, TYPE_FLOATP
+#include "mkcelldefs.h" // for createcell68k
+
 #define MAX_SMALL 65535  /* == 0x0000FFFF  */
 #define MIN_SMALL (-65536) /* == 0xFFFF0000  */
 
 #define MAX_FIXP 2147483647  /* == 0x7FFFFFFF  */
 #define MIN_FIXP (-2147483648) /* == 0x80000000  */
 
-#define GetSmalldata(x)          \
-  (((SEGMASK & (x)) == S_POSITIVE)            \
-       ? (0xFFFF & (x))            \
-       : (((SEGMASK & (x)) == S_NEGATIVE) ? (0xFFFF0000 | (x)) : error("Not smallp address")))
+/**
+ * extract an integer value from a smallp
+ */
+static inline int GetSmalldata(LispPTR x) {
+  if ((SEGMASK & (int)x) == S_POSITIVE) return (int)(x & 0xFFFF);
+  if ((SEGMASK & (int)x) == S_NEGATIVE) return (int)(x | 0xFFFF0000);
+  error("Not smallp address");
+  return (0);
+}
 
-#define GetSmallp(x)                                                                  \
-  ((0xFFFF0000 & (x)) ? (((0xFFFF0000 & (x)) == 0xFFFF0000) ? (S_NEGATIVE | (0xFFFF & (x))) \
-                                                        : error("Not Smallp data"))   \
-                    : (S_POSITIVE | (0xFFFF & (x))))
+/**
+ * construct a smallp from an integer value
+ */
 
-#define FIXP_VALUE(dest) *((int *)Addr68k_from_LADDR(dest))
+static inline LispPTR GetSmallp(long x) {
+  if (x >= 0) {
+    if (x <= MAX_SMALL) return (LispPTR)(S_POSITIVE | x);
+  } else {
+    if (x >= MIN_SMALL) return (LispPTR)(S_NEGATIVE | (x & 0xFFFF));
+  }
+  error("Not Smallp data");
+  return (S_POSITIVE | 0);
+}
 
-#define FLOATP_VALUE(dest) *((float *)Addr68k_from_LADDR(dest))
+/**
+ * construct a smallp from an unsigned value
+ */
+static inline LispPTR GetPosSmallp(unsigned long x) {
+  if (x <= MAX_SMALL) return (LispPTR)(S_POSITIVE | x);
+  error("Not Smallp data");
+  return (S_POSITIVE | 0);
+}
+
+#define FIXP_VALUE(dest) *((int *)NativeAligned4FromLAddr(dest))
+
+#define FLOATP_VALUE(dest) *((float *)NativeAligned4FromLAddr(dest))
 
 #define N_GETNUMBER(sour, dest, label)                        \
   do {                                                        \
-    (dest) = (sour); /* access memory once */                 \
-    switch (SEGMASK & (dest)) {                               \
-      case S_POSITIVE: (dest) = 0xFFFF & (dest); break;       \
-      case S_NEGATIVE: (dest) = 0xFFFF0000 | (dest); break;   \
+    switch (SEGMASK & (sour)) {                               \
+    case S_POSITIVE: (dest) = (int)((sour) & 0xFFFF); break;  \
+    case S_NEGATIVE: (dest) = (int)((sour) | 0xFFFF0000); break; \
       default:                                                \
         /* NOLINTNEXTLINE(bugprone-macro-parentheses) */      \
-        if (GetTypeNumber(dest) != TYPE_FIXP) goto label;     \
-        (dest) = FIXP_VALUE(dest);                            \
+        if (GetTypeNumber(sour) != TYPE_FIXP) goto label;     \
+        (dest) = FIXP_VALUE(sour);                            \
     }                                                         \
   } while (0)
 
 #define N_IGETNUMBER(sour, dest, label)                                                   \
   do {                                                                                    \
-    (dest) = (sour); /* access memory once */                                             \
-    switch (SEGMASK & (dest)) {                                                           \
-      case S_POSITIVE: (dest) = 0xFFFF & (dest); break;                                   \
-      case S_NEGATIVE: (dest) = 0xFFFF0000 | (dest); break;                               \
+    switch (SEGMASK & (sour)) {                                                           \
+    case S_POSITIVE: (dest) = (int)((sour) & 0xFFFF); break;            \
+    case S_NEGATIVE: (dest) = (int)((sour) | 0xFFFF0000); break;        \
       default:                                                                            \
-        switch (GetTypeNumber(dest)) {                                                    \
-          case TYPE_FIXP: (dest) = FIXP_VALUE(dest); break;               \
+        switch (GetTypeNumber(sour)) {                                                    \
+          case TYPE_FIXP: (dest) = FIXP_VALUE(sour); break;               \
           case TYPE_FLOATP: {                                                             \
-            register float temp;                                                          \
-            temp = FLOATP_VALUE(dest);                                                    \
+            float temp;                                                          \
+            temp = FLOATP_VALUE(sour);                                                    \
             /* NOLINTNEXTLINE(bugprone-macro-parentheses) */                              \
             if ((temp > ((float)0x7fffffff)) || (temp < ((float)0x80000000))) goto label; \
             (dest) = (int)temp;                                                           \
@@ -66,100 +94,33 @@
 
 #define ARITH_SWITCH(arg, result)                                          \
   do {                                                                     \
-    switch ((int)(arg) & 0xFFFF0000) {                                     \
+    switch ((arg) & (int)0xFFFF0000) {                      \
       case 0: (result) = (S_POSITIVE | (int)(arg)); break;                 \
-      case 0xFFFF0000: (result) = (S_NEGATIVE | (0xFFFF & (int)(arg))); break; \
+      case (int)0xFFFF0000: (result) = (S_NEGATIVE | (0xFFFF & (arg))); break; \
       default: {                                                           \
-        register LispPTR *wordp;                                           \
+        int *fixpp;                                           \
         /* arg is FIXP, call createcell */                                 \
-        wordp = (LispPTR *)createcell68k(TYPE_FIXP);                       \
-        *((int *)wordp) = (int)(arg);                                      \
-        (result) = (LADDR_from_68k(wordp));                                \
+        fixpp = (int *)createcell68k(TYPE_FIXP);                       \
+        *((int *)fixpp) = (int)(arg);                                      \
+        (result) = (LAddrFromNative(fixpp));                                \
         break;                                                             \
       }                                                                    \
     }                                                                      \
   } while (0)
 
-/* *******
-        NEED to See if this is faster than the N_ARITH_SWITCH macro
-
-        if( (MIN_FIXP <= result) && (result <= MAX_FIXP) ){
-                if(0 <= result){
-                        if(result <= MAX_SMALL)
-                                return(S_POSITIVE | result);
-                        else{
-                                wordp = createcell68k(TYPE_FIXP);
-                                *((unsigned int *)wordp) = result;
-                                return(LADDR_from_68k(wordp));
-                        }
-                }else{
-                        if(MIN_SMALL <= result)
-                                return(S_NEGATIVE | (0xFFFF & result));
-                        else{
-                                wordp = createcell68k(TYPE_FIXP);
-                                *((unsigned int *)wordp) = result;
-                                return(LADDR_from_68k(wordp));
-                        }
-                }/
-        }
-****** */
-
 #define N_ARITH_SWITCH(arg)                                  \
   do {                                                       \
-    switch ((arg) & 0xFFFF0000) {                              \
-      case 0: return (S_POSITIVE | (arg));                     \
-      case 0xFFFF0000: return (S_NEGATIVE | (0xFFFF & (arg))); \
+    switch ((arg) & (int)0xFFFF0000) {             \
+    case 0: return (LispPTR) (S_POSITIVE | (arg));                       \
+    case (int)0xFFFF0000: return (LispPTR)(S_NEGATIVE | (0xFFFF & (arg))); \
       default: {                                             \
-        register LispPTR *fixpp;                             \
+        int *fixpp;                             \
         /* arg is FIXP, call createcell */                   \
-        fixpp = (LispPTR *)createcell68k(TYPE_FIXP);         \
-        *((int *)fixpp) = arg;                               \
-        return (LADDR_from_68k(fixpp));                      \
+        fixpp = (int *)createcell68k(TYPE_FIXP);         \
+        *fixpp = arg;                                       \
+        return (LAddrFromNative(fixpp));                      \
       }                                                      \
     }                                                        \
   } while (0)
 
-#define N_IARITH_BODY_2(a, tos, op)  \
-  do {                               \
-    register int arg1, arg2;         \
-                                     \
-    N_IGETNUMBER(a, arg1, do_ufn);   \
-    N_IGETNUMBER(tos, arg2, do_ufn); \
-                                     \
-    arg1 = arg1 op arg2;             \
-                                     \
-    N_ARITH_SWITCH(arg1);            \
-                                     \
-  do_ufn:                            \
-    ERROR_EXIT(tos);                 \
-  } while (0)
-
-#define N_ARITH_BODY_1(a, n, op)  \
-  do {                            \
-    register int arg1;            \
-                                  \
-    N_GETNUMBER(a, arg1, do_ufn); \
-                                  \
-    arg1 = arg1 op n;             \
-                                  \
-    N_ARITH_SWITCH(arg1);         \
-                                  \
-  do_ufn:                         \
-    ERROR_EXIT(a);                \
-  } while (0)
-
-#define N_ARITH_BODY_1_UNSIGNED(a, n, op) \
-  do {                                    \
-    register unsigned int arg1;           \
-                                          \
-    N_GETNUMBER(a, arg1, do_ufn);         \
-                                          \
-    arg1 = arg1 op n;                     \
-                                          \
-    N_ARITH_SWITCH(arg1);                 \
-                                          \
-  do_ufn:                                 \
-    ERROR_EXIT(a);                        \
-  } while (0)
-
 #endif /* ARITH_H */

inc/arith2defs.h

@@ -1,15 +0,0 @@
-#ifndef ARITH2DEFS_H
-#define ARITH2DEFS_H 1
-#include "lispemul.h" /* for LispPTR */
-LispPTR N_OP_plus2(int tosm1, int tos);
-LispPTR N_OP_iplus2(int tosm1, int tos);
-LispPTR N_OP_difference(int tosm1, int tos);
-LispPTR N_OP_idifference(int tosm1, int tos);
-LispPTR N_OP_logxor(int tosm1, int tos);
-LispPTR N_OP_logand(int tosm1, int tos);
-LispPTR N_OP_logor(int tosm1, int tos);
-LispPTR N_OP_greaterp(int tosm1, int tos);
-LispPTR N_OP_igreaterp(int tosm1, int tos);
-LispPTR N_OP_iplusn(int tos, int n);
-LispPTR N_OP_idifferencen(int tos, int n);
-#endif

inc/arith3defs.h

@@ -1,7 +0,0 @@
-#ifndef ARITH3DEFS_H
-#define ARITH3DEFS_H 1
-#include "lispemul.h" /* for LispPTR */
-LispPTR N_OP_makenumber(int tosm1, int tos);
-LispPTR N_OP_boxiplus(register int a, int tos);
-LispPTR N_OP_boxidiff(register int a, int tos);
-#endif

inc/arith4defs.h

@@ -1,8 +0,0 @@
-#ifndef ARITH4DEFS_H
-#define ARITH4DEFS_H 1
-int N_OP_times2(int tosm1, int tos);
-int N_OP_itimes2(int tosm1, int tos);
-int N_OP_quot(int tosm1, int tos);
-int N_OP_iquot(int tosm1, int tos);
-int N_OP_iremainder(int tosm1, int tos);
-#endif

inc/arithopsdefs.h

@@ -0,0 +1,23 @@
+#ifndef ARITHOPSDEFS_H
+#define ARITHOPSDEFS_H 1
+#include "lispemul.h" /* for LispPTR */
+LispPTR N_OP_plus2(LispPTR tosm1, LispPTR tos);
+LispPTR N_OP_iplus2(LispPTR tosm1, LispPTR tos);
+LispPTR N_OP_difference(LispPTR tosm1, LispPTR tos);
+LispPTR N_OP_idifference(LispPTR tosm1, LispPTR tos);
+LispPTR N_OP_logxor(LispPTR tosm1, LispPTR tos);
+LispPTR N_OP_logand(LispPTR tosm1, LispPTR tos);
+LispPTR N_OP_logor(LispPTR tosm1, LispPTR tos);
+LispPTR N_OP_greaterp(LispPTR tosm1, LispPTR tos);
+LispPTR N_OP_igreaterp(LispPTR tosm1, LispPTR tos);
+LispPTR N_OP_iplusn(LispPTR tos, int n);
+LispPTR N_OP_idifferencen(LispPTR tos, int n);
+LispPTR N_OP_makenumber(LispPTR tosm1, LispPTR tos);
+LispPTR N_OP_boxiplus(LispPTR a, LispPTR tos);
+LispPTR N_OP_boxidiff(LispPTR a, LispPTR tos);
+LispPTR N_OP_times2(LispPTR tosm1, LispPTR tos);
+LispPTR N_OP_itimes2(LispPTR tosm1, LispPTR tos);
+LispPTR N_OP_quot(LispPTR tosm1, LispPTR tos);
+LispPTR N_OP_iquot(LispPTR tosm1, LispPTR tos);
+LispPTR N_OP_iremainder(LispPTR tosm1, LispPTR tos);
+#endif

inc/array2defs.h

@@ -1,6 +0,0 @@
-#ifndef ARRAY2DEFS_H
-#define ARRAY2DEFS_H 1
-#include "lispemul.h" /* for LispPTR */
-LispPTR N_OP_misc4(register LispPTR data, register LispPTR base, register LispPTR typenumber,
-                   register LispPTR inx, int alpha);
-#endif

inc/array3defs.h

@@ -1,5 +0,0 @@
-#ifndef ARRAY3DEFS_H
-#define ARRAY3DEFS_H 1
-#include "lispemul.h" /* for LispPTR */
-LispPTR N_OP_aref1(register LispPTR arrayarg, register LispPTR inx);
-#endif

inc/array4defs.h

@@ -1,5 +0,0 @@
-#ifndef ARRAY4DEFS_H
-#define ARRAY4DEFS_H 1
-#include "lispemul.h" /* for LispPTR */
-LispPTR N_OP_aset1(register LispPTR data, LispPTR arrayarg, register int inx);
-#endif

inc/array5defs.h

@@ -1,5 +0,0 @@
-#ifndef ARRAY5DEFS_H
-#define ARRAY5DEFS_H 1
-#include "lispemul.h" /* for LispPTR */
-LispPTR N_OP_aref2(LispPTR arrayarg, LispPTR inx0, LispPTR inx1);
-#endif

inc/array6defs.h

@@ -1,5 +0,0 @@
-#ifndef ARRAY6DEFS_H
-#define ARRAY6DEFS_H 1
-#include "lispemul.h" /* for LispPTR */
-LispPTR N_OP_aset2(register LispPTR data, LispPTR arrayarg, LispPTR inx0, LispPTR inx1);
-#endif

inc/arraydefs.h

@@ -1,5 +0,0 @@
-#ifndef ARRAYDEFS_H
-#define ARRAYDEFS_H 1
-#include "lispemul.h" /* for LispPTR */
-LispPTR N_OP_misc3(LispPTR baseL, LispPTR typenumber, LispPTR inx, int alpha);
-#endif

inc/arrayopsdefs.h

@@ -0,0 +1,10 @@
+#ifndef ARRAYOPSDEFS_H
+#define ARRAYOPSDEFS_H 1
+#include "lispemul.h" /* for LispPTR */
+LispPTR N_OP_misc3(LispPTR baseL, LispPTR typenumber, LispPTR inx, int alpha);
+LispPTR N_OP_misc4(LispPTR data, LispPTR base, LispPTR typenumber, LispPTR inx, int alpha);
+LispPTR N_OP_aref1(LispPTR arrayarg, LispPTR inx);
+LispPTR N_OP_aset1(LispPTR data, LispPTR arrayarg, int inx);
+LispPTR N_OP_aref2(LispPTR arrayarg, LispPTR inx0, LispPTR inx1);
+LispPTR N_OP_aset2(LispPTR data, LispPTR arrayarg, LispPTR inx0, LispPTR inx1);
+#endif

inc/bb.h

@@ -389,7 +389,7 @@
  do_partial_transfer						\
  dst32addr++;							\
  switch (op)							\
- { register int cnt;						\
+ { int cnt;						\
    case op_repl_src: ForInner { DestGetsF(=)  } break;		\
    case op_fn_and:   ForInner { DestGetsF(&=) } break;		\
    case op_fn_or:    ForInner { DestGetsF(|=) } break;		\
@@ -416,14 +416,14 @@
  if (aligned_loop)						\
  {								\
    if (src_comp) switch (op)					\
-   { register int cnt;							\
+   { int cnt;							\
      case op_repl_src: ForInner {*dst32addr++  = ~*src32addr++;} break;	\
      case op_fn_and:   ForInner {*dst32addr++ &= ~*src32addr++;} break;	\
      case op_fn_or:    ForInner {*dst32addr++ |= ~*src32addr++;} break;	\
      case op_fn_xor:   ForInner {*dst32addr++ ^= ~*src32addr++;} break;	\
    }									\
    else switch (op)							\
-   { register int cnt;							\
+   { int cnt;							\
      case op_repl_src: ForInner {*dst32addr++  = *src32addr++;} break;	\
      case op_fn_and:   ForInner {*dst32addr++ &= *src32addr++;} break;	\
      case op_fn_or:    ForInner {*dst32addr++ |= *src32addr++;} break;	\
@@ -433,14 +433,14 @@
  else									\
  {									\
    if (src_comp) switch (op)						\
-   { register int cnt;							\
+   { int cnt;							\
      case op_repl_src: ForInner {GetSrcCF DestGetsF(=)  } break;	\
      case op_fn_and:   ForInner {GetSrcCF DestGetsF(&=) } break;	\
      case op_fn_or:    ForInner {GetSrcCF DestGetsF(|=) } break;	\
      case op_fn_xor:   ForInner {GetSrcCF DestGetsF(^=) } break;	\
    }									\
    else switch (op)							\
-   { register int cnt;							\
+   { int cnt;							\
      case op_repl_src: ForInner {GetSrcF  DestGetsF(=)  } break;	\
      case op_fn_and:   ForInner {GetSrcF  DestGetsF(&=) } break;	\
      case op_fn_or:    ForInner {GetSrcF  DestGetsF(|=) } break;	\
@@ -470,14 +470,14 @@
  if (aligned_loop)						\
  {								\
    if (src_comp) switch (op)					\
-   { register int cnt;							\
+   { int cnt;							\
      case op_repl_src: ForInner {*dst32addr--  = ~*src32addr--;} break;	\
      case op_fn_and:   ForInner {*dst32addr-- &= ~*src32addr--;} break;	\
      case op_fn_or:    ForInner {*dst32addr-- |= ~*src32addr--;} break;	\
      case op_fn_xor:   ForInner {*dst32addr-- ^= ~*src32addr--;} break;	\
    }									\
    else switch (op)							\
-   { register int cnt;							\
+   { int cnt;							\
      case op_repl_src: ForInner {*dst32addr--  = *src32addr--;} break;	\
      case op_fn_and:   ForInner {*dst32addr-- &= *src32addr--;} break;	\
      case op_fn_or:    ForInner {*dst32addr-- |= *src32addr--;} break;	\
@@ -487,14 +487,14 @@
  else									\
  {									\
    if (src_comp) switch (op)						\
-   { register int cnt;							\
+   { int cnt;							\
      case op_repl_src: ForInner {GetSrcCB DestGetsB(=)  } break;	\
      case op_fn_and:   ForInner {GetSrcCB DestGetsB(&=) } break;	\
      case op_fn_or:    ForInner {GetSrcCB DestGetsB(|=) } break;	\
      case op_fn_xor:   ForInner {GetSrcCB DestGetsB(^=) } break;	\
    }									\
    else switch (op)							\
-   { register int cnt;							\
+   { int cnt;							\
      case op_repl_src: ForInner {GetSrcB  DestGetsB(=)  } break;	\
      case op_fn_and:   ForInner {GetSrcB  DestGetsB(&=) } break;	\
      case op_fn_or:    ForInner {GetSrcB  DestGetsB(|=) } break;	\
@@ -698,7 +698,7 @@
 /*	However, YOU must set up the control variables that are used	*/
 /*	as "arguments" to the bitblt code:				*/
 /*									*/
-/*	register DLword	*srcbase, *dstbase;				*/
+/*	DLword	*srcbase, *dstbase;				*/
 /*	int	sx, dx, w, h, srcbpl, dstbpl, backwardflg;		*/
 /*	int	src_comp, op, gray, num_gray, curr_gray_line;		*/
 /*									*/
@@ -713,9 +713,9 @@ int abc, dst32rbit, src32rbit, fwd;				\
 unsigned int *OrigSrcAddr, *OrigDstAddr;			\
 int bb_fast;							\
 unsigned int preloop_mask, postloop_mask, sdw_mask;		\
-register unsigned int *dst32addr, *src32addr;			\
-register unsigned int shS, savedS, newS;			\
-register int srcRshift;
+unsigned int *dst32addr, *src32addr;			\
+unsigned int shS, savedS, newS;			\
+int srcRshift;
 
 
 

inc/bindefs.h

@@ -1,5 +1,5 @@
 #ifndef BINDEFS_H
 #define BINDEFS_H 1
 #include "lispemul.h" /* for LispPTR */
-LispPTR N_OP_bin(register int tos);
+LispPTR N_OP_bin(LispPTR tos);
 #endif

inc/bindsdefs.h

@@ -1,7 +1,7 @@
 #ifndef BINDSDEFS_H
 #define BINDSDEFS_H 1
 #include "lispemul.h" /* for LispPTR */
-LispPTR *N_OP_bind(register LispPTR *stack_pointer, register LispPTR tos, int byte1, int byte2);
-LispPTR *N_OP_unbind(register LispPTR *stack_pointer);
-LispPTR *N_OP_dunbind(register LispPTR *stack_pointer, register LispPTR tos);
+LispPTR *N_OP_bind(LispPTR *stack_pointer, LispPTR tos, int byte1, int byte2);
+LispPTR *N_OP_unbind(LispPTR *stack_pointer);
+LispPTR *N_OP_dunbind(LispPTR *stack_pointer, LispPTR tos);
 #endif

inc/bitbltdefs.h

@@ -1,7 +1,7 @@
 #ifndef BITBLTDEFS_H
 #define BITBLTDEFS_H 1
 #include "lispemul.h" /* for LispPTR, DLword */
-LispPTR N_OP_pilotbitblt(LispPTR pilot_bt_tbl,int tos);
+LispPTR N_OP_pilotbitblt(LispPTR pilot_bt_tbl, LispPTR tos);
 int cursorin(DLword addrhi, DLword addrlo, int w, int h, int backward);
 #endif
 

inc/bltdefs.h

@@ -1,6 +1,6 @@
 #ifndef BLTDEFS_H
 #define BLTDEFS_H 1
 #include "lispemul.h" /* for LispPTR */
-LispPTR N_OP_blt(LispPTR destptr, LispPTR sourceptr, register LispPTR wordcount);
+LispPTR N_OP_blt(LispPTR destptr, LispPTR sourceptr, LispPTR wordcount);
 #endif
 

inc/byteswapdefs.h

@@ -16,7 +16,7 @@ static inline unsigned int swapx(unsigned int word) {
 /*                                                              */
 /****************************************************************/
 static inline unsigned short byte_swap_word(unsigned short word) {
-  return (((word >> 8) & 0xff) | ((word & 0xff) << 8));
+  return ((word >> 8) | (unsigned short)((word & 0xff) << 8));
 }
 
 void byte_swap_page(unsigned short *page, int wordcount);

inc/car-cdrdefs.h

@@ -2,13 +2,13 @@
 #define CAR_CDRDEFS_H 1
 #include "cell.h" /* for ConsCell */
 #include "lispemul.h" /* for LispPTR */
-LispPTR car(register LispPTR datum);
-LispPTR cdr(register LispPTR datum);
-LispPTR rplaca(register LispPTR x, register LispPTR y);
-LispPTR rplacd(LispPTR x, register LispPTR y);
-LispPTR N_OP_car(register LispPTR tos);
-LispPTR N_OP_cdr(register LispPTR tos);
-LispPTR N_OP_rplaca(register LispPTR tosm1, register LispPTR tos);
-LispPTR N_OP_rplacd(register LispPTR tosm1, register LispPTR tos);
+LispPTR car(LispPTR datum);
+LispPTR cdr(LispPTR datum);
+LispPTR rplaca(LispPTR x, LispPTR y);
+LispPTR rplacd(LispPTR x, LispPTR y);
+LispPTR N_OP_car(LispPTR tos);
+LispPTR N_OP_cdr(LispPTR tos);
+LispPTR N_OP_rplaca(LispPTR tosm1, LispPTR tos);
+LispPTR N_OP_rplacd(LispPTR tosm1, LispPTR tos);
 ConsCell *find_close_prior_cell(struct conspage *page, LispPTR oldcell);
 #endif

inc/cell.h

@@ -9,6 +9,8 @@
 /*									*/
 /************************************************************************/
 
+#include "version.h"
+
 /**********************************************************************/
 /*
                 File Name :	cell.h
@@ -20,8 +22,8 @@
 
 */
 /**********************************************************************/
+#include "adr68k.h"   /* for NativeAligned4FromLPage, NativeAligned4FromLAddr */
 #include "lispemul.h" /* for LispPTR, DLword */
-#include "version.h" /* for BIGVM, NEWCDRCODING, BIGATOMS */
 
 /*  CONS CELL (LISTP) definitions moved to lispemulater.h */
 
@@ -100,13 +102,13 @@ struct conspage {
 /* Following MACROs for Conspage */
 
 /* lisp_ptr is LISP pointer, returns 68k ptr points struct conspage obj */
-#define Get_ConsPageBase(lisp_ptr) (struct conspage *)Addr68k_from_LPAGE(POINTER_PAGEBASE(lisp_ptr))
+#define Get_ConsPageBase(lisp_ptr) (struct conspage *)NativeAligned4FromLPage(POINTER_PAGEBASE(lisp_ptr))
 
 #define GetNewCell_68k(conspage68k) \
   (ConsCell *)(((DLword *)(conspage68k)) + (unsigned)((conspage68k)->next_cell))
 
 /* page : LISP page */
-#define GetCONSCount(page) (((struct conspage *)Addr68k_from_LPAGE(page))->count)
+#define GetCONSCount(page) (((struct conspage *)NativeAligned4FromLPage(page))->count)
 
 #ifndef BYTESWAP
 /* For chaining together free cons cells on a page */
@@ -376,20 +378,16 @@ struct cadr_cell {
 #else
 /* Good for old LITATOMS and new NEW-ATOMs */
 #define GetDEFCELL68k(index)                                                                 \
-  ((((index) & SEGMASK) != 0) ? (LispPTR *)(Addr68k_from_LADDR(index) + NEWATOM_DEFN_OFFSET) \
-                            : GetDEFCELLlitatom(index))
+  ((((index) & SEGMASK) != 0) ? GetDEFCELLnew(index) : GetDEFCELLlitatom(index))
 
 #define GetVALCELL68k(index)                                                                  \
-  ((((index) & SEGMASK) != 0) ? (LispPTR *)(Addr68k_from_LADDR(index) + NEWATOM_VALUE_OFFSET) \
-                            : GetVALCELLlitatom(index))
+  ((((index) & SEGMASK) != 0) ? GetVALCELLnew(index) : GetVALCELLlitatom(index))
 
 #define GetPnameCell(index)                                                                   \
-  ((((index) & SEGMASK) != 0) ? (LispPTR *)(Addr68k_from_LADDR(index) + NEWATOM_PNAME_OFFSET) \
-                            : GetPnameCelllitatom(index))
+  ((((index) & SEGMASK) != 0) ? GetPnameCellnew(index) : GetPnameCelllitatom(index))
 
 #define GetPropCell(index)                                                                    \
-  ((((index) & SEGMASK) != 0) ? (LispPTR *)(Addr68k_from_LADDR(index) + NEWATOM_PLIST_OFFSET) \
-                            : GetPropCelllitatom(index))
+  ((((index) & SEGMASK) != 0) ? GetPropCellnew(index) : GetPropCelllitatom(index))
 
 /* Good only for old-style LITATOMS */
 #ifdef BIGVM
@@ -405,10 +403,13 @@ struct cadr_cell {
 #endif
 
 /* Good only for new-style NEW-ATOMs */
-#define GetDEFCELLnew(index) (LispPTR *)(Addr68k_from_LADDR(index) + NEWATOM_DEFN_OFFSET)
-#define GetVALCELLnew(index) (LispPTR *)(Addr68k_from_LADDR(index) + NEWATOM_VALUE_OFFSET)
-#define GetPnameCellnew(index) (LispPTR *)(Addr68k_from_LADDR(index) + NEWATOM_PNAME_OFFSET)
-#define GetPropCellnew(index) (LispPTR *)(Addr68k_from_LADDR(index) + NEWATOM_PLIST_OFFSET)
+/* Note: the _OFFSET values are in units of DLword so need to be adjusted before doing pointer
+ *       arithmetic since we now have native pointers to cells not DLwords
+ */
+#define GetDEFCELLnew(index) (NativeAligned4FromLAddr(index) + (NEWATOM_DEFN_OFFSET / DLWORDSPER_CELL))
+#define GetVALCELLnew(index) (NativeAligned4FromLAddr(index) + (NEWATOM_VALUE_OFFSET / DLWORDSPER_CELL))
+#define GetPnameCellnew(index) (NativeAligned4FromLAddr(index) + (NEWATOM_PNAME_OFFSET / DLWORDSPER_CELL))
+#define GetPropCellnew(index) (NativeAligned4FromLAddr(index) + (NEWATOM_PLIST_OFFSET / DLWORDSPER_CELL))
 
 #endif /* BIGATOMS */
 
@@ -416,7 +417,7 @@ struct cadr_cell {
 
 #define S_N_CHECKANDCADR(sour, dest, tos)    \
   {                                          \
-    register LispPTR parm = sour;            \
+    LispPTR parm = sour;            \
     if (GetTypeNumber(parm) != TYPE_LISTP) { \
       ERROR_EXIT(tos);                       \
     } else                                   \

inc/conspagedefs.h

@@ -2,6 +2,6 @@
 #define CONSPAGEDEFS_H 1
 #include "lispemul.h" /* for LispPTR */
 struct conspage *next_conspage(void);
-LispPTR N_OP_cons(register int cons_car, register int cons_cdr);
+LispPTR N_OP_cons(int cons_car, int cons_cdr);
 LispPTR cons(LispPTR cons_car, LispPTR cons_cdr);
 #endif

inc/dbprint.h

@@ -43,7 +43,7 @@ extern int flushing;
 #define DBPRINT(X) do {printf X ; if (flushing) fflush(stdout); } while(0)
 #define DEBUGGER(X) X
 #else
-#define DBPRINT(X) do {} while(0)
+#define DBPRINT(X) if (0) do {printf X ; } while(0)
 #define DEBUGGER(X)
 #endif
 
@@ -55,7 +55,7 @@ extern int flushing;
 #define TRACER(X) X
 #else /* TRACE */
 
-#define TPRINT(X) do { } while (0)
+#define TPRINT(X) if (0) do {  printf X; } while (0)
 #define TRACER(X)
 #endif /* TRACE */
 
@@ -67,7 +67,7 @@ extern int flushing;
 #define OPTPRINT(X) do { printf X; if (flushing) fflush(stdout); } while (0)
 #define OPTRACER(X) X
 #else
-#define OPTPRINT(X) do { } while (0)
+#define OPTPRINT(X) if (0) do {  printf X; } while (0)
 #define OPTRACER(X)
 #endif
 
@@ -78,7 +78,7 @@ extern int flushing;
 #define FNTPRINT(X) do { printf X; if (flushing) fflush(stdout); } while (0)
 #define FNTRACER(X)  X
 #else
-#define FNTPRINT(X) do { } while (0)
+#define FNTPRINT(X) if (0) do {  printf X; } while (0)
 #define FNTRACER(X)
 #endif
 
@@ -89,7 +89,7 @@ extern int flushing;
 #define FNCHKPRINT(X) do { printf X ; if (flushing) fflush(stdout); } while (0)
 #define FNCHECKER(X) X
 #else
-#define FNCHKPRINT(X) do { } while (0)
+#define FNCHKPRINT(X) if (0) do {  printf X; } while (0)
 #define FNCHECKER(X)
 #endif
 

inc/dirdefs.h

@@ -1,6 +1,65 @@
 #ifndef DIRDEFS_H
 #define DIRDEFS_H 1
-#include "lispemul.h" /* for LispPTR */
+#include <dirent.h>         // for MAXNAMLEN
+#include <sys/types.h>      // for u_short, ino_t
+#include "lispemul.h"       // for LispPTR
+/*
+ * FINFO and FPROP are used to store the information of the enumerated files
+ * and directories.  They are arranged in a form of linked list.  Each list is
+ * corresponding to the each directory enumeration.  All of the informations
+ * Lisp needs are stored in the list.  This list is in the emulator's address space
+ * and can be specified by "ID" which is the interface between the emulator and Lisp
+ * code.  In this implementation, ID is represented as an integer and is actually
+ * an index of the array of the lists.
+ *
+ * To avoid the overhead of the FINFO and FPROP structure dynamic allocation and
+ * deallocation, some number of their instances are pre-allocated when the emulator
+ * starts and managed in a free list.  If all of the pre-allocated instances are in
+ * use, new instances are allocated.  The new instances are linked to the free list
+ * when it is freed.
+ *
+ * As described above, the linked list result of the enumeration is stored in a
+ * array for the subsequent request from Lisp.  Lisp code requests the emulator to
+ * release the list when it enumerated all of the entries in the list or the
+ * enumerating operation is aborted.
+ */
+
+typedef struct fprop {
+  unsigned length;   /* Byte length of this file. */
+  unsigned wdate;    /* Written (Creation) date in Lisp sense. */
+  unsigned rdate;    /* Read date in Lisp sense. */
+  unsigned protect;  /* Protect mode of this file. */
+  char author[256];  /* Author in Lisp sense. */
+  u_short au_len;    /* Byte length of author. */
+  unsigned long nil; /* padding to 8-byte multiple */
+} FPROP;
+
+/* This structure has a pointer at each end to force alignment to
+   be correct when a pointer is 8 bytes long. */
+typedef struct finfo {
+  FPROP *prop;           /* File properties Lisp needs. */
+  char lname[MAXNAMLEN]; /* Name in Lisp Format. */
+  u_short lname_len;     /* Byte length of lname. */
+  char no_ver_name[MAXNAMLEN];
+  /*
+   * Name in UNIX Format.  Does not
+   * include Version field.
+   * All lower case.
+   */
+  ino_t ino;          /* I-node number of this file. */
+  unsigned version;   /* Version in Lisp sense. */
+  u_short dirp;       /* If 1, this file is a directory. */
+  struct finfo *next; /*
+                       * Link to a next entry.  Last entry is
+                       * indicated by NULL pointer.
+                       */
+} FINFO;
+
+typedef struct dfinfo {
+  FINFO *head; /* Head of the linked FINFO structures. */
+  FINFO *next; /* FINFO structure generated next time. */
+} DFINFO;
+
 #ifdef DOS
 int make_old_version(char *old, char *file);
 #endif
@@ -8,7 +67,7 @@ int make_old_version(char *old, char *file);
 void print_finfo(FINFO *fp);
 #endif
 int init_finfo(void);
-LispPTR COM_gen_files(register LispPTR *args);
-LispPTR COM_next_file(register LispPTR *args);
-LispPTR COM_finish_finfo(register LispPTR *args);
+LispPTR COM_gen_files(LispPTR *args);
+LispPTR COM_next_file(LispPTR *args);
+LispPTR COM_finish_finfo(LispPTR *args);
 #endif

inc/display.h

@@ -10,7 +10,6 @@
 /*									*/
 /************************************************************************/
 #include "lispemul.h" /* for DLword */
-#include "version.h" /* for UNSIGNED */
 
 #define BCPLDISPLAY	stdout
 
@@ -74,13 +73,4 @@ extern DLword *DisplayRegion68k;
 #undef DISPLAYBUFFER
 #endif /* XWINDOW */
 
-void flush_display_buffer();
-void flush_display_lineregion(UNSIGNED x, DLword *ybase, UNSIGNED w, UNSIGNED h);
-void flush_display_region(int x, int y, int w, int h);
-void flush_display_ptrregion(DLword *ybase, UNSIGNED bitoffset, UNSIGNED w, UNSIGNED h);
-
-#ifdef BYTESWAP
-void byte_swapped_displayregion(int x, int y, int w, int h);
-#endif
-
 #endif

inc/dskdefs.h

@@ -6,20 +6,20 @@ void separate_host(char *lfname, char *host, char *drive);
 #else
 void separate_host(char *lfname, char *host);
 #endif
-LispPTR COM_openfile(register LispPTR *args);
-LispPTR COM_closefile(register LispPTR *args);
-LispPTR DSK_getfilename(register LispPTR *args);
-LispPTR DSK_deletefile(register LispPTR *args);
-LispPTR DSK_renamefile(register LispPTR *args);
-LispPTR DSK_directorynamep(register LispPTR *args);
-LispPTR COM_getfileinfo(register LispPTR *args);
-LispPTR COM_setfileinfo(register LispPTR *args);
-LispPTR COM_readpage(register LispPTR *args);
-LispPTR COM_writepage(register LispPTR *args);
-LispPTR COM_truncatefile(register LispPTR *args);
-LispPTR COM_changedir(register LispPTR *args);
-LispPTR COM_getfreeblock(register LispPTR *args);
+LispPTR COM_openfile(LispPTR *args);
+LispPTR COM_closefile(LispPTR *args);
+LispPTR DSK_getfilename(LispPTR *args);
+LispPTR DSK_deletefile(LispPTR *args);
+LispPTR DSK_renamefile(LispPTR *args);
+LispPTR DSK_directorynamep(LispPTR *args);
+LispPTR COM_getfileinfo(LispPTR *args);
+LispPTR COM_setfileinfo(LispPTR *args);
+LispPTR COM_readpage(LispPTR *args);
+LispPTR COM_writepage(LispPTR *args);
+LispPTR COM_truncatefile(LispPTR *args);
+LispPTR COM_changedir(LispPTR *args);
+LispPTR COM_getfreeblock(LispPTR *args);
 void separate_version(char *name, char *ver, int checkp);
 int unpack_filename(char *file, char *dir, char *name, char *ver, int checkp);
-int true_name(register char *path);
+int true_name(char *path);
 #endif

inc/dspsubrsdefs.h

@@ -5,7 +5,7 @@ void DSP_dspbout(LispPTR *args);
 void DSP_showdisplay(LispPTR *args);
 LispPTR DSP_VideoColor(LispPTR *args);
 void DSP_Cursor(LispPTR *args, int argnum);
-void DSP_SetMousePos(register LispPTR *args);
+void DSP_SetMousePos(LispPTR *args);
 LispPTR DSP_ScreenWidth(LispPTR *args);
 LispPTR DSP_ScreenHight(LispPTR *args);
 void flip_cursor(void);

inc/eqfdefs.h

@@ -1,8 +1,8 @@
 #ifndef EQFDEFS_H
 #define EQFDEFS_H 1
 #include "lispemul.h" /* for LispPTR */
-LispPTR N_OP_clequal(register int arg1, register int arg2);
-LispPTR N_OP_eqlop(register int arg1, register int arg2);
-LispPTR N_OP_equal(register int arg1, register int arg2);
-LispPTR N_OP_eqq(register int arg1, register int arg2);
+LispPTR N_OP_clequal(LispPTR arg1, LispPTR arg2);
+LispPTR N_OP_eqlop(LispPTR arg1, LispPTR arg2);
+LispPTR N_OP_equal(LispPTR arg1, LispPTR arg2);
+LispPTR N_OP_eqq(LispPTR arg1, LispPTR arg2);
 #endif

inc/etherdefs.h

@@ -13,5 +13,5 @@ int *ether_debug(void);
 LispPTR check_ether(void);
 void init_ifpage_ether(void);
 void init_ether(void);
-LispPTR check_sum(register LispPTR *args);
+LispPTR check_sum(LispPTR *args);
 #endif

inc/findkeydefs.h

@@ -1,5 +1,5 @@
 #ifndef FINDKEYDEFS_H
 #define FINDKEYDEFS_H 1
 #include "lispemul.h" /* for LispPTR */
-LispPTR N_OP_findkey(register LispPTR tos, register int byte);
+LispPTR N_OP_findkey(LispPTR tos, int byte);
 #endif

inc/fvardefs.h

@@ -2,10 +2,10 @@
 #define FVARDEFS_H 1
 #include "lispemul.h" /* for LispPTR, DLword */
 #include "stack.h" /* for fnhead, frameex1 */
-LispPTR N_OP_fvarn(register int n);
+LispPTR N_OP_fvarn(int n);
 LispPTR N_OP_stkscan(LispPTR tos);
-LispPTR N_OP_fvar_(register LispPTR tos, register int n);
-void nnewframe(register struct frameex1 *newpfra2, register DLword *achain, register int name);
-void nfvlookup(struct frameex1 *apframe1, register DLword *achain, register struct fnhead *apfnhead1);
+LispPTR N_OP_fvar_(LispPTR tos, int n);
+void nnewframe(struct frameex1 *newpfra2, DLword *achain, int name);
+void nfvlookup(struct frameex1 *apframe1, DLword *achain, struct fnhead *apfnhead1);
 LispPTR native_newframe(int slot);
 #endif

inc/gcdata.h

@@ -19,6 +19,7 @@
 /**********************************************************************/
 #include "lispemul.h" /* for LispPTR, DLword */
 #include "version.h" /* for USHORT */
+#include "gchtfinddefs.h"
 
 #define ADDREF  0       /* for gclookup routine. */
 #define DELREF  1       /* for gclookup routine. */

inc/gcscandefs.h

@@ -1,6 +1,6 @@
 #ifndef GCSCANDEFS_H
 #define GCSCANDEFS_H 1
 #include "lispemul.h" /* for DLword */
-DLword gcscan1(register int probe);
-DLword gcscan2(register int probe);
+DLword gcscan1(int probe);
+DLword gcscan2(int probe);
 #endif

inc/gvar2defs.h

@@ -1,6 +1,6 @@
 #ifndef GVAR2DEFS_H
 #define GVAR2DEFS_H 1
 #include "lispemul.h" /* for LispPTR */
-LispPTR N_OP_gvar_(register LispPTR tos, unsigned int atom_index);
-LispPTR N_OP_rplptr(register LispPTR tos_m_1, register LispPTR tos, unsigned int alpha);
+LispPTR N_OP_gvar_(LispPTR tos, unsigned int atom_index);
+LispPTR N_OP_rplptr(LispPTR tos_m_1, LispPTR tos, unsigned int alpha);
 #endif

inc/initdspdefs.h

@@ -10,6 +10,6 @@ void display_before_exit(void);
 void flush_display_buffer(void);
 void flush_display_region(int x, int y, int w, int h);
 void byte_swapped_displayregion(int x, int y, int w, int h);
-void flush_display_lineregion(UNSIGNED x, DLword *ybase, UNSIGNED w, UNSIGNED h);
-void flush_display_ptrregion(DLword *ybase, UNSIGNED bitoffset, UNSIGNED w, UNSIGNED h);
+void flush_display_lineregion(UNSIGNED x, DLword *ybase, int w, int h);
+void flush_display_ptrregion(DLword *ybase, UNSIGNED bitoffset, int w, int h);
 #endif

inc/inlineC.h

@@ -101,9 +101,9 @@
 #define OPCAR                                                                                     \
   do {                                                                                            \
     if (Listp(TOPOFSTACK)) {                                                                      \
-      register ConsCell *DATUM68K = (ConsCell *)(Addr68k_from_LADDR(TOPOFSTACK));                 \
+      ConsCell *DATUM68K = (ConsCell *)NativeAligned4FromLAddr(TOPOFSTACK);			  \
       if (DATUM68K->cdr_code == CDR_INDIRECT) {                                                   \
-        TOPOFSTACK = ((LispPTR)((ConsCell *)Addr68k_from_LADDR(DATUM68K->car_field))->car_field); \
+        TOPOFSTACK = ((LispPTR)((ConsCell *)NativeAligned4FromLAddr(DATUM68K->car_field))->car_field); \
         nextop1;                                                                                  \
       } else {                                                                                    \
         TOPOFSTACK = ((LispPTR)DATUM68K->car_field);                                              \
@@ -122,8 +122,8 @@
 #define OPCDR                                                                              \
   do {                                                                                     \
     if (Listp(TOPOFSTACK)) {                                                               \
-      register ConsCell *DATUM68K = (ConsCell *)(Addr68k_from_LADDR(TOPOFSTACK));          \
-      register int CDRCODEX = DATUM68K->cdr_code;                                          \
+      ConsCell *DATUM68K = (ConsCell *)(NativeAligned4FromLAddr(TOPOFSTACK));          \
+      int CDRCODEX = DATUM68K->cdr_code;                                          \
       if (CDRCODEX == CDR_NIL) {                                                           \
         /* cdr-nil */                                                                      \
         TOPOFSTACK = (NIL_PTR);                                                            \
@@ -139,7 +139,7 @@
       } else {                                                                             \
         /* cdr-differentpage */                                                            \
         TOPOFSTACK =                                                                       \
-            ((ConsCell *)(Addr68k_from_LADDR((TOPOFSTACK) + (CDRCODEX << 1))))->car_field; \
+            ((ConsCell *)(NativeAligned4FromLAddr((TOPOFSTACK) + (CDRCODEX << 1))))->car_field; \
         nextop1;                                                                           \
       }                                                                                    \
     } else if (TOPOFSTACK == NIL_PTR) {                                                    \
@@ -152,8 +152,8 @@
 #define OPCDR                                                                                  \
   do {                                                                                         \
     if (Listp(TOPOFSTACK)) {                                                                   \
-      register ConsCell *DATUM68K = (ConsCell *)(Addr68k_from_LADDR(TOPOFSTACK));              \
-      register int CDRCODEX = DATUM68K->cdr_code;                                              \
+      ConsCell *DATUM68K = (ConsCell *)(NativeAligned4FromLAddr(TOPOFSTACK));              \
+      int CDRCODEX = DATUM68K->cdr_code;                                              \
       if (CDRCODEX == CDR_NIL) {                                                               \
         /* cdr-nil */                                                                          \
         TOPOFSTACK = (NIL_PTR);                                                                \
@@ -169,7 +169,7 @@
       } else {                                                                                 \
         /* cdr-differentpage */                                                                \
         TOPOFSTACK =                                                                           \
-            ((ConsCell *)(Addr68k_from_LADDR(POINTER_PAGEBASE(TOPOFSTACK) + (CDRCODEX << 1)))) \
+            ((ConsCell *)(NativeAligned4FromLAddr(POINTER_PAGEBASE(TOPOFSTACK) + (CDRCODEX << 1)))) \
                 ->car_field;                                                                   \
         nextop1;                                                                               \
       }                                                                                        \
@@ -239,19 +239,19 @@
 #define GETBASE_N(N)                                                                          \
   do {                                                                                        \
     TOPOFSTACK =                                                                              \
-      (S_POSITIVE | GETWORD((DLword *)Addr68k_from_LADDR((POINTERMASK & TOPOFSTACK) + (N)))); \
+      (S_POSITIVE | GETWORD((DLword *)NativeAligned2FromLAddr((POINTERMASK & TOPOFSTACK) + (N)))); \
     nextop2;                                                                                  \
   } while (0)
 
 #define GETBASEPTR_N(N)                                                                            \
   do {                                                                                             \
-    TOPOFSTACK = (POINTERMASK & *((LispPTR *)Addr68k_from_LADDR((POINTERMASK & TOPOFSTACK) + (N)))); \
+    TOPOFSTACK = (POINTERMASK & *((LispPTR *)NativeAligned4FromLAddr((POINTERMASK & TOPOFSTACK) + (N)))); \
     nextop2;                                                                                       \
   } while (0)
 #define PUTBASEBYTE                                                                    \
   do {                                                                                 \
-    register int byteoffset;                                                           \
-    register char *p_data;                                                             \
+    LispPTR byteoffset;                                                           \
+    char *p_data;                                                             \
     if (((SEGMASK & TOPOFSTACK) != S_POSITIVE) || ((unsigned short)TOPOFSTACK >= 256)) \
       goto op_ufn;                                                                     \
     byteoffset = GET_TOS_1;                                                            \
@@ -261,12 +261,12 @@
       default:                                                                         \
         goto op_ufn;                                                                   \
         /***      if( GetTypeNumber(byteoffset) == TYPE_FIXP )                         \
-                        byteoffset = *((int *)Addr68k_from_LADDR(byteoffset));         \
+                        byteoffset = *((int *)NativeAligned4FromLAddr(byteoffset));         \
                 else                                                                   \
                         goto op_ufn; ***/                                              \
     }                                                                                  \
     --CSTKPTRL;                                                                        \
-    p_data = (char *)Addr68k_from_LADDR(POINTERMASK & (POP_TOS_1)) + byteoffset;       \
+    p_data = (char *)NativeAligned2FromLAddr(POINTERMASK & (POP_TOS_1)) + byteoffset;       \
     GETBYTE(p_data) = 0xFF & TOPOFSTACK;                                               \
     nextop1;                                                                           \
   } while (0)
@@ -278,31 +278,30 @@
       case S_NEGATIVE: TOPOFSTACK |= 0xFFFF0000; break;                                            \
       default:                                                                                     \
         if (GetTypeNumber(TOPOFSTACK) == TYPE_FIXP)                                                \
-          TOPOFSTACK = *((int *)Addr68k_from_LADDR(TOPOFSTACK));                                   \
+          TOPOFSTACK = *NativeAligned4FromLAddr(TOPOFSTACK);                                       \
         else                                                                                       \
           goto op_ufn;                                                                             \
     }                                                                                              \
-    TOPOFSTACK =                                                                                   \
-        (0xFF & (GETBYTE((char *)Addr68k_from_LADDR((POINTERMASK & (POP_TOS_1))) + TOPOFSTACK))) | \
-        S_POSITIVE;                                                                                \
+    TOPOFSTACK = S_POSITIVE | (0xFF &                                                              \
+            (GETBYTE((char *)NativeAligned2FromLAddr((POINTERMASK & (POP_TOS_1))) + TOPOFSTACK))); \
     nextop1;                                                                                       \
   } while (0)
 
 #define PUTBASEPTR_N(n)                                        \
   do {                                                         \
-    register int base;                                         \
+    LispPTR base;                                              \
     base = POINTERMASK & POP_TOS_1;                            \
-    *((LispPTR *)Addr68k_from_LADDR(base + (n))) = TOPOFSTACK; \
+    *((LispPTR *)NativeAligned4FromLAddr(base + (n))) = TOPOFSTACK; \
     TOPOFSTACK = base;                                         \
     nextop2;                                                   \
   } while (0)
 
 #define PUTBASE_N(n)                                                           \
   do {                                                                         \
-    register int base;                                                         \
+    LispPTR base;                                                         \
     if (GetHiWord(TOPOFSTACK) != (S_POSITIVE >> 16)) goto op_ufn;              \
     base = POINTERMASK & POP_TOS_1;                                            \
-    GETWORD((DLword *)Addr68k_from_LADDR(base + (n))) = GetLoWord(TOPOFSTACK); \
+    GETWORD((DLword *)NativeAligned2FromLAddr(base + (n))) = GetLoWord(TOPOFSTACK); \
     TOPOFSTACK = base;                                                         \
     nextop2;                                                                   \
   } while (0)
@@ -337,9 +336,9 @@
 #elif defined(BIGVM)
 #define GVAR(x)                                                                  \
   do {                                                                           \
-    register int tx = x;                                                         \
+    LispPTR tx = x;                                                         \
     if (tx & SEGMASK) {                                                          \
-      PUSH(GetLongWord(Addr68k_from_LADDR((tx) + NEWATOM_VALUE_OFFSET)));        \
+      PUSH(GetLongWord(NativeAligned4FromLAddr((tx) + NEWATOM_VALUE_OFFSET)));        \
     } else                                                                       \
       PUSH(GetLongWord((LispPTR *)AtomSpace + (tx * 5) + NEWATOM_VALUE_PTROFF)); \
                                                                                  \
@@ -348,9 +347,9 @@
 #else
 #define GVAR(x)                                                           \
   do {                                                                    \
-    register int tx = x;                                                  \
+    LispPTR tx = x;                                                  \
     if (tx & SEGMASK) {                                                   \
-      PUSH(GetLongWord(Addr68k_from_LADDR((tx) + NEWATOM_VALUE_OFFSET))); \
+      PUSH(GetLongWord(NativeAligned4FromLAddr((tx) + NEWATOM_VALUE_OFFSET))); \
     } else                                                                \
       PUSH(GetLongWord(Valspace + ((tx) << 1)));                          \
                                                                           \
@@ -366,7 +365,7 @@
 
 #define SWAP                \
   do {                      \
-    register LispPTR temp;  \
+    LispPTR temp;  \
     temp = GET_TOS_1;       \
     GET_TOS_1 = TOPOFSTACK; \
     TOPOFSTACK = temp;      \
@@ -421,15 +420,15 @@
 
 #define BIN                                                                                  \
   do {                                                                                       \
-    register Stream *stream68k; /* stream instance on TOS */                                 \
-    register char *buff68k;     /* pointer to BUFF */                                        \
+    Stream *stream68k; /* stream instance on TOS */                                 \
+    char *buff68k;     /* pointer to BUFF */                                        \
                                                                                              \
     if (GetTypeNumber(TOPOFSTACK) == TYPE_STREAM) {                                          \
-      stream68k = (Stream *)Addr68k_from_LADDR(TOPOFSTACK);                                  \
+      stream68k = (Stream *)NativeAligned4FromLAddr(TOPOFSTACK);                                  \
       if ((!stream68k->BINABLE) || (stream68k->COFFSET >= stream68k->CBUFSIZE)) goto op_ufn; \
                                                                                              \
       /* get BUFFER instance */                                                              \
-      buff68k = (char *)Addr68k_from_LADDR(stream68k->CBUFPTR);                              \
+      buff68k = (char *)NativeAligned2FromLAddr(stream68k->CBUFPTR);                              \
                                                                                              \
       /* get BYTE data and set it to TOS */                                                  \
       TOPOFSTACK = (S_POSITIVE | (Get_BYTE(buff68k + (stream68k->COFFSET)++)));              \
@@ -496,11 +495,11 @@
 
 #define BIND                                                    \
   do {                                                          \
-    register int byte = Get_BYTE_PCMAC1;                        \
-    register unsigned n1;                                       \
-    register unsigned n2;                                       \
-    register LispPTR *ppvar;                                    \
-    register int i;                                             \
+    LispPTR byte = Get_BYTE_PCMAC1;                        \
+    unsigned n1;                                       \
+    unsigned n2;                                       \
+    LispPTR *ppvar;                                    \
+    int i;                                             \
     n1 = byte >> 4;                                             \
     n2 = byte & 0xf;                                            \
     ppvar = (LispPTR *)PVAR + 1 + Get_BYTE_PCMAC2;              \
@@ -517,10 +516,10 @@
 
 #define UNBIND                                                  \
   do {                                                          \
-    register int num;                                           \
-    register LispPTR *ppvar;                                    \
-    register int i;                                             \
-    register LispPTR value;                                     \
+    int num;                                           \
+    LispPTR *ppvar;                                    \
+    int i;                                             \
+    LispPTR value;                                     \
     for (; (((int)*--CSTKPTRL) >= 0);)                          \
       ;                                                         \
     value = *CSTKPTR;                                           \
@@ -532,10 +531,10 @@
 
 #define DUNBIND                                                          \
   do {                                                                   \
-    register int num;                                                    \
-    register LispPTR *ppvar;                                             \
-    register int i;                                                      \
-    register LispPTR value;                                              \
+    int num;                                                    \
+    LispPTR *ppvar;                                             \
+    int i;                                                      \
+    LispPTR value;                                              \
     if ((int)TOPOFSTACK < 0) {                                           \
       num = (~TOPOFSTACK) >> 16;                                         \
       if (num != 0) {                                                    \
@@ -567,9 +566,9 @@
 
 #define GETBITS_N_M(a, b)                                                                          \
   do {                                                                                             \
-    register int temp, bb = b;                                                                     \
+    int temp, bb = b;                                                                     \
     temp = 0xF & bb;                                                                               \
-    TOPOFSTACK = S_POSITIVE | (((GETWORD(Addr68k_from_LADDR(POINTERMASK & (TOPOFSTACK + (a))))) >> \
+    TOPOFSTACK = S_POSITIVE | (((GETWORD(NativeAligned2FromLAddr(POINTERMASK & (TOPOFSTACK + (a))))) >> \
                                 (16 - ((0xF & (bb >> 4)) + temp + 1))) &                           \
                                n_mask_array[temp]);                                                \
     nextop3;                                                                                       \
@@ -577,13 +576,13 @@
 
 #define PUTBITS_N_M(a, b)                                                                \
   do {                                                                                   \
-    int base;                                                                            \
-    register int bb = b;                                                                 \
-    register DLword *pword;                                                              \
-    register int shift_size, field_size, fmask;                                          \
+    LispPTR base;                                                                            \
+    int bb = b;                                                                 \
+    DLword *pword;                                                              \
+    int shift_size, field_size, fmask;                                          \
     if ((SEGMASK & TOPOFSTACK) != S_POSITIVE) { goto op_ufn; };                          \
     base = POINTERMASK & POP_TOS_1;                                                      \
-    pword = (DLword *)Addr68k_from_LADDR(base + (a));                                    \
+    pword = NativeAligned2FromLAddr(base + (a));                                         \
     field_size = 0xF & bb;                                                               \
     shift_size = 15 - (0xF & (bb >> 4)) - field_size;                                    \
     fmask = n_mask_array[field_size] << shift_size;                                      \
@@ -606,7 +605,7 @@
 
 #define MYARGCOUNT                                                \
   do {                                                            \
-    register UNSIGNED arg_num;                                    \
+    UNSIGNED arg_num;                                    \
     if ((CURRENTFX->alink & 1) == 0)                              \
       arg_num = (UNSIGNED)((LispPTR *)(CURRENTFX)-1);             \
     else                                                          \
@@ -671,7 +670,7 @@
 
 #define CLARITHEQUAL                            \
   do {                                          \
-    register int arg2;                          \
+    LispPTR arg2;                          \
     SV;                                         \
     arg2 = POP_TOS_1;                           \
     if ((TOPOFSTACK & SEGMASK) == S_POSITIVE) { \
@@ -687,18 +686,16 @@
     N_OP_POPPED_CALL_2(N_OP_eqq, arg2);         \
   } while (0)
 
-#define S_CHARACTER 0x70000
-
 #define AREF1                                                                                      \
   do {                                                                                             \
     LispPTR arrayarg;                                                                              \
-    register LispPTR baseL;                                                                        \
-    register int index;                                                                            \
-    register OneDArray *arrayblk;                                                                  \
+    LispPTR baseL;                                                                        \
+    int index;                                                                            \
+    OneDArray *arrayblk;                                                                  \
     SV;                                                                                            \
     arrayarg = POP_TOS_1;                                                                          \
     if (GetTypeNumber(arrayarg) != TYPE_ONED_ARRAY) goto aref_ufn;                                 \
-    arrayblk = (OneDArray *)Addr68k_from_LADDR(arrayarg);                                          \
+    arrayblk = (OneDArray *)NativeAligned4FromLAddr(arrayarg);                                     \
     if ((TOPOFSTACK & SEGMASK) != S_POSITIVE) goto aref_ufn;                                       \
     index = TOPOFSTACK & 0xFFFF;                                                                   \
     if (index >= arrayblk->totalsize) goto aref_ufn;                                               \
@@ -706,10 +703,10 @@
     baseL = arrayblk->base;                                                                        \
     switch (arrayblk->typenumber) {                                                                \
       case 38: /* pointer : 32 bits */                                                             \
-        TOPOFSTACK = *(((int *)Addr68k_from_LADDR(baseL)) + index);                                \
+        TOPOFSTACK = *(NativeAligned4FromLAddr(baseL) + index);                           \
         nextop1;                                                                                   \
       case 20: /* signed : 16 bits */                                                              \
-        TOPOFSTACK = (GETWORD(((DLword *)Addr68k_from_LADDR(baseL)) + index)) & 0xFFFF;            \
+        TOPOFSTACK = (GETWORD(((DLword *)NativeAligned2FromLAddr(baseL)) + index)) & 0xFFFF;       \
         if (TOPOFSTACK & 0x8000)                                                                   \
           TOPOFSTACK |= S_NEGATIVE;                                                                \
         else                                                                                       \
@@ -717,47 +714,47 @@
         nextop1;                                                                                   \
       case 67: /* Character :  8 bits */                                                           \
         TOPOFSTACK =                                                                               \
-            S_CHARACTER | ((GETBYTE(((char *)Addr68k_from_LADDR(baseL)) + index)) & 0xFF);         \
+            S_CHARACTER | ((GETBYTE(((char *)NativeAligned2FromLAddr(baseL)) + index)) & 0xFF);    \
         nextop1;                                                                                   \
       case 22: /* signed : 32 bits */                                                              \
-        TOPOFSTACK = *(((int *)Addr68k_from_LADDR(baseL)) + index);                                \
+        TOPOFSTACK = *(NativeAligned4FromLAddr(baseL) + index);                           \
         switch (TOPOFSTACK & 0xFFFF0000) {                                                         \
           case 0: TOPOFSTACK |= S_POSITIVE; break;                                                 \
           case (unsigned)0xFFFF0000: TOPOFSTACK &= S_NEGATIVE; break;                              \
           default: {                                                                               \
-            register DLword *wordp;                                                                \
-            wordp = createcell68k(TYPE_FIXP);                                                      \
-            *((int *)wordp) = TOPOFSTACK;                                                          \
-            TOPOFSTACK = (LispPTR)LADDR_from_68k(wordp);                                           \
+            LispPTR *cellp;                                                                        \
+            cellp = (LispPTR *)createcell68k(TYPE_FIXP);                \
+            *cellp = TOPOFSTACK;                                                          \
+            TOPOFSTACK = (LispPTR)LAddrFromNative(cellp);                                          \
           }                                                                                        \
         }                                                                                          \
         nextop1;                                                                                   \
       case 0: /* unsigned : 1 bit per element */                                                   \
         TOPOFSTACK =                                                                               \
-            S_POSITIVE | (((GETBYTE(((char *)Addr68k_from_LADDR(baseL)) + (index >> 3))) >>        \
+            S_POSITIVE | (((GETBYTE(((char *)NativeAligned2FromLAddr(baseL)) + (index >> 3))) >>   \
                            (7 - (index & 7))) &                                                    \
                           1);                                                                      \
         nextop1;                                                                                   \
       case 3: /* unsigned : 8 bits per element */                                                  \
-        TOPOFSTACK = S_POSITIVE | ((GETBYTE(((char *)Addr68k_from_LADDR(baseL)) + index)) & 0xFF); \
+        TOPOFSTACK = S_POSITIVE | ((GETBYTE(((char *)NativeAligned2FromLAddr(baseL)) + index)) & 0xFF); \
         nextop1;                                                                                   \
       case 4: /* unsigned : 16 bits per element */                                                 \
         TOPOFSTACK =                                                                               \
-            S_POSITIVE | ((GETWORD(((DLword *)Addr68k_from_LADDR(baseL)) + index)) & 0xFFFF);      \
+            S_POSITIVE | ((GETWORD(((DLword *)NativeAligned2FromLAddr(baseL)) + index)) & 0xFFFF); \
         nextop1;                                                                                   \
       case 54: /* Float : 32 bits */ {                                                             \
-        register DLword *wordp;                                                                    \
-        wordp = createcell68k(TYPE_FLOATP);                                                        \
-        *((int *)wordp) = *(((int *)Addr68k_from_LADDR(baseL)) + index);                           \
-        TOPOFSTACK = (LispPTR)LADDR_from_68k(wordp);                                               \
+        LispPTR *cellp;                                                                            \
+        cellp = (LispPTR *)createcell68k(TYPE_FLOATP);                  \
+        *cellp = *(NativeAligned4FromLAddr(baseL) + index);                                        \
+        TOPOFSTACK = (LispPTR)LAddrFromNative(cellp);                                              \
       }                                                                                            \
         nextop1;                                                                                   \
       case 68: /* Character :  16 bits */                                                          \
         TOPOFSTACK =                                                                               \
-            S_CHARACTER | ((GETWORD(((DLword *)Addr68k_from_LADDR(baseL)) + index)) & 0xFFFF);     \
+            S_CHARACTER | ((GETWORD(((DLword *)NativeAligned2FromLAddr(baseL)) + index)) & 0xFFFF);\
         nextop1;                                                                                   \
       case 86: /* XPointer : 32 bits */                                                            \
-        TOPOFSTACK = *(((int *)Addr68k_from_LADDR(baseL)) + index);                                \
+        TOPOFSTACK = *(NativeAligned4FromLAddr(baseL) + index);                           \
         nextop1;                                                                                   \
       default: /* Illegal or Unimplemented */ goto aref_ufn;                                       \
     } /* end switch typenumber */                                                                  \
@@ -768,8 +765,8 @@
 #ifdef BIGVM
 #define DTEST(n)                                                                                   \
   do {                                                                                             \
-    register int atom_index;                                                                       \
-    register struct dtd *dtd68k;                                                                   \
+    int atom_index;                                                                       \
+    struct dtd *dtd68k;                                                                   \
     atom_index = n;                                                                                \
     for (dtd68k = (struct dtd *)GetDTD(GetTypeNumber(TOPOFSTACK)); atom_index != dtd68k->dtd_name; \
          dtd68k = (struct dtd *)GetDTD(dtd68k->dtd_supertype)) {                                   \
@@ -780,8 +777,8 @@
 #else /* BIGVM */
 #define DTEST(n)                                                               \
   do {                                                                         \
-    register int atom_index;                                                   \
-    register struct dtd *dtd68k;                                               \
+    int atom_index;                                                   \
+    struct dtd *dtd68k;                                               \
     atom_index = n;                                                            \
     for (dtd68k = (struct dtd *)GetDTD(GetTypeNumber(TOPOFSTACK));             \
          atom_index != dtd68k->dtd_namelo + ((int)(dtd68k->dtd_namehi) << 16); \
@@ -794,26 +791,26 @@
 
 #define FVAR(n)                                                                             \
   do {                                                                                      \
-    register LispPTR *chain;                                                                \
+    LispPTR *chain;                                                                         \
     chain = (LispPTR *)(PVar + (n));                                                        \
     if (WBITSPTR(chain)->LSB) {                                                             \
-      PUSH(GetLongWord(Addr68k_from_LADDR(POINTERMASK &swapx(native_newframe((n) >> 1))))); \
+      PUSH(GetLongWord(NativeAligned4FromLAddr(POINTERMASK &swapx(native_newframe((n) >> 1))))); \
       nextop1;                                                                              \
     } /* if(((WBITS */                                                                      \
-    PUSH(GetLongWord(Addr68k_from_LADDR(POINTERMASK &swapx(*chain))));                      \
+    PUSH(GetLongWord(NativeAligned4FromLAddr(POINTERMASK &swapx(*chain))));                 \
     nextop1;                                                                                \
   } while (0)
 
 #define FVARX(n)                                                                           \
   do {                                                                                     \
-    register int nn = n;                                                                   \
-    register LispPTR *chain;                                                               \
+    int nn = n;                                                                            \
+    LispPTR *chain;                                                                        \
     chain = (LispPTR *)(PVar + nn);                                                        \
     if (WBITSPTR(chain)->LSB) {                                                            \
-      PUSH(GetLongWord(Addr68k_from_LADDR(POINTERMASK &swapx(native_newframe(nn >> 1))))); \
+      PUSH(GetLongWord(NativeAligned4FromLAddr(POINTERMASK &swapx(native_newframe(nn >> 1))))); \
       nextop2;                                                                             \
     } /* if(((WBITS */                                                                     \
-    PUSH(GetLongWord(Addr68k_from_LADDR(POINTERMASK &swapx(*chain))));                     \
+    PUSH(GetLongWord(NativeAligned4FromLAddr(POINTERMASK &swapx(*chain))));                     \
     nextop2;                                                                               \
   } while (0)
 
@@ -837,7 +834,7 @@
 #elif defined(BIGVM)
 #define ATOMCELL_N(n)                                                                             \
   do {                                                                                            \
-    register int nn = n;                                                                          \
+    int nn = n;                                                                          \
     if (0 == ((unsigned int)(TOPOFSTACK &= POINTERMASK) & SEGMASK)) {                             \
       /* old-symbol case; just add cell-number arg */                                             \
       switch (nn) {                                                                               \
@@ -881,7 +878,7 @@
 
 #define ATOMCELL_N(n)                                         \
   do {                                                        \
-    register int nn = n;                                      \
+    int nn = n;                                      \
     if (0 == ((unsigned int)TOPOFSTACK & SEGMASK)) {          \
       /* old-symbol case; just add cell-number arg */         \
       TOPOFSTACK = (nn << 16) + (TOPOFSTACK << 1);            \

inc/inlnPS2.h

@@ -39,8 +39,8 @@
 /*									*/
 /*		   R E G I S T E R   C O N V E N T I O N S		*/
 /*									*/
-/*	The following register conventions hold in the dispatch loop,	*/
-/*	and are set up by register ... asm("...") decls in xc.c:	*/
+/*	The following conventions hold in the dispatch loop,	*/
+/*	and are set up by ... asm("...") decls in xc.c:	*/
 /*									*/
 /*		esi	pccache	- the current PC			*/
 /*		edi	cspcache - the current lisp stack ptr.		*/
@@ -48,7 +48,7 @@
 /*									*/
 /*									*/
 /*	Register conventions within arithmetic functions in the files	*/
-/*	arith2.c - arith4.c, etc.:					*/
+/*	arithops.c, etc.:						*/
 /*									*/
 /*		esi	first argument to the function			*/
 /*		edi	second argument to the function			*/
@@ -60,7 +60,7 @@
 /*									*/
 /*    G E N E R A L - P U R P O S E   I N L I N E   F U N C T I O N S	*/
 /*									*/
-/*	These functions don't rely on register conventions.		*/
+/*	These functions don't rely on conventions.		*/
 /*									*/
 /************************************************************************/
 
@@ -88,7 +88,7 @@
 extern inline const unsigned int Get_BYTE_PCMAC0fn (pccache)
 unsigned int pccache;
  {
-    register unsigned int word;
+    unsigned int word;
     asm("leal	-1(%1),%0 \n\
 	xorl	$3,%0 \n\
 	movzbl	(%0),%0 \n\
@@ -99,7 +99,7 @@ unsigned int pccache;
 extern inline const unsigned int Get_BYTE_PCMAC1fn (pccache)
 unsigned int pccache;
  {
-    register unsigned int word;
+    unsigned int word;
     asm("movl	%1,%0 \n\
 	xorl	$3,%0 \n\
 	movzbl	(%0),%0 \n\
@@ -110,7 +110,7 @@ unsigned int pccache;
 extern inline const unsigned int Get_BYTE_PCMAC2fn (pccache)
 unsigned int pccache;
  {
-    register unsigned int word;
+    unsigned int word;
     asm("leal	1(%1),%0 \n\
 	xorl	$3,%0 \n\
 	movzbl	(%0),%0 \n\
@@ -121,7 +121,7 @@ unsigned int pccache;
 extern inline const unsigned int Get_BYTE_PCMAC3fn (pccache)
 unsigned int pccache;
  {
-    register unsigned int word;
+    unsigned int word;
     asm("leal	2(%1),%0 \n\
 	xorl	$3,%0 \n\
 	movzbl	(%0),%0 \n\
@@ -144,7 +144,7 @@ unsigned int pccache;
 extern inline const unsigned int Get_DLword_PCMAC0fn(pccache)
 unsigned int pccache;
  {
-    register unsigned int word asm("ax");
+    unsigned int word asm("ax");
     asm("movl	%1,%%edx \n\
 	xorb	$3,%%dl \n\
 	movzbl	(%%edx),%%eax \n\
@@ -158,7 +158,7 @@ unsigned int pccache;
 extern inline const unsigned int Get_DLword_PCMAC1fn(pccache)
 unsigned int pccache;
  {
-    register unsigned int word asm("ax");
+    unsigned int word asm("ax");
     asm("leal	1(%1),%%edx \n\
 	xorb	$3,%%dl \n\
 	movzbl	(%%edx),%%eax \n\
@@ -173,7 +173,7 @@ unsigned int pccache;
 extern inline const unsigned int Get_DLword_PCMAC2fn(pccache)
 unsigned int pccache;
  {
-    register unsigned int word asm("ax");
+    unsigned int word asm("ax");
     asm("leal	2(%1),%%edx \n\
 	xorb	$3,%%dl \n\
 	movzbl	(%%edx),%%eax \n\
@@ -187,7 +187,7 @@ unsigned int pccache;
 extern inline const unsigned int Get_DLword_PCMAC3fn(pccache)
 unsigned int pccache;
  {
-    register unsigned int word asm("ax");
+    unsigned int word asm("ax");
     asm("leal	3(%1),%%edx \n\
 	xorb	$3,%%dl \n\
 	movzbl	(%%edx),%%eax \n\
@@ -211,7 +211,7 @@ unsigned int pccache;
 extern inline const unsigned int Get_Pointer_PCMAC0fn(pccache)
 unsigned int pccache;
  {
-    register unsigned int word asm("ax");
+    unsigned int word asm("ax");
     asm("leal	-1(%1),%%edx	\n\
 	xorb	$3,%%dl		\n\
 	movzbl	(%%edx),%%eax	\n\
@@ -229,7 +229,7 @@ unsigned int pccache;
 extern inline const unsigned int Get_Pointer_PCMAC1fn(pccache)
 unsigned int pccache;
  {
-    register unsigned int word asm("ax");
+    unsigned int word asm("ax");
     asm("leal	(%1),%%edx	\n\
 	xorb	$3,%%dl		\n\
 	movzbl	(%%edx),%%eax	\n\
@@ -248,7 +248,7 @@ unsigned int pccache;
 extern inline const unsigned int Get_Pointer_PCMAC2fn(pccache)
 unsigned int pccache;
  {
-    register unsigned int word asm("ax");
+    unsigned int word asm("ax");
     asm("leal	1(%1),%%edx	\n\
 	xorb	$3,%%dl		\n\
 	movzbl	(%%edx),%%eax	\n\

inc/inlnSPARC.h

@@ -26,7 +26,7 @@
 /*
 	Get_BYTE(PCMAC+1);			\
 xc.c:		#define PCMAC pccache
-xc.c:		register InstPtr pccache;
+xc.c:		InstPtr pccache;
 xc.c:		typedef ByteCode *InstPtr;  CHANGED TO
 xc.c:		typedef BYTECODE *InstPtr;
 lispemul.h:	typedef char ByteCode;
@@ -51,15 +51,15 @@ lispemul.h:	typedef struct {unsigned code : 8;} BYTECODE;
 
 #define BOX_INTO(result, dest){					\
 	if (NSMALLP_RANGE(result))/* dest = box_fixp(result);*/	\
-		{register LispPTR *wordp; 			\
+		{LispPTR *wordp; 			\
 		wordp = (LispPTR *) createcell68k(TYPE_FIXP);	\
 		*((int *)wordp) = result;			\
-		dest = (LADDR_from_68k(wordp));	}		\
+		dest = (LAddrFromNative(wordp));	}		\
 	else dest = (( (unsigned)result <<15) >>15) | S_POSITIVE;}
 
 
 #define ARITH_OP(op, exceptions, handler) 			\
-	{register int arg1, arg2, result;			\
+	{int arg1, arg2, result;			\
 	arg1 = GET_TOS_1;		 /* w/o side effect */	\
 	if(!NSMALLP(TOPOFSTACK) && !NSMALLP(arg1)) {		\
 		arg2 = UNBOX_SMALLP(TOPOFSTACK);		\
@@ -71,7 +71,7 @@ lispemul.h:	typedef struct {unsigned code : 8;} BYTECODE;
 	N_OP_CALL_2(handler); }
 
 #define BINARY_OP(exp, exceptions) {				\
-	register int arg1, arg2, result;			\
+	int arg1, arg2, result;			\
 	arg1 = GET_TOS_1;		 /* w/o side effect */	\
 	UNBOX_ELSE_UFN(TOPOFSTACK, arg2);			\
 	UNBOX_ELSE_UFN(arg1, arg1);				\
@@ -84,7 +84,7 @@ lispemul.h:	typedef struct {unsigned code : 8;} BYTECODE;
 #undef IGREATERP
 
 #define GREATERP {						\
-	register int arg1, arg2, result;			\
+	int arg1, arg2, result;			\
 	arg1 = GET_TOS_1;		 /* w/o side effect */	\
 	UNBOX_ELSE_UFN(TOPOFSTACK, arg2);			\
 	UNBOX_ELSE_UFN(arg1, arg1);				\
@@ -92,7 +92,7 @@ lispemul.h:	typedef struct {unsigned code : 8;} BYTECODE;
 	POP_TOS_1; nextop1;}
 
 #define IGREATERP {						\
-	register int arg1, arg2, result;			\
+	int arg1, arg2, result;			\
 	arg1 = GET_TOS_1;		 /* w/o side effect */	\
 	UNBOX_ELSE_UFN(TOPOFSTACK, arg2);			\
 	UNBOX_ELSE_UFN(arg1, arg1);				\
@@ -122,7 +122,7 @@ lispemul.h:	typedef struct {unsigned code : 8;} BYTECODE;
 #define LOGXOR		BINARY_OP(arg1 ^ arg2, 0)
 
 #define UNARY_OP(exp, exceptions) {				\
-	register int arg, result; 						\
+	int arg, result; 						\
 	UNBOX_ELSE_UFN(TOPOFSTACK, arg);			\
 	result = exp;						\
 	if (exceptions) goto op_ufn;				\
@@ -141,7 +141,7 @@ lispemul.h:	typedef struct {unsigned code : 8;} BYTECODE;
 
 #undef ADDBASE
 #define ADDBASE {						\
-	register int arg1, arg2;				\
+	int arg1, arg2;				\
 	UNBOX_ELSE_UFN(TOPOFSTACK, arg2);			\
 	TOPOFSTACK = POP_TOS_1 + arg2;				\
 	nextop1;}

inc/inlndos.h

@@ -39,8 +39,8 @@
 /*									*/
 /*		   R E G I S T E R   C O N V E N T I O N S		*/
 /*									*/
-/*	The following register conventions hold in the dispatch loop,	*/
-/*	and are set up by register ... asm("...") decls in xc.c:	*/
+/*	The following conventions hold in the dispatch loop,	*/
+/*	and are set up by ... asm("...") decls in xc.c:	*/
 /*									*/
 /*		esi	pccache	- the current PC			*/
 /*		edi	cspcache - the current lisp stack ptr.		*/
@@ -48,7 +48,7 @@
 /*									*/
 /*									*/
 /*	Register conventions within arithmetic functions in the files	*/
-/*	arith2.c - arith4.c, etc.:					*/
+/*	arithops.c etc.:						*/
 /*									*/
 /*		esi	first argument to the function			*/
 /*		edi	second argument to the function			*/
@@ -60,7 +60,7 @@
 /*									*/
 /*    G E N E R A L - P U R P O S E   I N L I N E   F U N C T I O N S	*/
 /*									*/
-/*	These functions don't rely on register conventions.		*/
+/*	These functions don't rely on conventions.		*/
 /*									*/
 /************************************************************************/
 
@@ -88,7 +88,7 @@
 extern inline  unsigned int Get_BYTE_PCMAC0fn (pccache)
 unsigned int pccache;
  {
-    register unsigned int word;
+    unsigned int word;
     asm("lea	%0,-1[%1] \n\
 	xor	%0,3 \n\
 	movzx	%0,BYTE PTR [%0] \n\
@@ -99,7 +99,7 @@ unsigned int pccache;
 extern inline  unsigned int Get_BYTE_PCMAC1fn (pccache)
 unsigned int pccache;
  {
-    register unsigned int word;
+    unsigned int word;
     asm("lea	%0,[%1] \n\
 	xor	%0,3 \n\
 	movzx	%0,BYTE PTR [%0] \n\
@@ -110,7 +110,7 @@ unsigned int pccache;
 extern inline  unsigned int Get_BYTE_PCMAC2fn (pccache)
 unsigned int pccache;
  {
-    register unsigned int word;
+    unsigned int word;
     asm("lea	%0,1[%1] \n\
 	xor	%0,3 \n\
 	movzx	%0,BYTE PTR [%0] \n\
@@ -121,7 +121,7 @@ unsigned int pccache;
 extern inline  unsigned int Get_BYTE_PCMAC3fn (pccache)
 unsigned int pccache;
  {
-    register unsigned int word;
+    unsigned int word;
     asm("lea	%0,2[%1] \n\
 	xor	%0,3 \n\
 	movzx	%0,BYTE PTR [%0] \n\
@@ -144,7 +144,7 @@ unsigned int pccache;
 extern inline  unsigned int Get_DLword_PCMAC0fn(pccache)
 unsigned int pccache;
  {
-    register unsigned int word asm("ax");
+    unsigned int word asm("ax");
     asm("mov	edx,%1 \n\
 	xor	dl,3 \n\
 	movzx	eax, byte ptr [edx] \n\
@@ -158,7 +158,7 @@ unsigned int pccache;
 extern inline  unsigned int Get_DLword_PCMAC1fn(pccache)
 unsigned int pccache;
  {
-    register unsigned int word asm("ax");
+    unsigned int word asm("ax");
     asm("lea	edx,1[%1] \n\
 	xor	dl,3 \n\
 	movzx	eax, byte ptr [edx] \n\
@@ -173,7 +173,7 @@ unsigned int pccache;
 extern inline  unsigned int Get_DLword_PCMAC2fn(pccache)
 unsigned int pccache;
  {
-    register unsigned int word asm("ax");
+    unsigned int word asm("ax");
     asm("lea	edx,2[%1] \n\
 	xor	dl,3 \n\
 	movzx	eax, byte ptr [edx] \n\
@@ -187,7 +187,7 @@ unsigned int pccache;
 extern inline  unsigned int Get_DLword_PCMAC3fn(pccache)
 unsigned int pccache;
  {
-    register unsigned int word asm("ax");
+    unsigned int word asm("ax");
     asm("lea	edx,3[%1] \n\
 	xor	dl,3 \n\
 	movzx	eax, byte ptr [edx] \n\
@@ -211,7 +211,7 @@ unsigned int pccache;
 extern inline const unsigned int Get_Pointer_PCMAC0fn(pccache)
 unsigned int pccache;
  {
-    register unsigned int word asm("ax");
+    unsigned int word asm("ax");
     asm("lea	edx,-1[%1]	\n\
 	xor	dl,3		\n\
 	movzx	eax,byte ptr [edx]	\n\
@@ -229,7 +229,7 @@ unsigned int pccache;
 extern inline const unsigned int Get_Pointer_PCMAC1fn(pccache)
 unsigned int pccache;
  {
-    register unsigned int word asm("ax");
+    unsigned int word asm("ax");
     asm("lea	edx,[%1]	\n\
 	xor	dl,3		\n\
 	movzx	eax,byte ptr [edx]	\n\
@@ -248,7 +248,7 @@ unsigned int pccache;
 extern inline const unsigned int Get_Pointer_PCMAC2fn(pccache)
 unsigned int pccache;
  {
-    register unsigned int word asm("ax");
+    unsigned int word asm("ax");
     asm("lea	edx,1[%1]	\n\
 	xor	dl,3		\n\
 	movzx	eax,byte ptr [edx]	\n\

inc/intcalldefs.h

@@ -1,4 +1,4 @@
 #ifndef INTCALLDEFS_H
 #define INTCALLDEFS_H 1
-void cause_interruptcall(register unsigned int atom_index);
+void cause_interruptcall(unsigned int atom_index);
 #endif

inc/keyeventdefs.h

@@ -1,7 +1,7 @@
 #ifndef KEYEVENTDEFS_H
 #define KEYEVENTDEFS_H 1
 #include <sys/types.h>
-void process_io_events();
+void process_io_events(void);
 void kb_trans(u_short keycode, u_short upflg);
 void taking_mouse_down(void);
 void copy_cursor(int newx, int newy);

inc/lineblt8defs.h

@@ -2,6 +2,6 @@
 #define LINEBLT8DEFS_H 1
 #include <sys/types.h> /* for u_char */
 #include "lispemul.h" /* for LispPTR, DLword */
-void lineBlt8(DLword *srcbase, register int offset, register u_char *destl, register int width,
+void lineBlt8(DLword *srcbase, int offset, u_char *destl, int width,
               u_char color0, u_char color1, LispPTR sourcetype, LispPTR operation);
 #endif

inc/lisp2cdefs.h

@@ -2,7 +2,7 @@
 #define LISP2CDEFS_H 1
 #include "lispemul.h" /* for LispPTR */
 int LispStringP(LispPTR object);
-int LispStringLength(LispPTR lispstring);
+int LispStringSimpleLength(LispPTR lispstring);
 void LispStringToCStr(LispPTR lispstring, char *cstring);
 int LispIntToCInt(LispPTR lispint);
 LispPTR CIntToLispInt(int cint);

inc/lispemul.h

@@ -9,7 +9,9 @@
 /*	Manufactured in the United States of America.			*/
 /*									*/
 /************************************************************************/
-#include "version.h" /* for BIGVM, BIGATOMS, UNSIGNED, UNALIGNED_FETCH_OK */
+#include "version.h"
+
+#include "lispmap.h"     // for S_POSITIVE
 
 #ifndef BYTESWAP
 /*** Normal byte-order type decls */
@@ -82,17 +84,17 @@ typedef struct interrupt_state_2 { /* alternate view of the interrupt state */
 } INTSTAT2;
 
 struct state {
-  DLword *ivar;               /* + 0 */
-  DLword *pvar;               /* + 4 */
-  DLword *csp;                /* + 8 */
-  LispPTR tosvalue;           /* + 12 */
-  ByteCode *currentpc;        /* + 16 */
-  struct fnhead *currentfunc; /* + 20*/
-  DLword *endofstack;         /* + 24*/
-  UNSIGNED irqcheck;          /* + 28 */
-  UNSIGNED irqend;            /* + 32 */
-  LispPTR scratch_cstk;       /* + 34 */
-  int errorexit;              /* + 38 */
+  DLword *ivar;
+  DLword *pvar;
+  DLword *csp;
+  ByteCode *currentpc;
+  struct fnhead *currentfunc;
+  DLword *endofstack;
+  UNSIGNED irqcheck;
+  UNSIGNED irqend;
+  LispPTR tosvalue;
+  LispPTR scratch_cstk;
+  int errorexit;
 };
 
 /***** Get_DLword(ptr) ptr is char* ***/
@@ -226,17 +228,17 @@ typedef struct interrupt_state_2 { /* alternate view of the interrupt state */
 } INTSTAT2;
 
 struct state {
-  DLword *ivar;               /* + 0 */
-  DLword *pvar;               /* + 4 */
-  DLword *csp;                /* + 8 */
-  LispPTR tosvalue;           /* + 12 */
-  ByteCode *currentpc;        /* + 16 */
-  struct fnhead *currentfunc; /* + 20*/
-  DLword *endofstack;         /* + 24*/
-  UNSIGNED irqcheck;          /* + 28 */
-  UNSIGNED irqend;            /* + 32 */
-  LispPTR scratch_cstk;       /* + 34 */
-  int errorexit;              /* + 38 */
+  DLword *ivar;
+  DLword *pvar;
+  DLword *csp;
+  ByteCode *currentpc;
+  struct fnhead *currentfunc;
+  DLword *endofstack;
+  UNSIGNED irqcheck;
+  UNSIGNED irqend;
+  LispPTR tosvalue;
+  LispPTR scratch_cstk;
+  int errorexit;
 };
 
 /* Fetching 2 bytes to make a word -- always do it the hard way */
@@ -444,20 +446,21 @@ DOSTACKOVERFLOW(argnum,bytenum) if it needs hardreturn-cleanup
 /*	so that it picks up where it left off after the interrupt.	*/
 /*									*/
 /*	Call Interface where neg number indicates an error return	*/
+/*	but the function returns a LispPTR and casts back to int	*/
 /*									*/
 /************************************************************************/
 
 #define ERROR_EXIT(tos) \
   do {                  \
-    TopOfStack = tos;   \
+    TopOfStack = (LispPTR)tos; \
     Error_Exit = 1;     \
-    return (-1);        \
+    return ((LispPTR)-1); \
   } while (0)
 #define TIMER_EXIT(tos) \
   do {                  \
-    TopOfStack = tos;   \
+    TopOfStack = (LispPTR)tos; \
     Error_Exit = 1;     \
-    return (-2);        \
+    return ((LispPTR)-2); \
   } while (0)
 
 #define WARN(message, operation) \

inc/lispmap.h

@@ -154,7 +154,7 @@
 #define SNEG_SIZE	0x10000
 
 /* for characters */
-#define S_CHAR		0x70000
+#define S_CHARACTER	0x70000
 
 /* for HTMAIN */
 #define HTMAIN_HI	     22
@@ -307,7 +307,7 @@
 #define SNEG_SIZE	0x10000
 
 /* for characters */
-#define S_CHAR		0x70000
+#define S_CHARACTER	0x70000
 
 #ifdef BIGVM
 /* for HTMAIN */

inc/lispver1.h

@@ -6,8 +6,8 @@
 #define LispVersionToUnixVersion(pathname, ver)				\
   {									\
 									\
-    register char	*cp;						\
-    register char	*vp;						\
+    char	*cp;						\
+    char	*vp;						\
     char		ver_buf[VERSIONLEN];				\
 									\
     cp = pathname;							\

inc/lispver2.h

@@ -6,9 +6,9 @@
 
 #define LispVersionToUnixVersion(pathname){				\
 									\
-	register char	*lv_cp;						\
-	register char	*lv_vp;						\
-	register unsigned lv_ver;					\
+	char	*lv_cp;						\
+	char	*lv_vp;						\
+	unsigned lv_ver;					\
 	char		lv_ver_buf[VERSIONLEN];				\
 									\
 	lv_cp = pathname;						\

inc/llstkdefs.h

@@ -4,12 +4,12 @@
 #include "stack.h" /* for FX, StackWord, Bframe */
 int do_stackoverflow(int incallp);
 DLword *freestackblock(DLword n, StackWord *start68k, int align);
-void decusecount68k(register FX *frame68k);
+void decusecount68k(FX *frame68k);
 void flip_cursorbar(int n);
-void blt(register DLword *dest68k, register DLword *source68k, int nw);
+void blt(DLword *dest68k, DLword *source68k, int nw);
 void stack_check(StackWord *start68k);
 void walk_stack(StackWord *start68k);
-void quick_stack_check(void);
+int quick_stack_check(void);
 void check_FX(FX *fx68k);
 void check_BF(Bframe *bf68k);
 int check_stack_rooms(FX *fx68k);

inc/locfile.h

@@ -45,15 +45,17 @@ extern	DLword	*Lisp_world;	/* To access LispSysout area */
 			/* For getfileinfo. For WDATE&RDATE */
 			/* 29969152 == (timer.c)LISP_UNIX_TIME_DIFF */
 
-#define StrNCpyFromCToLisp(lispbuf, cbuf ,len)	{int lf_i;	\
-			char *lf_sptr,*lf_dptr;		\
-			for(lf_i=0,lf_sptr=(cbuf),lf_dptr =(lispbuf);lf_i<(len);lf_i++)\
+#define StrNCpyFromCToLisp(lispbuf, cbuf ,len)	{	\
+			char *lf_sptr = (cbuf);		\
+                        char *lf_dptr = (lispbuf);                      \
+			for(size_t lf_i=0;lf_i<(len);lf_i++)\
 				GETBYTE(lf_dptr++) = *lf_sptr++;		\
 		}
 
-#define StrNCpyFromLispToC(cbuf , lispbuf, len)	{int lf_i;	\
-			char *lf_sptr,*lf_dptr;			\
-			for(lf_i=0,lf_sptr=(lispbuf),lf_dptr =(cbuf);lf_i<(len);lf_i++)\
+#define StrNCpyFromLispToC(cbuf , lispbuf, len)	{	\
+			char *lf_sptr = (lispbuf);                                          \
+			char *lf_dptr = (cbuf);                       \
+			for(size_t lf_i=0;lf_i<(len);lf_i++)\
 				*lf_dptr++ = GETBYTE(lf_sptr++);		\
 		}
 
@@ -83,23 +85,24 @@ extern	DLword	*Lisp_world;	/* To access LispSysout area */
     OneDArray	*lf_arrayp;						\
     char	*lf_base, *lf_dp;						\
     short	*lf_sbase;							\
-    int	lf_i, lf_length;						\
-    lf_arrayp = (OneDArray *)(Addr68k_from_LADDR(Lisp));			\
+    size_t		 lf_length;						\
+    lf_arrayp = (OneDArray *)NativeAligned4FromLAddr(Lisp);		\
     lf_length = min(MaxLen, lf_arrayp->fillpointer);			\
     switch(lf_arrayp->typenumber)						\
       {									\
 	case THIN_CHAR_TYPENUMBER:					\
-		lf_base = ((char *)(Addr68k_from_LADDR(lf_arrayp->base)))  	\
+		lf_base = ((char *)(NativeAligned2FromLAddr(lf_arrayp->base)))  	\
 		       + ((int)(lf_arrayp->offset));			\
 		strncpy(C, lf_base, lf_length);				\
 		(C)[lf_length] = '\0';					\
 		break;							\
 									\
 	case FAT_CHAR_TYPENUMBER:					\
-		lf_sbase = ((short *)(Addr68k_from_LADDR(lf_arrayp->base)))	\
+		lf_sbase = ((short *)(NativeAligned2FromLAddr(lf_arrayp->base)))	\
 		       + ((int)(lf_arrayp->offset));			\
-		for(lf_i=0,lf_dp=C;lf_i<(lf_length);lf_i++)	\
-		  *lf_dp++ = (char)(*lf_sbase++);				\
+                lf_dp = C;						\
+		for(size_t lf_i=0;lf_i<(lf_length);lf_i++)		\
+		  *lf_dp++ = (char)(*lf_sbase++);			\
 		*lf_dp = '\0';						\
 		break;							\
 	default:							\
@@ -112,22 +115,23 @@ extern	DLword	*Lisp_world;	/* To access LispSysout area */
     OneDArray	*lf_arrayp;						\
     char	*lf_base, *lf_dp;						\
     short	*lf_sbase;							\
-    int	lf_ii, lf_length;						\
-    lf_arrayp = (OneDArray *)(Addr68k_from_LADDR(Lisp));			\
+    size_t 	lf_length;						\
+    lf_arrayp = (OneDArray *)(NativeAligned4FromLAddr(Lisp));			\
     lf_length = min(MaxLen, lf_arrayp->fillpointer);			\
     switch(lf_arrayp->typenumber)						\
       {									\
 	case THIN_CHAR_TYPENUMBER:					\
-		lf_base = ((char *)(Addr68k_from_LADDR(lf_arrayp->base)))  	\
+		lf_base = ((char *)(NativeAligned2FromLAddr(lf_arrayp->base)))  	\
 		       + ((int)(lf_arrayp->offset));			\
 		StrNCpyFromLispToC(C , lf_base , lf_length );		\
 		(C)[lf_length] = '\0';					\
 		break;							\
 									\
 	case FAT_CHAR_TYPENUMBER:					\
-		lf_sbase = ((short *)(Addr68k_from_LADDR(lf_arrayp->base)))	\
+		lf_sbase = ((short *)(NativeAligned2FromLAddr(lf_arrayp->base)))	\
 		       + ((int)(lf_arrayp->offset));			\
-		for(lf_ii=0,lf_dp=C;lf_ii<(lf_length);lf_ii++,lf_sbase++)  \
+                lf_dp = C;						\
+		for(size_t lf_ii=0;lf_ii<(lf_length);lf_ii++,lf_sbase++)  \
                     *lf_dp++ = (char)(GETWORD(lf_sbase));               \
 		*lf_dp = '\0';						\
 		break;							\
@@ -152,7 +156,7 @@ extern	DLword	*Lisp_world;	/* To access LispSysout area */
 #define	LispStringLength(LispString, Length, FatP)			\
   {									\
     OneDArray	*lf_arrayp;						\
-    lf_arrayp = (OneDArray *)(Addr68k_from_LADDR(LispString));		\
+    lf_arrayp = (OneDArray *)(NativeAligned4FromLAddr(LispString));		\
     switch(lf_arrayp->typenumber)					\
       {									\
 	case THIN_CHAR_TYPENUMBER:					\
@@ -182,8 +186,8 @@ extern	DLword	*Lisp_world;	/* To access LispSysout area */
 #define STRING_BASE(lstringp, cstringp) \
   {				\
 	LispPTR	*lf_naddress;				  \
-	lf_naddress = (LispPTR *)(Addr68k_from_LADDR(lstringp));		  \
-	(cstringp) = (char *)(Addr68k_from_LADDR(((OneDArray *)lf_naddress)->base)); \
+	lf_naddress = (LispPTR *)(NativeAligned4FromLAddr(lstringp));		  \
+	(cstringp) = (char *)(NativeAligned2FromLAddr(((OneDArray *)lf_naddress)->base)); \
   }
 
 #ifndef min
@@ -192,7 +196,7 @@ extern	DLword	*Lisp_world;	/* To access LispSysout area */
 
 #define	LispNumToCInt(Lisp)					\
 	( (((Lisp) & SEGMASK) == S_POSITIVE) ?                  \
-          ((Lisp) & 0xFFFF) : (*((int *)(Addr68k_from_LADDR(Lisp)))) )
+          ((Lisp) & 0xFFFF) : (*((int *)(NativeAligned4FromLAddr(Lisp)))) )
 
 #define	UPLOWDIFF	0x20
 

inc/loopsopsdefs.h

@@ -1,12 +1,12 @@
 #ifndef LOOPSOPSDEFS_H
 #define LOOPSOPSDEFS_H 1
 #include "lispemul.h" /* for LispPTR */
-LispPTR lcfuncall(register unsigned int atom_index, register int argnum, register int bytenum);
+LispPTR lcfuncall(unsigned int atom_index, int argnum, int bytenum);
 LispPTR LCinit(void);
-LispPTR LCFetchMethod(register LispPTR class, register LispPTR selector);
-LispPTR LCFetchMethodOrHelp(register LispPTR object, register LispPTR selector);
-LispPTR LCFindVarIndex(register LispPTR iv, register LispPTR object);
-LispPTR LCGetIVValue(register LispPTR object, register LispPTR iv);
-LispPTR LCPutIVValue(register LispPTR object, register LispPTR iv, register LispPTR val);
-LispPTR lcfuncall(register unsigned int atom_index, register int argnum, register int bytenum);
+LispPTR LCFetchMethod(LispPTR class, LispPTR selector);
+LispPTR LCFetchMethodOrHelp(LispPTR object, LispPTR selector);
+LispPTR LCFindVarIndex(LispPTR iv, LispPTR object);
+LispPTR LCGetIVValue(LispPTR object, LispPTR iv);
+LispPTR LCPutIVValue(LispPTR object, LispPTR iv, LispPTR val);
+LispPTR lcfuncall(unsigned int atom_index, int argnum, int bytenum);
 #endif

inc/lowlev1defs.h

@@ -1,8 +1,8 @@
 #ifndef LOWLEV1DEFS_H
 #define LOWLEV1DEFS_H 1
 #include "lispemul.h" /* for LispPTR */
-LispPTR N_OP_putbitsnfd(register LispPTR base, register LispPTR data, int word_offset, register int beta);
-LispPTR N_OP_getbitsnfd(int base_addr, register int word_offset, int beta);
-LispPTR N_OP_putbasen(register LispPTR base, register LispPTR tos, int n);
-LispPTR N_OP_putbaseptrn(register LispPTR base, register LispPTR tos, int n);
+LispPTR N_OP_putbitsnfd(LispPTR base, LispPTR data, int word_offset, int beta);
+LispPTR N_OP_getbitsnfd(int base_addr, int word_offset, int beta);
+LispPTR N_OP_putbasen(LispPTR base, LispPTR tos, int n);
+LispPTR N_OP_putbaseptrn(LispPTR base, LispPTR tos, int n);
 #endif

inc/lowlev2defs.h

@@ -1,7 +1,7 @@
 #ifndef LOWLEV2DEFS_H
 #define LOWLEV2DEFS_H 1
 #include "lispemul.h" /* for LispPTR */
-LispPTR N_OP_addbase(register int base, register int offset);
-LispPTR N_OP_getbasebyte(register LispPTR base_addr, register int byteoffset);
-LispPTR N_OP_putbasebyte(register LispPTR base_addr, register int byteoffset, register int tos);
+LispPTR N_OP_addbase(LispPTR base, LispPTR offset);
+LispPTR N_OP_getbasebyte(LispPTR base_addr, LispPTR byteoffset);
+LispPTR N_OP_putbasebyte(LispPTR base_addr, LispPTR byteoffset, LispPTR tos);
 #endif

inc/lsptypes.h

@@ -18,6 +18,7 @@
 */
 /**********************************************************************/
 #include "version.h" /* for BIGVM, BIGATOMS */
+#include <stdint.h> /* for int32_t */
 #include "lispemul.h" /* for LispPTR, DLword */
 
 /************************************************************************/
@@ -238,8 +239,8 @@ typedef struct oned_array {
 		unsigned int extendablep : 1;
 		unsigned int typenumber : 8 ;
 		DLword offset;
-		LispPTR fillpointer ;
-		LispPTR totalsize ; } OneDArray;
+		int32_t fillpointer ;
+		int32_t totalsize ; } OneDArray;
 
 typedef struct oned_array NEWSTRINGP;
 
@@ -256,10 +257,10 @@ typedef struct general_array {
 		unsigned int extendablep : 1;
 		unsigned int typenumber : 8 ;
 		unsigned int nil2:16;
-		LispPTR Dim0;
-		LispPTR totalsize;
-		LispPTR Dim1 ;
-		LispPTR Dim2 ; } LispArray;
+		int32_t Dim0;
+		int32_t totalsize;
+		int32_t Dim1 ;
+		int32_t Dim2 ; } LispArray;
 
 typedef struct compiled_closure {
 		unsigned int nil1	: 4 ;
@@ -434,8 +435,8 @@ typedef struct oned_array {
 		unsigned int bitp :1 ;
 		unsigned int indirectp : 1; /* as used arrayheader */
 		unsigned int readonlyp :1 ;
-		LispPTR fillpointer ;
-		LispPTR totalsize ; } OneDArray;
+		int32_t fillpointer ;
+		int32_t totalsize ; } OneDArray;
 
 
 typedef struct oned_array NEWSTRINGP;
@@ -453,10 +454,10 @@ typedef struct general_array {
 		unsigned int bitp :1 ;
 		unsigned int indirectp : 1; /* as used arrayheader */
 		unsigned int readonlyp :1 ;
-		LispPTR Dim0;
-		LispPTR totalsize;
-		LispPTR Dim1 ;
-		LispPTR Dim2 ; } LispArray;
+		int32_t Dim0;
+		int32_t totalsize;
+		int32_t Dim1 ;
+		int32_t Dim2 ; } LispArray;
 
 typedef struct compiled_closure {
 		unsigned int def_ptr	: 28; /* function */
@@ -630,6 +631,7 @@ typedef struct
 /* This MACRO is similar to LISTP */
 #define Listp(address)	(GetTypeNumber(address) == TYPE_LISTP)
 
+#define Numberp(address) (GetTypeEntry(address) & TT_NUMBERP)
 
 	/******************************************/
 	/*        Lisp's PATHNAME datatype        */

inc/lsthandldefs.h

@@ -1,7 +1,7 @@
 #ifndef LSTHANDLDEFS_H
 #define LSTHANDLDEFS_H 1
 #include "lispemul.h" /* for LispPTR */
-LispPTR N_OP_fmemb(register LispPTR item, register LispPTR tos);
-LispPTR fmemb(register LispPTR item, register LispPTR list);
-LispPTR N_OP_listget(register LispPTR plist, register LispPTR tos);
+LispPTR N_OP_fmemb(LispPTR item, LispPTR tos);
+LispPTR fmemb(LispPTR item, LispPTR list);
+LispPTR N_OP_listget(LispPTR plist, LispPTR tos);
 #endif

inc/mkatomdefs.h

@@ -3,7 +3,7 @@
 #include "lispemul.h" /* for LispPTR, DLword */
 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 compare_chars(const char *char1, const char *char2, DLword length);
+LispPTR compare_lisp_chars(const char *char1, const char *char2, DLword length, DLword fat1, DLword fat2);
 LispPTR make_atom(const char *char_base, DLword offset, DLword length);
 #endif

inc/mkcelldefs.h

@@ -1,6 +1,6 @@
 #ifndef MKCELLDEFS_H
 #define MKCELLDEFS_H 1
 #include "lispemul.h" /* for LispPTR, DLword */
-LispPTR N_OP_createcell(register LispPTR tos);
+LispPTR N_OP_createcell(LispPTR tos);
 DLword *createcell68k(unsigned int type);
 #endif

inc/mnxdefs.h

@@ -501,7 +501,7 @@ typedef union mnwevenT
 /* to a Medley window structure.                   */
 /* The result of the calculation is a C pointer.   */
 /***************************************************/
-#define Cptr(LADDR) Addr68k_from_LADDR(LADDR)
+#define Cptr(LADDR) NativeAligned4FromLAddr(LADDR)
 #define WIfFromMw(win) (((MedleyWindow)Cptr(win))->NativeIf)
 #define ScrnFromMw(win) ((MedleyScreenRec *)Cptr(((MedleyWindow)Cptr(win))->SCREEN))
 #define DspstreamFromMw(win) ((Stream *)Cptr(((MedleyWindow)Cptr(win))->DSP))

inc/mvsdefs.h

@@ -4,6 +4,6 @@
 #include "stack.h" /* for FX2 */
 LispPTR make_value_list(int argcount, LispPTR *argarray);
 void simulate_unbind(FX2 *frame, int unbind_count, FX2 *returner);
-LispPTR values(int arg_count, register LispPTR *args);
-LispPTR values_list(int arg_count, register LispPTR *args);
+LispPTR values(int arg_count, LispPTR *args);
+LispPTR values_list(int arg_count, LispPTR *args);
 #endif

inc/my.h

@@ -16,18 +16,15 @@
 /*	Manufactured in the United States of America.			*/
 /*									*/
 /************************************************************************/
-#include "adr68k.h" /* for Addr68k_from_LADDR */
-#include "lispemul.h" /* for LispPTR, DLword */
-#include "lispmap.h" /* for S_NEGATIVE, S_POSITIVE */
-#include "lsptypes.h" /* for GETWORD */
-
-#define S_CHARACTER 0x70000
-#ifdef BIGVM
-#define IsNumber(address)     ((GETWORD(MDStypetbl +(((address) & 0x0fffff00)>>9))) & 0x1000)
-#else
-#define IsNumber(address)     ((GETWORD(MDStypetbl +(((address) & 0x0ffff00)>>9))) & 0x1000)
-#endif
-
+#include "version.h"     // for BIGVM
+#include "adr68k.h"      // for NativeAligned2FromLAddr, NativeAligned4FromLAddr, LAddrFromNative
+#include "arith.h"       // for N_ARITH_SWITCH, N_GETNUMBER
+#include "gcdata.h"	 // for ADDREF, DELREF
+#include "lispemul.h"    // for ERROR_EXIT, LispPTR, DLword, SEGMASK, state
+#include "lispmap.h"     // for S_POSITIVE, S_CHARACTER, S_NEGATIVE
+#include "lspglob.h"
+#include "lsptypes.h"    // for GETBYTE, GETWORD, GetTypeNumber, TYPE_FLOATP
+#include "mkcelldefs.h"  // for createcell68k
 
 /************************************************************************/
 /*									*/
@@ -48,10 +45,10 @@
 	default:							\
 		switch (GetTypeNumber(arg)) {				\
 		  case TYPE_FLOATP: 					\
-		    (dest) = *((float *)Addr68k_from_LADDR(arg));	\
+		    (dest) = *((float *)NativeAligned4FromLAddr(arg));	\
 		    break; 						\
 		  case TYPE_FIXP: 					\
-		    (dest) = (float)(*((int *)Addr68k_from_LADDR(arg)));\
+		    (dest) = (float)(*((int *)NativeAligned4FromLAddr(arg))); \
 		    break;						\
 		  default: ERROR_EXIT(tos);				\
 		}							\
@@ -65,107 +62,118 @@
 		(dest) = (arg) & 0xFFFF;				\
 	else	{							\
 	if (GetTypeNumber(arg) != TYPE_FIXP) ERROR_EXIT(tos);		\
-	if (((dest) = *((int *)Addr68k_from_LADDR(arg))) & 0x80000000)	\
+	if (((dest) = *((int *)NativeAligned4FromLAddr(arg))) & 0x80000000)	\
 		ERROR_EXIT(tos);					\
 		}							\
 	}
 
 static inline LispPTR
 aref_switch(unsigned type, LispPTR tos, LispPTR baseL, int index)
-{								  
-  LispPTR result;
-  DLword *wordp;
+{
+  int result;
 
   switch (type)
     {
     case 38: /* pointer : 32 bits */
-      return(*(((LispPTR *)Addr68k_from_LADDR(baseL)) + index));		
-    case 20: /* signed : 16 bits */					
-      result = (GETWORD(((DLword *)Addr68k_from_LADDR(baseL)) + index)) & 0xFFFF;
+      return(*(((LispPTR *)NativeAligned4FromLAddr(baseL)) + index));
+
+    case 20: /* signed : 16 bits */
+      result = (GETWORD(((DLword *)NativeAligned2FromLAddr(baseL)) + index)) & 0xFFFF;
       if (result & 0x8000) return(result | S_NEGATIVE);
-      else return(result | S_POSITIVE);				
-    case 67: /* Character :  8 bits */				
-      return(S_CHARACTER | ((GETBYTE(((char *)Addr68k_from_LADDR(baseL)) + index)) & 0xFF));								
-    case 22: /* signed : 32 bits */					
-      result = *(((LispPTR *)Addr68k_from_LADDR(baseL)) + index);	
-      N_ARITH_SWITCH(result);					
-    case 0: /* unsigned : 1 bit per element */			
-      return(S_POSITIVE | (((GETBYTE(((char *)Addr68k_from_LADDR(baseL)) + (index >> 3))) >> (7 - (index & 7))) & 1));					
-    case 3: /* unsigned : 8 bits per element */			
-      return(S_POSITIVE | ((GETBYTE(((char *)Addr68k_from_LADDR(baseL)) + index)) & 0xFF));								
-    case 4: /* unsigned : 16 bits per element */			
-      return(S_POSITIVE | ((GETWORD(((DLword *)Addr68k_from_LADDR(baseL)) + index)) & 0xFFFF));								
-    case 54: /* Float : 32 bits */					
-      wordp = createcell68k(TYPE_FLOATP);				
-      *((LispPTR *)wordp) = *(((LispPTR *)Addr68k_from_LADDR(baseL)) + index);										
-      return(LADDR_from_68k(wordp));					
-    case 68: /* Character :  16 bits */				
-      return(S_CHARACTER | ((GETWORD(((DLword *)Addr68k_from_LADDR(baseL)) + index)) & 0xFFFF));								
-    case 86: /* XPointer : 32 bits */					
-      return(*(((LispPTR *)Addr68k_from_LADDR(baseL)) + index));		
-    default: /* Illegal or Unimplemented */				
-      ERROR_EXIT(tos);						
-    }/* end switch typenumber */					
+      else return(result | S_POSITIVE);
+
+    case 67: /* Character :  8 bits */
+      return(S_CHARACTER | ((GETBYTE(((char *)NativeAligned2FromLAddr(baseL)) + index)) & 0xFF));
+
+    case 22: /* signed : 32 bits */
+      result = *(((int *)NativeAligned4FromLAddr(baseL)) + index);
+      N_ARITH_SWITCH(result);
+
+    case 0: /* unsigned : 1 bit per element */
+      return(S_POSITIVE | (((GETBYTE(((char *)NativeAligned2FromLAddr(baseL)) + (index >> 3))) >> (7 - (index & 7))) & 1));
+
+    case 3: /* unsigned : 8 bits per element */
+      return(S_POSITIVE | ((GETBYTE(((char *)NativeAligned2FromLAddr(baseL)) + index)) & 0xFF));
+
+    case 4: /* unsigned : 16 bits per element */
+      return(S_POSITIVE | ((GETWORD(((DLword *)NativeAligned2FromLAddr(baseL)) + index)) & 0xFFFF));
+
+    case 54: /* Float : 32 bits */
+      {
+        float *cellp = (float *)createcell68k(TYPE_FLOATP);
+        *cellp = *(float *)(NativeAligned4FromLAddr(baseL) + index);
+        return (LAddrFromNative(cellp));
+      }
+
+    case 68: /* Character :  16 bits */
+      return(S_CHARACTER | ((GETWORD(((DLword *)NativeAligned2FromLAddr(baseL)) + index)) & 0xFFFF));
+
+    case 86: /* XPointer : 32 bits */
+      return(*(((LispPTR *)NativeAligned4FromLAddr(baseL)) + index));
+
+   default: /* Illegal or Unimplemented */
+      ERROR_EXIT(tos);
+    }/* end switch typenumber */
 }
 
 #define aset_switch(type, tos)						\
 {									\
    switch (type) {							\
       case 38: /* pointer : 32 bits */					\
-	GCLOOKUP(*(((int *)Addr68k_from_LADDR(base)) + index), DELREF); \
+	GCLOOKUP(*(((int *)NativeAligned4FromLAddr(base)) + index), DELREF); \
 	GCLOOKUP(data, ADDREF);						\
-        *(((int *)Addr68k_from_LADDR(base)) + index) = data;		\
+        *(((int *)NativeAligned4FromLAddr(base)) + index) = data;		\
         return(data);							\
       case 20: /* signed : 16 bits */					\
         new = data & 0xFFFF;						\
         if ((((data & SEGMASK) == S_POSITIVE) && ((data & 0x8000) == 0)) ||\
 	    (((data & SEGMASK) == S_NEGATIVE) && (data & 0x8000)))	\
-        GETWORD(((DLword *)Addr68k_from_LADDR(base)) + index) = new;		\
+        GETWORD(((DLword *)NativeAligned2FromLAddr(base)) + index) = new;		\
         else ERROR_EXIT(tos);						\
         return(data);							\
       case 67: /* Character :  8 bits */				\
         if ((data & SEGMASK) != S_CHARACTER) ERROR_EXIT(tos);	\
         new = data & 0xFFFF;						\
         if (new > 0xFF) ERROR_EXIT(tos);				\
-        GETBYTE(((char *)Addr68k_from_LADDR(base)) + index) = new;		\
+        GETBYTE(((char *)NativeAligned2FromLAddr(base)) + index) = new;		\
         return(data);							\
       case 22: /* signed : 32 bits */					\
         N_GETNUMBER(data, new, doufn);					\
-        *(((int *)Addr68k_from_LADDR(base)) + index) = new;		\
+        *(((int *)NativeAligned4FromLAddr(base)) + index) = new;		\
         return(data);							\
       case 0: /* unsigned : 1 bit per element */			\
         N_GetPos(data, new, tos);					\
         if (new > 1) ERROR_EXIT(tos);					\
         if (new) {							\
           new = (1 << (7 - (index & 7)));				\
-          GETBYTE(((char *)Addr68k_from_LADDR(base)) + (index >> 3)) |= new;	\
+          GETBYTE(((char *)NativeAligned2FromLAddr(base)) + (index >> 3)) |= new;	\
         }								\
         else {								\
           new = 0xFF - (1 << (7 - (index & 7)));			\
-          GETBYTE(((char *)Addr68k_from_LADDR(base)) + (index >> 3)) &= new;	\
+          GETBYTE(((char *)NativeAligned2FromLAddr(base)) + (index >> 3)) &= new;	\
         }								\
         return(data);							\
       case 3: /* unsigned : 8 bits per element */			\
         N_GetPos(data, new, tos);					\
         if (new > 0xFF) ERROR_EXIT(tos);				\
-        GETBYTE(((char *)Addr68k_from_LADDR(base)) + index) = new;		\
+        GETBYTE(((char *)NativeAligned2FromLAddr(base)) + index) = new;		\
         return(data);							\
       case 4: /* unsigned : 16 bits per element */			\
         N_GetPos(data, new, tos); 					\
         if (new > 0xFFFF) ERROR_EXIT(tos);				\
-        GETWORD(((DLword *)Addr68k_from_LADDR(base)) + index) = new;		\
+        GETWORD(((DLword *)NativeAligned2FromLAddr(base)) + index) = new;		\
         return(data);							\
       case 54: /* Float : 32 bits */					\
         if (GetTypeNumber(data) != TYPE_FLOATP) ERROR_EXIT(tos);	\
-        *(((int *)Addr68k_from_LADDR(base)) + index) = *((int *)Addr68k_from_LADDR(data));								\
+        *(((int *)NativeAligned4FromLAddr(base)) + index) = *((int *)NativeAligned4FromLAddr(data)); \
         return(data);							\
       case 68: /* Character :  16 bits */				\
         if ((data & SEGMASK) != S_CHARACTER) ERROR_EXIT(tos); 	\
         new = data & 0xFFFF;						\
-        GETWORD(((DLword *)Addr68k_from_LADDR(base)) + index) = new;		\
+        GETWORD(((DLword *)NativeAligned2FromLAddr(base)) + index) = new;		\
         return(data);							\
       case 86: /* XPointer : 32 bits */					\
-        *(((int *)Addr68k_from_LADDR(base)) + index) = data;		\
+        *(((int *)NativeAligned4FromLAddr(base)) + index) = data;		\
         return(data);							\
       default: /* Illegal or Unimplemented */				\
         ERROR_EXIT(tos);						\

inc/osmsg.h

@@ -15,6 +15,7 @@
 /*	Manufactured in the United States of America.			*/
 /*									*/
 /************************************************************************/
+#include "osmsgdefs.h"   // for flush_pty
 
 #define	OSMESSAGE_PRINT(print_exp)		\
   {						\

inc/return.h

@@ -37,10 +37,9 @@
 #define FastRetCALL							\
   do {									\
     /* Get IVar from Returnee's IVAR offset slot(BF) */ 			\
-    IVar = Addr68k_from_LADDR(STK_OFFSET | GETWORD((DLword *)CURRENTFX -1)); \
+    IVar = NativeAligned2FromLAddr(STK_OFFSET | GETWORD((DLword *)CURRENTFX -1)); \
     /* Get FuncObj from Returnee's FNHEAD slot in FX */ 			\
-    FuncObj = (struct fnhead *)						\
-		Addr68k_from_LADDR(FX_FNHEADER);	\
+    FuncObj = (struct fnhead *)NativeAligned4FromLAddr(FX_FNHEADER);	        \
     /* Get PC from Returnee's pc slot in FX */ 				\
     PC = (ByteCode *)FuncObj + CURRENTFX->pc ; 				\
   } while (0)
@@ -48,10 +47,9 @@
 #define FastRetCALL							\
   do {									\
     /* Get IVar from Returnee's IVAR offset slot(BF) */ 			\
-    IVar = Addr68k_from_LADDR(STK_OFFSET | GETWORD((DLword *)CURRENTFX -1)); \
+    IVar = NativeAligned2FromLAddr(STK_OFFSET | GETWORD((DLword *)CURRENTFX -1)); \
     /* Get FuncObj from Returnee's FNHEAD slot in FX */ 			\
-    FuncObj = (struct fnhead *)						\
-		Addr68k_from_LADDR(FX_FNHEADER);	\
+    FuncObj = (struct fnhead *)NativeAligned4FromLAddr(FX_FNHEADER);	        \
     /* Get PC from Returnee's pc slot in FX */ 				\
     PC = (ByteCode *)FuncObj + CURRENTFX->pc ; 				\
     if (!(FuncObj->byteswapped))					\
@@ -67,8 +65,8 @@
 /** in CONTEXTSW , for exchanging context **/
 
 #define Midpunt(fxnum) 							\
-  { register DLword midpunt; 					\
-    midpunt = LOLOC(LADDR_from_68k(CURRENTFX));			\
+  { DLword midpunt; 					\
+    midpunt = LOLOC(LAddrFromNative(CURRENTFX));			\
     PVar=(DLword *)							\
 	    Addr68k_from_StkOffset(					\
                         (GETWORD(((DLword *)InterfacePage) + (fxnum)))) \
@@ -80,7 +78,7 @@
 #define CHECKFX							\
   if (((UNSIGNED)PVar -(UNSIGNED)CURRENTFX) != 20)			\
     { printf("Invalid FX(0x%x) and PV(0x%x) \n",		\
-	     LADDR_from_68k(CURRENTFX),LADDR_from_68k(PVar));	\
+	     LAddrFromNative(CURRENTFX),LAddrFromNative(PVar));	\
     }
 
 
@@ -98,7 +96,7 @@
 
 
 #define AFTER_CONTEXTSW							\
-  { register DLword *ac_ptr68k,*ac_freeptr;					\
+  { DLword *ac_ptr68k,*ac_freeptr;					\
     ac_ptr68k = (DLword*)Addr68k_from_StkOffset(CURRENTFX->nextblock);	\
     if(GETWORD(ac_ptr68k) != STK_FSB_WORD) error("pre_moveframe: MP9316");	\
     CHECK_FX(CURRENTFX);						\

inc/returndefs.h

@@ -2,5 +2,5 @@
 #define RETURNDEFS_H 1
 #include "lispemul.h" /* for DLword */
 void OP_contextsw(void);
-void contextsw(register DLword fxnum, register DLword bytenum, register DLword flags);
+void contextsw(DLword fxnum, DLword bytenum, DLword flags);
 #endif

inc/rplconsdefs.h

@@ -1,5 +1,5 @@
 #ifndef RPLCONSDEFS_H
 #define RPLCONSDEFS_H 1
 #include "lispemul.h" /* for LispPTR */
-LispPTR N_OP_rplcons(register LispPTR list, register LispPTR item);
+LispPTR N_OP_rplcons(LispPTR list, LispPTR item);
 #endif

inc/shiftdefs.h

@@ -1,9 +1,9 @@
 #ifndef SHIFTDEFS_H
 #define SHIFTDEFS_H 1
 #include "lispemul.h" /* for LispPTR */
-LispPTR N_OP_llsh1(int a);
-LispPTR N_OP_llsh8(int a);
-LispPTR N_OP_lrsh1(int a);
-LispPTR N_OP_lrsh8(int a);
-LispPTR N_OP_lsh(int a, int b);
+LispPTR N_OP_llsh1(LispPTR a);
+LispPTR N_OP_llsh8(LispPTR a);
+LispPTR N_OP_lrsh1(LispPTR a);
+LispPTR N_OP_lrsh8(LispPTR a);
+LispPTR N_OP_lsh(LispPTR a, LispPTR b);
 #endif

inc/stack.h

@@ -8,8 +8,11 @@
 /*	Manufactured in the United States of America.			*/
 /*									*/
 /************************************************************************/
+#include "version.h"  /* for BIGVM, UNSIGNED */
+#include "adr68k.h"   /* for LAddrFromNative, NativeAligned4FromLAddr */
+#include "address.h"  /* for LOLOC */
+#include "commondefs.h" /* for error */
 #include "lispemul.h" /* for LispPTR, DLword, FRAMESIZE, DLWORDSPER_CELL */
-#include "version.h" /* for BIGVM, UNSIGNED */
 
 /* ContextSW frame number */
 #define CurrentFXP 0
@@ -294,7 +297,7 @@ typedef struct stackp {
 #define STKWORD(stkptr) ((StackWord *)WORDPTR(stkptr))
 
 #define FX_INVALIDP(fx68k) (((fx68k) == 0) || ((DLword *)(fx68k) == Stackspace))
-#define FX_size(fx68k) (((FX *)(fx68k))->nextblock - LOLOC(LADDR_from_68k(fx68k)))
+#define FX_size(fx68k) (((FX *)(fx68k))->nextblock - LOLOC(LAddrFromNative(fx68k)))
 #define FSBP(ptr68k) (((STKBLK *)(ptr68k))->flagword == STK_FSB_WORD)
 #define FSB_size(ptr68k) (((STKBLK *)(ptr68k))->size)
 /** Following suff assumes fx is 68kptr and val is LISP_LO_OFFSET **/
@@ -314,13 +317,13 @@ typedef struct stackp {
 #define SETALINK(fx, val)                                \
   {                                                      \
     if (FASTP(fx)) {                                     \
-      ((FX *)(fx))->blink = LADDR_from_68k(DUMMYBF(fx)); \
+      ((FX *)(fx))->blink = LAddrFromNative(DUMMYBF(fx)); \
       ((FX *)(fx))->clink = ((FX *)(fx))->alink;         \
     }                                                    \
     ((FX *)(fx))->alink = (val) + FRAMESIZE + 1;         \
   }
 
-#define GETBLINK(fx) (SLOWP(fx) ? ((FX *)(fx))->blink : LOLOC(LADDR_from_68k(DUMMYBF(fx))))
+#define GETBLINK(fx) (SLOWP(fx) ? ((FX *)(fx))->blink : LOLOC(LAddrFromNative(DUMMYBF(fx))))
 #define SETBLINK(fx, val)                        \
   {                                              \
     ((FX *)(fx))->blink = (val);                 \
@@ -336,14 +339,14 @@ typedef struct stackp {
   {                                                      \
     ((FX *)(fx))->clink = (val) + FRAMESIZE;             \
     if (FASTP((fx))) {                                   \
-      ((FX *)(fx))->blink = LADDR_from_68k(DUMMYBF(fx)); \
+      ((FX *)(fx))->blink = LAddrFromNative(DUMMYBF(fx)); \
       SLOWP(fx) = 1;                                     \
     }                                                    \
   }
 
 #define SETACLINK(fx, val)                                                \
   {                                                                       \
-    if (FASTP(fx)) { ((FX *)(fx))->blink = LADDR_from_68k(DUMMYBF(fx)); } \
+    if (FASTP(fx)) { ((FX *)(fx))->blink = LAddrFromNative(DUMMYBF(fx)); } \
     ((FX *)(fx))->clink = (val) + FRAMESIZE;                              \
     ((FX *)(fx))->alink = ((FX *)(fx))->clink + 1;                        \
   }
@@ -355,7 +358,7 @@ typedef struct stackp {
 #endif /* BIGVM */
 
 #define GETNAMETABLE(fx)                                                                          \
-  ((struct fnhead *)Addr68k_from_LADDR(                                                           \
+  ((struct fnhead *)NativeAligned4FromLAddr(                                                      \
       SWAP_FNHEAD(                                                                                \
         ((((FX2 *)(fx))->validnametable) ? ((FX2 *)(fx))->nametable : ((FX2 *)(fx))->fnheader)) & \
       POINTERMASK))
@@ -383,6 +386,7 @@ typedef struct stackp {
 #ifdef STACKCHECK
 
 #include <stdio.h>
+#include "testtooldefs.h"
 
 #define S_CHECK(condition, msg)                          \
   {                                                      \

inc/storagedefs.h

@@ -1,7 +1,7 @@
 #ifndef STORAGEDEFS_H
 #define STORAGEDEFS_H 1
 #include "lispemul.h" /* for LispPTR */
-void checkfor_storagefull(register unsigned int npages);
+void checkfor_storagefull(unsigned int npages);
 LispPTR newpage(LispPTR base);
 void init_storage(void);
 #endif

inc/timeout.h

@@ -8,14 +8,15 @@
 /*	Manufactured in the United States of America.			*/
 /*									*/
 /************************************************************************/
-#include "setjmp.h" /* for jmp_buf */
+#include <setjmp.h> /* for jmp_buf */
+#include <unistd.h> /* for alarm */
 
 extern jmp_buf jmpbuf;
 
 /*** TIMEOUT_TIME is changeable by UNIX env var LDEFILETIMEOUT. 
 #define	TIMEOUT_TIME	10 **/
 
-extern	int	TIMEOUT_TIME;
+extern	unsigned int TIMEOUT_TIME;
 
 #define	SETJMP(x)	\
   {				\

inc/tosfns.h

@@ -183,9 +183,9 @@
 
 #define OPFN(argcount, num_args_fn, fn_xna_args, fn_native)                            \
   do { /* argcount is a number of the arguments on stack */                               \
-    register struct fnhead *LOCFNCELL;                                                 \
-    register int defcell_word;                                                         \
-    register int NEXTBLOCK;                                                            \
+    struct fnhead *LOCFNCELL;                                                 \
+    int defcell_word;                                                         \
+    int NEXTBLOCK;                                                            \
     FNTRACER(Trace_FNCall(argcount, Get_AtomNo_PCMAC1, TOPOFSTACK, CSTKPTR - 1));      \
     FNCHECKER(if (quick_stack_check())                                                 \
                   Trace_FNCall(argcount, Get_AtomNo_PCMAC1, TOPOFSTACK, CSTKPTR - 1)); \
@@ -198,17 +198,17 @@
       fn_apply = 0;                                                                    \
       goto op_fn_common;                                                               \
     }                                                                                  \
-    LOCFNCELL = (struct fnhead *)Addr68k_from_LADDR((defcell_word &= POINTERMASK));    \
+    LOCFNCELL = (struct fnhead *)NativeAligned4FromLAddr((defcell_word &= POINTERMASK));    \
     BCE_CURRENTFX->pc = ((UNSIGNED)PCMAC - (UNSIGNED)FuncObj) + FN_OPCODE_SIZE;        \
     FN_STACK_CHECK;                                                                    \
     {                                                                                  \
-      register UNSIGNED newivar;                                                       \
+      UNSIGNED newivar;                                                       \
       newivar = (UNSIGNED)(IVARL = (DLword *)(CSTKPTR - (argcount) + 1));              \
       BCE_CURRENTFX->nextblock = NEXTBLOCK = StkOffset_from_68K(newivar);              \
     }                                                                                  \
     HARD_PUSH(TOPOFSTACK); /* save TOS */                                              \
     if (LOCFNCELL->na >= 0) {                                                          \
-      register int RESTARGS;                                                           \
+      int RESTARGS;                                                           \
       RESTARGS = (argcount) - LOCFNCELL->na;                                           \
       while (RESTARGS < 0) {                                                           \
         HARD_PUSH(NIL_PTR);                                                            \
@@ -238,9 +238,9 @@
 /*************** OPFNX *************/
 #define OPFNX                                                                          \
   do {                                                                                    \
-    register struct fnhead *LOCFNCELL;                                                 \
-    register DefCell *defcell; /* this reg is not allocated */                         \
-    register int NEXTBLOCK;                                                            \
+    struct fnhead *LOCFNCELL;                                                 \
+    DefCell *defcell; /* this reg is not allocated */                         \
+    int NEXTBLOCK;                                                            \
     int num_args = Get_BYTE_PCMAC1;                                                    \
     defcell = (DefCell *)GetDEFCELL68k(Get_AtomNo_PCMAC2);                             \
     FNTRACER(Trace_FNCall(num_args, Get_AtomNo_PCMAC2, TOPOFSTACK, CSTKPTR - 1));      \
@@ -254,17 +254,17 @@
       fn_apply = 0;                                                                    \
       goto op_fn_common;                                                               \
     }                                                                                  \
-    LOCFNCELL = (struct fnhead *)Addr68k_from_LADDR(defcell->defpointer);              \
+    LOCFNCELL = (struct fnhead *)NativeAligned4FromLAddr(defcell->defpointer);              \
     BCE_CURRENTFX->pc = ((UNSIGNED)PCMAC - (UNSIGNED)FuncObj) + FNX_OPCODE_SIZE;       \
     FN_STACK_CHECK;                                                                    \
     {                                                                                  \
-      register UNSIGNED newivar;                                                       \
+      UNSIGNED newivar;                                                       \
       newivar = (UNSIGNED)(IVARL = (DLword *)(CSTKPTR - num_args + 1));                \
       BCE_CURRENTFX->nextblock = NEXTBLOCK = StkOffset_from_68K(newivar);              \
     }                                                                                  \
     HARD_PUSH(TOPOFSTACK); /* save TOS */                                              \
     if (LOCFNCELL->na >= 0) {                                                          \
-      register int RESTARGS;                                                           \
+      int RESTARGS;                                                           \
       RESTARGS = num_args - LOCFNCELL->na;                                             \
       while (RESTARGS < 0) {                                                           \
         HARD_PUSH(NIL_PTR);                                                            \
@@ -296,7 +296,7 @@
 #ifdef BIGATOMS
 #define OPCHECKAPPLY                                                                        \
   do {                                                                                         \
-    register DefCell *defcell;                                                              \
+    DefCell *defcell;                                                              \
     defcell = (DefCell *)GetDEFCELL68k(TOPOFSTACK & POINTERMASK);                           \
     if (!(defcell->ccodep &&                                                                \
           (((TOPOFSTACK & SEGMASK) == 0) || (GetTypeNumber(TOPOFSTACK) == TYPE_NEWATOM)) && \
@@ -306,7 +306,7 @@
 #else
 #define OPCHECKAPPLY                                              \
   do {                                                               \
-    register DefCell *defcell;                                    \
+    DefCell *defcell;                                    \
     defcell = (DefCell *)GetDEFCELL68k(TOPOFSTACK & POINTERMASK); \
     if (!(defcell->ccodep && ((TOPOFSTACK & SEGMASK) == 0)) &&    \
         ((defcell->argtype == 0) || (defcell->argtype == 2)))     \
@@ -322,7 +322,7 @@
 #define UFN_COMMON                                        \
   op_ufn:                                                 \
   use code in XC.c {                                      \
-    register UFN *entry68k;                               \
+    UFN *entry68k;                               \
     entry68k = (UFN *)GetUFNEntry(Get_BYTE_PCMAC0);       \
     fn_num_args = entry68k->arg_num;                      \
     fn_opcode_size = entry68k->byte_num + 1;              \
@@ -346,16 +346,16 @@
 #define needpush NEXTBLOCK
 #define OP_FN_COMMON                                                                           \
   op_fn_common : {                                                                             \
-    register struct fnhead *LOCFNCELL;                                                         \
-    register DefCell *defcell; /* this reg is not allocated */                                 \
+    struct fnhead *LOCFNCELL;                                                         \
+    DefCell *defcell; /* this reg is not allocated */                                 \
     CClosure *closure;                                                                         \
     LispPTR closure_env = (LispPTR)0xffffffff;                                                 \
     {                                                                                          \
-      register int NEXTBLOCK = NIL;                                                            \
+      int NEXTBLOCK = NIL;                                                            \
       defcell = fn_defcell;                                                                    \
       if (defcell->ccodep == 0) {                                                              \
         if (GetTypeNumber(defcell->defpointer) == TYPE_COMPILED_CLOSURE) { /* setup closure */ \
-          closure = (CClosure *)Addr68k_from_LADDR(defcell->defpointer);                       \
+          closure = (CClosure *)NativeAligned4FromLAddr(defcell->defpointer);                       \
           defcell = (DefCell *)closure;                                                        \
           /* not  a closure if closure's env is NIL */                                         \
           if (closure->env_ptr) { closure_env = (LispPTR)(closure->env_ptr); }                 \
@@ -366,19 +366,19 @@
           needpush = 1;                                                                        \
         } /*else end */                                                                        \
       }                                                                                        \
-      LOCFNCELL = (struct fnhead *)Addr68k_from_LADDR(defcell->defpointer);                    \
+      LOCFNCELL = (struct fnhead *)NativeAligned4FromLAddr(defcell->defpointer);                    \
       BCE_CURRENTFX->pc = ((UNSIGNED)PCMAC - (UNSIGNED)FuncObj) + fn_opcode_size;              \
-      FNTPRINT(("Saving PC = 0%o (0x%x).\n", BCE_CURRENTFX->pc, PCMAC + fn_opcode_size));      \
+      FNTPRINT(("Saving PC = 0%o (%p).\n", BCE_CURRENTFX->pc, (void *)PCMAC + fn_opcode_size)); \
       FN_STACK_CHECK;                                                                          \
       APPLY_POP_PUSH_TEST;                                                                     \
       {                                                                                        \
-        register UNSIGNED newivar;                                                             \
+        UNSIGNED newivar;                                                             \
         newivar = (UNSIGNED)(IVARL = (DLword *)(CSTKPTR + (1 - fn_num_args - needpush)));      \
         BCE_CURRENTFX->nextblock = NEXTBLOCK = StkOffset_from_68K(newivar);                    \
       }                                                                                        \
       HARD_PUSH(TOPOFSTACK); /* save TOS */                                                    \
       if (LOCFNCELL->na >= 0) {                                                                \
-        register int RESTARGS;                                                                 \
+        int RESTARGS;                                                                 \
         RESTARGS = fn_num_args - LOCFNCELL->na;                                                \
         while (RESTARGS < 0) {                                                                 \
           HARD_PUSH(NIL_PTR);                                                                  \
@@ -394,8 +394,8 @@
     CSTKPTRL = (LispPTR *)(((DLword *)CSTKPTR) + FRAMESIZE);                                   \
     PVARL = (DLword *)CSTKPTR;                                                                 \
     {                                                                                          \
-      register int result;                                                                     \
-      register LispPTR unboundval;                                                             \
+      int result;                                                                     \
+      LispPTR unboundval;                                                             \
       unboundval = (LispPTR)0xffffffff;                                                        \
       result = LOCFNCELL->pv;                                                                  \
       HARD_PUSH(closure_env);                                                                  \
@@ -428,12 +428,12 @@
 
 #define OP_ENVCALL                                                        \
   do {                                                                    \
-    register struct fnhead *LOCFNCELL;                                    \
-    register int NEXTBLOCK;                                               \
-    register LispPTR closure_env = TOPOFSTACK;                            \
-    register int num_args;                                                \
-    register LispPTR Fn_DefCell = GET_TOS_1;                              \
-    LOCFNCELL = (struct fnhead *)Addr68k_from_LADDR(Fn_DefCell);          \
+    struct fnhead *LOCFNCELL;                                    \
+    int NEXTBLOCK;                                               \
+    LispPTR closure_env = TOPOFSTACK;                            \
+    int num_args;                                                \
+    LispPTR Fn_DefCell = GET_TOS_1;                              \
+    LOCFNCELL = (struct fnhead *)NativeAligned4FromLAddr(Fn_DefCell);          \
     FNTPRINT(("ENVCall.\n"));                                             \
     FNCHECKER(if (quick_stack_check()) printf("In ENVCALL.\n"));          \
     N_GETNUMBER(GET_TOS_2, num_args, op_ufn);                             \
@@ -441,12 +441,12 @@
     FN_STACK_CHECK;                                                       \
     CSTKPTRL -= 2;                                                        \
     {                                                                     \
-      register UNSIGNED newivar;                                          \
+      UNSIGNED newivar;                                          \
       newivar = (UNSIGNED)(IVARL = (DLword *)(CSTKPTR - num_args));       \
       BCE_CURRENTFX->nextblock = NEXTBLOCK = StkOffset_from_68K(newivar); \
     }                                                                     \
     if (LOCFNCELL->na >= 0) {                                             \
-      register int RESTARGS;                                              \
+      int RESTARGS;                                              \
       RESTARGS = num_args - LOCFNCELL->na;                                \
       while (RESTARGS < 0) {                                              \
         HARD_PUSH(NIL_PTR);                                               \
@@ -461,10 +461,10 @@
     CSTKPTRL = (LispPTR *)(((DLword *)CSTKPTR) + FRAMESIZE);              \
     PVARL = (DLword *)CSTKPTR;                                            \
     {                                                                     \
-      register int result;                                                \
+      int result;                                                \
       result = LOCFNCELL->pv;                                             \
       if (result >= 0) {                                                  \
-        register LispPTR unboundval;                                      \
+        LispPTR unboundval;                                      \
         unboundval = (LispPTR)0xffffffff;                                 \
         if (closure_env == NIL_PTR)                                       \
           HARD_PUSH(unboundval);                                          \
@@ -524,7 +524,7 @@
         goto Hack_Label;                                                       \
       nnewframe(CURRENTFX, scratch, TOPOFSTACK & 0xffff);                      \
       work = POINTERMASK & ((GETBASEWORD(scratch,1) << 16) | GETBASEWORD(scratch,0)); \
-      lookuped = *((LispPTR *)(Addr68k_from_LADDR(work)));                     \
+      lookuped = *((LispPTR *)(NativeAligned4FromLAddr(work)));                     \
       if (lookuped == NOBIND_PTR)                                              \
         goto op_ufn;                                                           \
       TOPOFSTACK = lookuped;                                                   \
@@ -564,7 +564,7 @@
         goto Hack_Label;                                                       \
       nnewframe(CURRENTFX, scratch, TOPOFSTACK & 0xffff);                      \
       work = POINTERMASK & ((GETBASEWORD(scratch,1) << 16) | GETBASEWORD(scratch,0)); \
-      lookuped = *((LispPTR *)(Addr68k_from_LADDR(work)));                     \
+      lookuped = *((LispPTR *)(NativeAligned4FromLAddr(work)));                     \
       if (lookuped == NOBIND_PTR)                                              \
         goto op_ufn;                                                           \
       TOPOFSTACK = lookuped;                                                   \
@@ -588,7 +588,7 @@
       case TYPE_NEWATOM:                                                       \
         nnewframe(CURRENTFX, scratch, TOPOFSTACK);                             \
         work = POINTERMASK & ((GETBASEWORD(scratch,1) << 16) | GETBASEWORD(scratch,0)); \
-        lookuped = *((LispPTR *)(Addr68k_from_LADDR(work)));                   \
+        lookuped = *((LispPTR *)(NativeAligned4FromLAddr(work)));                   \
         if (lookuped == NOBIND_PTR)                                            \
           goto op_ufn;                                                         \
         TOPOFSTACK = lookuped;                                                 \

inc/tosret.h

@@ -12,6 +12,7 @@
 /*									*/
 /************************************************************************/
 
+#include "kprintdefs.h" // for prindatum
 
 /************************************************************************/
 /*									*/
@@ -22,8 +23,8 @@
 /************************************************************************/
 
 #define OPRETURN	{						\
- register struct frameex2 *returnFX ;					\
- register int alink;							\
+ struct frameex2 *returnFX ;					\
+ int alink;							\
  FNCHECKER(struct frameex2 *old_bce_fx = (struct frameex2 *) BCE_CURRENTFX); \
  alink = ((struct frameex2 *) BCE_CURRENTFX)->alink;			\
  FNTPRINT(("RETURN = 0x%x,  ", TOPOFSTACK));						\
@@ -38,14 +39,14 @@
  CSTKPTRL = (LispPTR *) IVAR;						\
  returnFX = (struct  frameex2 *)					\
 	((DLword *)							\
-	    (PVARL = (DLword *) Addr68k_from_StkOffset(alink))		\
+	    (PVARL = (DLword *) NativeAligned2FromStackOffset(alink))	\
 	    - FRAMESIZE);						\
  IVARL = (DLword *)							\
-	    Addr68k_from_StkOffset(GETWORD((DLword *)returnFX -1));	\
+	    NativeAligned2FromStackOffset(GETWORD((DLword *)returnFX -1));\
 	/* Get PC from Returnee's pc slot in FX */			\
  PCMACL = returnFX->pc  + (ByteCode *)					\
 	(FuncObj = (struct fnhead *)					\
-	Addr68k_from_LADDR(SWAP_FNHEAD(returnFX->fnheader) & POINTERMASK)) + 1;\
+	NativeAligned4FromLAddr(SWAP_FNHEAD(returnFX->fnheader) & POINTERMASK)) + 1;\
  Irq_Stk_Check = STK_END_COMPUTE(EndSTKP,FuncObj);			\
   FNCHECKER(if (quick_stack_check()) printf("In RETURN.\n"));	\
  if (((UNSIGNED)(CSTKPTR) >= Irq_Stk_Check) || (Irq_Stk_End <= 0))		\

inc/typeofdefs.h

@@ -1,6 +1,6 @@
 #ifndef TYPEOFDEFS_H
 #define TYPEOFDEFS_H 1
 #include "lispemul.h" /* for LispPTR */
-LispPTR N_OP_dtest(register LispPTR tos, register int atom_index);
-LispPTR N_OP_instancep(register LispPTR tos, register int atom_index);
+LispPTR N_OP_dtest(LispPTR tos, int atom_index);
+LispPTR N_OP_instancep(LispPTR tos, int atom_index);
 #endif

inc/unixcommdefs.h

@@ -1,7 +1,7 @@
 #ifndef UNIXCOMMDEFS_H
 #define UNIXCOMMDEFS_H 1
 #include "lispemul.h" /* for LispPTR */
-int find_process_slot(register int pid);
+int find_process_slot(int pid);
 void wait_for_comm_processes(void);
 char *build_socket_pathname(int desc);
 void close_unix_descriptors(void);

inc/unwinddefs.h

@@ -1,5 +1,5 @@
 #ifndef UNWINDDEFS_H
 #define UNWINDDEFS_H 1
 #include "lispemul.h" /* for LispPTR */
-LispPTR *N_OP_unwind(register LispPTR *cstkptr, register LispPTR tos, int n, int keep);
+LispPTR *N_OP_unwind(LispPTR *cstkptr, LispPTR tos, int n, int keep);
 #endif

inc/uraidextdefs.h

@@ -0,0 +1,23 @@
+#ifndef URAIDEXTDEFS_H
+#define URAIDEXTDEFS_H 1
+
+#include "stack.h" /* for FX */
+#include "lispemul.h" /* for LispPTR */
+
+#define URMAXFXNUM 2000
+#define URMAXCOMM 512
+#define URSCAN_ALINK 0
+#define URSCAN_CLINK 1
+
+extern FX *URaid_FXarray[URMAXFXNUM];
+extern char URaid_arg1[URMAXCOMM / 2];
+extern char URaid_arg2[URMAXCOMM / 2];
+extern char URaid_comm;
+extern char URaid_inputstring[URMAXCOMM];
+extern const char *URaid_errmess;
+extern int URaid_ArrMAXIndex;
+extern int URaid_argnum;
+extern int URaid_currentFX;
+extern int URaid_scanlink;
+extern LispPTR Uraid_mess;
+#endif

inc/uutilsdefs.h

@@ -1,9 +1,6 @@
 #ifndef UUTILSDEFS_H
 #define UUTILSDEFS_H 1
-#include <stddef.h> /* for size_t */
 #include "lispemul.h" /* for LispPTR */
-int lisp_string_to_c_string(LispPTR Lisp, char *C, size_t length);
-int c_string_to_lisp_string(char *C, LispPTR Lisp);
 LispPTR check_unix_password(LispPTR *args);
 LispPTR unix_username(LispPTR *args);
 LispPTR unix_getparm(LispPTR *args);

inc/vars3defs.h

@@ -3,6 +3,6 @@
 #include "cell.h" /* for cadr_cell */
 #include "lispemul.h" /* for LispPTR */
 struct cadr_cell cadr(LispPTR cell_adr);
-LispPTR N_OP_arg0(register LispPTR tos);
-LispPTR N_OP_assoc(register LispPTR key, register LispPTR list);
+LispPTR N_OP_arg0(LispPTR tos);
+LispPTR N_OP_assoc(LispPTR key, LispPTR list);
 #endif

inc/version.h

@@ -11,7 +11,8 @@
 /*									*/
 /************************************************************************/
 
-#include "maiko/platform.h"
+#include <stdint.h>
+#include "maiko/platform.h" // IWYU pragma: export
 
 /************************************************************************/
 /*									*/
@@ -187,8 +188,8 @@ error Must specify RELEASE to build Medley.
 
 	/* Set up defaults */
 #define UNALIGNED_FETCH_OK
-typedef unsigned long UNSIGNED;
-typedef long INT;
+typedef uintptr_t UNSIGNED;
+typedef intptr_t INT;
 
 
 

inc/xbitmaps.h

@@ -25,7 +25,7 @@ typedef struct {
 	short cudata;		/* ?? */
 } LISP_CURSOR;
 
-const uint8_t defaultcursor_bitmap[]=
+static const uint8_t defaultcursor_bitmap[]=
   {
 	  0x80, 0, 0xc0, 0, 0xe0, 0, 0xf0, 0
 	, 0xf8, 0, 0xfc, 0, 0xfe, 0, 0xf0, 0
@@ -44,7 +44,7 @@ LISP_CURSOR default_cursor =
   };
 
 
-const uint8_t  waitcursor_bitmap[]=
+static const uint8_t  waitcursor_bitmap[]=
   {
 	  0xFF, 0xFE, 0xC0, 0x06, 0x60, 0x1C, 0x3D, 0x78
 	, 0x1F, 0xF0, 0x0F, 0xE0, 0x06, 0xC0, 0x03, 0x80
@@ -62,7 +62,7 @@ LISP_CURSOR wait_cursor =
    , 0
   };
 	
-const uint8_t horizscrollcursor_bitmap[]={
+static const uint8_t horizscrollcursor_bitmap[]={
 	  0x00, 0x00
 	, 0x00, 0x00
 	, 0x00, 0x00
@@ -92,7 +92,7 @@ LISP_CURSOR horizscroll_cursor = {
 	
 
 
-const uint8_t horizthumbcursor_bitmap[]={
+static const uint8_t horizthumbcursor_bitmap[]={
 	  0x00, 0x00
 	, 0x00, 0x00
 	, 0x00, 0x00
@@ -122,7 +122,7 @@ LISP_CURSOR horizthumb_cursor = {
 	
 
 
-const uint8_t scrolldowncursor_bitmap[]={
+static const uint8_t scrolldowncursor_bitmap[]={
 		  0x03, 0x80
 		, 0x03, 0x80
 		, 0x03, 0x80
@@ -152,7 +152,7 @@ LISP_CURSOR scrolldown_cursor = {
 	
 
 
-const uint8_t scrollleftcursor_bitmap[]={
+static const uint8_t scrollleftcursor_bitmap[]={
 	  0x00, 0x00
 	, 0x00, 0x00
 	, 0x00, 0x00
@@ -182,7 +182,7 @@ LISP_CURSOR scrollleft_cursor = {
 	
 
 
-const uint8_t scrollrightcursor_bitmap[]={
+static const uint8_t scrollrightcursor_bitmap[]={
 	  0x00, 0x00
 	, 0x00, 0x00
 	, 0x00, 0x00
@@ -212,7 +212,7 @@ LISP_CURSOR scrollright_cursor = {
 	
 
 
-const uint8_t scrollupcursor_bitmap[]={
+static const uint8_t scrollupcursor_bitmap[]={
 		  0x01, 0x00
 		, 0x03, 0x80
 		, 0x03, 0x80
@@ -242,7 +242,7 @@ LISP_CURSOR scrollup_cursor = {
 	
 
 
-const uint8_t vertscrollcursor_bitmap[]={
+static const uint8_t vertscrollcursor_bitmap[]={
 		  0x01, 0x00
 		, 0x03, 0x80
 		, 0x03, 0x80
@@ -272,7 +272,7 @@ LISP_CURSOR vertscroll_cursor = {
 	
 
 
-const uint8_t vertthumbcursor_bitmap[]={
+static const uint8_t vertthumbcursor_bitmap[]={
 		 0x00,0x00
 		,0x00,0x1f
 		,0x00,0x00

inc/xcursordefs.h

@@ -1,7 +1,6 @@
 #ifndef XCURSORDEFS_H
 #define XCURSORDEFS_H 1
 #include <X11/X.h>     /* for Cursor, Window */
-#include <X11/Xlib.h>  /* for Display */
 #include <stdint.h>    /* for uint8_t */
 #include "devif.h"     /* for DspInterface */
 void Init_XCursor(void);

inc/xinitdefs.h

@@ -1,6 +1,7 @@
 #ifndef XINITDEFS_H
 #define XINITDEFS_H 1
 #include "devif.h" /* for DspInterface */
+#include "lispemul.h" /* for LispPTR */
 void init_Xevent(DspInterface dsp);
 void lisp_Xexit(DspInterface dsp);
 void Xevent_before_raid(DspInterface dsp);

inc/z2defs.h

@@ -2,6 +2,6 @@
 #define Z2DEFS_H 1
 #include "lispemul.h" /* for LispPTR */
 LispPTR N_OP_classoc(LispPTR key, LispPTR list);
-LispPTR N_OP_clfmemb(register LispPTR item, register LispPTR list);
-LispPTR N_OP_restlist(register LispPTR tail, register int last, register int skip);
+LispPTR N_OP_clfmemb(LispPTR item, LispPTR list);
+LispPTR N_OP_restlist(LispPTR tail, int last, int skip);
 #endif

src/allocmds.c

@@ -25,21 +25,15 @@
 */
 /**********************************************************************/
 
-#include "lispemul.h"
-#include "address.h"
-#include "adr68k.h"
-#include "lsptypes.h"
-#include "cell.h"
-#include "lispmap.h"
-#include "initatms.h"
-#include "lspglob.h"
-
-#include "allocmdsdefs.h"
-#include "commondefs.h"
-#include "gcrdefs.h"
-#include "perrnodefs.h"
-#include "storagedefs.h"
-#include "timerdefs.h"
+#include "address.h"       // for LOLOC                                                                                                                                     
+#include "adr68k.h"        // for LAddrFromNative, LPageFromNative, Addr68k_fr...                                                                                             
+#include "allocmdsdefs.h"  // for alloc_mdspage, initmdspage                                                                                                                
+#include "commondefs.h"    // for error                                                                                                                                     
+#include "lispemul.h"      // for DLword, LispPTR, DLWORDSPER_PAGE, MDSINCRE...                                                                                             
+#include "lispmap.h"       // for S_POSITIVE                                                                                                                                
+#include "lspglob.h"       // for MDStypetbl                                                                                                                                
+#include "lsptypes.h"      // for GETWORD, GetTypeNumber, TYPE_SMALLP                                                                                                       
+#include "storagedefs.h"   // for newpage, checkfor_storagefull                                                                                                             
 
 /************************************************************************/
 /*									*/
@@ -68,7 +62,7 @@ static inline void Make_MDSentry(UNSIGNED page, DLword pattern) {
 */
 /**********************************************************************/
 
-LispPTR initmdspage(register LispPTR *base, register DLword size, register LispPTR prev)
+LispPTR initmdspage(LispPTR *base, DLword size, LispPTR prev)
 /* MDS page base */
 /* object cell size you need (WORD) */
 /* keeping top of previous MDS cell */
@@ -76,11 +70,11 @@ LispPTR initmdspage(register LispPTR *base, register DLword size, register LispP
 {
   extern DLword *MDStypetbl;
 
-  register int remain_size; /* (IREMAINDER WORDSPERPAGE SIZE) */
-  register short num_pages;
-  register int limit;
+  int remain_size; /* (IREMAINDER WORDSPERPAGE SIZE) */
+  short num_pages;
+  int limit;
   int used; /* used space in MDS page */
-  register int i;
+  int i;
 
 #ifdef TRACE2
   printf("TRACE: initmdspage()\n");
@@ -100,7 +94,7 @@ LispPTR initmdspage(register LispPTR *base, register DLword size, register LispP
     used = 0;
     while ((used += size) <= limit) {
       *base = prev;                /* write prev MDS address to the top of MDS page */
-      prev = LADDR_from_68k(base); /* exchanging pointers */
+      prev = LAddrFromNative(base); /* exchanging pointers */
       base = (LispPTR *)((DLword *)base + size);
     } /* while end */
 
@@ -127,20 +121,20 @@ LispPTR initmdspage(register LispPTR *base, register DLword size, register LispP
 */
 /**********************************************************************/
 
-LispPTR *alloc_mdspage(register short int type) {
+LispPTR *alloc_mdspage(short int type) {
   extern LispPTR *MDS_free_page_word; /* Free MDS page number */
 
   extern DLword *Next_MDSpage; /* next vacant(new) MDS page */
   extern LispPTR *Next_MDSpage_word;
   extern LispPTR *Next_Array_word;
 
-  register LispPTR *ptr; /* points Top 32 bit of the MDS page */
+  LispPTR *ptr; /* points Top 32 bit of the MDS page */
   LispPTR next_page;
 
-  /* Next_Array=(DLword *)Addr68k_from_LADDR(((*Next_Array_word)& 0xffff ) << 8); */
+  /* Next_Array=(DLword *)NativeAligned2FromLAddr(((*Next_Array_word)& 0xffff ) << 8); */
 
   if (LOLOC(*MDS_free_page_word) != NIL) {
-    ptr = (LispPTR *)Addr68k_from_LPAGE(LOLOC(*MDS_free_page_word));
+    ptr = (LispPTR *)NativeAligned4FromLPage(LOLOC(*MDS_free_page_word));
 
     if (((next_page = LOLOC(*ptr)) != 0) && (GetTypeNumber((*ptr)) != TYPE_SMALLP))
       error("alloc_mdspage: Bad Free Page Link");
@@ -151,20 +145,20 @@ LispPTR *alloc_mdspage(register short int type) {
     /* I guess Next_MDSpage is redundant */
     checkfor_storagefull(NIL);
 #ifdef BIGVM
-    Next_MDSpage = (DLword *)Addr68k_from_LADDR(((*Next_MDSpage_word)) << 8);
+    Next_MDSpage = (DLword *)NativeAligned2FromLAddr(((*Next_MDSpage_word)) << 8);
 #else
-    Next_MDSpage = (DLword *)Addr68k_from_LADDR(((*Next_MDSpage_word) & 0xffff) << 8);
+    Next_MDSpage = (DLword *)NativeAligned2FromLAddr(((*Next_MDSpage_word) & 0xffff) << 8);
 #endif
     ptr = (LispPTR *)Next_MDSpage;       /* Get Pointer to First Page */
     Next_MDSpage -= DLWORDSPER_PAGE * 2; /* decrement MDS count */
 #ifdef BIGVM
-    *Next_MDSpage_word = LPAGE_from_68k(Next_MDSpage);
+    *Next_MDSpage_word = LPageFromNative(Next_MDSpage);
 #else
-    *Next_MDSpage_word = S_POSITIVE | LPAGE_from_68k(Next_MDSpage);
+    *Next_MDSpage_word = S_POSITIVE | LPageFromNative(Next_MDSpage);
 #endif
-    newpage(newpage(LADDR_from_68k(ptr)) + DLWORDSPER_PAGE);
+    newpage(newpage(LAddrFromNative(ptr)) + DLWORDSPER_PAGE);
   }
 
-  Make_MDSentry(LPAGE_from_68k(ptr), type);
+  Make_MDSentry(LPageFromNative(ptr), type);
   return (ptr);
 } /* alloc_mdspage end */

src/arith2.c

@@ -1,271 +0,0 @@
-/* $Id: arith2.c,v 1.4 2001/12/24 01:08:58 sybalsky Exp $ (C) Copyright Venue, All Rights Reserved
- */
-
-/************************************************************************/
-/*									*/
-/*	(C) Copyright 1989-99 Venue. All Rights Reserved.		*/
-/*	Manufactured in the United States of America.			*/
-/*									*/
-/************************************************************************/
-
-#include "version.h"
-
-#include <stdio.h>
-#include "lispemul.h"
-#include "lspglob.h"
-#include "adr68k.h"
-#include "lispmap.h"
-#include "lsptypes.h"
-#include "medleyfp.h"
-#include "arith.h"
-
-#include "arith2defs.h"
-#include "fpdefs.h"
-#include "mkcelldefs.h"
-
-/************************************************************
-N_OP_plus2
-        entry		PLUS2		OPCODE[0324]
-        entry		IPLUS2		OPCODE[0330]
-        return(tos + b)
-************************************************************/
-
-LispPTR N_OP_plus2(int tosm1, int tos) {
-  int arg1, arg2;
-  int result;
-
-  N_GETNUMBER(tos, arg1, doufn);
-  N_GETNUMBER(tosm1, arg2, doufn);
-
-#ifdef USE_OVERFLOW_BUILTINS
-
-  if (__builtin_sadd_overflow(arg1, arg2, &result)) {
-    ERROR_EXIT(tos);
-  }
-  N_ARITH_SWITCH(result);
-
-#else
-  /* UB: signed integer overflow: 2147483647 + 2147483647 cannot be represented in type 'int' */
-  result = arg1 + arg2;
-  if (((arg1 >= 0) == (arg2 >= 0)) && ((result >= 0) != (arg1 >= 0))) { ERROR_EXIT(tos); }
-  N_ARITH_SWITCH(result);
-
-#endif
-
-doufn:
-  return (N_OP_fplus2(tosm1, tos));
-}
-
-/************************************************************************/
-/*									*/
-/*			N _ O P _ i p l u s 2				*/
-/*									*/
-/*	Implements the IPLUS2 opcode--add the two arguments, which	*/
-/*	must be SMALLP or FIXP						*/
-/*									*/
-/************************************************************************/
-
-LispPTR N_OP_iplus2(int tosm1, int tos) {
-  int arg1, arg2;
-  int result;
-
-  N_IGETNUMBER(tos, arg1, doufn);
-  N_IGETNUMBER(tosm1, arg2, doufn);
-
-#ifdef USE_OVERFLOW_BUILTINS
-
-  if (__builtin_sadd_overflow(arg1, arg2, &result)) {
-    ERROR_EXIT(tos);
-  }
-  N_ARITH_SWITCH(result);
-
-#else
-
-  /* UB: signed integer overflow: 2147483647 + 2147483647 cannot be represented in type 'int' */
-  result = arg1 + arg2;
-  if (((arg1 >= 0) == (arg2 >= 0)) && ((result >= 0) != (arg1 >= 0))) { ERROR_EXIT(tos); }
-  N_ARITH_SWITCH(result);
-
-#endif
-
-doufn:
-  ERROR_EXIT(tos);
-}
-
-/************************************************************
-N_OP_difference
-        entry		DIFFERENCE		OPCODE[0325]
-        entry		IDIFFERENCE		OPCODE[0331]
-        return(a - tos)
-************************************************************/
-
-LispPTR N_OP_difference(int tosm1, int tos) {
-  int arg1, arg2;
-  int result;
-
-  N_GETNUMBER(tosm1, arg1, doufn);
-  N_GETNUMBER(tos, arg2, doufn);
-
-#ifdef USE_OVERFLOW_BUILTINS
-
-  if (__builtin_ssub_overflow(arg1, arg2, &result)) {
-    ERROR_EXIT(tos);
-  }
-  N_ARITH_SWITCH(result);
-
-#else
-
-  /* UB: signed integer overflow: -2147483647 - 320 cannot be represented in type 'int' */
-  result = arg1 - arg2;
-  if (((arg1 >= 0) == (arg2 < 0)) && ((result >= 0) != (arg1 >= 0))) { ERROR_EXIT(tos); }
-  N_ARITH_SWITCH(result);
-
-#endif
-
-doufn:
-  return (N_OP_fdifference(tosm1, tos));
-}
-
-LispPTR N_OP_idifference(int tosm1, int tos) {
-  int arg1, arg2;
-  int result;
-
-  N_IGETNUMBER(tosm1, arg1, doufn);
-  N_IGETNUMBER(tos, arg2, doufn);
-
-#ifdef USE_OVERFLOW_BUILTINS
-
-  if (__builtin_ssub_overflow(arg1, arg2, &result)) {
-    ERROR_EXIT(tos);
-  }
-  N_ARITH_SWITCH(result);
-
-#else
-  /* UB: signed integer overflow: -2147483647 - 100 cannot be represented in type 'int' */
-  result = arg1 - arg2;
-  if (((arg1 >= 0) == (arg2 < 0)) && ((result >= 0) != (arg1 >= 0))) { ERROR_EXIT(tos); }
-  N_ARITH_SWITCH(result);
-
-#endif
-doufn:
-  ERROR_EXIT(tos);
-}
-
-/************************************************************
-N_OP_logxor
-        entry		LOGXOR2		OPCODE[0346]
-        return(tosm1 ^ tos)
-************************************************************/
-
-LispPTR N_OP_logxor(int tosm1, int tos) { N_IARITH_BODY_2(tosm1, tos, ^); }
-
-/************************************************************
-N_OP_logand
-        entry		LOGAND2		OPCODE[0345]
-        return(tosm1 & tos)
-************************************************************/
-LispPTR N_OP_logand(int tosm1, int tos) { N_IARITH_BODY_2(tosm1, tos, &); }
-
-/************************************************************
-N_OP_logor
-        entry		LOGOR2		OPCODE[0344]
-        return(tosm1 | tos)
-************************************************************/
-LispPTR N_OP_logor(int tosm1, int tos) { N_IARITH_BODY_2(tosm1, tos, |); }
-
-/************************************************************
-N_OP_greaterp
-        entry		GREATERP		OPCODE[0363]
-        entry		IGREATERP		OPCODE[0361]
-        return(tosm1 > tos)
-
-************************************************************/
-LispPTR N_OP_greaterp(int tosm1, int tos) {
-  register int arg1, arg2;
-
-  N_GETNUMBER(tosm1, arg1, do_ufn);
-  N_GETNUMBER(tos, arg2, do_ufn);
-
-  if (arg1 > arg2)
-    return (ATOM_T);
-  else
-    return (NIL_PTR);
-
-do_ufn:
-  return (N_OP_fgreaterp(tosm1, tos));
-}
-
-LispPTR N_OP_igreaterp(int tosm1, int tos) {
-  register int arg1, arg2;
-
-  N_IGETNUMBER(tosm1, arg1, do_ufn);
-  N_IGETNUMBER(tos, arg2, do_ufn);
-
-  if (arg1 > arg2)
-    return (ATOM_T);
-  else
-    return (NIL_PTR);
-
-do_ufn:
-  ERROR_EXIT(tos);
-}
-
-/************************************************************
-N_OP_iplusn
-        entry		IPLUS.N		OPCODE[0335]
-        return(tos + n)
-************************************************************/
-LispPTR N_OP_iplusn(int tos, int n) {
-  int arg1;
-  int result;
-
-  N_IGETNUMBER(tos, arg1, do_ufn);
-
-#ifdef USE_OVERFLOW_BUILTINS
-
-  if (__builtin_sadd_overflow(arg1, n, &result)) {
-    ERROR_EXIT(tos);
-  }
-  N_ARITH_SWITCH(result);
-
-#else
-
-  result = arg1 + n;
-  if ((result < 0) && (arg1 >= 0)) { ERROR_EXIT(tos); }
-  N_ARITH_SWITCH(result);
-
-#endif
-
-do_ufn:
-  ERROR_EXIT(tos);
-}
-
-/************************************************************
-N_OP_idifferencen
-        entry		IDIFFERENCE.N		OPCODE[0336]
-        return(tos - n)
-************************************************************/
-LispPTR N_OP_idifferencen(int tos, int n) {
-  int arg1;
-  int result;
-
-  N_IGETNUMBER(tos, arg1, do_ufn);
-
-#ifdef USE_OVERFLOW_BUILTINS
-
-  if (__builtin_ssub_overflow(arg1, n, &result)) {
-    ERROR_EXIT(tos);
-  }
-  N_ARITH_SWITCH(result);
-
-#else
-
-  result = arg1 - n;
-  if ((result >= 0) && (arg1 < 0)) { ERROR_EXIT(tos); }
-  N_ARITH_SWITCH(result);
-
-#endif
-
-do_ufn:
-  ERROR_EXIT(tos);
-}

src/arith3.c

@@ -1,97 +0,0 @@
-/* $Id: arith3.c,v 1.3 1999/05/31 23:35:21 sybalsky Exp $ (C) Copyright Venue, All Rights Reserved
- */
-
-/************************************************************************/
-/*									*/
-/*	(C) Copyright 1989-95 Venue. All Rights Reserved.		*/
-/*	Manufactured in the United States of America.			*/
-/*									*/
-/************************************************************************/
-
-#include "version.h"
-
-/************************************************************************/
-/*									*/
-/*			    A R I T H 3 . C				*/
-/*									*/
-/*	Including :	OP_makenumber					*/
-/*			OP_boxiplus					*/
-/*			OP_boxidiff					*/
-/*									*/
-/*									*/
-/************************************************************************/
-
-#include "lispemul.h"
-#include "lispmap.h"
-#include "lspglob.h"
-#include "lsptypes.h"
-#include "address.h"
-#include "adr68k.h"
-#include "cell.h"
-#include "arith.h"
-
-#include "arith3defs.h"
-#include "mkcelldefs.h"
-
-/************************************************************************/
-/*									*/
-/*			N _ O P _ m a k e n u m b e r			*/
-/*									*/
-/*	Given the 2 halves of a FIXP as SMALLP's, create a number	*/
-/*	box for the number, and fill it in.				*/
-/*									*/
-/************************************************************************/
-
-LispPTR N_OP_makenumber(int tosm1, int tos) {
-  register int result;
-
-  if (((tosm1 & 0xFFFF0000) != S_POSITIVE) || ((tos & 0xFFFF0000) != S_POSITIVE)) ERROR_EXIT(tos);
-  /* UB: left shift of 49152 by 16 places cannot be represented in type 'int' */
-  result = ((tosm1 & 0xffff) << 16) | (tos & 0xffff);
-  N_ARITH_SWITCH(result);
-} /* end OP_makenumber */
-
-/************************************************************************/
-/*									*/
-/*			N _ O P _ b o x i p l u s			*/
-/*									*/
-/*	Given a FIXP box and a number to add to it, add the number,	*/
-/*	leaving the result in the box given.  Used to avoid garbaging.	*/
-/*									*/
-/************************************************************************/
-
-LispPTR N_OP_boxiplus(register int a, int tos) {
-  register int arg2;
-
-  if (GetTypeNumber(a) == TYPE_FIXP) {
-    N_GETNUMBER(tos, arg2, bad);
-    *((LispPTR *)Addr68k_from_LADDR(a)) += arg2;
-    return (a);
-  }
-bad:
-  ERROR_EXIT(tos);
-
-} /* OP_boxiplus */
-
-/************************************************************************/
-/*									*/
-/*			O P _ b o x i d i f f				*/
-/*									*/
-/*	Given a FIXP box and a number to subtract from it, do the	*/
-/*	subtraction, and leave the result in the box given.		*/
-/*	Used to avoid allocating storage in low-level routines.		*/
-/*									*/
-/************************************************************************/
-
-LispPTR N_OP_boxidiff(register int a, int tos) {
-  register int arg2;
-
-  if (GetTypeNumber(a) == TYPE_FIXP) {
-    N_GETNUMBER(tos, arg2, bad);
-    *((LispPTR *)Addr68k_from_LADDR(a)) -= arg2;
-    return (a);
-  }
-bad:
-  ERROR_EXIT(tos);
-
-} /* end OP_boxidiff */

src/arith4.c

@@ -1,166 +0,0 @@
-/* $Id: arith4.c,v 1.3 1999/05/31 23:35:21 sybalsky Exp $ (C) Copyright Venue, All Rights Reserved
- */
-
-/************************************************************************/
-/*									*/
-/*	(C) Copyright 1989-95 Venue. All Rights Reserved.		*/
-/*	Manufactured in the United States of America.			*/
-/*									*/
-/************************************************************************/
-
-#include "version.h"
-
-/***********************************************************************/
-/*
-                File Name :	arith4.c
-
-                Including :	OP_times2 326Q(OP_itimes2 332Q)
-
-                                OP_quot 327Q(OP_iquot 333Q)
-                                OP_reminder 334Q
-
-*/
-/**********************************************************************/
-
-#include "lispemul.h"
-#include "lispmap.h"
-#include "lspglob.h"
-#include "lsptypes.h"
-#include "address.h"
-#include "adr68k.h"
-#include "cell.h"
-#include "medleyfp.h"
-#include "arith.h"
-
-#include "arith4defs.h"
-#include "fpdefs.h"
-#include "mkcelldefs.h"
-
-/**********************************************************************/
-/*
-
-                Func name :	N_OP_times2(itimes2)
-
-*/
-/**********************************************************************/
-int N_OP_times2(int tosm1, int tos) {
-  int arg1, arg2;
-  int result;
-
-  N_GETNUMBER(tosm1, arg1, doufn);
-  N_GETNUMBER(tos, arg2, doufn);
-
-#ifdef USE_OVERFLOW_BUILTINS
-
-  if (__builtin_smul_overflow(arg1, arg2, &result)) {
-    goto doufn2;
-  }
-  N_ARITH_SWITCH(result);
-
-#else
-
-  result = arg1 * arg2;
-  if ((arg2 != 0) && ((result / arg2) != arg1)) goto doufn2;
-  N_ARITH_SWITCH(result);
-
-#endif
-
-doufn2:
-  ERROR_EXIT(tos);
-doufn:
-  return (N_OP_ftimes2(tosm1, tos));
-
-} /* end N_OP_times2 */
-
-int N_OP_itimes2(int tosm1, int tos) {
-  int arg1, arg2;
-  int result;
-
-  N_IGETNUMBER(tosm1, arg1, doufn);
-  N_IGETNUMBER(tos, arg2, doufn);
-
-#ifdef USE_OVERFLOW_BUILTINS
-
-  if (__builtin_smul_overflow(arg1, arg2, &result)) {
-    goto doufn;
-  }
-  N_ARITH_SWITCH(result);
-
-#else
-
-  /* UB: signed integer overflow: 1073741824 * 32768 cannot be represented in type 'int' */
-  result = arg1 * arg2;
-  if ((arg2 != 0) && ((result / arg2) != arg1)) { goto doufn; }
-  N_ARITH_SWITCH(result);
-
-#endif
-
-doufn:
-  ERROR_EXIT(tos);
-
-} /* end N_OP_itimes2 */
-
-/**********************************************************************/
-/*
-
-                Func name :	N_OP_quot(iquot)
-
-*/
-/**********************************************************************/
-int N_OP_quot(int tosm1, int tos) {
-  int arg1, arg2;
-  int result;
-
-  N_GETNUMBER(tosm1, arg1, doufn);
-  N_GETNUMBER(tos, arg2, doufn);
-  if (arg2 == 0) goto doufn2;
-
-  result = arg1 / arg2; /* lmm: note: no error case!! */
-  N_ARITH_SWITCH(result);
-
-doufn2:
-  ERROR_EXIT(tos);
-doufn:
-  return (N_OP_fquotient(tosm1, tos));
-
-} /* end N_OP_quot */
-
-int N_OP_iquot(int tosm1, int tos) {
-  register int arg1, arg2;
-  register int result;
-
-  N_IGETNUMBER(tosm1, arg1, doufn);
-  N_IGETNUMBER(tos, arg2, doufn);
-  if (arg2 == 0) goto doufn;
-
-  result = arg1 / arg2;
-  N_ARITH_SWITCH(result);
-
-doufn:
-  ERROR_EXIT(tos);
-
-} /* end N_OP_quot */
-
-/**********************************************************************/
-/*
-
-                Func name :	N_OP_iremainder
-
-*/
-/**********************************************************************/
-
-int N_OP_iremainder(int tosm1, int tos) {
-  register int arg1, arg2;
-  register int result;
-
-  N_IGETNUMBER(tosm1, arg1, doufn);
-  N_IGETNUMBER(tos, arg2, doufn);
-  if (arg2 == 0) goto doufn;
-
-  result = arg1 % arg2;
-  N_ARITH_SWITCH(result);
-
-doufn:
-  ERROR_EXIT(tos);
-
-} /* end N_OP_iremainder */

src/arithops.c

@@ -0,0 +1,492 @@
+/************************************************************************/
+/*									*/
+/*	(C) Copyright 1989-95 Venue. All Rights Reserved.		*/
+/*	Manufactured in the United States of America.			*/
+/*									*/
+/************************************************************************/
+
+#include "version.h"
+
+#include "adr68k.h"      // for NativeAligned4FromLAddr
+#include "arith.h"       // for N_IGETNUMBER, N_ARITH_SWITCH, N_GETNUMBER
+#include "arithopsdefs.h"  // for N_OP_difference, N_OP_greaterp, N_OP_idiffer...
+#include "fpdefs.h"      // for N_OP_fdifference, N_OP_fgreaterp, N_OP_fplus2
+#include "lispemul.h"    // for state, ERROR_EXIT, LispPTR, ATOM_T, NIL_PTR
+#include "lispmap.h"     // for S_POSITIVE
+#include "lspglob.h"
+#include "lsptypes.h"
+
+/************************************************************
+N_OP_plus2
+        entry		PLUS2		OPCODE[0324]
+        entry		IPLUS2		OPCODE[0330]
+        return(tos + b)
+************************************************************/
+
+LispPTR N_OP_plus2(LispPTR tosm1, LispPTR tos) {
+  int arg1, arg2;
+  int result;
+
+  N_GETNUMBER(tos, arg1, doufn);
+  N_GETNUMBER(tosm1, arg2, doufn);
+
+#ifdef USE_OVERFLOW_BUILTINS
+
+  if (__builtin_sadd_overflow(arg1, arg2, &result)) {
+    ERROR_EXIT(tos);
+  }
+  N_ARITH_SWITCH(result);
+
+#else
+  /* UB: signed integer overflow: 2147483647 + 2147483647 cannot be represented in type 'int' */
+  result = arg1 + arg2;
+  if (((arg1 >= 0) == (arg2 >= 0)) && ((result >= 0) != (arg1 >= 0))) { ERROR_EXIT(tos); }
+  N_ARITH_SWITCH(result);
+
+#endif
+
+doufn:
+  return (N_OP_fplus2(tosm1, tos));
+}
+
+/************************************************************************/
+/*									*/
+/*			N _ O P _ i p l u s 2				*/
+/*									*/
+/*	Implements the IPLUS2 opcode--add the two arguments, which	*/
+/*	must be SMALLP or FIXP						*/
+/*									*/
+/************************************************************************/
+
+LispPTR N_OP_iplus2(LispPTR tosm1, LispPTR tos) {
+  int arg1, arg2;
+  int result;
+
+  N_IGETNUMBER(tos, arg1, doufn);
+  N_IGETNUMBER(tosm1, arg2, doufn);
+
+#ifdef USE_OVERFLOW_BUILTINS
+
+  if (__builtin_sadd_overflow(arg1, arg2, &result)) {
+    ERROR_EXIT(tos);
+  }
+  N_ARITH_SWITCH(result);
+
+#else
+
+  /* UB: signed integer overflow: 2147483647 + 2147483647 cannot be represented in type 'int' */
+  result = arg1 + arg2;
+  if (((arg1 >= 0) == (arg2 >= 0)) && ((result >= 0) != (arg1 >= 0))) { ERROR_EXIT(tos); }
+  N_ARITH_SWITCH(result);
+
+#endif
+
+doufn:
+  ERROR_EXIT(tos);
+}
+
+/************************************************************
+N_OP_difference
+        entry		DIFFERENCE		OPCODE[0325]
+        entry		IDIFFERENCE		OPCODE[0331]
+        return(a - tos)
+************************************************************/
+
+LispPTR N_OP_difference(LispPTR tosm1, LispPTR tos) {
+  int arg1, arg2;
+  int result;
+
+  N_GETNUMBER(tosm1, arg1, doufn);
+  N_GETNUMBER(tos, arg2, doufn);
+
+#ifdef USE_OVERFLOW_BUILTINS
+
+  if (__builtin_ssub_overflow(arg1, arg2, &result)) {
+    ERROR_EXIT(tos);
+  }
+  N_ARITH_SWITCH(result);
+
+#else
+
+  /* UB: signed integer overflow: -2147483647 - 320 cannot be represented in type 'int' */
+  result = arg1 - arg2;
+  if (((arg1 >= 0) == (arg2 < 0)) && ((result >= 0) != (arg1 >= 0))) { ERROR_EXIT(tos); }
+  N_ARITH_SWITCH(result);
+
+#endif
+
+doufn:
+  return (N_OP_fdifference(tosm1, tos));
+}
+
+LispPTR N_OP_idifference(LispPTR tosm1, LispPTR tos) {
+  int arg1, arg2;
+  int result;
+
+  N_IGETNUMBER(tosm1, arg1, doufn);
+  N_IGETNUMBER(tos, arg2, doufn);
+
+#ifdef USE_OVERFLOW_BUILTINS
+
+  if (__builtin_ssub_overflow(arg1, arg2, &result)) {
+    ERROR_EXIT(tos);
+  }
+  N_ARITH_SWITCH(result);
+
+#else
+  /* UB: signed integer overflow: -2147483647 - 100 cannot be represented in type 'int' */
+  result = arg1 - arg2;
+  if (((arg1 >= 0) == (arg2 < 0)) && ((result >= 0) != (arg1 >= 0))) { ERROR_EXIT(tos); }
+  N_ARITH_SWITCH(result);
+
+#endif
+doufn:
+  ERROR_EXIT(tos);
+}
+
+/************************************************************
+N_OP_logxor
+        entry		LOGXOR2		OPCODE[0346]
+        return(tosm1 ^ tos)
+************************************************************/
+
+LispPTR N_OP_logxor(LispPTR tosm1, LispPTR tos) {
+    int arg1, arg2;
+
+    N_IGETNUMBER(tosm1, arg1, do_ufn);
+    N_IGETNUMBER(tos, arg2, do_ufn);
+
+    arg1 = arg1 ^ arg2;
+
+    N_ARITH_SWITCH(arg1);
+
+  do_ufn:
+    ERROR_EXIT(tos);
+}
+
+/************************************************************
+N_OP_logand
+        entry		LOGAND2		OPCODE[0345]
+        return(tosm1 & tos)
+************************************************************/
+LispPTR N_OP_logand(LispPTR tosm1, LispPTR tos) {
+    int arg1, arg2;
+
+    N_IGETNUMBER(tosm1, arg1, do_ufn);
+    N_IGETNUMBER(tos, arg2, do_ufn);
+
+    arg1 = arg1 & arg2;
+
+    N_ARITH_SWITCH(arg1);
+
+  do_ufn:
+    ERROR_EXIT(tos);
+}
+
+/************************************************************
+N_OP_logor
+        entry		LOGOR2		OPCODE[0344]
+        return(tosm1 | tos)
+************************************************************/
+LispPTR N_OP_logor(LispPTR tosm1, LispPTR tos) {
+      int arg1, arg2;
+
+    N_IGETNUMBER(tosm1, arg1, do_ufn);
+    N_IGETNUMBER(tos, arg2, do_ufn);
+
+    arg1 = arg1 | arg2;
+
+    N_ARITH_SWITCH(arg1);
+
+  do_ufn:
+    ERROR_EXIT(tos);
+}
+
+/************************************************************
+N_OP_greaterp
+        entry		GREATERP		OPCODE[0363]
+        entry		IGREATERP		OPCODE[0361]
+        return(tosm1 > tos)
+
+************************************************************/
+LispPTR N_OP_greaterp(LispPTR tosm1, LispPTR tos) {
+  int arg1, arg2;
+
+  N_GETNUMBER(tosm1, arg1, do_ufn);
+  N_GETNUMBER(tos, arg2, do_ufn);
+
+  if (arg1 > arg2)
+    return (ATOM_T);
+  else
+    return (NIL_PTR);
+
+do_ufn:
+  return (N_OP_fgreaterp(tosm1, tos));
+}
+
+LispPTR N_OP_igreaterp(LispPTR tosm1, LispPTR tos) {
+  int arg1, arg2;
+
+  N_IGETNUMBER(tosm1, arg1, do_ufn);
+  N_IGETNUMBER(tos, arg2, do_ufn);
+
+  if (arg1 > arg2)
+    return (ATOM_T);
+  else
+    return (NIL_PTR);
+
+do_ufn:
+  ERROR_EXIT(tos);
+}
+
+/************************************************************
+N_OP_iplusn
+        entry		IPLUS.N		OPCODE[0335]
+        return(tos + n)
+************************************************************/
+LispPTR N_OP_iplusn(LispPTR tos, int n) {
+  int arg1;
+  int result;
+
+  N_IGETNUMBER(tos, arg1, do_ufn);
+
+#ifdef USE_OVERFLOW_BUILTINS
+
+  if (__builtin_sadd_overflow(arg1, n, &result)) {
+    ERROR_EXIT(tos);
+  }
+  N_ARITH_SWITCH(result);
+
+#else
+
+  result = arg1 + n;
+  if ((result < 0) && (arg1 >= 0)) { ERROR_EXIT(tos); }
+  N_ARITH_SWITCH(result);
+
+#endif
+
+do_ufn:
+  ERROR_EXIT(tos);
+}
+
+/************************************************************
+N_OP_idifferencen
+        entry		IDIFFERENCE.N		OPCODE[0336]
+        return(tos - n)
+************************************************************/
+LispPTR N_OP_idifferencen(LispPTR tos, int n) {
+  int arg1;
+  int result;
+
+  N_IGETNUMBER(tos, arg1, do_ufn);
+
+#ifdef USE_OVERFLOW_BUILTINS
+
+  if (__builtin_ssub_overflow(arg1, n, &result)) {
+    ERROR_EXIT(tos);
+  }
+  N_ARITH_SWITCH(result);
+
+#else
+
+  result = arg1 - n;
+  if ((result >= 0) && (arg1 < 0)) { ERROR_EXIT(tos); }
+  N_ARITH_SWITCH(result);
+
+#endif
+
+do_ufn:
+  ERROR_EXIT(tos);
+}
+
+/************************************************************************/
+/*									*/
+/*			N _ O P _ m a k e n u m b e r			*/
+/*									*/
+/*	Given the 2 halves of a FIXP as SMALLP's, create a number	*/
+/*	box for the number, and fill it in.				*/
+/*									*/
+/************************************************************************/
+
+LispPTR N_OP_makenumber(LispPTR tosm1, LispPTR tos) {
+  int result;
+
+  if (((tosm1 & 0xFFFF0000) != S_POSITIVE) || ((tos & 0xFFFF0000) != S_POSITIVE)) ERROR_EXIT(tos);
+  /* UB: left shift of 49152 by 16 places cannot be represented in type 'int' */
+  result = ((tosm1 & 0xffff) << 16) | (tos & 0xffff);
+  N_ARITH_SWITCH(result);
+} /* end OP_makenumber */
+
+/************************************************************************/
+/*									*/
+/*			N _ O P _ b o x i p l u s			*/
+/*									*/
+/*	Given a FIXP box and a number to add to it, add the number,	*/
+/*	leaving the result in the box given.  Used to avoid garbaging.	*/
+/*									*/
+/************************************************************************/
+
+LispPTR N_OP_boxiplus(LispPTR a, LispPTR tos) {
+  int arg2;
+
+  if (GetTypeNumber(a) == TYPE_FIXP) {
+    N_GETNUMBER(tos, arg2, bad);
+    *((int *)NativeAligned4FromLAddr(a)) += arg2;
+    return (a);
+  }
+bad:
+  ERROR_EXIT(tos);
+
+} /* OP_boxiplus */
+
+/************************************************************************/
+/*									*/
+/*			O P _ b o x i d i f f				*/
+/*									*/
+/*	Given a FIXP box and a number to subtract from it, do the	*/
+/*	subtraction, and leave the result in the box given.		*/
+/*	Used to avoid allocating storage in low-level routines.		*/
+/*									*/
+/************************************************************************/
+
+LispPTR N_OP_boxidiff(LispPTR a, LispPTR tos) {
+  int arg2;
+
+  if (GetTypeNumber(a) == TYPE_FIXP) {
+    N_GETNUMBER(tos, arg2, bad);
+    *((int *)NativeAligned4FromLAddr(a)) -= arg2;
+    return (a);
+  }
+bad:
+  ERROR_EXIT(tos);
+
+} /* end OP_boxidiff */
+
+/**********************************************************************/
+/*
+
+                Func name :	N_OP_times2
+
+*/
+/**********************************************************************/
+LispPTR N_OP_times2(LispPTR tosm1, LispPTR tos) {
+  int arg1, arg2;
+  int result;
+
+  N_GETNUMBER(tosm1, arg1, doufn);
+  N_GETNUMBER(tos, arg2, doufn);
+
+#ifdef USE_OVERFLOW_BUILTINS
+
+  if (__builtin_smul_overflow(arg1, arg2, &result)) {
+    goto doufn2;
+  }
+  N_ARITH_SWITCH(result);
+
+#else
+
+  result = arg1 * arg2;
+  if ((arg2 != 0) && ((result / arg2) != arg1)) goto doufn2;
+  N_ARITH_SWITCH(result);
+
+#endif
+
+doufn2:
+  ERROR_EXIT(tos);
+doufn:
+  return (N_OP_ftimes2(tosm1, tos));
+
+} /* end N_OP_times2 */
+
+LispPTR N_OP_itimes2(LispPTR tosm1, LispPTR tos) {
+  int arg1, arg2;
+  int result;
+
+  N_IGETNUMBER(tosm1, arg1, doufn);
+  N_IGETNUMBER(tos, arg2, doufn);
+
+#ifdef USE_OVERFLOW_BUILTINS
+
+  if (__builtin_smul_overflow(arg1, arg2, &result)) {
+    goto doufn;
+  }
+  N_ARITH_SWITCH(result);
+
+#else
+
+  /* UB: signed integer overflow: 1073741824 * 32768 cannot be represented in type 'int' */
+  result = arg1 * arg2;
+  if ((arg2 != 0) && ((result / arg2) != arg1)) { goto doufn; }
+  N_ARITH_SWITCH(result);
+
+#endif
+
+doufn:
+  ERROR_EXIT(tos);
+
+} /* end N_OP_itimes2 */
+
+/**********************************************************************/
+/*
+
+                Func name :	N_OP_quot(iquot)
+
+*/
+/**********************************************************************/
+LispPTR N_OP_quot(LispPTR tosm1, LispPTR tos) {
+  int arg1, arg2;
+  int result;
+
+  N_GETNUMBER(tosm1, arg1, doufn);
+  N_GETNUMBER(tos, arg2, doufn);
+  if (arg2 == 0) goto doufn2;
+
+  result = arg1 / arg2; /* lmm: note: no error case!! */
+  N_ARITH_SWITCH(result);
+
+doufn2:
+  ERROR_EXIT(tos);
+doufn:
+  return (N_OP_fquotient(tosm1, tos));
+
+} /* end N_OP_quot */
+
+LispPTR N_OP_iquot(LispPTR tosm1, LispPTR tos) {
+  int arg1, arg2;
+  int result;
+
+  N_IGETNUMBER(tosm1, arg1, doufn);
+  N_IGETNUMBER(tos, arg2, doufn);
+  if (arg2 == 0) goto doufn;
+
+  result = arg1 / arg2;
+  N_ARITH_SWITCH(result);
+
+doufn:
+  ERROR_EXIT(tos);
+
+} /* end N_OP_quot */
+
+/**********************************************************************/
+/*
+
+                Func name :	N_OP_iremainder
+
+*/
+/**********************************************************************/
+
+LispPTR N_OP_iremainder(LispPTR tosm1, LispPTR tos) {
+  int arg1, arg2;
+  int result;
+
+  N_IGETNUMBER(tosm1, arg1, doufn);
+  N_IGETNUMBER(tos, arg2, doufn);
+  if (arg2 == 0) goto doufn;
+
+  result = arg1 % arg2;
+  N_ARITH_SWITCH(result);
+
+doufn:
+  ERROR_EXIT(tos);
+
+} /* end N_OP_iremainder */

src/array.c

@@ -1,57 +0,0 @@
-/* @(#) array.c Version 2.8 (12/23/88). copyright envos & Fuji Xerox  */
-
-/************************************************************************/
-/*									*/
-/*	(C) Copyright 1989-95 Venue. All Rights Reserved.		*/
-/*	Manufactured in the United States of America.			*/
-/*									*/
-/************************************************************************/
-
-#include "version.h"
-
-#include <stdio.h>
-#include "lispemul.h"
-#include "lspglob.h"
-#include "adr68k.h"
-#include "lispmap.h"
-#include "lsptypes.h"
-#include "emlglob.h"
-
-#include "arraydefs.h"
-#include "mkcelldefs.h"
-#include "arith.h"
-#include "my.h"
-
-
-/************************************************************
- OP_claref  -- op 372/9 (base typenumber index)
-
-type    size    typenumber
-  0       0             0      unsigned  : 1 bit
-  0       3             3      unsigned  : 8 bits
-  0       4             4      unsigned  : 16 bits
-  1       4            20      signed    : 16 bits
-  1       6            22      signed    : 32 bits
-  2       6            38      pointer   : 32 bits
-  3       6            54      float     : 32 bits
-  4       3            67      character : 8 bits
-  4       4            68      character : 16 bits
-  5       6            86      Xpointer  : 32 bits
-
-
-***********************************************************/
-
-/***	N_OP_misc3  -- op 372/9 (base typenumber index)   ***/
-LispPTR N_OP_misc3(LispPTR baseL, LispPTR typenumber, LispPTR inx, int alpha) {
-  register int index, type;
-
-  if (alpha != 9) ERROR_EXIT(inx);
-  /*  test and setup index  */
-  N_GetPos(inx, index, inx);
-
-  /*  test and setup typenumber  */
-  N_GetPos(typenumber, type, inx);
-
-  /*  disp on type  */
-  return (aref_switch(type, inx, baseL, index));
-} /*  end N_OP_misc3()  */

src/array2.c

@@ -1,62 +0,0 @@
-/* This is G-file @(#) array2.c Version 2.9 (10/12/88). copyright Xerox & Fuji Xerox  */
-
-/************************************************************************/
-/*									*/
-/*	(C) Copyright 1989-95 Venue. All Rights Reserved.		*/
-/*	Manufactured in the United States of America.			*/
-/*									*/
-/************************************************************************/
-
-#include "version.h"
-
-/************************************************************************/
-/*									*/
-/*			    A R R A Y 2 . C				*/
-/*									*/
-/*	Contains N_OP_misc4, the ASET opcode.				*/
-/*									*/
-/************************************************************************/
-
-#include <stdio.h>
-#include "lispemul.h"
-#include "lspglob.h"
-#include "adr68k.h"
-#include "lispmap.h"
-#include "lsptypes.h"
-#include "emlglob.h"
-#include "gcdata.h"
-#include "mkcelldefs.h"
-#include "arith.h"
-#include "my.h"
-
-#include "array2defs.h"
-#include "gchtfinddefs.h"
-
-/************************************************************************/
-/*									*/
-/*			N _ O P _ m i s c 4				*/
-/*									*/
-/*	CL:ASET opcode	op 373/7 (data, base typenumber, index)		*/
-/*									*/
-/************************************************************************/
-
-LispPTR N_OP_misc4(register LispPTR data, register LispPTR base, register LispPTR typenumber,
-                   register LispPTR inx, int alpha) {
-  register int new;
-  register int index;
-  int type;
-
-  if (alpha != 7) ERROR_EXIT(inx);
-
-  /*  test and setup index  */
-  N_GetPos(inx, index, inx);
-
-  /*  test and setup typenumber  */
-  N_GetPos(typenumber, type, inx);
-
-  aset_switch(type, inx);
-
-doufn:
-  ERROR_EXIT(inx);
-
-} /*  end N_OP_misc4()  */

src/array3.c

@@ -1,53 +0,0 @@
-/* This is G-file @(#) array3.c Version 2.9 (10/12/88). copyright Xerox & Fuji Xerox  */
-
-/************************************************************************/
-/*									*/
-/*	(C) Copyright 1989-95 Venue. All Rights Reserved.		*/
-/*	Manufactured in the United States of America.			*/
-/*									*/
-/************************************************************************/
-
-#include "version.h"
-
-/************************************************************************/
-/*									*/
-/*			     A R R A Y 3 . C				*/
-/*									*/
-/*	Contains:	N_OP_aref1					*/
-/*									*/
-/************************************************************************/
-
-#include <stdio.h>
-#include "lispemul.h"
-#include "lspglob.h"
-#include "adr68k.h"
-#include "lispmap.h"
-#include "lsptypes.h"
-#include "emlglob.h"
-
-#include "array3defs.h"
-#include "mkcelldefs.h"
-#include "arith.h"
-#include "my.h"
-
-/***	N_OP_aref1   -- op 266   (array index)   ***/
-LispPTR N_OP_aref1(register LispPTR arrayarg, register LispPTR inx) {
-  register LispPTR baseL;
-  register int index;
-  register OneDArray *arrayblk;
-
-  /*  verify array  */
-  if (GetTypeNumber(arrayarg) != TYPE_ONED_ARRAY) ERROR_EXIT(inx);
-  arrayblk = (OneDArray *)Addr68k_from_LADDR(arrayarg);
-
-  /*  test and setup index  */
-  N_GetPos(inx, index, inx);
-  if (index >= arrayblk->totalsize) ERROR_EXIT(inx);
-  index += arrayblk->offset;
-
-  /*  setup base  */
-  baseL = arrayblk->base;
-
-  /*  disp on type  */
-  return (aref_switch(arrayblk->typenumber, inx, baseL, index));
-} /*  end N_OP_aref1()  */