Merge pull request #533 from Interlisp/nhb-rewrite-version-parser-v2

Extensive rewrite of various parts of the file name/version handling code. Converts a lot of unsafe string handling functions to safer variants. Passes buffer sizes in various places to enable overflow checks. Removes some unused variable declarations. Updates comments. Improves performance with alarm timeout setting when sequences of alarm set/cancel operations are performed. Adds GETFILEINFO processing for INODE_LO and INODE_HI attributes.
Removes assigned-but-not-used rval in DSK_getfilename and redundant test of current_len in conc_dir_and_name
2026-01-11 23:43:19 +00:00 · 2025-10-31 15:29:43 -07:00 · 2025-10-21 18:04:40 -07:00 · 2025-10-21 18:03:11 -07:00 · 2025-10-21 17:23:31 -07:00 · 2025-10-20 16:57:44 -07:00
31 changed files with 1395 additions and 1407 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -364,7 +364,6 @@ SET(MAIKO_HDRS
    inc/lispemul.h
    inc/lispmap.h
    inc/lispver1.h
-    inc/lispver2.h
    inc/llcolordefs.h
    inc/lldsp.h
    inc/llstkdefs.h
--- a/README.md
+++ b/README.md
@ -37,6 +37,7 @@ $ ./makeright x

 * The build will (attempt to) detect the OS-type and cpu-type. It will build binaries `lde` and `ldex` in `../`_`ostype.cputype`_ (with .o files in `../`_`ostype.cputype-x`_. For example, Linux on a 64-bit x86 will use `linux.x86_64`, while macOS 11 on a (new M1) Mac will use `darwin.aarch64`.
 * If you prefer `gcc` over `clang`, you will need to edit the makefile fragment for your configuration (`makefile-ostype.cputype-x`) and comment out the line (with a #) that defines `CC` as `clang` and uncomment the line (delete the #) for the line that defines `CC` as `gcc`.
+* If you want to do your own loadups to construct sysout files (see [the Medley repository](https://github.com/Interlisp/medley) for details), you also need the `ldeinit` binary, which you can build using `./makeright init`.

 ### Building with CMake
 We provide a `CMakeLists.txt` which provides mostly matching build capabilities to the `make` setup.
--- a/bin/makefile-dos
+++ b/bin/makefile-dos
@ -18,7 +18,7 @@ SRCFILES = conspage.c gcoflow.c shift.c dbgtool.c gcr.c         gcrcell.c llstk.
 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 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    bbtmacro.h debug.h devconf.h dspdata.h fast_dsp.h gcdata.h initatms.h inlinec.h keyboard.h         lispver1.h lispver2.h lldsp.h locfile.h medleyfp.h mouseif.h my.h  opcodes.h osmsgprint.h pilotbbt.h print.h retmacro.h stack.h stream.h subrs.h timeout.h   tos1defs.h tosfns.h tosret.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    bbtmacro.h debug.h devconf.h dspdata.h fast_dsp.h gcdata.h initatms.h inlinec.h keyboard.h         lispver1.h lldsp.h locfile.h medleyfp.h mouseif.h my.h  opcodes.h osmsgprint.h pilotbbt.h print.h retmacro.h stack.h stream.h subrs.h timeout.h   tos1defs.h tosfns.h tosret.h xdefs.h xbitmaps.h xkeymap.h



--- a/bin/makefile-tail
+++ b/bin/makefile-tail
@ -340,7 +340,7 @@ $(OBJECTDIR)car-cdr.o: $(SRCDIR)car-cdr.c $(REQUIRED-INCS) \
 $(OBJECTDIR)chardev.o: $(SRCDIR)chardev.c $(REQUIRED-INCS) \
 	$(INCDIR)lispemul.h $(INCDIR)lispmap.h \
 	$(INCDIR)adr68k.h $(INCDIR)lsptypes.h $(INCDIR)arith.h $(INCDIR)timeout.h \
-	$(INCDIR)locfile.h $(INCDIR)lispver2.h $(INCDIR)dbprint.h \
+	$(INCDIR)locfile.h $(INCDIR)dbprint.h \
 	$(INCDIR)chardevdefs.h $(INCDIR)byteswapdefs.h $(INCDIR)commondefs.h \
 	$(INCDIR)perrnodefs.h
 	$(CC) $(RFLAGS) $(SRCDIR)chardev.c -o $(OBJECTDIR)chardev.o
@ -505,7 +505,7 @@ $(OBJECTDIR)dsk.o: $(SRCDIR)dsk.c $(REQUIRED-INCS) \
 	$(INCDIR)lispemul.h $(INCDIR)lispmap.h \
 	$(INCDIR)adr68k.h $(INCDIR)lsptypes.h $(INCDIR)lspglob.h $(INCDIR)ifpage.h \
 	$(INCDIR)iopage.h $(INCDIR)miscstat.h $(INCDIR)arith.h $(INCDIR)stream.h \
-	$(INCDIR)timeout.h $(INCDIR)locfile.h $(INCDIR)lispver2.h \
+	$(INCDIR)timeout.h $(INCDIR)locfile.h \
 	$(INCDIR)dbprint.h $(INCDIR)dskdefs.h $(INCDIR)byteswapdefs.h \
 	$(INCDIR)car-cdrdefs.h $(INCDIR)cell.h $(INCDIR)commondefs.h \
 	$(INCDIR)ufsdefs.h
@ -515,7 +515,7 @@ $(OBJECTDIR)ufs.o: $(SRCDIR)ufs.c $(REQUIRED-INCS) \
 	$(INCDIR)lispemul.h $(INCDIR)lispmap.h \
 	$(INCDIR)adr68k.h $(INCDIR)lsptypes.h $(INCDIR)lspglob.h $(INCDIR)ifpage.h \
 	$(INCDIR)iopage.h $(INCDIR)miscstat.h $(INCDIR)arith.h $(INCDIR)stream.h \
-	$(INCDIR)timeout.h $(INCDIR)locfile.h $(INCDIR)lispver2.h $(INCDIR)dbprint.h \
+	$(INCDIR)timeout.h $(INCDIR)locfile.h $(INCDIR)dbprint.h \
 	$(INCDIR)ufsdefs.h $(INCDIR)commondefs.h $(INCDIR)dskdefs.h
 	$(CC) $(RFLAGS) $(SRCDIR)ufs.c -o $(OBJECTDIR)ufs.o

@ -523,7 +523,7 @@ $(OBJECTDIR)dir.o: $(SRCDIR)dir.c $(REQUIRED-INCS) \
 	$(INCDIR)lispemul.h $(INCDIR)lispmap.h \
 	$(INCDIR)adr68k.h $(INCDIR)lsptypes.h $(INCDIR)arith.h $(INCDIR)lspglob.h \
 	$(INCDIR)ifpage.h $(INCDIR)iopage.h $(INCDIR)miscstat.h $(INCDIR)timeout.h \
-	$(INCDIR)locfile.h $(INCDIR)lispver2.h $(INCDIR)dirdefs.h \
+	$(INCDIR)locfile.h $(INCDIR)dirdefs.h \
 	$(INCDIR)commondefs.h $(INCDIR)dskdefs.h $(INCDIR)ufsdefs.h
 	$(CC) $(RFLAGS) $(SRCDIR)dir.c -o $(OBJECTDIR)dir.o

@ -640,7 +640,7 @@ $(OBJECTDIR)inet.o: $(SRCDIR)inet.c $(REQUIRED-INCS) \
 	$(INCDIR)lispemul.h $(INCDIR)lispmap.h \
 	$(INCDIR)lsptypes.h $(INCDIR)arith.h $(INCDIR)emlglob.h $(INCDIR)lspglob.h \
 	$(INCDIR)ifpage.h $(INCDIR)iopage.h $(INCDIR)miscstat.h $(INCDIR)adr68k.h \
-	$(INCDIR)dbprint.h $(INCDIR)locfile.h $(INCDIR)lispver2.h \
+	$(INCDIR)dbprint.h $(INCDIR)locfile.h \
 	$(INCDIR)inetdefs.h $(INCDIR)byteswapdefs.h $(INCDIR)commondefs.h \
 	$(INCDIR)mkcelldefs.h
 	$(CC) $(RFLAGS) $(SRCDIR)inet.c -o $(OBJECTDIR)inet.o
@ -674,7 +674,7 @@ $(OBJECTDIR)initsout.o: $(SRCDIR)initsout.c $(REQUIRED-INCS) \

 $(OBJECTDIR)kbdsubrs.o: $(SRCDIR)kbdsubrs.c $(REQUIRED-INCS) \
 	$(INCDIR)lispemul.h $(INCDIR)kbdsubrsdefs.h \
-	$(INCDIR)commondefs.h $(INCDIR)lisp2cdefs.h $(INCDIR)xwinmandefs.h \
+	$(INCDIR)commondefs.h $(INCDIR)xwinmandefs.h \
 	$(INCDIR)devif.h
 	$(CC) $(RFLAGS) $(SRCDIR)kbdsubrs.c -o $(OBJECTDIR)kbdsubrs.o

@ -758,7 +758,7 @@ $(OBJECTDIR)osmsg.o: $(SRCDIR)osmsg.c $(REQUIRED-INCS) \
 	$(INCDIR)lispemul.h $(INCDIR)lispmap.h \
 	$(INCDIR)adr68k.h $(INCDIR)lsptypes.h $(INCDIR)arith.h $(INCDIR)stream.h \
 	$(INCDIR)lspglob.h $(INCDIR)ifpage.h $(INCDIR)iopage.h $(INCDIR)miscstat.h \
-	$(INCDIR)timeout.h $(INCDIR)locfile.h $(INCDIR)lispver2.h $(INCDIR)osmsgprint.h \
+	$(INCDIR)timeout.h $(INCDIR)locfile.h $(INCDIR)osmsgprint.h \
 	$(INCDIR)dbprint.h $(INCDIR)commondefs.h $(INCDIR)osmsgdefs.h
 	$(CC) $(RFLAGS) $(SRCDIR)osmsg.c -o $(OBJECTDIR)osmsg.o

@ -865,7 +865,7 @@ $(OBJECTDIR)unixcomm.o: $(SRCDIR)unixcomm.c $(REQUIRED-INCS) \
 	$(INCDIR)lspglob.h $(INCDIR)ifpage.h $(INCDIR)iopage.h $(INCDIR)miscstat.h \
 	$(INCDIR)cell.h $(INCDIR)stack.h $(INCDIR)arith.h $(INCDIR)dbprint.h \
 	$(INCDIR)timeout.h $(INCDIR)unixcommdefs.h $(INCDIR)byteswapdefs.h \
-	$(INCDIR)commondefs.h $(INCDIR)locfile.h $(INCDIR)lispver2.h
+	$(INCDIR)commondefs.h $(INCDIR)locfile.h
 	$(CC) $(RFLAGS) $(SRCDIR)unixcomm.c -o $(OBJECTDIR)unixcomm.o

 $(OBJECTDIR)unixfork.o: $(SRCDIR)unixfork.c $(REQUIRED-INCS) \
@ -888,7 +888,7 @@ $(OBJECTDIR)rpc.o: $(SRCDIR)rpc.c $(REQUIRED-INCS) \
 	$(INCDIR)lispemul.h $(INCDIR)lispmap.h \
 	$(INCDIR)lsptypes.h $(INCDIR)lspglob.h $(INCDIR)ifpage.h $(INCDIR)iopage.h \
 	$(INCDIR)miscstat.h $(INCDIR)emlglob.h $(INCDIR)adr68k.h $(INCDIR)arith.h \
-	$(INCDIR)locfile.h $(INCDIR)lispver2.h $(INCDIR)rpcdefs.h \
+	$(INCDIR)locfile.h $(INCDIR)rpcdefs.h \
 	$(INCDIR)commondefs.h
 	$(CC) $(RFLAGS) $(SRCDIR)rpc.c -o $(OBJECTDIR)rpc.o

@ -909,7 +909,7 @@ $(OBJECTDIR)vmemsave.o: $(SRCDIR)vmemsave.c $(REQUIRED-INCS) \
 	$(INCDIR)lispemul.h \
 	$(INCDIR)lispmap.h $(INCDIR)lspglob.h $(INCDIR)ifpage.h $(INCDIR)iopage.h \
 	$(INCDIR)miscstat.h $(INCDIR)timeout.h $(INCDIR)adr68k.h \
-	$(INCDIR)lsptypes.h $(INCDIR)locfile.h $(INCDIR)lispver2.h $(INCDIR)dbprint.h \
+	$(INCDIR)lsptypes.h $(INCDIR)locfile.h $(INCDIR)dbprint.h \
 	$(INCDIR)devif.h $(INCDIR)vmemsavedefs.h $(INCDIR)byteswapdefs.h $(INCDIR)commondefs.h \
 	$(INCDIR)dskdefs.h $(INCDIR)initkbddefs.h $(INCDIR)perrnodefs.h \
 	$(INCDIR)ufsdefs.h
--- a/inc/dirdefs.h
+++ b/inc/dirdefs.h
@ -58,7 +58,7 @@ typedef struct dfinfo {
 } DFINFO;

 #ifdef DOS
-int make_old_version(char *old, char *file);
+int make_old_version(char *old, size_t oldsize, char *file);
 #endif
 #ifdef FSDEBUG
 void print_finfo(FINFO *fp);
--- a/inc/dskdefs.h
+++ b/inc/dskdefs.h
@ -19,7 +19,9 @@ 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);
+void conc_dir_and_name(char *dir, char *name, char *fname, size_t fname_size);
+void conc_name_and_version(char *name, char *ver, char *rname, size_t rname_size);
+void separate_version(char *name, size_t namesize, char *ver, size_t versize, int checkp);
 int unpack_filename(char *file, char *dir, char *name, char *ver, int checkp);
-int true_name(char *path);
+int true_name(char *path, size_t pathsize);
 #endif
--- a/inc/gcfinaldefs.h
+++ b/inc/gcfinaldefs.h
@ -2,14 +2,10 @@
 #define GCFINALDEFS_H 1
 #include "lispemul.h" /* for LispPTR, DLword */
 void printarrayblock(LispPTR base);
-int integerlength(unsigned int n);
-LispPTR findptrsbuffer(LispPTR ptr);
+void printfreeblockchainn(int arlen);
 LispPTR releasingvmempage(LispPTR ptr);
 LispPTR checkarrayblock(LispPTR base, LispPTR free, LispPTR onfreelist);
-LispPTR deleteblock(LispPTR base);
-LispPTR linkblock(LispPTR base);
 LispPTR makefreearrayblock(LispPTR block, DLword length);
-LispPTR arrayblockmerger(LispPTR base, LispPTR nbase);
 LispPTR mergebackward(LispPTR base);
 LispPTR mergeforward(LispPTR base);
 LispPTR reclaimarrayblock(LispPTR ptr);
--- a/inc/lispver2.h
+++ b/inc/lispver2.h
@ -1,74 +0,0 @@
-#ifndef LISPVER2_H
-#define LISPVER2_H 1
-/* $Id: lispver2.h,v 1.2 1999/01/03 02:06:09 sybalsky Exp $ (C) Copyright Venue, All Rights Reserved  */
-
-/* non-DOS version of LispVersionToUnixVersion */
-
-#define LispVersionToUnixVersion(pathname) do {				\
-									\
-	char	*lv_cp;						\
-	char	*lv_vp;						\
-	unsigned lv_ver;					\
-	char		lv_ver_buf[VERSIONLEN];				\
-									\
-	lv_cp = pathname;						\
-	lv_vp = NULL;							\
-	while (*lv_cp) {						\
-		switch (*lv_cp) {					\
-									\
-		      case ';':						\
-			lv_vp = lv_cp;					\
-			lv_cp++;					\
-			break;						\
-									\
-		      case '\'':					\
-			if (*(lv_cp + 1) != 0) lv_cp += 2; 		\
-			else lv_cp++;					\
-			break;						\
-									\
-		      default:						\
-			lv_cp++;					\
-			break;						\
-		}							\
-	}								\
-									\
-	if (lv_vp != NULL) {						\
-		/*							\
-		 * A semicolon which is not quoted has been found.	\
-		 */							\
-		if (*(lv_vp + 1) == 0) {				\
-			/*						\
-			 * The empty version field.			\
-			 * This is regarded as a versionless file.	\
-			 */						\
-			*lv_vp = 0;					\
-		} else {						\
-			NumericStringP((lv_vp + 1), YES, NO);		\
-		      YES:						\
-			/*						\
-			 * Convert the remaining field to digit.	\
-			 */						\
-			lv_ver = strtoul(lv_vp + 1, (char **)NULL, 10); \
-			if (lv_ver == 0) {				\
-				/* versionless */			\
-				*lv_vp = 0;				\
-			} else {					\
-				sprintf(lv_ver_buf, ".~%u~", lv_ver);	\
-				*lv_vp = 0;				\
-				strcat(pathname, lv_ver_buf);		\
-			}						\
-			goto CONT;					\
-									\
-		      NO:						\
-			strcpy(lv_ver_buf, lv_vp + 1);			\
-			strcat(lv_ver_buf, "~");			\
-			*lv_vp++ = '.';					\
-			*lv_vp++ = '~';					\
-			*lv_vp = 0;					\
-			strcat(pathname, lv_ver_buf);			\
-		      CONT:						\
-			lv_vp--;	/* Just for label */		\
-		}							\
-	}								\
-} while (0)
-#endif /* LISPVER2_H */
--- a/inc/locfile.h
+++ b/inc/locfile.h
@ -12,6 +12,7 @@
 #include <limits.h>   /* for NAME_MAX */
 #include <dirent.h>   /* for MAXNAMLEN */
 #include "lispemul.h" /* for DLword */
+#include "commondefs.h" /* for error */

 #define	FDEV_PAGE_SIZE		512	/* 1 page == 512 byte */

@ -34,6 +35,8 @@
 #define	PROTECTION		(S_POSITIVE | 6)
 #define	EOL			(S_POSITIVE | 7)
 #define	ALL			(S_POSITIVE | 8)
+#define INODE_LO		(S_POSITIVE | 9)
+#define INODE_HI		(S_POSITIVE | 10)

 #define	ToLispTime(x)	((int)(x) + 29969152)
 			/* For getfileinfo. For WDATE&RDATE */
@ -44,18 +47,17 @@
 			/* For getfileinfo. For WDATE&RDATE */
 			/* 29969152 == (timer.c)LISP_UNIX_TIME_DIFF */

-#define StrNCpyFromCToLisp(lispbuf, cbuf ,len)	do {	\
-			char *lf_sptr = (cbuf);		\
-                        char *lf_dptr = (lispbuf);                      \
-			for(size_t lf_i=0;lf_i<(len);lf_i++)\
-				GETBYTE(lf_dptr++) = *lf_sptr++;		\
-  } while (0)
-
-#define StrNCpyFromLispToC(cbuf , lispbuf, len)	do {	\
-			char *lf_sptr = (lispbuf);                                          \
-			char *lf_dptr = (cbuf);                       \
-			for(size_t lf_i=0;lf_i<(len);lf_i++)\
-				*lf_dptr++ = GETBYTE(lf_sptr++);		\
+/*
+ *  Copy memory between native memory locations accounting for potential
+ *  byte-swapping necessary when then destination is within Lisp memory space
+ *  though the provided destination pointer is a native address within the
+ *  Lisp space.
+ */
+ #define MemCpyToLispFromNative(lispbuf, cbuf, len)                               \
+  do {                                                                            \
+    char *lf_sptr = (cbuf);                                                       \
+    char *lf_dptr = (lispbuf);                                                    \
+    for (size_t lf_i = 0; lf_i < (len); lf_i++) *BYTEPTR(lf_dptr++) = *lf_sptr++; \
  } while (0)

 #define FGetNum(ptr, place) do { \
@ -64,6 +66,10 @@
        else {return(NIL);}} while (0)


+#ifndef min
+#define min(a, b) (((a) <= (b))?(a):(b))
+#endif /* min */
+
 /************************************************************************/
 /*									*/
 /*		  L i s p S t r i n g T o C S t r i n g			*/
@ -79,65 +85,52 @@
 /*									*/
 /************************************************************************/
 #ifndef BYTESWAP
-#define	LispStringToCString(Lisp, C, MaxLen)				\
-  do {									\
-    OneDArray	*lf_arrayp;						\
-    char	*lf_base, *lf_dp;						\
-    short	*lf_sbase;							\
-    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 *)(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 *)(NativeAligned2FromLAddr(lf_arrayp->base)))	\
-		       + ((int)(lf_arrayp->offset));			\
-                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:							\
-		error("LispStringToCString: Not a character array.\n");	\
-      }									\
- } while (0)
+static void LispStringToCString(LispPTR Lisp, char *C, size_t MaxLen) {
+  OneDArray *lf_arrayp;
+  char *lf_base, *lf_dp;
+  short *lf_sbase;
+  size_t lf_length;
+  lf_arrayp = (OneDArray *)NativeAligned4FromLAddr(Lisp);
+  lf_length = min(MaxLen - 1, lf_arrayp->fillpointer);
+  lf_dp = (C);
+  switch (lf_arrayp->typenumber) {
+    case THIN_CHAR_TYPENUMBER:
+      lf_base = ((char *)(NativeAligned2FromLAddr(lf_arrayp->base))) + ((int)(lf_arrayp->offset));
+      strncpy(lf_dp, lf_base, lf_length);
+      lf_dp[lf_length] = '\0';
+      break;
+
+    case FAT_CHAR_TYPENUMBER:
+      lf_sbase = ((short *)(NativeAligned2FromLAddr(lf_arrayp->base))) + ((int)(lf_arrayp->offset));
+      for (size_t lf_i = 0; lf_i < (lf_length); lf_i++) *lf_dp++ = (char)(*lf_sbase++);
+      *lf_dp = '\0';
+      break;
+    default: error("LispStringToCString: Not a character array.\n");
+  }
+}
 #else  /* BYTESWAP == T CHANGED-BY-TAKE */
-#define	LispStringToCString(Lisp, C, MaxLen)				\
-  do {									\
-    OneDArray	*lf_arrayp;						\
-    char	*lf_base, *lf_dp;						\
-    short	*lf_sbase;							\
-    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 *)(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 *)(NativeAligned2FromLAddr(lf_arrayp->base)))	\
-		       + ((int)(lf_arrayp->offset));			\
-                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;							\
-	default:							\
-		error("LispStringToCString: Not a character array.\n");	\
-      }									\
-  } while (0)
+static void LispStringToCString(LispPTR Lisp, char *C, size_t MaxLen) {
+  OneDArray *lf_arrayp;
+  char *lf_base, *lf_dp;
+  short *lf_sbase;
+  size_t lf_length;
+  lf_arrayp = (OneDArray *)(NativeAligned4FromLAddr(Lisp));
+  lf_length = min(MaxLen - 1, lf_arrayp->fillpointer);
+  lf_dp = (C);
+  switch (lf_arrayp->typenumber) {
+    case THIN_CHAR_TYPENUMBER:
+      lf_base = ((char *)(NativeAligned2FromLAddr(lf_arrayp->base))) + ((int)(lf_arrayp->offset));
+      for (size_t lf_i = 0; lf_i < lf_length; lf_i++) *lf_dp++ = GETBYTE(lf_base++);
+      break;
+
+    case FAT_CHAR_TYPENUMBER:
+      lf_sbase = ((short *)(NativeAligned2FromLAddr(lf_arrayp->base))) + ((int)(lf_arrayp->offset));
+      for (size_t lf_ii = 0; lf_ii < lf_length; lf_ii++) *lf_dp++ = (char)(GETWORD(lf_sbase++));
+      break;
+    default: error("LispStringToCString: Not a character array.\n");
+  }
+  *lf_dp = '\0';
+}

 #endif /* BYTESWAP */

@ -189,10 +182,6 @@ do  {				\
 	(cstringp) = (char *)(NativeAligned2FromLAddr(((OneDArray *)lf_naddress)->base)); \
 } while (0)

-#ifndef min
-#define min(a, b) (((a) <= (b))?(a):(b))
-#endif /* min */
-
 #define	LispNumToCInt(Lisp)					\
       ( (((Lisp) & SEGMASK) == S_POSITIVE) ? ((Lisp) & 0xFFFF) : \
          (((Lisp) & SEGMASK) == S_NEGATIVE) ? ((Lisp) | 0xFFFF0000) : \
@ -299,7 +288,7 @@ do  {				\
 * Argument:	char	*pathname
 *				Xerox Lisp syntax pathname.
 *
- * Value:	If succeed, returns 1, otherwise 0.
+ * Value:	On success returns 1, otherwise 0.
 *
 * Side Effect:	The version part of pathname is destructively modified.
 *
@ -312,7 +301,7 @@ do  {				\
 * code.
 * This macro should be called at the top of the routines which accept the
 * file name from lisp before converting it into UNIX file name, because
- * locating the version part, the informations about quoted characters are needed.
+ * locating the version part, the information about quoted characters are needed.
 * They might be lost in the course of the conversion.
 *
 */
@ -323,179 +312,10 @@ do  {				\
 /* * * * * it gave "Too many characters in a character constant" errors!        */
 #include "lispver1.h"
 #else /* DOS */
-/* NON-DOS version of the macro LispVersionToUnixVersion */
-#include "lispver2.h"
+/* NON-DOS version is inline in ufs.c */
 #endif /* DOS */

-
-/*		
- * Name:	UnixVersionToLispVersion
- *
- * Argument:	char	*pathname
- *				UNIX syntax pathname.
- *		int	vlessp
- *				If 0, versionless file is converted to version 1.
- *				Otherwise, remains as versionless.
- *
- * Value:	If succeed, returns 1, otherwise 0.
- *
- * Side Effect:	The version part of pathname is destructively modified.
- *
- * Description:
- *
- * Destructively modify the version part of pathname which is following the
- * UNIX file naming convention to Xerox Lisp one.
- * This macro should be called, in the routines which convert the UNIX pathname
- * to Lisp one, just before it returns the result to Lisp, because converting
- * version field will append a semicolon and it might make the routine be
- * confused.
- * The file which has not a valid version field, that is ".~##~" form, is
- * dealt with as version 1. 
- */
-
-#define UnixVersionToLispVersion(pathname, vlessp) do {				\
-										\
-	char	*start;							\
-	char	*end;							\
-	char	*lf_cp;							\
-	int	ver_no;								\
-	size_t	len;								\
-	char		ver_buf[VERSIONLEN];					\
-										\
-	if ((start = strchr(pathname, '~')) != NULL) {				\
-		/* First of all, find the version field in pathname. */		\
-		end = start;							\
-		lf_cp = start + 1;							\
-		while (*lf_cp) {							\
-			if (*lf_cp == '~') {					\
-				start = end;					\
-				end = lf_cp;					\
-				lf_cp++;						\
-			} else {						\
-				lf_cp++;						\
-			}							\
-		}								\
-										\
-		if (start != end && *(start - 1) == '.' && end == (lf_cp - 1)) {	\
-			/*							\
-			 * pathname ends in the form ".~###~".  But we		\
-			 * check ### is a valid number or not.			\
-			 */							\
-			len = (end - start) - 1;			\
-			strncpy(ver_buf, start + 1, len);			\
-			ver_buf[len] = '\0';					\
-			NumericStringP(ver_buf, YES, NO);			\
-		      YES:							\
-			*(start - 1) = ';';					\
-			*start = '\0';						\
-			*end = '\0';						\
-			/* call strtoul() to eliminate leading 0s. */		\
-			ver_no = strtoul(start + 1, (char **)NULL, 10);		\
-			sprintf(ver_buf, "%u", ver_no);				\
-			strcat(pathname, ver_buf);				\
-			goto CONT;						\
-										\
-		      NO:							\
-			/* Dealt with as version 1 unless vlessp */		\
-			if (!(vlessp)) strcat(pathname, ";1");                  \
-		      CONT:							\
-			lf_cp--;	/* Just for label */			\
-		} else {							\
-			/* Dealt with as version 1 unless vlessp. */		\
-                        if (!(vlessp)) strcat(pathname, ";1");                  \
-		}								\
-	} else {								\
-		/* Dealt with as version 1 unless vlessp. */			\
-                if (!(vlessp)) strcat(pathname, ";1");                          \
-	}									\
-  } while (0)
-
-/*		
- * Name:	ConcDirAndName
- *
- * Argument:	char	*dir	The name of the directory.
- *		char	*name	The name of a file.
- *		char	*fname	The place where the full file name should be
- *				stored.
- * Value:	N/A
- *
- * Side Effect:	fname is replaced with the full file name.
- *
- * Description:
- *
- * Concatenate the directory name and root file name.  Checks if dir contains
- * the trail directory delimiter or not.
- *
- */
-
-#define ConcDirAndName(dir, name, fname) do {					\
-									\
-	char	*lf_cp1, *lf_cp2;					\
-									\
-	lf_cp1 = dir;							\
-	lf_cp2 = dir;							\
-									\
-	while (*lf_cp2 != '\0') {						\
-		switch (*lf_cp2) {						\
-									\
-		      case '/':						\
-			lf_cp1 = lf_cp2;					\
-			lf_cp2++;						\
-			break;						\
-									\
-		      default:						\
-			lf_cp2++;						\
-			break;						\
-		}							\
-	}								\
-	if (lf_cp1 == (lf_cp2 - 1)) {						\
-                if (lf_cp1 == (dir)) {					\
-			/* dir is a root directory. */			\
-			strcpy(fname, "/");				\
-			strcat(fname, name);				\
-		} else {						\
-			/* The trail directory is included. */		\
-			strcpy(fname, dir);				\
-			strcat(fname, name);				\
-		}							\
-	} else {							\
-		/* The trail directory is not included */		\
-		strcpy(fname, dir);					\
-		strcat(fname, "/");					\
-		strcat(fname, name);					\
-	}								\
-  } while (0)
-
-/*		
- * Name:	ConcNameAndVersion
- *
- * Argument:	char	*name	The root file name.
- *		char	*ver	The file version.
- *		char	*rname 	The place where the concatenated file name will be
- *				stored.
- * Value:	N/A
- *
- * Side Effect:	rname is replaced with the concatenated file name.
- *
- * Description:
- *
- * Concatenate the root file name and its version in UNIX format.
- *
- */
-
-#define ConcNameAndVersion(name, ver, rname) do {				\
-	if (*(ver) != '\0') {						\
-		strcpy(rname, name);					\
-		strcat(rname, ".~");					\
-		strcat(rname, ver);					\
-		strcat(rname, "~");					\
-	} else {							\
-		strcpy(rname, name);					\
-	}								\
-} while (0)
-
-#define	 VERSIONLEN		16
-
+#define	VERSIONLEN		24
 #define	MAXVERSION		999999999

 #define	LASTVERSIONARRAY	((unsigned) -1)
--- a/inc/timeout.h
+++ b/inc/timeout.h
@ -37,10 +37,13 @@ extern	unsigned int TIMEOUT_TIME;
    alarm(0);		\
  } while (0)

+
+/* After any use of S_TOUT one should call alarm(0) to cancel
+ * the last pending alarm.
+ */
 #define	S_TOUT(exp)	\
-  alarm(TIMEOUT_TIME),                  \
-    (exp),                              \
-    alarm(0)
+  alarm(TIMEOUT_TIME),  \
+    (exp)

 #define	ERRSETJMP(rval)					\
  do {							\
--- a/inc/ufsdefs.h
+++ b/inc/ufsdefs.h
@ -5,15 +5,14 @@ LispPTR UFS_getfilename(LispPTR *args);
 LispPTR UFS_deletefile(LispPTR *args);
 LispPTR UFS_renamefile(LispPTR *args);
 LispPTR UFS_directorynamep(LispPTR *args);
+void UnixVersionToLispVersion(char *pathname, size_t pathsize, int vlessp);
+void LispVersionToUnixVersion(char *pathname, size_t pathsize);
 #ifdef DOS
-int unixpathname(char *src, char *dst, int versionp, int genp, char *drive, int *extlenptr, char *rawname);
+int unixpathname(char *src, char *dst, int dstlen, int versionp, int genp, char *drive, int *extlenptr, char *rawname);
 #else
-int unixpathname(char *src, char *dst, int versionp, int genp);
+int unixpathname(char *src, char *dst, size_t dstlen, int versionp, int genp);
 #endif
-int lisppathname(char *fullname, char *lispname, int dirp, int versionp);
-int quote_fname(char *file);
-int quote_fname_ufs(char *file);
-int quote_dname(char *dir);
+int lisppathname(char *fullname, char *lispname, size_t lispnamesize, int dirp, int versionp);
 #ifdef DOS
 init_host_filesystem(void);
 exit_host_filesystem(void);
--- a/inc/uraidextdefs.h
+++ b/inc/uraidextdefs.h
@ -4,7 +4,7 @@
 #include "stack.h" /* for FX */
 #include "lispemul.h" /* for LispPTR */

-#define URMAXFXNUM 2000
+#define URMAXFXNUM 4096
 #define URMAXCOMM 512
 #define URSCAN_ALINK 0
 #define URSCAN_CLINK 1
--- a/inc/vmemsavedefs.h
+++ b/inc/vmemsavedefs.h
@ -1,7 +1,6 @@
 #ifndef VMEMSAVEDEFS_H
 #define VMEMSAVEDEFS_H 1
-#include "lispemul.h" /* for LispPTR, DLword */
-int lispstringP(LispPTR Lisp);
+#include "lispemul.h" /* for LispPTR */
 LispPTR vmem_save(char *sysout_file_name);
 LispPTR vmem_save0(LispPTR *args);
 void lisp_finish(int exit_status);
--- a/src/dir.c
+++ b/src/dir.c
--- a/src/dsk.c
+++ b/src/dsk.c
--- a/src/ether_nethub.c
+++ b/src/ether_nethub.c
@ -468,7 +468,7 @@ LispPTR ether_get(LispPTR args[])
  log_debug(("ether_get() - begin\n"));

  target = (u_char *)NativeAligned2FromLAddr(args[1]);
-  maxByteCount = 2 * LispIntToCInt(args[0]); /* words to bytes */
+  maxByteCount = BYTESPER_DLWORD * LispIntToCInt(args[0]); /* words to bytes */
  log_debug(("  target = %p maxBytecount: %d bytes\n", (void *)target, maxByteCount));

  ether_buf = target;
@ -501,7 +501,7 @@ LispPTR ether_send(LispPTR args[])
  log_debug(("ether_send() - begin\n"));

  u_char *source = (u_char *)NativeAligned2FromLAddr(args[1]);
-  int byteCount = 2 * LispIntToCInt(args[0]); /* words to bytes */
+  int byteCount = BYTESPER_DLWORD * LispIntToCInt(args[0]); /* words to bytes */

  log_debug(("   source = %p , bytecount: %d bytes\n", (void *)source, byteCount));

--- a/src/ether_sunos.c
+++ b/src/ether_sunos.c
@ -366,7 +366,7 @@ LispPTR ether_get(LispPTR args[])
  LispPTR MaxByteCount;
  sigset_t signals;

-  MaxByteCount = 2 * (0xFFFF & args[0]); /* words to bytes */
+  MaxByteCount = BYTERSPER_DLWORD * (0xFFFF & args[0]); /* words to bytes */

  DBPRINT(("Ether Get.  "));

@ -408,7 +408,7 @@ LispPTR ether_send(LispPTR args[])
  LispPTR MaxByteCount;
  u_char *BufferAddr; /* buffer address pointer(in native address) */

-  MaxByteCount = 2 * (0xFFFF & args[0]); /* words to bytes */
+  MaxByteCount = BYTESPER_DLWORD * (0xFFFF & args[0]); /* words to bytes */
  BufferAddr = (u_char *)NativeAligned2FromLAddr(args[1]);

  if (ether_fd > 0) {
--- a/src/gcarray.c
+++ b/src/gcarray.c
@ -99,35 +99,35 @@ struct hashtable {
 LispPTR aref1(LispPTR array, int index) {
  LispPTR retval = 0;
  LispPTR base;
-  short typenumber;
-  struct arrayheader *actarray;
+  struct arrayheader *array_np;

-  actarray = (struct arrayheader *)NativeAligned4FromLAddr(array);
-  if (index >= actarray->totalsize) {
+  array_np = (struct arrayheader *)NativeAligned4FromLAddr(array);
+  if (index >= array_np->totalsize) {
    printf("Invalid index in GC's AREF1:  0x%x\n", index);
-    printf(" Array size limit:  0x%x\n", actarray->totalsize);
+    printf(" Array size limit:  0x%x\n", array_np->totalsize);
    printf(" Array ptr: 0x%x\n", array);
-    printf(" Array 68K ptr: %p\n", (void *)actarray);
-    printf("base:     0x%x\n", actarray->base);
-    printf("offset:   0x%x\n", actarray->offset);
-    printf("type #:   0x%x\n", actarray->typenumber);
-    printf("fill ptr: 0x%x\n", actarray->fillpointer);
+    printf(" Array native ptr: %p\n", (void *)array_np);
+    printf("base:     0x%x\n", array_np->base);
+    printf("offset:   0x%x\n", array_np->offset);
+    printf("type #:   0x%x\n", array_np->typenumber);
+    printf("fill ptr: 0x%x\n", array_np->fillpointer);
    error("index out of range in GC's AREF1.");
  }
-  index += actarray->offset;
-  typenumber = actarray->typenumber;
-  base = actarray->base;
-  switch (typenumber) {
-    case 3: /* unsigned 8bits */
-      retval = (GETBYTE(((char *)NativeAligned2FromLAddr(base)) + index)) & 0x0ff;
-      retval |= S_POSITIVE;
-      break;
-    case 4: /* unsigned 16bits */
-      retval = (GETWORD(((DLword *)NativeAligned2FromLAddr(base)) + index)) & 0x0ffff;
-      retval |= S_POSITIVE;
-      break;
-    case 38: retval = (*(((LispPTR *)NativeAligned4FromLAddr(base)) + index)); break;
-    default: error("Not Implemented in gc's aref1 (other types)");
+  index += array_np->offset;
+  base = array_np->base;
+  switch (array_np->typenumber) {
+  case 3: /* unsigned 8 bits */
+    retval = (GETBYTE(((char *)NativeAligned2FromLAddr(base)) + index)) & 0x0ff;
+    retval |= S_POSITIVE;
+    break;
+  case 4: /* unsigned 16 bits */
+    retval = (GETWORD(((DLword *)NativeAligned2FromLAddr(base)) + index)) & 0x0ffff;
+    retval |= S_POSITIVE;
+    break;
+  case 38: /* pointer 32 bits */
+    retval = (*(((LispPTR *)NativeAligned4FromLAddr(base)) + index));
+    break;
+  default: error("Not Implemented in gc's aref1 (other types)");
  }
  return (retval);
 }
--- a/src/gcfinal.c
+++ b/src/gcfinal.c
@ -50,7 +50,7 @@
 #include "gccodedefs.h"   // for reclaimcodeblock
 #include "gcdata.h"       // for DELREF, REC_GCLOOKUP
 #include "gchtfinddefs.h" // for htfind, rec_htfind
-#include "gcfinaldefs.h"  // for arrayblockmerger, checkarrayblock, deleteblock
+#include "gcfinaldefs.h"  // for checkarrayblock
 #include "lispemul.h"     // for LispPTR, NIL, T, POINTERMASK, DLword, ATOM_T
 #include "llstkdefs.h"    // for decusecount68k
 #include "lspglob.h"      // for FreeBlockBuckets_word, ArrayMerging_word
@ -69,13 +69,16 @@
 #endif /* NEVER */

 #define min(a, b) (((a) > (b)) ? (b) : (a))
-#define Trailer(ldatum, datum68) ((ldatum) + 2 * ((datum68)->arlen - ARRAYBLOCKTRAILERCELLS))
+#define Trailer(ldatum, datum68) ((ldatum) + DLWORDSPER_CELL * ((datum68)->arlen - ARRAYBLOCKTRAILERCELLS))
 #define BucketIndex(n) min(integerlength(n), MAXBUCKETINDEX)
 #define FreeBlockChainN(n) ((POINTERMASK & *FreeBlockBuckets_word) + 2 * BucketIndex(n))

+/*
+ * Declaration of buffer must be identical layout to Lisp BUFFER datatype in PMAP.
+ */
 #ifndef BYTESWAP
 #ifdef BIGVM
-struct buf {
+struct buffer {
  LispPTR filepage;
  LispPTR vmempage;
  LispPTR buffernext;
@ -86,7 +89,7 @@ struct buf {
  unsigned sysnext : 28;
 };
 #else
-struct buf {
+struct buffer {
  LispPTR filepage;
  LispPTR vmempage;
  LispPTR buffernext;
@ -99,7 +102,7 @@ struct buf {
 #endif /* BIGVM */
 #else
 #ifdef BIGVM
-struct buf {
+struct buffer {
  LispPTR filepage;
  LispPTR vmempage;
  LispPTR buffernext;
@ -110,7 +113,7 @@ struct buf {
  unsigned noreference : 1;
 };
 #else
-struct buf {
+struct buffer {
  LispPTR filepage;
  LispPTR vmempage;
  LispPTR buffernext;
@ -123,24 +126,32 @@ struct buf {
 #endif /* BIGVM */
 #endif /* BYTESWAP */

-/************* The following procedure is common !! **************************/
+static int integerlength(unsigned int n) {
+  int p = 0;

-int integerlength(unsigned int n) {
-  int cnt;
-  if (n <= 2)
-    return (n);
-  else {
-    cnt = 1;
-    do {
-      cnt++;
-      n = (n >> 1);
-    } while (n != 1);
-    return (cnt);
+  if (n <= 2) return (n); /* easy case */
+  if (n >= 65536) {
+    n >>= 16;
+    p += 16;
  }
+  if (n >= 256) {
+    n >>= 8;
+    p += 8;
+  }
+  if (n >= 16) {
+    n >>= 4;
+    p += 4;
+  }
+  if (n >= 4) {
+    n >>= 2;
+    p += 2;
+  }
+  if (n >= 2) {
+    p += 1;
+  }
+  return (p + 1);
 }

-/************* The above procedure is common !! **************************/
-
 /************************************************************************/
 /*									*/
 /*			f i n d p t r s b u f f e r			*/
@ -151,14 +162,16 @@ int integerlength(unsigned int n) {
 /*									*/
 /************************************************************************/

-LispPTR findptrsbuffer(LispPTR ptr) {
-  struct buf *bptr;
-  bptr = (struct buf *)NativeAligned4FromLAddr(*System_Buffer_List_word);
-  while (LAddrFromNative(bptr) != NIL) {
-    if (ptr == bptr->vmempage)
-      return (LAddrFromNative(bptr));
-    else
-      bptr = (struct buf *)NativeAligned4FromLAddr(bptr->sysnext);
+static LispPTR findptrsbuffer(LispPTR ptr) {
+  LispPTR buf;
+  struct buffer *buf_np;
+  buf = *System_Buffer_List_word;
+  while (buf != NIL) {
+    buf_np = (struct buffer *)NativeAligned4FromLAddr(buf);
+    if (ptr == buf_np->vmempage) {
+      return (buf);
+    }
+    buf = buf_np->sysnext;
  }
  return (NIL);
 }
@ -175,13 +188,13 @@ LispPTR findptrsbuffer(LispPTR ptr) {
 /************************************************************************/

 LispPTR releasingvmempage(LispPTR ptr) {
-  struct buf *bptr;
-  LispPTR bufferptr = findptrsbuffer(ptr);
+  LispPTR buffer = findptrsbuffer(ptr);
+  struct buffer *buffer_np;

-  if (bufferptr == NIL) return (NIL); /* Not in use, OK to reclaim it */
+  if (buffer == NIL) return (NIL); /* Not in use, OK to reclaim it */

-  bptr = (struct buf *)NativeAligned4FromLAddr(bufferptr);
-  bptr->noreference = T; /* Mark the buffer free to use ?? */
+  buffer_np = (struct buffer *)NativeAligned4FromLAddr(buffer);
+  buffer_np->noreference = T; /* Mark the buffer free to use ?? */
  return (ATOM_T);
 }

@ -192,10 +205,9 @@ LispPTR releasingvmempage(LispPTR ptr) {
 /*	Given an array block, do consistency checks on it.		*/
 /*									*/
 /************************************************************************/
-
 LispPTR checkarrayblock(LispPTR base, LispPTR free, LispPTR onfreelist) {
-  struct arrayblock *bbase, *btrailer;
-  struct arrayblock *bfwd, *bbwd, *rbase;
+  struct arrayblock *base_np, *trailer_np;
+  struct arrayblock *fwd_np, *bkwd_np, *rbase;
  LispPTR fbl;
  LispPTR *rover, *tmprover;
 #ifdef ARRAYCHECK
@ -204,38 +216,51 @@ LispPTR checkarrayblock(LispPTR base, LispPTR free, LispPTR onfreelist) {
  if (*Array_Block_Checking_word != NIL)
 #endif
  {
-    bbase = (struct arrayblock *)NativeAligned4FromLAddr(base);
-    btrailer = (struct arrayblock *)NativeAligned4FromLAddr(Trailer(base, bbase));
-    if (bbase->password != ARRAYBLOCKPASSWORD) {
+    base_np = (struct arrayblock *)NativeAligned4FromLAddr(base);
+    trailer_np = (struct arrayblock *)NativeAligned4FromLAddr(Trailer(base, base_np));
+#if 0
+    printf("cblock: 0x%x free: %x onfreelist: %x pw: %x arlen %d\n",
+           base, free, onfreelist, base_np->password, base_np->arlen);
+#endif
+    if (base_np->password != ARRAYBLOCKPASSWORD) {
      printarrayblock(base);
      error("ARRAYBLOCK password wrong\n");
-    } else if (bbase->inuse == free) {
+      return(T);
+    } else if (base_np->inuse == free) {
      printarrayblock(base);
      error("ARRAYBLOCK INUSE bit set wrong\n");
-    } else if (btrailer->password != ARRAYBLOCKPASSWORD) {
+      return(T);
+    } else if (trailer_np->password != ARRAYBLOCKPASSWORD) {
      printarrayblock(base);
      error("ARRAYBLOCK trailer password wrong\n");
-    } else if (bbase->arlen != btrailer->arlen) {
+      return(T);
+    } else if (base_np->arlen != trailer_np->arlen) {
      printarrayblock(base);
      error("ARRAYBLOCK Header and Trailer length don't match\n");
-    } else if (btrailer->inuse == free)
+      return(T);
+    } else if (trailer_np->inuse == free)
    /* This is not original source.(in original,
-       btrailer -> bbase) maybe, this is correction. */
+       trailer_np -> base_np) maybe, this is correction. */
    {
      printarrayblock(base);
      error("ARRAYBLOCK Trailer INUSE bit set wrong\n");
-    } else if (!onfreelist || (bbase->arlen < MINARRAYBLOCKSIZE))
+      return(T);
+    } else if (!onfreelist || (base_np->arlen < MINARRAYBLOCKSIZE))
      return (NIL);
    /* Remaining tests only for free list. */
-    bfwd = (struct arrayblock *)NativeAligned4FromLAddr(bbase->fwd);
-    bbwd = (struct arrayblock *)NativeAligned4FromLAddr(bbase->bkwd);
-    if ((bbwd->fwd != base) || (bfwd->bkwd != base)) {
+    fwd_np = (struct arrayblock *)NativeAligned4FromLAddr(base_np->fwd);
+    bkwd_np = (struct arrayblock *)NativeAligned4FromLAddr(base_np->bkwd);
+    if ((bkwd_np->fwd != base) || (fwd_np->bkwd != base)) {
      error("ARRAYBLOCK links fouled\n");
+      return(T);
    } else {
-      fbl = FreeBlockChainN(bbase->arlen);
+      fbl = FreeBlockChainN(base_np->arlen);
      rover = tmprover = (LispPTR *)NativeAligned4FromLAddr(fbl);
      /* GETBASEPTR */
-      if ((*rover & POINTERMASK) == NIL) error("Free Block's bucket empty\n");
+      if ((*rover & POINTERMASK) == NIL) {
+        error("Free Block's bucket empty\n");
+        return(T);
+      }
      do {
        if ((*rover & POINTERMASK) == base) return (NIL);
        checkarrayblock((*rover & POINTERMASK), T, NIL);
@ -254,32 +279,38 @@ LispPTR checkarrayblock(LispPTR base, LispPTR free, LispPTR onfreelist) {
 /*									*/
 /*									*/
 /************************************************************************/
-
-LispPTR deleteblock(LispPTR base) {
-  struct arrayblock *bbase, *fbbase, *bbbase;
-  LispPTR fwd, bkwd, fbl, freeblocklsp;
-  LispPTR *freeblock;
-  bbase = (struct arrayblock *)NativeAligned4FromLAddr(base);
-  if ((bbase->arlen >= MINARRAYBLOCKSIZE) && (bbase->fwd != NIL)) {
-    fwd = bbase->fwd;
-    fbbase = (struct arrayblock *)NativeAligned4FromLAddr(fwd);
-    bkwd = bbase->bkwd;
-    bbbase = (struct arrayblock *)NativeAligned4FromLAddr(bkwd);
-    fbl = FreeBlockChainN(bbase->arlen);
-    freeblock = (LispPTR *)NativeAligned4FromLAddr(fbl);
-    freeblocklsp = POINTERMASK & *freeblock;
-    if (base == fwd) {
-      if (base == freeblocklsp)
-        *freeblock = NIL;
+/*
+ * Removes "base", a block from the free list and
+ * adjusts the forward and backward pointers of the blocks behind and
+ * ahead of the deleted block.
+ * The forward and backward pointers of this deleted block are left
+ * dangling - as in the Lisp implementation. Also does not affect the
+ * inuse bit in header and trailer.
+ */
+static void deleteblock(LispPTR base) {
+  struct arrayblock *base_np, *f_np, *b_np;
+  LispPTR f, b, fbl, freeblock;
+  LispPTR *fbl_np;
+  base_np = (struct arrayblock *)NativeAligned4FromLAddr(base);
+  if ((base_np->arlen >= MINARRAYBLOCKSIZE) && (base_np->fwd != NIL)) {
+    f = base_np->fwd;
+    f_np = (struct arrayblock *)NativeAligned4FromLAddr(f);
+    b = base_np->bkwd;
+    b_np = (struct arrayblock *)NativeAligned4FromLAddr(b);
+    fbl = FreeBlockChainN(base_np->arlen);
+    fbl_np = (LispPTR *)NativeAligned4FromLAddr(fbl);
+    freeblock = POINTERMASK & *fbl_np;
+    if (base == f) {
+      if (base == freeblock)
+        *fbl_np = NIL;
      else
        error("GC error:deleting last list # FREEBLOCKLIST\n");
-      return (NIL);
-    } else if (base == freeblocklsp)
-      *freeblock = fwd;
-    fbbase->bkwd = bkwd;
-    bbbase->fwd = fwd;
+      return;
+    } else if (base == freeblock)
+      *fbl_np = f;
+    f_np->bkwd = b;
+    b_np->fwd = f;
  }
-  return (NIL);
 }

 /************************************************************************/
@ -289,34 +320,53 @@ LispPTR deleteblock(LispPTR base) {
 /*									*/
 /*									*/
 /************************************************************************/
+/*
+ * Links a block onto the free list for a particular size range.
+ * The free list is maintained as a doubly linked circular list accessed
+ * from the block pointed to by the free list bucket for the size.
+ * If there are no blocks in the free list bucket then the forward and
+ * backward pointers of the newly added block point to the block itself.
+ */
+static LispPTR linkblock(LispPTR base) {
+  struct arrayblock *base_np, *freeblock_np, *tail_np;
+  LispPTR fbl, freeblock;
+  LispPTR *fbl_np;

-LispPTR linkblock(LispPTR base) {
-  struct arrayblock *bbase, *fbbase, *tmpbase;
-  LispPTR fbl, freeblocklsp;
-  LispPTR *freeblock;
-  if (*FreeBlockBuckets_word != NIL) {
-    bbase = (struct arrayblock *)NativeAligned4FromLAddr(base);
-    if (bbase->arlen < MINARRAYBLOCKSIZE)
-      checkarrayblock(base, T, NIL);
-    else {
-      fbl = FreeBlockChainN(bbase->arlen);
-      freeblock = (LispPTR *)NativeAligned4FromLAddr(POINTERMASK & fbl);
-      freeblocklsp = POINTERMASK & (*freeblock);
-      if (freeblocklsp == NIL) {
-        bbase->fwd = base;
-        bbase->bkwd = base;
-      } else {
-        fbbase = (struct arrayblock *)NativeAligned4FromLAddr(freeblocklsp);
-        bbase->fwd = freeblocklsp;
-        bbase->bkwd = fbbase->bkwd;
-        tmpbase = (struct arrayblock *)NativeAligned4FromLAddr(fbbase->bkwd);
-        tmpbase->fwd = base;
-        fbbase->bkwd = base;
-      }
-      *freeblock = base;
-      checkarrayblock(base, T, T);
-    }
+  if (*FreeBlockBuckets_word == NIL)
+    return (base);
+
+  base_np = (struct arrayblock *)NativeAligned4FromLAddr(base);
+  if (base_np->arlen < MINARRAYBLOCKSIZE) {
+    checkarrayblock(base, T, NIL);
+    return (base);
  }
+
+  /* lisp pointer to bucket for size */
+  fbl = FreeBlockChainN(base_np->arlen);
+  /* native pointer to bucket */
+  fbl_np = (LispPTR *)NativeAligned4FromLAddr(POINTERMASK & fbl);
+  /* lisp pointer to first free block on chain */
+  freeblock = POINTERMASK & (*fbl_np);
+  if (freeblock == NIL) { /* no blocks already in chain */
+    base_np->fwd = base;
+    base_np->bkwd = base;
+  } else {
+    /* set up new block to be first free block on the chain */
+    freeblock_np = (struct arrayblock *)NativeAligned4FromLAddr(freeblock);
+    /* link new block forward to free block */
+    base_np->fwd = freeblock;
+    /* new block's backward link becomes free block's backward link  */
+    base_np->bkwd = freeblock_np->bkwd;
+    /* get the tail location (backward pointer of freelist head) */
+    tail_np = (struct arrayblock *)NativeAligned4FromLAddr(freeblock_np->bkwd);
+    /* set its forward pointer to new block */
+    tail_np->fwd = base;
+    /* and the update the free block's backward link to new block */
+    freeblock_np->bkwd = base;
+  }
+  /* new block becomes the head of the free list */
+  *fbl_np = base;
+  checkarrayblock(base, T, T); /* free, and on free list */
  return (base);
 }

@ -330,17 +380,26 @@ LispPTR linkblock(LispPTR base) {

 LispPTR makefreearrayblock(LispPTR block, DLword length) {
  LispPTR trailer;
-  struct arrayblock *bbase;
-  struct abdum *dbase;
-  bbase = (struct arrayblock *)NativeAligned4FromLAddr(block);
-  dbase = (struct abdum *)WORDPTR(bbase);
-  dbase->abflags = FREEARRAYFLAGWORD;
-  bbase->arlen = length;
-  trailer = Trailer(block, bbase);
-  bbase = (struct arrayblock *)NativeAligned4FromLAddr(trailer);
-  dbase = (struct abdum *)WORDPTR(bbase);
-  dbase->abflags = FREEARRAYFLAGWORD;
-  bbase->arlen = length;
+  struct arrayblock *block_np, *trailer_np;
+  struct abdum *flags_np;
+  block_np = (struct arrayblock *)NativeAligned4FromLAddr(block);
+  /* this is an appropriate place to test whether the block that
+     is about to be freed contains words that look like valid
+     array header/trailer pairs as data.  This may result in
+     false positives, but could help if there's a real smash happening.
+  */
+  /* struct abdum's abflags is a DLword and does not account for
+     the BYTESWAP setup (as arrayblock does), so use WORDPTR to
+     pick the correct word of the cell
+  */
+  flags_np = (struct abdum *)WORDPTR(block_np);
+  flags_np->abflags = FREEARRAYFLAGWORD;
+  block_np->arlen = length;
+  trailer = Trailer(block, block_np);
+  trailer_np = (struct arrayblock *)NativeAligned4FromLAddr(trailer);
+  flags_np = (struct abdum *)WORDPTR(trailer_np);
+  flags_np->abflags = FREEARRAYFLAGWORD;
+  trailer_np->arlen = length;
  return (block);
 }

@ -351,13 +410,13 @@ LispPTR makefreearrayblock(LispPTR block, DLword length) {
 /*									*/
 /*									*/
 /************************************************************************/
-LispPTR arrayblockmerger(LispPTR base, LispPTR nbase) {
+static LispPTR arrayblockmerger(LispPTR base, LispPTR nbase) {
  DLword arlens, narlens, secondbite, minblocksize, shaveback;
-  struct arrayblock *bbase, *bnbase;
-  bbase = (struct arrayblock *)NativeAligned4FromLAddr(base);
-  bnbase = (struct arrayblock *)NativeAligned4FromLAddr(nbase);
-  arlens = bbase->arlen;
-  narlens = bnbase->arlen;
+  struct arrayblock *base_np, *nbase_np;
+  base_np = (struct arrayblock *)NativeAligned4FromLAddr(base);
+  nbase_np = (struct arrayblock *)NativeAligned4FromLAddr(nbase);
+  arlens = base_np->arlen;
+  narlens = nbase_np->arlen;
  secondbite = MAXARRAYBLOCKSIZE - arlens;
  /* There are three cases for merging the blocks
   * (1) the total size of the two blocks is less than max:
@ -367,7 +426,7 @@ LispPTR arrayblockmerger(LispPTR base, LispPTR nbase) {
   * (3) creating a max size block leaves a non-viable leftover block
   *     move the boundary to make a big block and a minimum size leftover block
   */
-  if (base + (2 * arlens) != nbase) {
+  if (base + (DLWORDSPER_CELL * arlens) != nbase) {
    error("Attempt to merge non-adjacent blocks in array space\n");
  }
  if (narlens > secondbite) { /* (2) or (3) */
@ -381,7 +440,7 @@ LispPTR arrayblockmerger(LispPTR base, LispPTR nbase) {
      arlens += shaveback;
      secondbite += shaveback;
    }
-    linkblock(makefreearrayblock(nbase + 2 * secondbite, narlens));
+    linkblock(makefreearrayblock(nbase + DLWORDSPER_CELL * secondbite, narlens));
    narlens = 0;
  }
  return (linkblock(makefreearrayblock(base, arlens + narlens)));
@ -395,18 +454,34 @@ LispPTR arrayblockmerger(LispPTR base, LispPTR nbase) {
 /*									*/
 /************************************************************************/

+/*
+ * merges this block into the block behind it, unless there are
+ * disqualifying conditions:
+ *     merging is turned off or
+ *     this is the first block in array space or
+ *     this is the first block in the 2nd array space or
+ *     the block behind it is in use
+ * in which case it is linked onto the freelist (fwd and backward pointers)
+ * and added to the free block chain by size.
+ * If it can be merged, 
+ */
 LispPTR mergebackward(LispPTR base) {
  LispPTR pbase;
-  struct arrayblock *ptrailer;
+  struct arrayblock *ptrailer_np;

  if (base == NIL)
    return (NIL);
-  ptrailer = (struct arrayblock *)NativeAligned4FromLAddr(base - ARRAYBLOCKTRAILERWORDS);
+  /* back up to get the trailer of the previous block */
+  ptrailer_np = (struct arrayblock *)NativeAligned4FromLAddr(base - ARRAYBLOCKTRAILERWORDS);
+  /* check that there are no disqualifying conditions for merging with previous block */
  if ((*ArrayMerging_word == NIL) ||
-           ((base == *ArraySpace_word) || ((base == *ArraySpace2_word) || (ptrailer->inuse == T))))
+           ((base == *ArraySpace_word) || ((base == *ArraySpace2_word) || (ptrailer_np->inuse == T))))
    return (linkblock(base));
-  pbase = base - 2 * ptrailer->arlen;
+  /* back up to the header of the previous block */
+  pbase = base - DLWORDSPER_CELL * ptrailer_np->arlen;
+  /* check that it is free, but skip free list checks */
  checkarrayblock(pbase, T, NIL);
+  /* remove it from the free list */
  deleteblock(pbase);
  return (arrayblockmerger(pbase, base));
 }
@ -421,17 +496,17 @@ LispPTR mergebackward(LispPTR base) {

 LispPTR mergeforward(LispPTR base) {
  LispPTR nbase, nbinuse;
-  struct arrayblock *bbase, *bnbase;
+  struct arrayblock *base_np, *nbase_np;
  if (*ArrayMerging_word == NIL) return NIL;
  if (base == NIL) return NIL;
  if (checkarrayblock(base, T, T)) return NIL;

-  bbase = (struct arrayblock *)NativeAligned4FromLAddr(base);
-  nbase = base + 2 * (bbase->arlen);
+  base_np = (struct arrayblock *)NativeAligned4FromLAddr(base);
+  nbase = base + DLWORDSPER_CELL * (base_np->arlen);
  if (nbase == *ArrayFrLst_word || nbase == *ArrayFrLst2_word) return NIL;

-  bnbase = (struct arrayblock *)NativeAligned4FromLAddr(nbase);
-  nbinuse = bnbase->inuse;
+  nbase_np = (struct arrayblock *)NativeAligned4FromLAddr(nbase);
+  nbinuse = nbase_np->inuse;
  if (checkarrayblock(nbase, !nbinuse, NIL)) return NIL;
  if (nbinuse) return (NIL);
  deleteblock(nbase);
@ -446,10 +521,13 @@ LispPTR mergeforward(LispPTR base) {
 /*	Reclaim a block of storage in the array-space heap.		*/
 /*									*/
 /************************************************************************/
-
+/*
+ * The pointer passed is to the data of the block, not the array block
+ * header.
+ */
 LispPTR reclaimarrayblock(LispPTR ptr) {
  LispPTR tmpptr, btrailer;
-  struct arrayblock *base;
+  struct arrayblock *base_np;
  LispPTR *tmpp;
  int reclaim_p;

@ -458,7 +536,7 @@ LispPTR reclaimarrayblock(LispPTR ptr) {
  checkarrayblock(ptr - ARRAYBLOCKHEADERWORDS, NIL, NIL);
 #endif /* ARRAYCHECK */

-  base = (struct arrayblock *)NativeAligned4FromLAddr(ptr - ARRAYBLOCKHEADERWORDS);
+  base_np = (struct arrayblock *)NativeAligned4FromLAddr(ptr - ARRAYBLOCKHEADERWORDS);
 #ifdef ARRAYCHECK
  if (HILOC(ptr) < FIRSTARRAYSEGMENT) {
    printarrayblock(ptr - ARRAYBLOCKHEADERWORDS);
@ -466,11 +544,11 @@ LispPTR reclaimarrayblock(LispPTR ptr) {
        "Bad array block reclaimed [not in array space].\nContinue with 'q' but save state ASAP. "
        "\n");
    return (T);
-  } else if (ARRAYBLOCKPASSWORD != base->password) {
+  } else if (ARRAYBLOCKPASSWORD != base_np->password) {
    printarrayblock(ptr - ARRAYBLOCKHEADERWORDS);
    error("Bad array block reclaimed [password wrong].\nContinue with 'q' but save state ASAP. \n");
    return (T);
-  } else if (base->inuse == NIL) {
+  } else if (base_np->inuse == NIL) {
    printarrayblock(ptr - ARRAYBLOCKHEADERWORDS);
    error(
        "Bad array block reclaimed [block not in use].\nContinue with 'q' but save state ASAP. \n");
@ -479,15 +557,15 @@ LispPTR reclaimarrayblock(LispPTR ptr) {
 #else
  /* Normal case, just tell the guy something's wrong: */
  if ((HILOC(ptr) < FIRSTARRAYSEGMENT) ||
-      ((ARRAYBLOCKPASSWORD != base->password) || (base->inuse == NIL))) {
+      ((ARRAYBLOCKPASSWORD != base_np->password) || (base_np->inuse == NIL))) {
    error("Bad array block reclaimed--continue with 'q' but save state ASAP. \n");
    return (T);
  }
 #endif /* ARRAYCHECK */

-  switch (base->gctype) {
+  switch (base_np->gctype) {
    case PTRBLOCK_GCT: {
-      btrailer = (ptr - 2) + 2 * (base->arlen - ARRAYBLOCKTRAILERCELLS);
+      btrailer = (ptr - 2) + DLWORDSPER_CELL * (base_np->arlen - ARRAYBLOCKTRAILERCELLS);
      tmpptr = ptr;
      do {
        tmpp = (LispPTR *)NativeAligned4FromLAddr(tmpptr);
@ -504,7 +582,7 @@ LispPTR reclaimarrayblock(LispPTR ptr) {
      /* default:   No Action */
  }
  if (reclaim_p == T)
-    mergeforward(mergebackward(makefreearrayblock(ptr - ARRAYBLOCKHEADERWORDS, base->arlen)));
+    mergeforward(mergebackward(makefreearrayblock(ptr - ARRAYBLOCKHEADERWORDS, base_np->arlen)));
  return (T);
 }

@ -536,31 +614,62 @@ LispPTR reclaimstackp(LispPTR ptr) /* This is the entry function */
 /************************************************************************/

 void printarrayblock(LispPTR base) {
-  struct arrayblock *bbase, *btrailer, *ptrailer;
+  struct arrayblock *base_np, *trailer_np, *ptrailer_np;
  LispPTR *addr;
-
  LispPTR pbase, nbase;

-  bbase = (struct arrayblock *)NativeAligned4FromLAddr(base);
-  btrailer = (struct arrayblock *)NativeAligned4FromLAddr(Trailer(base, bbase));
-  ptrailer = (struct arrayblock *)NativeAligned4FromLAddr(base - ARRAYBLOCKTRAILERWORDS);
+  base_np = (struct arrayblock *)NativeAligned4FromLAddr(base);
+  trailer_np = (struct arrayblock *)NativeAligned4FromLAddr(Trailer(base, base_np));
+  ptrailer_np = (struct arrayblock *)NativeAligned4FromLAddr(base - ARRAYBLOCKTRAILERWORDS);

-  nbase = base + 2 * bbase->arlen;
-  pbase = base - 2 * ptrailer->arlen;
+  nbase = base + DLWORDSPER_CELL * base_np->arlen;
+  pbase = base - DLWORDSPER_CELL * ptrailer_np->arlen;

  printf("This array block: 0x%x.  Previous: 0x%x.  Next: 0x%x.\n", base, pbase, nbase);
-  printf("          Length: %d cells.\n\n", bbase->arlen);
+  printf("        password: 0x%x     gctype: 0x%x   in use: %d\n", base_np->password,
+         base_np->gctype, base_np->inuse);
+  if (!base_np->inuse)
+    printf("      Free list: fwd 0x%x bkwd 0x%x\n", base_np->fwd, base_np->bkwd);
+  printf("  Header  Length: %d cells.\n\n", base_np->arlen);
+  printf(" Trailer  Length: %d cells.\n\n", trailer_np->arlen);

-  addr = ((LispPTR *)bbase) - 20;
-  for (; addr < (LispPTR *)bbase; addr++) printf("%16p %8x\n", (void *)addr, *addr);
-  printf("%16p %8x <- array header\n", (void *)addr, *addr);
+  addr = ((LispPTR *)base_np) - 20;
+  for (; addr < (LispPTR *)base_np; addr++) printf("%16p (0x%8x) %8x\n", (void *)addr, LAddrFromNative(addr), *addr);
+  printf("%16p (0x%8x) %8x <- array header\n", (void *)addr, LAddrFromNative(addr), *addr);
  addr++;
-  for (; addr < (LispPTR *)bbase + 20; addr++) printf("%16p %8x\n", (void *)addr, *addr);
+  for (; addr < (LispPTR *)base_np + 20; addr++) printf("%16p (0x%8x) %8x\n", (void *)addr, LAddrFromNative(addr), *addr);
  printf(". . .\n");

-  addr = ((LispPTR *)btrailer) - 20;
-  for (; addr < (LispPTR *)btrailer; addr++) printf("%16p %8x\n", (void *)addr, *addr);
-  printf("%16p %8x <- array trailer\n", (void *)addr, *addr);
+  addr = ((LispPTR *)trailer_np) - 20;
+  for (; addr < (LispPTR *)trailer_np; addr++) printf("%16p (0x%8x) %8x\n", (void *)addr, LAddrFromNative(addr), *addr);
+  printf("%16p (0x%8x) %8x <- array trailer\n", (void *)addr, LAddrFromNative(addr), *addr);
  addr++;
-  for (; addr < (LispPTR *)btrailer + 20; addr++) printf("%16p %8x\n", (void *)addr, *addr);
+  for (; addr < (LispPTR *)trailer_np + 20; addr++) printf("%16p (0x%8x) %8x\n", (void *)addr, LAddrFromNative(addr), *addr);
+}
+
+static void printfreeblockchainhead(int index)
+{
+  LispPTR fbl, freeblock;
+  LispPTR *fbl_np;
+
+  fbl = POINTERMASK & ((*FreeBlockBuckets_word) + (DLWORDSPER_CELL * index));
+  fbl_np = (LispPTR *)NativeAligned4FromLAddr(fbl);
+  /* lisp pointer to free block on chain */
+  freeblock = POINTERMASK & (*fbl_np);
+  if (freeblock == NIL) { /* no blocks in chain */
+    printf("Free block chain (bucket %d): NIL\n", index);
+  } else {
+    printf("Free block chain(bucket %d): 0x%x\n", index, freeblock);
+  }
+}
+
+void printfreeblockchainn(int arlen)
+{
+  if (arlen >= 0) {
+    printfreeblockchainhead(BucketIndex(arlen));
+    return;
+  } else
+    for (int i = 0; i <= MAXBUCKETINDEX; i++) {
+      printfreeblockchainhead(i);
+    }
 }
--- a/src/kbdsubrs.c
+++ b/src/kbdsubrs.c
@ -28,7 +28,6 @@
 #include "kbdsubrsdefs.h"
 #include "commondefs.h"
 #ifdef XWINDOW
-#include "lisp2cdefs.h"
 #include "xwinmandefs.h"
 #endif

--- a/src/kprint.c
+++ b/src/kprint.c
@ -98,10 +98,12 @@ void prindatum(LispPTR x) {
      break;
    case TYPE_ONED_ARRAY:
    case TYPE_GENERAL_ARRAY:
+      /* this should probably use array.h's arrayheader */
      newstring = (NEWSTRINGP *)NativeAligned4FromLAddr(x);
      if (newstring->stringp) {
        print_NEWstring(x);
      }
+      /* it would be useful to print non-string arrays, too */
      break;
    default: dtd_base = (struct dtd *)GetDTD(typen); printf("{");
 #ifdef BIGVM
@ -173,14 +175,20 @@ void print_string(LispPTR x) {
 void print_NEWstring(LispPTR x) {
  NEWSTRINGP *string_point;
  DLword st_length;
+  DLword st_offset;
  DLbyte *string_base;

  int i;

  string_point = (NEWSTRINGP *)NativeAligned4FromLAddr(x);
  st_length = string_point->fillpointer;
+  st_offset = string_point->offset;
+  if (string_point->indirectp) {
+    /* base points to another array header not the raw storage */
+    string_point = (NEWSTRINGP *)NativeAligned4FromLAddr(string_point->base);
+  }
  string_base = (DLbyte *)NativeAligned2FromLAddr(string_point->base);
-  string_base += string_point->offset;
+  string_base += st_offset;

  printf("%c", DOUBLEQUOTE); /* print %" */

--- a/src/ldeether.c
+++ b/src/ldeether.c
@ -200,7 +200,7 @@ int main(int argc, char *argv[]) {
        goto I_Give_Up;
      }
      bcopy(if_data.ifc_req[0].ifr_addr.sa_data, ether_host, 6);
-      strcpy(Ename, if_data.ifc_req[0].ifr_name);
+      strlcpy(Ename, if_data.ifc_req[0].ifr_name, sizeof(Ename));

      fcntl(ether_fd, F_SETFL, fcntl(ether_fd, F_GETFL, 0) | O_ASYNC | O_NONBLOCK);

--- a/src/ldsout.c
+++ b/src/ldsout.c
@ -216,8 +216,8 @@ unsigned sysout_loader(const char *sysout_file_name, unsigned sys_size) {
  }

  if ((stat_buf.st_size & (BYTESPER_PAGE - 1)) != 0)
-    printf("CAUTION::not an integral number of pages.  sysout & 0x1ff = 0x%x\n",
-           (int)(stat_buf.st_size & (BYTESPER_PAGE - 1)));
+    printf("CAUTION::not an integral number of pages.  sysout & 0x%x = 0x%x\n",
+           BYTESPER_PAGE - 1, (int)(stat_buf.st_size & (BYTESPER_PAGE - 1)));

  if (ifpage.nactivepages != (sysout_size / 2)) {
    printf("sysout_loader:IFPAGE says sysout size is %d\n", ifpage.nactivepages);
--- a/src/lisp2c.c
+++ b/src/lisp2c.c
@ -38,6 +38,8 @@ int LispStringSimpleLength(LispPTR lispstring) {
  return (arrayp->fillpointer);
 }

+/* XXX: this string conversion is NOT useable on byte-swapped (little-endian) machines
+ */
 void LispStringToCStr(LispPTR lispstring, char *cstring) {
  OneDArray *arrayp;
  char *base;
--- a/src/osmsg.c
+++ b/src/osmsg.c
@ -233,15 +233,13 @@ LispPTR mess_read(LispPTR *args)
  struct stat sbuf;
  int size, save_size;
  char *base;
-  LispPTR *naddress;
  int i;
  static char temp_buf[MESSAGE_BUFFER_SIZE];

  SETJMP(NIL);

  /* Get buff address from LISP */
-  naddress = (LispPTR *)(NativeAligned4FromLAddr(args[0]));
-  base = (char *)(NativeAligned2FromLAddr(((OneDArray *)naddress)->base));
+  STRING_BASE(args[0], base);

  close(log_id);
  TIMEOUT(log_id = open(logfile, O_RDONLY));
@ -283,7 +281,7 @@ LispPTR mess_read(LispPTR *args)
    if (temp_buf[i] == '\n') temp_buf[i] = '\000';
  }
  /* COPY actual Lisp Buffer(for BYTESWAP magic) */
-  StrNCpyFromCToLisp(base, temp_buf, size);
+  MemCpyToLispFromNative(base, temp_buf, size);

  return (GetSmallp(size));
 #else
--- a/src/ufs.c
+++ b/src/ufs.c
@ -9,6 +9,7 @@

 #include "version.h"

+#include <ctype.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <setjmp.h>
@ -176,9 +177,9 @@ LispPTR UFS_getfilename(LispPTR *args)
 * unixpathname specifies it.
 */
 #ifdef DOS
-  if (unixpathname(lfname, file, 0, 0, 0, 0, 0) == 0) return (NIL);
+  if (unixpathname(lfname, file, sizeof(file), 0, 0, 0, 0, 0) == 0) return (NIL);
 #else
-  if (unixpathname(lfname, file, 0, 0) == 0) return (NIL);
+  if (unixpathname(lfname, file, sizeof(file), 0, 0) == 0) return (NIL);
 #endif /* DOS */

  switch (args[1]) {
@ -200,7 +201,7 @@ LispPTR UFS_getfilename(LispPTR *args)
    case RECOG_NON:
      /*
       * "New" file means the "not existing" file.  UNIX device always
-       * recognizes a not existing file as if, the subsequent OPENFILE will
+       * recognizes a not existing file as is, the subsequent OPENFILE will
       * find the truth.
       * "Non" recognition is used to recognize a sysout file.
       */
@ -210,15 +211,15 @@ LispPTR UFS_getfilename(LispPTR *args)
   * Now, we convert a file name back to Lisp format.  The version field have not
   * to be converted.  The fourth argument for lisppathname specifies it.
   */
-  if (lisppathname(file, lfname, 0, 0) == 0) return (NIL);
+  if (lisppathname(file, lfname, sizeof(lfname), 0, 0) == 0) return (NIL);

  STRING_BASE(args[2], base);
  len = strlen(lfname);

 #ifndef BYTESWAP
-  strncpy(base, lfname, len + 1);
+  strncpy(base, lfname, len);
 #else
-  StrNCpyFromCToLisp(base, lfname, len + 1);
+  MemCpyToLispFromNative(base, lfname, len);
 #endif /* BYTESWAP */

  return (GetSmallp(len));
@ -259,9 +260,9 @@ LispPTR UFS_deletefile(LispPTR *args)
  LispStringToCString(args[0], fbuf, MAXPATHLEN);

 #ifdef DOS
-  if (unixpathname(fbuf, file, 0, 0, 0, 0, 0) == 0) return (NIL);
+  if (unixpathname(fbuf, file, sizeof(file), 0, 0, 0, 0, 0) == 0) return (NIL);
 #else
-  if (unixpathname(fbuf, file, 0, 0) == 0) return (NIL);
+  if (unixpathname(fbuf, file, sizeof(file), 0, 0) == 0) return (NIL);
 #endif /* DOS */
  /* check if we're operating on directory or file */
  TIMEOUT(rval = stat(file, &sbuf));
@ -327,15 +328,15 @@ LispPTR UFS_renamefile(LispPTR *args)

  LispStringToCString(args[0], fbuf, MAXPATHLEN);
 #ifdef DOS
-  if (unixpathname(fbuf, src, 0, 0, 0, 0, 0) == 0) return (NIL);
+  if (unixpathname(fbuf, src, sizeof(src), 0, 0, 0, 0, 0) == 0) return (NIL);
 #else
-  if (unixpathname(fbuf, src, 0, 0) == 0) return (NIL);
+  if (unixpathname(fbuf, src, sizeof(src), 0, 0) == 0) return (NIL);
 #endif /* DOS */
  LispStringToCString(args[1], fbuf, MAXPATHLEN);
 #ifdef DOS
-  if (unixpathname(fbuf, dst, 0, 0, 0, 0, 0) == 0) return (NIL);
+  if (unixpathname(fbuf, dst, sizeof(dst), 0, 0, 0, 0, 0) == 0) return (NIL);
 #else
-  if (unixpathname(fbuf, dst, 0, 0) == 0) return (NIL);
+  if (unixpathname(fbuf, dst, sizeof(dst), 0, 0) == 0) return (NIL);
 #endif /* DOS */

  TIMEOUT(rval = rename(src, dst));
@ -400,9 +401,9 @@ LispPTR UFS_directorynamep(LispPTR *args)

 /* Convert Xerox Lisp file naming convention to Unix one. */
 #ifdef DOS
-  if (unixpathname(dirname, fullname, 0, 0, 0, 0, 0) == 0) return (NIL);
+  if (unixpathname(dirname, fullname, sizeof(fullname), 0, 0, 0, 0, 0) == 0) return (NIL);
 #else
-  if (unixpathname(dirname, fullname, 0, 0) == 0) return (NIL);
+  if (unixpathname(dirname, fullname, sizeof(fullname), 0, 0) == 0) return (NIL);
 #endif /* DOS */

  TIMEOUT(rval = stat(fullname, &sbuf));
@ -414,20 +415,109 @@ LispPTR UFS_directorynamep(LispPTR *args)
  if (!S_ISDIR(sbuf.st_mode)) return (NIL);

  /* Convert Unix file naming convention to Xerox Lisp one. */
-  if (lisppathname(fullname, dirname, 1, 0) == 0) return (NIL);
+  if (lisppathname(fullname, dirname, sizeof(dirname), 1, 0) == 0) return (NIL);

  len = strlen(dirname);
  STRING_BASE(args[1], base);

 #ifndef BYTESWAP
-  strncpy(base, dirname, len + 1);
+  strncpy(base, dirname, len);
 #else
-  StrNCpyFromCToLisp(base, dirname, len + 1);
+  MemCpyToLispFromNative(base, dirname, len);
 #endif /* BYTESWAP */

  return (GetSmallp(len));
 }

+/*
+ * Name: UnixVersionToLispVersion
+ *
+ * Argument:  char     *pathname
+ *            size_t    pathsize
+ *            int       vlessp
+ *
+ * Description:
+ *
+ * Converts the Unix version in pathname to a Lisp syntax version.
+ * If there is no recognizable version present, and vlessp is not
+ * true then a Lisp version 1 (";1") will be added to the name.
+ *
+ * Initially only the "standard" .~nnn~ form of a version is recognized.
+ * It may be possible in the future to recognize IFS "!nnn"
+ */
+
+void UnixVersionToLispVersion(char *pathname, size_t pathsize, int vlessp) {
+    char *ep = &pathname[strlen(pathname) - 1];
+    char *uvp;
+
+#ifdef IFSVERSION
+    if (isdigit(*ep)) goto maybeifsversion;       /* possibly foo!## */
+#endif
+    if (*ep-- != '~') goto noversion;             /* definitely not .~###~ */
+    if (!isdigit(*ep)) goto noversion;            /* requires at least one digit */
+    while (isdigit(*ep)) ep--;                    /* consume all digits */
+    if (*ep-- != '~') goto noversion;             /* definitely not .~###~ */
+    if (*ep != '.') goto noversion;
+    /* must end .~###~ and ep points at the dot */
+    *ep++ = ';';  /* smash . to ; and point to ~  where version will go*/
+    for (uvp = ep + 1; *uvp == '0' && *(uvp + 1) != '~'; uvp++); /* skip leading zeroes */
+    while (*uvp != '~') *ep++ = *uvp++;           /* shift version back */
+    *ep = '\0';                                   /* terminate the string */
+    return;
+ noversion:
+    if (!vlessp) strlcat(pathname, ";1", pathsize);
+    return;
+#ifdef IFSVERSION
+ maybeifsversion:
+    while (isdigit(*ep)) ep--;                     /* consume all digits */
+    if (*ep != '!') goto noversion;
+    *ep = ';';
+    return;
+#endif
+}
+
+/*
+ * Name: LispVersionToUnixVersion
+ *
+ * Arguments:    char *pathname     Xerox Lisp style pathname
+ *               size_t pathsize    Length of pathname buffer
+ *
+ * Helper procedure used by unixpathname to convert from a Lisp style path
+ * with ";version" style version number to the ".~version~" format used in
+ * the underlying host file system.
+ * If a syntactically correct version (all numeric, starting at the rightmost
+ * unescaped (') semicolon) is found it will be replaced by the host version,
+ * otherwise the procedure will return the pathname unchanged.
+ *
+ */
+void LispVersionToUnixVersion(char *pathname, size_t pathsize) {
+    char version[VERSIONLEN] = {0};
+    char *vp = NULL;
+    char *ep = &pathname[strlen(pathname) - 1];   /* from the end */
+    while (ep >= pathname) {                      /* until the beginning */
+        if (*ep == ';' &&                           /* found a semicolon */
+            (ep == pathname || *(ep - 1) != '\'')) {/* at the beginning or not quoted */
+            vp = ep;                                  /* version starts at unquoted semicolon */
+            break;                                    /* stop when found version */
+        }
+        ep--;                                       /* previous character */
+    }
+
+    if (vp == NULL) return;                       /* there was no version field */
+
+    *vp++ = '\0';                                 /* end name at the semicolon */
+    if (*vp == '\0') return;                      /* empty version field */
+
+    while (*vp == '0') vp++;                      /* skip leading zeros */
+    if (*vp == '\0') return;                      /* all zero version is no version */
+    version[0] = '.';                             /* leading version marker */
+    version[1] = '~';                             /* leading version marker */
+    strlcat(version, vp, VERSIONLEN);             /* the trimmed version from the source */
+    strlcat(version, "~", VERSIONLEN);            /* trailing version marker */
+    strlcat(pathname, version, pathsize);         /* concatenate version to pathname */
+    return;
+}
+
 /*
 * Name:	unixpathname
 *
@ -437,6 +527,7 @@ LispPTR UFS_directorynamep(LispPTR *args)
 *				if the pathname is passed as a directory, the
 *				tail delimiter may be included.
 *		char	*dst	The buffer to which the converted pathname is stored.
+ *              int     dstlen  The size of the dst buffer
 *		int	versionp
 *				If 1, version field in src is converted to UNIX
 *				version form.  {DSK} device invokes unixpathname
@ -463,9 +554,9 @@ LispPTR UFS_directorynamep(LispPTR *args)
 *
 */
 #ifdef DOS
-int unixpathname(char *src, char *dst, int versionp, int genp, char *drive, int *extlenptr, char *rawname)
+int unixpathname(char *src, char *dst, int dstlen, int versionp, int genp, char *drive, int *extlenptr, char *rawname)
 #else
-int unixpathname(char *src, char *dst, int versionp, int genp)
+int unixpathname(char *src, char *dst, size_t dstlen, int versionp, int genp)
 #endif /* DOS */
 {
  char *cp, *dp, *np;
@ -495,12 +586,12 @@ int unixpathname(char *src, char *dst, int versionp, int genp)
   * file system code.
   */
  if (strcmp(src, "<") == 0) {
-    strcpy(dst, DIRSEPSTR);
+    strlcpy(dst, DIRSEPSTR, dstlen);
    return (1);
  }

  /* Copy src to protect it from destructive modification. */
-  strcpy(lfname, src);
+  strlcpy(lfname, src, sizeof(lfname));

 /*
 * If versionp is specified, we have to deal with the version field first,
@ -510,7 +601,7 @@ int unixpathname(char *src, char *dst, int versionp, int genp)
 #ifdef DOS
  if (versionp) LispVersionToUnixVersion(lfname, version); else version = -1;
 #else
-  if (versionp) LispVersionToUnixVersion(lfname);
+  if (versionp) LispVersionToUnixVersion(lfname, sizeof(lfname));
 #endif /* DOS */

  cp = lfname;
@ -582,7 +673,7 @@ int unixpathname(char *src, char *dst, int versionp, int genp)
        TIMEOUT0(pwd = getpwuid(getuid()));
        if (pwd == NULL) return (0);

-        strcpy(dst, pwd->pw_dir);
+        strlcpy(dst, pwd->pw_dir, dstlen);
        while (*dp != '\0') dp++;
        if (*(dp - 1) != DIRSEP) {
          /*
@ -606,7 +697,7 @@ int unixpathname(char *src, char *dst, int versionp, int genp)
        TIMEOUT0(pwd = getpwnam(name));
        if (pwd == NULL) return (0);

-        strcpy(dst, pwd->pw_dir);
+        strlcpy(dst, pwd->pw_dir, dstlen);
        while (*dp != '\0') dp++;
        if (*(dp - 1) != DIRSEP) {
          /*
@ -769,6 +860,8 @@ int unixpathname(char *src, char *dst, int versionp, int genp)
 #ifdef DOS
          if (NameValid) *dp++ = *(cp + 1);
          CountNameChars;
+#else
+          *dp++ = *(cp + 1);
 #endif /* DOS */
          cp += 2;
          break;
@ -807,10 +900,10 @@ int unixpathname(char *src, char *dst, int versionp, int genp)
     * for the convenience of the pattern matching routines, we don't
     * care about the last period character.
     */
-    strcpy(fbuf1, lfname);
-    strcpy(fbuf2, dst);
-    separate_version(fbuf1, ver1, 1);
-    separate_version(fbuf2, ver2, 1);
+    strlcpy(fbuf1, lfname, sizeof(fbuf1));
+    strlcpy(fbuf2, dst, sizeof(fbuf2));
+    separate_version(fbuf1, sizeof(fbuf1), ver1, sizeof(ver1), 1);
+    separate_version(fbuf2, sizeof(fbuf2), ver2, sizeof(ver2), 1);
    for (cp = fbuf1; *cp; cp++) {}
    for (dp = fbuf2; *dp; dp++) {}
    if (*(cp - 1) == '.') {
@ -825,11 +918,11 @@ int unixpathname(char *src, char *dst, int versionp, int genp)
    }
 #ifdef DOS
    if (version >= 0)
-      sprintf(ver2, "%d", version);
+      snprintf(ver2, sizeof(ver2), "%d", version);
    else
      *ver2 = '\0';
 #endif /* DOS */
-    ConcNameAndVersion(fbuf2, ver2, dst);
+    conc_name_and_version(fbuf2, ver2, dst, dstlen);
  }
  return (1);
 }
@ -845,6 +938,7 @@ int unixpathname(char *src, char *dst, int versionp, int genp)
 *					The lispname is used to determine which
 *					character should be quoted in the result
 *					Xerox Lisp pathname representation.
+ *		size_t	lispnamesize	size of storage available for lispname
 *		int	dirp		If 1, fullname is a directory.  If 0,
 *					fullname is a file.
 *		int	versionp	If 1, version field is also converted
@ -871,14 +965,14 @@ int unixpathname(char *src, char *dst, int versionp, int genp)
 *
 */

-int lisppathname(char *fullname, char *lispname, int dirp, int versionp)
+int lisppathname(char *fullname, char *lispname, size_t lispnamesize, int dirp, int versionp)
 {
  char *cp, *dp, *lnamep, *cnamep;
  char namebuf[MAXPATHLEN], fbuf[MAXPATHLEN], ver[VERSIONLEN];
  int i, mask, extensionp;

  if (strcmp(fullname, DIRSEPSTR) == 0) {
-    strcpy(lispname, "<");
+    strlcpy(lispname, "<", lispnamesize);
    return (1);
  }

@ -940,7 +1034,7 @@ int lisppathname(char *fullname, char *lispname, int dirp, int versionp)
   *	'		''
   *	.		'.   only if it is used as a part of the extension
   *			     field.
-   *	others		as if
+   *	others		as is
   */

  cp = fullname + 1;
@ -982,7 +1076,7 @@ int lisppathname(char *fullname, char *lispname, int dirp, int versionp)
  if (dirp) {
    if (*(dp - 1) != '>' || *(dp - 2) == '\'') *dp++ = '>';
    *dp = '\0';
-    strcpy(lispname, namebuf);
+    strlcpy(lispname, namebuf, lispnamesize);
    return (1);
  }

@ -1046,7 +1140,7 @@ int lisppathname(char *fullname, char *lispname, int dirp, int versionp)
   * or not.  If extension field is not included, we have to add a period
   * to specify empty extension field.
   */
-  strcpy(fbuf, namebuf);
+  strlcpy(fbuf, namebuf, sizeof(fbuf));
  dp = cp = fbuf;
  while (*cp) {
    switch (*cp) {
@ -1066,7 +1160,7 @@ int lisppathname(char *fullname, char *lispname, int dirp, int versionp)
    }
  }
  cp = dp + 1;
-  if (versionp) separate_version(fbuf, ver, 1);
+  if (versionp) separate_version(fbuf, sizeof(fbuf), ver, sizeof(ver), 1);
  extensionp = 0;
  while (*cp && !extensionp) {
    switch (*cp) {
@ -1087,237 +1181,16 @@ int lisppathname(char *fullname, char *lispname, int dirp, int versionp)
    *cp = '\0';
  }
  if (versionp && *ver != '\0') {
-    ConcNameAndVersion(fbuf, ver, namebuf);
+    conc_name_and_version(fbuf, ver, namebuf, sizeof(namebuf));
  } else {
-    strcpy(namebuf, fbuf);
+    strlcpy(namebuf, fbuf, sizeof(namebuf));
  }

  /*
   * Now, it's time to convert the version field.
   */
-  if (!dirp && versionp) UnixVersionToLispVersion(namebuf, 0);
+  if (!dirp && versionp) UnixVersionToLispVersion(namebuf, sizeof(namebuf), 0);

-  strcpy(lispname, namebuf);
-  return (1);
-}
-
-/*
- * Name:	quote_fname
- *
- * Argument:	char	*file		The root file name in UNIX format.  "Root"
- *					file name contains the name, extension and
- *					version fields.  A valid version field is in a
- *					form as ".~##~".
- *
- * Value:	If succeed, returns 1, otherwise 0.
- *
- * Side Effect:	If succeed, file is replaced with the file name in Xerox Lisp format
- *		in which special characters are quoted.
- *
- * Description:
- *
- * Converts a UNIX root file name to Xerox Lisp one.  This routine only quotes special
- * characters in Xerox file naming convention, does not care about the "true" name
- * which might be specified directly by the user as like lisppathname.   Thus, this
- * routine can be invoked when you don't know how to escape the period character.  This
- * is the case when you convert a file name in the course of the directory enumeration.
- *
- * This routine is used when file is a "FILE" name and being converted to {DSK} name.
- *
- * The special characters which is quoted include "<", ">", ";", and "'" itself.  Notice
- * again that "." is not quoted, because we don't know it is a extension separator in
- * Lisp sense or not.
- */
-
-int quote_fname(char *file)
-{
-  char *cp, *dp;
-  int extensionp;
-  char fbuf[MAXNAMLEN + 1], namebuf[MAXNAMLEN + 1], ver[VERSIONLEN];
-
-  cp = file;
-  dp = fbuf;
-
-  while (*cp) {
-    switch (*cp) {
-      case '>':
-      case ';':
-      case '\'':
-        *dp++ = '\'';
-        *dp++ = *cp++;
-        break;
-
-      default: *dp++ = *cp++; break;
-    }
-  }
-  *dp = '\0';
-
-  /*
-   * extensionp indicates whether extension field is included in a file
-   * name or not.  If extension field is not included, we have to add a
-   * period to specify empty extension field.
-   */
-  separate_version(fbuf, ver, 1);
-  cp = fbuf;
-  extensionp = 0;
-  while (*cp && !extensionp) {
-    switch (*cp) {
-      case '.':
-        if (*(cp + 1)) extensionp = 1;
-        cp++;
-        break;
-
-      case '\'':
-        if (*(cp + 1) != '\0')
-          cp += 2;
-        else
-          cp++;
-        break;
-
-      default: cp++; break;
-    }
-  }
-  if (!extensionp) {
-    if (*(cp - 1) == '.') {
-      *(cp - 1) = '\'';
-      *cp++ = '.';
-    }
-    *cp++ = '.';
-    *cp = '\0';
-  }
-  if (*ver != '\0') {
-    ConcNameAndVersion(fbuf, ver, namebuf);
-  } else {
-    strcpy(namebuf, fbuf);
-  }
-  UnixVersionToLispVersion(namebuf, 1);
-  strcpy(file, namebuf);
-  return (1);
-}
-
-/*
- * Name:	quote_fname_ufs
- *
- * Argument:	char	*file		The root file name in UNIX format.  "Root"
- *					file name contains the name, extension and
- *					version fields.  A valid version field is in a
- *					form as ".~##~".
- *
- * Value:	If succeed, returns 1, otherwise 0.
- *
- * Side Effect:	If succeed, file is replaced with the file name in Xerox Lisp format
- *		in which special characters are quoted.
- *
- * Description:
- *
- * Similar to quote_fname, but this routine is only used when file is a "FILE" name
- * and being converted to {UNIX} name.
- */
-
-int quote_fname_ufs(char *file)
-{
-  char *cp, *dp;
-  int extensionp;
-  char fbuf[MAXNAMLEN + 1];
-
-  cp = file;
-  dp = fbuf;
-
-  while (*cp) {
-    switch (*cp) {
-      case '>':
-      case ';':
-      case '\'':
-        *dp++ = '\'';
-        *dp++ = *cp++;
-        break;
-
-      default: *dp++ = *cp++; break;
-    }
-  }
-  *dp = '\0';
-
-  /*
-   * extensionp indicates whether extension field is included in a file
-   * name or not.  If extension field is not included, we have to add a
-   * period to specify empty extension field.
-   */
-  cp = fbuf;
-  extensionp = 0;
-  while (*cp && !extensionp) {
-    switch (*cp) {
-      case '.':
-        if (*(cp + 1)) extensionp = 1;
-        cp++;
-        break;
-
-      case '\'':
-        if (*(cp + 1) != '\0')
-          cp += 2;
-        else
-          cp++;
-        break;
-
-      default: cp++; break;
-    }
-  }
-  if (!extensionp) {
-    if (*(cp - 1) == '.') {
-      *(cp - 1) = '\'';
-      *cp++ = '.';
-    }
-    *cp++ = '.';
-    *cp = '\0';
-  }
-  strcpy(file, fbuf);
-  return (1);
-}
-
-/*
- * Name:	quote_dname
- *
- * Argument:	char	*dir		The directory name in UNIX format.  Does not
- *					include its parent name.
- *
- * Value:	If succeed, returns 1, otherwise 0.
- *
- * Side Effect:	If succeed, dir is replaced with the directory name in Xerox Lisp
- * 		format in which special characters are quoted.
- *
- * Description:
- *
- * Similar to quote_fname, but this routine is only used when dir is a "DIRECTORY"
- * name.  Both {DSK} and {UNIX} uses this routine.
- */
-
-int quote_dname(char *dir)
-{
-  char *cp, *dp;
-  char fbuf[MAXNAMLEN + 1];
-
-  cp = dir;
-  dp = fbuf;
-
-  while (*cp) {
-    switch (*cp) {
-      case '>':
-      case ';':
-      case '\'':
-        *dp++ = '\'';
-        *dp++ = *cp++;
-        break;
-
-      default: *dp++ = *cp++; break;
-    }
-  }
-  *dp = '\0';
-
-  if (*(dp - 1) == '.') {
-    /* Trail period should be quoted. */
-    *(dp - 1) = '\'';
-    *dp++ = '.';
-  }
-
-  strcpy(dir, fbuf);
+  strlcpy(lispname, namebuf, lispnamesize);
  return (1);
 }
--- a/src/unixcomm.c
+++ b/src/unixcomm.c
@ -303,7 +303,7 @@ int FindUnixPipes(void) {
 /*									*/
 /************************************************************************/

-static int FindAvailablePty(char *Slave) {
+static int FindAvailablePty(char *Slave, size_t SlaveLen) {
  int res;

  res = posix_openpt(O_RDWR);
@ -313,7 +313,7 @@ static int FindAvailablePty(char *Slave) {
  }
  grantpt(res);
  unlockpt(res);
-  strcpy(Slave, ptsname(res));
+  strlcpy(Slave, ptsname(res), SlaveLen);
  DBPRINT(("slave pty name is %s.\n", Slave));

  if (res != -1) {
@ -392,7 +392,7 @@ LispPTR Unix_handlecomm(LispPTR *args) {
      PipeName = build_socket_pathname(sockFD);
      memset(&sock, 0, sizeof(sock));
      sock.sun_family = AF_UNIX;
-      strcpy(sock.sun_path, PipeName);
+      strlcpy(sock.sun_path, PipeName, sizeof(sock.sun_path));
      if (bind(sockFD, (struct sockaddr *)&sock, sizeof(struct sockaddr_un)) < 0) {
        close(sockFD);
        perror("binding sockets");
@ -570,7 +570,7 @@ LispPTR Unix_handlecomm(LispPTR *args) {
      int Master;
      unsigned short len;

-      Master = FindAvailablePty(SlavePTY);
+      Master = FindAvailablePty(SlavePTY, sizeof(SlavePTY));
      DBPRINT(("Fork Shell; Master PTY = %d. Slave=%c%c.\n", Master, SlavePTY[0], SlavePTY[1]));
      if (Master < 0) {
        printf("Open of lisp side of PTY failed.\n");
@ -771,6 +771,7 @@ LispPTR Unix_handlecomm(LispPTR *args) {
    {
      int sockFD;
      struct sockaddr_un sock;
+      size_t pathsize;

      /* First open the socket */
      sockFD = socket(AF_UNIX, SOCK_STREAM, 0);
@ -782,12 +783,13 @@ LispPTR Unix_handlecomm(LispPTR *args) {
         socket into it */
      /* need to type-check the string here */
      LispStringToCString(args[1], shcom, 2048);
-      UJ[sockFD].pathname = malloc(strlen(shcom) + 1);
-      strcpy(UJ[sockFD].pathname, shcom);
+      pathsize = strlen(shcom) + 1;
+      UJ[sockFD].pathname = malloc(pathsize);
+      strlcpy(UJ[sockFD].pathname, shcom, pathsize);
      /* Then bind it to the pathname, and get it	listening properly */

      sock.sun_family = AF_UNIX;
-      strcpy(sock.sun_path, shcom);
+      strlcpy(sock.sun_path, shcom, sizeof(sock.sun_path));
      if (bind(sockFD, (struct sockaddr *)&sock, sizeof(struct sockaddr_un)) < 0) {
        close(sockFD);
        free(UJ[sockFD].pathname);
--- a/src/unixfork.c
+++ b/src/unixfork.c
@ -358,7 +358,7 @@ int fork_Unix(void) {
            (void)snprintf(PipeName, sizeof(PipeName), "/tmp/LPU%ld-%d", StartTime, slot);
            memset(&addr, 0, sizeof(struct sockaddr_un));
            addr.sun_family = AF_UNIX;
-            strcpy(addr.sun_path, PipeName);
+            strlcpy(addr.sun_path, PipeName, sizeof(addr.sun_path));
            status =
                connect(sock, (struct sockaddr *)&addr, sizeof(struct sockaddr_un));
            if (status < 0) {
--- a/src/uraid.c
+++ b/src/uraid.c
@ -168,6 +168,7 @@ static const char *URaid_summary2 =
    "\n-- Memory display commands\n\
 a litatom\t\tDisplays the top-level value of the litatom\n\
 B Xaddress\t\tPrint the contents of the arrayblock at that address.\n\
+F [size]\t\tPrint the head of the array free list chain for given size, or all\n\
 d litatom\t\tDisplays the definition cell for the litatom\n\
 M\t\t\tDisplays TOS,CSP,PVAR,IVAR,PC\n\
 m func1 func2\t\tMOVD func1 to func2\n\
@ -201,6 +202,7 @@ l [type]\t\tDisplays backtrace for specified type of stack. (k|m|r|g|p|u|<null>)
 \n-- Memory display commands\n\
 a litatom\t\tDisplays the top-level value of the litatom\n\
 B Xaddress\t\tDisplays the contents of the arrayblock at that address.\n\
+F [size]\t\tPrint the head of the array free list chain for given size, or all\n\
 d litatom\t\tDisplays the definition cell of the litatom\n\
 M\t\t\tDisplays TOS,CSP,PVAR,IVAR,PC\n\
 m func1 func2\t\tMoves definition of func1 to func2 (MOVD)\n\
@ -467,6 +469,26 @@ LispPTR uraid_commands(void) {
    }
    break;

+    case 'F': { /* print array block free list head(s) */
+      long size;
+      if (URaid_argnum != 1 && URaid_argnum != 2) {
+        printf("FREE-BLOCK-CHAIN: F [block-size (cells)]\n");
+        return (T);
+      }
+      if (URaid_argnum == 1) {
+        size = -1;
+      } else {
+        errno = 0;
+        size = (LispPTR)strtol(URaid_arg1, &endpointer, 0);
+        if (errno != 0 || *endpointer != '\0') {
+          printf("Arg not number\n");
+          return (T);
+        }
+      }
+      printfreeblockchainn(size);
+    }
+    break;
+
    case 'd': /* DEFCELL */
      if (URaid_argnum != 2) {
        printf("GETD: d litatom\n");
--- a/src/vmemsave.c
+++ b/src/vmemsave.c
@ -92,7 +92,7 @@ extern int please_fork;
 /*									*/
 /************************************************************************/

-int lispstringP(LispPTR Lisp)
+static int lispstringP(LispPTR Lisp)
 {
  switch (((OneDArray *)(NativeAligned4FromLAddr(Lisp)))->typenumber) {
    case THIN_CHAR_TYPENUMBER:
@ -156,36 +156,36 @@ LispPTR vmem_save0(LispPTR *args)
    LispStringToCString(args[0], pathname, MAXPATHLEN);
    separate_host(pathname, host);
 #ifdef DOS
-    if (!unixpathname(pathname, sysout, 0, 0, drive, 0, 0)) return (BADFILENAME);
+    if (!unixpathname(pathname, sysout, sizeof(sysout), 0, 0, drive, 0, 0)) return (BADFILENAME);
 #else
-    if (!unixpathname(pathname, sysout, 0, 0)) return (BADFILENAME);
+    if (!unixpathname(pathname, sysout, sizeof(sysout), 0, 0)) return (BADFILENAME);
 #endif /* DOS */
    return (vmem_save(sysout));
  } else {
    if ((def = getenv("LDEDESTSYSOUT")) == 0) {
 #ifdef DOS
      if (getcwd(pwd, MAXNAMLEN) == NULL) return (FILETIMEOUT);
-      strcpy(sysout, pwd);
-      strcat(sysout, "/lisp.vm");
+      strlcpy(sysout, pwd, sizeof(sysout));
+      strlcat(sysout, "/lisp.vm", sizeof(sysout));
 #else
      pwd = getpwuid(getuid()); /* NEED TIMEOUT */
      if (pwd == (struct passwd *)NULL) return (FILETIMEOUT);
-      strcpy(sysout, pwd->pw_dir);
-      strcat(sysout, "/lisp.virtualmem");
+      strlcpy(sysout, pwd->pw_dir, sizeof(sysout));
+      strlcat(sysout, "/lisp.virtualmem", sizeof(sysout));
 #endif /* DOS */
    } else {
      if (*def == '~' && (*(def + 1) == '/' || *(def + 1) == '\0')) {
 #ifdef DOS
        if (getcwd(pwd, MAXNAMLEN) == NULL) return (FILETIMEOUT);
-        strcpy(sysout, pwd);
+        strlcpy(sysout, pwd, sizeof(sysout));
 #else
        pwd = getpwuid(getuid()); /* NEED TIMEOUT */
        if (pwd == (struct passwd *)NULL) return (FILETIMEOUT);
-        strcpy(sysout, pwd->pw_dir);
+        strlcpy(sysout, pwd->pw_dir, sizeof(sysout));
 #endif /* DOS */
-        strcat(sysout, def + 1);
+        strlcat(sysout, def + 1, sizeof(sysout));
      } else {
-        strcpy(sysout, def);
+        strlcpy(sysout, def, sizeof(sysout));
      }
    }
    return (vmem_save(sysout));
@ -349,9 +349,9 @@ LispPTR vmem_save(char *sysout_file_name)
  SETJMP(FILETIMEOUT);
 #ifdef DOS
  /* Bloddy 8 char filenames in dos ... /jarl */
-  make_old_version(tempname, sysout_file_name);
+  make_old_version(tempname, sizeof(tempname), sysout_file_name);
 #else  /* DOS */
-  sprintf(tempname, "%s-temp", sysout_file_name);
+  snprintf(tempname, sizeof(tempname), "%s-temp", sysout_file_name);
 #endif /* DOS */

  /* Confirm protection of specified file by open/close */
--- a/src/xrdopt.c
+++ b/src/xrdopt.c
@ -17,7 +17,7 @@
 #include <limits.h>         // for PATH_MAX
 #include <stdio.h>          // for fprintf, NULL, stderr, sscanf
 #include <stdlib.h>         // for getenv, exit, strtol
-#include <string.h>         // for strncpy, strcat, strcpy, strcmp
+#include <string.h>         // for strncpy, strlcat, strlcpy, strcmp
 #include <sys/types.h>      // for u_char
 #include <unistd.h>         // for access, R_OK
 #include "xdefs.h"          // for WINDOW_NAME
@ -211,13 +211,13 @@ void read_Xoption(int *argc, char *argv[])
    print_Xusage(argv[0]);
  } else {
    envname = getenv("DISPLAY");
-    (void)strcpy(Display_Name, envname);
+    (void)strlcpy(Display_Name, envname, sizeof(Display_Name));
  }
  if ((xdisplay = XOpenDisplay(Display_Name)) != NULL) {
    /* read the other databases */
    /* Start with app-defaults/medley */
-    (void)strcpy(tmp, "/usr/lib/X11/app-defaults/");
-    (void)strcat(tmp, "medley");
+    (void)strlcpy(tmp, "/usr/lib/X11/app-defaults/", sizeof(tmp));
+    (void)strlcat(tmp, "medley", sizeof(tmp));
    applicationDB = XrmGetFileDatabase(tmp);
    if (applicationDB != NULL) { (void)XrmMergeDatabases(applicationDB, &rDB); }
    /* Then try the displays defaults */
@ -232,8 +232,8 @@ void read_Xoption(int *argc, char *argv[])
  }

  envname = getenv("HOME");
-  (void)strcat(tmp, envname);
-  (void)strcat(tmp, "/.Xdefaults");
+  (void)strlcpy(tmp, envname, sizeof(tmp));
+  (void)strlcat(tmp, "/.Xdefaults", sizeof(tmp));
  if (access(tmp, R_OK) != 0) {
    serverDB = XrmGetFileDatabase(tmp);
    if (serverDB != NULL) { (void)XrmMergeDatabases(serverDB, &rDB); }
@ -255,7 +255,7 @@ void read_Xoption(int *argc, char *argv[])
  if (XrmGetResource(rDB, "ldex.icontitle", "Ldex.icontitle", str_type, &value) == True) {
    (void)strncpy(iconTitle, value.addr, value.size);
  } else {
-    (void)strcpy(iconTitle, "Medley");
+    (void)strlcpy(iconTitle, "Medley", sizeof(iconTitle));
  }

  if (XrmGetResource(rDB, "ldex.iconbitmap", "Ldex.Iconbitmap", str_type, &value) == True) {
@ -276,8 +276,6 @@ void read_Xoption(int *argc, char *argv[])
                             &LispDisplayRequestedWidth, &LispDisplayRequestedHeight);
  }

-  (void)strcpy(tmp, ""); /* Clear the string */
-
  if (XrmGetResource(rDB, "ldex.cursorColor", "Ldex.cursorColor", str_type, &value) == True) {
    (void)strncpy(cursorColor, value.addr, sizeof(cursorColor) - 1);
  }
Author	SHA1	Message	Date
Nick Briggs	d791b1d332	Merge pull request #533 from Interlisp/nhb-rewrite-version-parser-v2 Extensive rewrite of various parts of the file name/version handling code. Converts a lot of unsafe string handling functions to safer variants. Passes buffer sizes in various places to enable overflow checks. Removes some unused variable declarations. Updates comments. Improves performance with alarm timeout setting when sequences of alarm set/cancel operations are performed. Adds GETFILEINFO processing for INODE_LO and INODE_HI attributes.	2025-10-31 15:29:43 -07:00
Nick Briggs	3d09555c6c	Removes assigned-but-not-used rval in DSK_getfilename and redundant test of current_len in conc_dir_and_name	2025-10-21 18:04:40 -07:00
Nick Briggs	8ad8b4db2a	Removes unused local variable len	2025-10-21 18:03:11 -07:00
Nick Briggs	673ec07a58	Updates CMakeLists.txt to reflect removal of inc/lispver2.h	2025-10-21 17:23:31 -07:00
Nick Briggs	60e12dabc0	Removes comment that is now unnecessary/confusing	2025-10-20 16:57:44 -07:00
Nick Briggs	e2f69f4e48	Adds comment clarifying requirement to call alarm(0) after S_TOUT	2025-10-20 16:57:00 -07:00
Nick Briggs	9f1bcb9299	Simplify conc_dir_and_name implementation for Gemini	2025-10-20 16:35:54 -07:00
Nick Briggs	4dfbdf27ff	Responds to Gemini review of potential buffer overflows in quote_... fns	2025-10-20 16:07:36 -07:00
Nick Briggs	51a33680f4	Resolves error and style complaints by Gemini code review	2025-10-20 15:50:52 -07:00
Nick Briggs	d4a882adc2	Uses sizeof() or passed size, where known, in calls to conc_name_and_version	2025-10-20 15:08:51 -07:00
Nick Briggs	67f8cc0cf0	Cleanup UnixVersionToLispVersion and LispVersionToUnixVersion * implements these as functions rather than #define macros * moves definitions to ufs.c * adds parameter to UnixVersionToLispVersion for the storage size of the buffer being passed * removes inc/lispver2.h * adjusts makefile-dos an makefile-tail to update dependencies	2025-10-20 14:31:18 -07:00
Konrad Hinsen	853d133cda	No need to do makeright init clean	2025-09-29 11:37:54 -07:00
Konrad Hinsen	0370354432	Corrected instructions for building ldeinit	2025-09-29 11:37:54 -07:00
Konrad Hinsen	f85f6ce004	Add instructions for building a function ldeinit	2025-09-29 11:37:54 -07:00
Nick Briggs	04ad740ead	Adds GETFILEATTRIBUTE processing for INODE_LO and INODE_HI attributes.	2025-08-18 23:05:53 -07:00
Nick Briggs	fe7beafcc1	"as if" => "as is" in comments.	2025-08-16 19:13:09 -07:00
Nick Briggs	e745381970	Fixup: wrong quoting function used in updates to enum_ufs, enum_ufs_prop	2025-08-16 18:56:56 -07:00
Nick Briggs	5190a3976f	Resolves issue medley #2165 ignored quoting characters in filename	2025-08-16 18:56:56 -07:00
Nick Briggs	babe728d3a	Improves performance of some file operations, fixes some memory leaks, and increases clarity. * Avoids unnecessary alarm(0) when it is about to be set again, only cleans up after it’s all done. * Renames DIRCHAR to LISPDIRCHAR to be more descriptive, adds LISPDIRSTR for contexts where a string is required rather than a character. * Avoids leaks of directory structures by ensuring that any opendir() has a matching closedir(), with a timeout check, on the return path * Ensures that closedir() calls that could smash errno happen after errno is saved for Lisp’s consumption * Simplifies code to take advantage of strlcpy()/strlcat() guarantee that destination string is NUL terminated * Reduces number of unnecessary copies into scratch buffer for file name processing * Removes some commented out code left over from copy/paste of functions	2025-08-16 18:56:56 -07:00
Nick Briggs	38d65df90c	Replaces unchecked strcpy/strcat with strlcpy/strlcat Unchecked strcpy/strcat can result in memory smashes if provided with overly long source arguments. Replacing these with the strl... functions protects against overruns of the destination memory. Requires changing the signature of various functions to pass destination storage size when destination argument is a pointer rather than something amenable to sizeof() operator.	2025-08-16 18:56:56 -07:00
Nick Briggs	d4a9286962	Replaces unchecked strcpy with strlcpy.	2025-08-16 18:56:55 -07:00
Nick Briggs	24327920f2	Replaces unchecked strcpy with strlcpy.	2025-08-16 18:56:55 -07:00
Nick Briggs	987fa637a9	Replaces unchecked strcpy with strlcpy.	2025-08-16 18:56:55 -07:00
Nick Briggs	4de8b733fd	Replaces unchecked strcpy/strcat with strlcpy/strlcat Unchecked writes to strings using strcpy and strcat can cause memory smashes, replacing them with (destination) bounds checked strl... equivalents can avoid this. Incidentally, fix construction of file name for $HOME/.Xdefaults	2025-08-16 18:56:55 -07:00
Nick Briggs	353f6d202e	Clean up quote_fname, quote_fname_ufs, and quote_dname Moves definitions of the quote_xxx functions from ufs.c where they are not used to dir.c where they are used. Adds a parameter to each of the quote_xxx functions to supply the length of the storage allocated for the result string, and change strcpy() to strlcpy() to avoid potential memory smash if used carelessly.	2025-08-16 18:56:55 -07:00
Nick Briggs	55209aa7e7	Adds size of output parameter to lisppathname() and replaces various strcpy() with strlcpy()	2025-08-16 18:56:55 -07:00
Nick Briggs	dfb820cc62	Replace sprintf() with snprintf()	2025-08-16 18:56:55 -07:00
Nick Briggs	11b81f6c17	Replaces all calls to sprintf() with snprintf() in ufs.c	2025-08-16 18:56:55 -07:00
Nick Briggs	9557ae8f5b	Updates unixpathname() signature to include output string length, replace strcpy with strlcpy	2025-08-16 18:56:55 -07:00
Nick Briggs	d1f7361429	Replaces strcat() with strlcat() in dsk.c	2025-08-16 18:56:55 -07:00
Nick Briggs	4c6aef8fd4	Replaces all strcpy() by strlcpy() in dsk.c	2025-08-16 18:56:55 -07:00
Nick Briggs	409617b506	Adds destination size to conc_... functions and switch to strlcpy/strlcat	2025-08-16 18:56:55 -07:00
Nick Briggs	6a550b4ca3	Replaces ConcNameAndVersion and ConcDirAndName macros with functions Replaces ConcNameAndVersion and ConcDirAndName macros with conc_name_and_version and conc_dir_and_name functions respectively, moves the definitions from locfile.h to dsk.c, and adds them to dskdefs.h for use by other source files.	2025-08-16 18:56:55 -07:00
Nick Briggs	f0bd8e0f1f	Merge pull request #540 from Interlisp/nhb-string-handling-cleanup	2025-08-10 09:55:25 -07:00
Nick Briggs	c9e2759666	Replaces magic number with value calculated from appropriate constant	2025-07-29 19:59:03 -07:00
Nick Briggs	9960010129	Adds handling of strings with indirect headers for URaid object printing	2025-07-28 16:09:10 -07:00
Nick Briggs	ce20b3520e	Replaces magic number 2 with BYTESPER_DLWORD in calculation of buffer size.	2025-07-26 22:11:44 -07:00
Nick Briggs	c4752e6caa	Makes vmemsave.c lispstringP implementation local and updates header file accordingly	2025-07-26 17:54:17 -07:00
Nick Briggs	78dfa9b243	Adds warning note to lisp2c.c LispStringToCStr regarding endianness sensitivity	2025-07-26 17:47:24 -07:00
Nick Briggs	cfbd78007a	Replaces #defined LispStringToCString with static procedure, reformats code	2025-07-26 17:46:13 -07:00
Nick Briggs	afe40004b8	Removes unnecessary dependency on lisp2c from kbdsubrs.c	2025-07-26 17:43:14 -07:00
Nick Briggs	fe8c991a11	Fixes possible buffer overrun when source string too long If the Lisp string passed to LispStringToCString were longer than the destination buffer's MaxLen the could would have written the terminating nul past the end of the array. Fixes formatting of LispStringToCString Corrects English grammar in some comments.	2025-07-26 11:33:14 -07:00
Nick Briggs	5343b12991	Eliminates nul at end of Lisp string since Lisp strings are not nul terminated	2025-07-25 18:39:53 -07:00
Nick Briggs	a0e703678c	Replaces (expanded) lisp string base access pattern with STRING_BASE macro	2025-07-25 17:52:34 -07:00
Nick Briggs	364bc1f31c	Removes StrNCpyFromLispToC(), renames StrNCpyFromCToLisp to MemCpyToLispFromNative Removes StrNCpyFromLispToC and the single use of it in LispStringToCString in the BYTESWAP implementation case. Rename StrNCpyFromCToLisp, which does NOT follow "strncpy" semantics, to be MemCpyToLispFromNative, where the types in the name match the types of the arguments, and the semantics (and argument order) are those of the C library "memcpy".	2025-07-25 14:12:30 -07:00
Nick Briggs	428e7cf1a2	Merge pull request #539 from Interlisp/nhb-gc-cleanup Minor cleanup of code style in gcfinal.c and additional array free list debugging from URaid	2025-07-25 14:02:13 -07:00
Nick Briggs	01d21b0a44	Revert integerlength() to pure (but more efficient) C as glibc does not provide fls()	2025-07-22 09:43:49 -07:00
Nick Briggs	3569e54524	Uses consistent naming (_np) for native pointer equivalents of Lisp addresses in GC aref1	2025-07-20 10:48:20 -07:00
Nick Briggs	b75e66d91c	Renames struct buf to struct buffer to match corresponding Lisp datatype name	2025-07-19 23:19:19 -07:00
Nick Briggs	0e2cda2328	Cleans up releasingvmempage implementation Uses consistent naming (_np) for native pointer equivalents of Lisp addresses	2025-07-19 22:44:27 -07:00
Nick Briggs	c58336f813	Cleans up checkarrayblock implementation Uses consistent naming (_np) for native pointer equivalents of Lisp addresses Ensures non-zero return value if arrayblock fails check	2025-07-19 18:11:43 -07:00
Nick Briggs	f2bf026b07	Adds URaid F command to print array block free list heads	2025-07-19 17:50:55 -07:00
Nick Briggs	3fad090a6c	Cleans up printarrayblock implementation Uses consistent naming (_np) for native pointer equivalents of Lisp addresses	2025-07-19 17:34:52 -07:00
Nick Briggs	812e296fe8	Cleans up reclaimarrayblock implementation Uses consistent naming (_np) for native pointer equivalents of Lisp addresses Adds comments regarding the parameter passed to reclaimarrayblock	2025-07-19 15:41:50 -07:00
Nick Briggs	7c7da4cd0c	Cleans up mergeforward implementation Uses consistent naming (_np) for native pointer equivalents of Lisp addresses	2025-07-19 13:19:27 -07:00
Nick Briggs	f375519dbc	Cleans up mergebackward implementation Uses consistent naming (_np) for native pointer equivalents of Lisp addresses Adds comments with a little explanation of what the code is doing	2025-07-19 12:35:02 -07:00
Nick Briggs	2c46a9473a	Cleans up and makes static arrayblockmerger implementation Uses consistent naming (_np) for native pointer equivalents of Lisp addresses	2025-07-19 12:29:33 -07:00
Nick Briggs	93b3a709c9	Cleans up makefreearrayblock implementation Uses consistent naming (_np) for native pointer equivalents of Lisp addresses Adds comments regarding use of WORDPTR macro to hide BYTESWAP setting	2025-07-19 12:11:11 -07:00
Nick Briggs	31fcfb36ca	Cleans up linkblock implementation to increase clarity Procedure can be static as it is only used within this file Uses consistent naming (_np) for native pointer equivalents of Lisp addresses, and better matches Lisp implementation naming of variables. Improve readability by reducing if/else nesting with early outs in exceptional cases. Still equivalent to the original Lisp version. Adds comments with a little explanation of what the code is doing.	2025-07-19 11:49:30 -07:00
Nick Briggs	1f18779eb8	Cleans up deleteblock implementation to increase clarity Procedure can be static void as there was only an unused constant result. Uses consistent naming (_np) for native pointer equivalents of Lisp addresses, and better matches Lisp implementation naming of variables. Adds comments with a little explanation of what the code is doing.	2025-07-18 10:09:41 -07:00
Nick Briggs	357336b5f1	Rewrites (and makes static) findptrsbuffer to avoid multiple conversions between Lisp and native pointers	2025-07-18 09:12:43 -07:00
Nick Briggs	1ffd1ba7cb	Replaces integerlength(n) implementation with call to fls(n) and makes it static	2025-07-17 18:52:15 -07:00
Nick Briggs	0a6f8ac72b	Replaces scaling factor 2 for array length offsets by DLWORDSPER_CELL as that is what it represents.	2025-07-17 18:46:57 -07:00
Nick Briggs	fc90838ad8	Increases number of stack frames that can be displayed by URaid 'l' command (#538 )	2025-07-10 18:36:55 -07:00