6 files changed, 6922 insertions, 57 deletions

diff --git a/lang/scm/Makefile b/lang/scm/Makefile
index 19249920ef47..8e5fd33fafce 100644
--- a/lang/scm/Makefile
+++ b/lang/scm/Makefile
@@ -2,27 +2,29 @@
 # $FreeBSD$
 
 PORTNAME=	scm
-PORTVERSION=	5f1
-PORTREVISION=	1
+PORTVERSION=	5f2
 CATEGORIES=	lang scheme
 MASTER_SITES=	http://groups.csail.mit.edu/mac/ftpdir/scm/%SUBDIR%/
 MASTER_SITE_SUBDIR=	. OLD
-DISTFILES=	${DISTNAME}${EXTRACT_SUFX} slib-3b4.zip slib-psd1-3.tar.gz
-EXTRACT_ONLY=	${DISTNAME}${EXTRACT_SUFX} slib-3b4.zip
+DISTFILES=	${DISTNAME}${EXTRACT_SUFX} slib-3b5.zip slib-psd1-3.tar.gz
+EXTRACT_ONLY=	${DISTNAME}${EXTRACT_SUFX}
 
-MAINTAINER=	ports@FreeBSD.org
+MAINTAINER=	mi@aldan.algebra.com
 COMMENT=	Scheme interpreter
 
 LICENSE=	LGPL21
 
 WRKSRC=		${WRKDIR}/${PORTNAME}
 
-USES=		gmake readline zip
+USES=		readline zip
 USE_GCC=	any
 HAS_CONFIGURE=	yes
 CONFIGURE_ENV=	--prefix=${PREFIX}
 MAKE_JOBS_UNSAFE=	yes
 
+CFLAGS+=	-Wall -Wwrite-strings -Wmissing-declarations -Wredundant-decls -Wcast-qual
+CFLAGS+=	-Wno-unused-label -Wno-uninitialized
+
 SUB_FILES=	require.scm
 
 PLIST_SUB=	VERSION="${PORTVERSION}"
@@ -49,18 +51,26 @@ SCM_MODULES_X11=x.so
 
 .include <bsd.port.options.mk>
 
-.if ${ARCH} == "ia64" || ${ARCH} == "powerpc" || ${ARCH} == "sparc64"
-BROKEN=		Does not compile on ia64, powerpc, or sparc64
+.if ${PORT_OPTIONS:MX11}
+SCM_MODULES+=	${SCM_MODULES_X11}
+SCM_DATA+=	${SCM_DATA_X11}
+.endif
+
+.if ${ARCH} == "ia64"
+EXTRA_PATCHES+=	${FILESDIR}/ia64-patch
+ARCHOBJS=	continue-ia64.S
 .endif
 
 post-extract:
-	@${TAR} -C ${WRKDIR} -zxf ${DISTDIR}/slib-psd1-3.tar.gz
+	# Certain .scm files are needed during build:
+	@${TAR} -C ${WRKDIR} -zxf ${DISTDIR}/${DISTFILES:Mslib*.zip} '*.scm'
 
 post-patch:
 	@${REINPLACE_CMD} -e 's|/usr/include|${LOCALBASE}/include| ; \
 		 /strip/s|^|#|' ${WRKSRC}/Makefile
 	@${REINPLACE_CMD} -e 's|%%CC%%|${CC}|g ; \
 		 s|%%CFLAGS%%|${CFLAGS}|g ; \
+		 s|%%ARCHOBJS%%|${ARCHOBJS}|g ; \
 		 s|%%LOCALBASE%%|${LOCALBASE}|g' ${WRKSRC}/build.scm
 	@${REINPLACE_CMD} -e 's|__osf__|__FreeBSD__|' ${WRKSRC}/gmalloc.c
 	@${REINPLACE_CMD} -e 's|gnuregex\.h|gnu/regex.h|g' ${WRKSRC}/rgx.c
@@ -68,38 +78,16 @@ post-patch:
 		${WRKSRC}/xgen.scm
 
 do-install:
-	(cd ${WRKSRC} && ${INSTALL_PROGRAM} scm scmlit \
-		${STAGEDIR}${PREFIX}/bin)
-	(cd ${WRKSRC} && ${INSTALL_MAN} scm.1 \
-		${STAGEDIR}${MANPREFIX}/man/man1)
+	${INSTALL_PROGRAM} ${WRKSRC}/scm ${WRKSRC}/scmlit \
+		${STAGEDIR}${PREFIX}/bin
+	${INSTALL_MAN} ${WRKSRC}/scm.1 ${STAGEDIR}${MANPREFIX}/man/man1
 	@${MKDIR} ${STAGEDIR}${PREFIX}/lib/scm
-	(cd ${WRKDIR} && ${INSTALL_DATA} require.scm \
-		${STAGEDIR}${PREFIX}/lib/scm)
-.for i in ${SCM_DATA}
-	(cd ${WRKSRC} && ${INSTALL_DATA} ${i} \
-		${STAGEDIR}${PREFIX}/lib/scm)
-.endfor
-.for i in ${SCM_MODULES}
-	(cd ${WRKSRC} && ${INSTALL_LIB} ${i} \
-		${STAGEDIR}${PREFIX}/lib/scm)
-.endfor
-.if ${PORT_OPTIONS:MX11}
-.for i in ${SCM_DATA_X11}
-	(cd ${WRKSRC} && ${INSTALL_DATA} ${i} \
-		${STAGEDIR}${PREFIX}/lib/scm)
-.endfor
-.for i in ${SCM_MODULES_X11}
-	(cd ${WRKSRC} && ${INSTALL_LIB} ${i} \
-		${STAGEDIR}${PREFIX}/lib/scm)
-.endfor
-.endif
-	@${MKDIR} ${STAGEDIR}${PREFIX}/lib/scm/slib
-	(cd ${WRKDIR}/slib && ${INSTALL_DATA} *.scm \
-		${STAGEDIR}${PREFIX}/lib/scm/slib)
-	@${MKDIR} ${STAGEDIR}${PREFIX}/lib/scm/slib/psd
-	(cd ${WRKDIR}/slib/psd && ${INSTALL_DATA} *.scm \
-		${STAGEDIR}${PREFIX}/lib/scm/slib/psd)
-	(cd ${WRKDIR}/scm && ${INSTALL_DATA} scm.info \
-		${STAGEDIR}${PREFIX}/${INFO_PATH})
+	${INSTALL_DATA} ${WRKDIR}/require.scm ${SCM_DATA:S|^|${WRKSRC}/|} \
+		${STAGEDIR}${PREFIX}/lib/scm
+	${INSTALL_LIB} ${SCM_MODULES:S|^|${WRKSRC}/|} \
+		${STAGEDIR}${PREFIX}/lib/scm
+	${TAR} -C ${STAGEDIR}${PREFIX}/lib/scm -xf ${DISTDIR}/${DISTFILES:Mslib*.tar.gz} '*.scm'
+	${INSTALL_DATA} ${WRKDIR}/slib/*.scm ${STAGEDIR}${PREFIX}/lib/scm/slib/
+	${INSTALL_DATA} ${WRKDIR}/scm/scm.info ${STAGEDIR}${PREFIX}/${INFO_PATH}
 
 .include <bsd.port.mk>
diff --git a/lang/scm/distinfo b/lang/scm/distinfo
index f715cdbb12ec..27a1f11b8572 100644
--- a/lang/scm/distinfo
+++ b/lang/scm/distinfo
@@ -1,6 +1,6 @@
-SHA256 (scm-5f1.zip) = f469e08e03fef5e2fa54349faaff630e63e88fc39f5fc98a6a55a6aa865a57c0
-SIZE (scm-5f1.zip) = 952965
-SHA256 (slib-3b4.zip) = ddfa66c61db1dec44147cad98e46cb9ec151f62dfaa10aa2508fbd26d46272a7
-SIZE (slib-3b4.zip) = 1099910
+SHA256 (scm-5f2.zip) = 29f182bb5e675d4dcffac897b5e08c59739513fd09e5f1928c2c5419ca921114
+SIZE (scm-5f2.zip) = 954890
+SHA256 (slib-3b5.zip) = f8b64a9820c2ccbdb263a0cb7bcf4caadce0857fdf4e2f52111ca33b4a131760
+SIZE (slib-3b5.zip) = 1105432
 SHA256 (slib-psd1-3.tar.gz) = 1665fc6cf572e6d8d99e81b4f6b1e65b04a095b69baebd85d0085ad552dc2955
 SIZE (slib-psd1-3.tar.gz) = 62397
diff --git a/lang/scm/files/ia64-patch b/lang/scm/files/ia64-patch
new file mode 100644
index 000000000000..4b8328df4a81
--- /dev/null
+++ b/lang/scm/files/ia64-patch
@@ -0,0 +1,9 @@
+--- Makefile	2013-03-10 03:29:54.000000000 +0000
++++ Makefile	2015-01-23 21:59:51.747074000 +0000
+@@ -104,5 +104,5 @@
+ ofiles = scm.o time.o repl.o scl.o sys.o eval.o subr.o unif.o rope.o \
+ 	continue.o findexec.o script.o debug.o
+-# continue-ia64.o
++ofiles+= continue-ia64.o
+ ifiles = Init$(VERSION).scm Transcen.scm Link.scm Macro.scm Macexp.scm \
+ 	Tscript.scm compile.scm Iedline.scm Idiffer.scm
diff --git a/lang/scm/files/patch-build.scm b/lang/scm/files/patch-build.scm
index 692742b7a86e..2c31ead1237a 100644
--- a/lang/scm/files/patch-build.scm
+++ b/lang/scm/files/patch-build.scm
@@ -1,11 +1,18 @@
---- build.scm.orig	2009-08-04 03:35:57.000000000 +0900
-+++ build.scm	2009-08-07 01:59:30.000000000 +0900
+--- build.scm	2009-08-04 03:35:57.000000000 +0900
++++ build.scm	2015-01-23 16:23:32.000000000 -0500
+@@ -618,5 +618,5 @@
+ 
+      (nostart gcc "" "-e __start -nostartfiles" #f ("ecrt0.c") ())
+-     (dump gcc "" "" #f ("unexelf.c" "gmalloc.c") ())
++     (dump gcc "" "" #f ("unexelf.c") ())
+ 
+      (m hp-ux "" "-lm" #f () ())
 @@ -665,14 +665,15 @@
       (dump darwin "" "" #f ("unexmacosx.c" "lastfile.c") ())
       (dlll darwin "-DSUN_DL" "-ldl" "" () ())
  
 -     (c freebsd "" "-export-dynamic" #f () ())
-+     (c freebsd "" "-Wl,-export-dynamic" #f () ())
++     (c freebsd "" "-Wl,-export-dynamic %%ARCHOBJS%%" #f () ())
       (m freebsd "" "-lm" #f () ())
 -     (curses freebsd "" "-lncurses" "/usr/lib/libncurses.a" () ())
 +     (curses freebsd "" "-lcurses" "/usr/lib/libcurses.a" () ())
@@ -17,7 +24,7 @@
 +     (graphics freebsd "-I%%LOCALBASE%%/include -DX11" "-lX11" "-L%%LOCALBASE%%/lib" () ())
 +     (dlll freebsd "-DSUN_DL" "" "" () ())
 +     (nostart freebsd "" "" #f () ())
-+     (dump freebsd "" "" #f ("unexelf.c" "gmalloc.c") ())
++     (dump freebsd "" "" #f ("unexelf.c") ())
       (curses netbsd "-I/usr/pkg/include" "-lncurses" "-Wl,-rpath -Wl,/usr/pkg/lib -L/usr/pkg/lib" () ())
       (editline netbsd "-I/usr/pkg/include" "-lreadline" "-Wl,-rpath -Wl,/usr/pkg/lib -L/usr/pkg/lib" () ())
       (graphics netbsd "-I/usr/X11R6/include -DX11" "-lX11" "-Wl,-rpath -Wl,/usr/X11R6/lib -L/usr/X11R6/lib" () ())
diff --git a/lang/scm/files/patch-scmfig.h b/lang/scm/files/patch-scmfig.h
index 0b193ee5fd15..5c0cd0613feb 100644
--- a/lang/scm/files/patch-scmfig.h
+++ b/lang/scm/files/patch-scmfig.h
@@ -1,4 +1,4 @@
---- scmfig.h.orig
+--- scmfig.h
 +++ scmfig.h
 @@ -256,11 +256,7 @@
  #ifdef __alpha
@@ -9,24 +9,30 @@
 -# define CDR_DOUBLES
 -#endif
 -#ifdef __x86_64
-+#if defined(__amd64__) || defined(__ia64__) || defined(__powerpc64__) || defined(__x86_64__)
++#if defined(__amd64__) || defined(__ia64__) || defined(__powerpc64__) || defined(__x86_64__) || defined(__sparc64__)
  # define SHORT_INT
  # define CDR_DOUBLES
  #endif
-@@ -393,14 +389,10 @@
+@@ -393,14 +389,6 @@
  # define WHITE_SPACES  ' ':case '\t':case '\r':case '\f'
  #endif
  
 -#ifdef __ia64__
-+# if defined(__amd64__) || defined(__ia64__) || defined(__powerpc64__) || defined(__x86_64__)
- # define PTR2INT(x) ((long)(x))
- #else
+-# define PTR2INT(x) ((long)(x))
++#define PTR2INT(x) ((intptr_t)(x))
+-#else
 -# ifdef __x86_64
 -#  define PTR2INT(x) ((long)(x))
 -# else
 -#  define PTR2INT(x) ((int)(x))
 -# endif
-+# define PTR2INT(x) ((int)(x))
- #endif
+-#endif
  
  #ifndef __builtin_expect
+@@ -824,5 +816,5 @@
+ # ifdef ARM_ULIB
+     extern volatile int errno;
+-# else
++# elif defined(PLAN9)
+     extern int errno;
+ # endif
diff --git a/lang/scm/files/patch-warnings b/lang/scm/files/patch-warnings
new file mode 100644
index 000000000000..ff5257b9b27e
--- /dev/null
+++ b/lang/scm/files/patch-warnings
@@ -0,0 +1,6855 @@
+--- byte.c	2008-01-30 22:31:40.000000000 -0500
++++ byte.c	2015-01-23 18:55:19.000000000 -0500
+@@ -21,6 +21,6 @@
+ #include "scm.h"
+ 
+-char s_make_bytes[] = "make-bytes";
+-SCM scm_make_bytes(k, n)
++static const char s_make_bytes[] = "make-bytes";
++static SCM scm_make_bytes(k, n)
+      SCM k, n;
+ {
+@@ -39,5 +39,5 @@
+ }
+ #define s_bytes (s_make_bytes+5)
+-SCM scm_bytes(ints)
++static SCM scm_bytes(ints)
+      SCM ints;
+ {
+@@ -55,6 +55,6 @@
+   return res;
+ }
+-static char s_bt_ref[] = "byte-ref";
+-SCM scm_byte_ref(str, k)
++static const char s_bt_ref[] = "byte-ref";
++static SCM scm_byte_ref(str, k)
+      SCM str, k;
+ {
+@@ -64,6 +64,6 @@
+   return MAKINUM(UCHARS(str)[INUM(k)]);
+ }
+-static char s_bt_set[] = "byte-set!";
+-SCM scm_byte_set(str, k, n)
++static const char s_bt_set[] = "byte-set!";
++static SCM scm_byte_set(str, k, n)
+      SCM str, k, n;
+ {
+@@ -75,6 +75,6 @@
+   return UNSPECIFIED;
+ }
+-static char s_bytes2list[] = "bytes->list";
+-SCM scm_bytes2list(str)
++static const char s_bytes2list[] = "bytes->list";
++static SCM scm_bytes2list(str)
+      SCM str;
+ {
+@@ -87,6 +87,6 @@
+   return res;
+ }
+-static char s_bt_reverse[] = "bytes-reverse!";
+-SCM scm_bytes_reverse(str)
++static const char s_bt_reverse[] = "bytes-reverse!";
++static SCM scm_bytes_reverse(str)
+      SCM str;
+ {
+@@ -103,6 +103,6 @@
+   return str;
+ }
+-static char s_write_byte[] = "write-byte";
+-SCM scm_write_byte(chr, port)
++static const char s_write_byte[] = "write-byte";
++static SCM scm_write_byte(chr, port)
+      SCM chr, port;
+ {
+@@ -114,6 +114,6 @@
+   return UNSPECIFIED;
+ }
+-static char s_read_byte[] = "read-byte";
+-SCM scm_read_byte(port)
++static const char s_read_byte[] = "read-byte";
++static SCM scm_read_byte(port)
+      SCM port;
+ {
+@@ -126,6 +126,6 @@
+ }
+ 
+-static char s_sub_rd[] = "subbytes-read!";
+-SCM scm_subbytes_read(sstr, start, args)
++static const char s_sub_rd[] = "subbytes-read!";
++static SCM scm_subbytes_read(sstr, start, args)
+      SCM sstr, start, args;
+ {
+@@ -173,6 +173,6 @@
+ }
+ 
+-static char s_sub_wr[] = "subbytes-write";
+-SCM scm_subbytes_write(sstr, start, args)
++static const char s_sub_wr[] = "subbytes-write";
++static SCM scm_subbytes_write(sstr, start, args)
+      SCM sstr, start, args;
+ {
+--- bytenumb.c	2013-03-24 19:37:38.000000000 -0400
++++ bytenumb.c	2015-01-23 18:55:19.000000000 -0500
+@@ -27,5 +27,5 @@
+ #include "scm.h"
+ 
+-int get_bytes_length(obj)
++static int get_bytes_length(obj)
+      SCM obj;
+ {
+@@ -47,8 +47,8 @@
+ }
+ 
+-static char s_wrong_length[] = "wrong length";
++static const char s_wrong_length[] = "wrong length";
+ static SCM list_of_0;
+ 
+-char * get_bytes(obj, minlen, s_name)
++static void * get_bytes(obj, minlen, s_name)
+      SCM obj;
+      int minlen;
+@@ -60,13 +60,15 @@
+ 	 obj, ARG1, s_name);
+   {
++#ifndef RECKLESS
+     int byvlen = get_bytes_length(obj);
++#endif
+     ASRTER((minlen < 0) ? byvlen >= -minlen : byvlen == minlen,
+ 	   MAKINUM(byvlen), s_wrong_length, s_name);
+-    return (char*)scm_addr(cons(obj, list_of_0), s_name);
++    return scm_addr(cons(obj, list_of_0), s_name);
+   }
+ }
+ 
+-static char s_bytes_to_integer[] = "bytes->integer";
+-SCM scm_bytes_to_integer(sbyts, sn)
++static const char s_bytes_to_integer[] = "bytes->integer";
++static SCM scm_bytes_to_integer(sbyts, sn)
+      SCM sbyts;
+      SCM sn;
+@@ -76,5 +78,5 @@
+   {
+     int cnt = abs(n);
+-    char *byts = get_bytes(sbyts, -cnt, s_bytes_to_integer);
++    const unsigned char *byts = get_bytes(sbyts, -cnt, s_bytes_to_integer);
+     int iu = 0, id = cnt - sizeof(BIGDIG);
+     sizet ndigs = (cnt + sizeof(BIGDIG) - 1) / sizeof(BIGDIG);
+@@ -88,5 +90,5 @@
+ 	for (; j < sizeof(BIGDIG); j++) {
+ 	  dig = (dig<<8) +
+-	    (0xFF ^ ((id + j >= 0) ? (((unsigned char *)byts)[id + j]) : 255));
++	    (0xFF ^ ((id + j >= 0) ? byts[id + j] : 255));
+ 	  /* printf("byts[%d + %d] = %lx\n", id, j, 0xFF & dig); */
+ 	}
+@@ -102,5 +104,5 @@
+ 	for (; j < sizeof(BIGDIG); j++) {
+ 	  dig = (dig<<8) +
+-	    ((id + j >= 0) ? (((unsigned char *)byts)[id + j]) : 0);
++	    ((id + j >= 0) ? byts[id + j] : 0);
+ 	}
+ 	digs[iu] = dig;
+@@ -112,6 +114,6 @@
+ }
+ 
+-static char s_integer_to_bytes[] = "integer->bytes";
+-SCM scm_integer_to_bytes(sn, slen)
++static const char s_integer_to_bytes[] = "integer->bytes";
++static SCM scm_integer_to_bytes(sn, slen)
+      SCM sn;
+      SCM slen;
+@@ -150,5 +152,5 @@
+ 	    sizet j = sizeof(BIGDIG);
+ 	    dig = (iu < ndigs) ? digs[iu] : 0;
+-	    dig = dig ^ ((1 << (8 * sizeof(BIGDIG))) - 1);
++	    dig = dig ^ ((1UL << (8 * sizeof(BIGDIG))) - 1);
+ 	    /* printf("j = %d; id = %d; iu = %d; dig = %04x; borrow = %d\n", j, id, iu, dig, borrow); */
+ 	    for (; 0 < j-- && 0 <= id;) {
+@@ -156,5 +158,5 @@
+ 	      int dg = (0xFF & dig) + borrow;
+ 	      borrow = dg >> 8;
+-	      ((unsigned char *)byts)[id--] = dg;
++	      byts[id--] = dg;
+ 	      dig = (dig)>>8;
+ 	    }
+@@ -167,5 +169,5 @@
+ 	    for (; 0 < j-- && 0 <= id;) {
+ 	      /* printf("byts[%d] = %02x\n", id, 0xFF & dig); */
+-	      ((unsigned char *)byts)[id--] = 0xFF & dig;
++	      byts[id--] = 0xFF & dig;
+ 	      dig = (dig>>8);
+ 	    }
+@@ -177,23 +179,23 @@
+ }
+ 
+-static char s_bytes_to_ieee_float[] = "bytes->ieee-float";
+-SCM scm_bytes_to_ieee_float(sbyts)
++static const char s_bytes_to_ieee_float[] = "bytes->ieee-float";
++static SCM scm_bytes_to_ieee_float(sbyts)
+      SCM sbyts;
+ {
+-  char *byts = get_bytes(sbyts, 4, s_bytes_to_ieee_float);
++  const unsigned char *byts = get_bytes(sbyts, 4, s_bytes_to_ieee_float);
+   int len = LENGTH(sbyts);
+-  int s = (1<<(7)) & ((((unsigned char*)(byts))[0]));
+-  int e = ((0x7f&((((unsigned char*)(byts))[0])))<<1)
+-    + ((0x80&((((unsigned char*)(byts))[1])))>>7);
+-  float f = (((unsigned char*)(byts))[ -1 + (len)]);
++  int s = (1<<(7)) & (((byts)[0]));
++  int e = ((0x7f&(((byts))[0]))<<1)
++    + ((0x80&((((byts))[1])))>>7);
++  float f = (((byts))[ -1 + (len)]);
+   int idx = -2 + (len);
+   while (!((idx)<=1)) {
+     {
+       int T_idx = -1 + (idx);
+-      f = ((((unsigned char*)(byts))[idx])) + ((f) / 0x100);
++      f = ((((byts))[idx])) + ((f) / 0x100);
+       idx = T_idx;
+     }
+   }
+-  f = ((0x7f&((((unsigned char*)(byts))[1]))) + ((f) / 0x100)) / 0x80;
++  f = ((0x7f&((((byts))[1]))) + ((f) / 0x100)) / 0x80;
+   if ((0<(e))
+       && ((e)<0xff))
+@@ -207,23 +209,23 @@
+ }
+ 
+-static char s_bytes_to_ieee_double[] = "bytes->ieee-double";
+-SCM scm_bytes_to_ieee_double(sbyts)
++static const char s_bytes_to_ieee_double[] = "bytes->ieee-double";
++static SCM scm_bytes_to_ieee_double(sbyts)
+      SCM sbyts;
+ {
+-  char *byts = get_bytes(sbyts, 8, s_bytes_to_ieee_double);
++  const unsigned char *byts = get_bytes(sbyts, 8, s_bytes_to_ieee_double);
+   int len = LENGTH(sbyts);
+-  int s = (1<<(7)) & ((((unsigned char*)(byts))[0]));
+-  int e = ((0x7f&((((unsigned char*)(byts))[0])))<<4)
+-    + ((0xf0&((((unsigned char*)(byts))[1])))>>4);
+-  double f = (((unsigned char*)(byts))[ -1 + (len)]);
++  int s = (1<<(7)) & ((((byts))[0]));
++  int e = ((0x7f&((((byts))[0])))<<4)
++    + ((0xf0&((((byts))[1])))>>4);
++  double f = (((byts))[ -1 + (len)]);
+   int idx = -2 + (len);
+   while (!((idx)<=1)) {
+     {
+       int T_idx = -1 + (idx);
+-      f = ((((unsigned char*)(byts))[idx])) + ((f) / 0x100);
++      f = ((((byts))[idx])) + ((f) / 0x100);
+       idx = T_idx;
+     }
+   }
+-  f = ((0xf&((((unsigned char*)(byts))[1]))) + ((f) / 0x100)) / 0x10;
++  f = ((0xf&((((byts))[1]))) + ((f) / 0x100)) / 0x10;
+   if ((0<(e))
+       && ((e)<0x7ff))
+@@ -237,6 +239,6 @@
+ }
+ 
+-static char s_ieee_float_to_bytes[] = "ieee-float->bytes";
+-SCM scm_ieee_float_to_bytes(in_flt)
++static const char s_ieee_float_to_bytes[] = "ieee-float->bytes";
++static SCM scm_ieee_float_to_bytes(in_flt)
+      SCM in_flt;
+ {
+@@ -318,6 +320,6 @@
+ }
+ 
+-static char s_ieee_double_to_bytes[] = "ieee-double->bytes";
+-SCM scm_ieee_double_to_bytes(in_flt)
++static const char s_ieee_double_to_bytes[] = "ieee-double->bytes";
++static SCM scm_ieee_double_to_bytes(in_flt)
+      SCM in_flt;
+ {
+@@ -398,18 +400,18 @@
+ }
+ 
+-static char s_integer_byte_collate_M[] = "integer-byte-collate!";
+-SCM scm_integer_byte_collate_M(byte_vector)
++static const char s_integer_byte_collate_M[] = "integer-byte-collate!";
++static SCM scm_integer_byte_collate_M(byte_vector)
+      SCM byte_vector;
+ {
+-  char* bv = get_bytes(byte_vector, -1, s_integer_byte_collate_M);
++  unsigned char* bv = get_bytes(byte_vector, -1, s_integer_byte_collate_M);
+   bv[0] = 0x80^(bv[0]);
+   return byte_vector;
+ }
+ 
+-static char s_ieee_byte_collate_M[] = "ieee-byte-collate!";
+-SCM scm_ieee_byte_collate_M(byte_vector)
++static const char s_ieee_byte_collate_M[] = "ieee-byte-collate!";
++static SCM scm_ieee_byte_collate_M(byte_vector)
+      SCM byte_vector;
+ {
+-  char* byv = get_bytes(byte_vector, 4, s_ieee_byte_collate_M);
++  unsigned char* byv = get_bytes(byte_vector, 4, s_ieee_byte_collate_M);
+   int byvlen = get_bytes_length(byte_vector);
+   if (0x80&(byv[0])) {
+@@ -425,9 +427,9 @@
+ }
+ 
+-static char s_ieee_byte_decollate_M[] = "ieee-byte-decollate!";
+-SCM scm_ieee_byte_decollate_M(byte_vector)
++static const char s_ieee_byte_decollate_M[] = "ieee-byte-decollate!";
++static SCM scm_ieee_byte_decollate_M(byte_vector)
+      SCM byte_vector;
+ {
+-  char* byv = get_bytes(byte_vector, 4, s_ieee_byte_collate_M);
++  unsigned char* byv = get_bytes(byte_vector, 4, s_ieee_byte_collate_M);
+   int byvlen = get_bytes_length(byte_vector);
+   if (!(0x80&(byv[0]))) {
+--- continue.h	2008-02-19 00:12:54.000000000 -0500
++++ continue.h	2015-01-26 23:02:16.000000000 -0500
+@@ -70,5 +66,9 @@
+ 
+ #ifdef sparc
+-# define FLUSH_REGISTER_WINDOWS asm("ta 3")
++# ifdef __sparcv9
++#  define FLUSH_REGISTER_WINDOWS asm("flushw")
++# else
++#  define FLUSH_REGISTER_WINDOWS asm("ta 3")
++# endif
+ #else
+ # define FLUSH_REGISTER_WINDOWS /* empty */
+@@ -142,4 +138,6 @@
+ 
+ extern long thrown_value;
++void init_storage P((STACKITEM *start, long init_heap_size));
++void mark_locations P((const STACKITEM x[], sizet n));
+ long stack_size P((STACKITEM *start));
+ CONTINUATION *make_root_continuation P((STACKITEM *stack_base));
+--- crs.c	2009-10-21 15:41:30.000000000 -0400
++++ crs.c	2015-01-23 18:55:19.000000000 -0500
+@@ -43,5 +43,5 @@
+ #define WIN(obj) ((WINDOW*)CDR(obj))
+ #define WINP(obj) (tc16_window==TYP16(obj))
+-int freewindow(win)
++static int freewindow(win)
+      WINDOW *win;
+ {
+@@ -50,9 +50,9 @@
+   return 0;
+ }
+-int bwaddch(c, win) int c; WINDOW *win; {waddch(win, c);return c;}
+-int bwaddstr(str, win) char *str; WINDOW *win; {waddstr(win, str);return 0;}
+-sizet bwwrite(str, siz, num, win)
++static int bwaddch(c, win) int c; WINDOW *win; {waddch(win, c);return c;}
++static int bwaddstr(str, win) const char *str; WINDOW *win; {waddstr(win, str);return 0;}
++static sizet bwwrite(str, siz, num, win)
+      sizet siz, num;
+-     char *str; WINDOW *win;
++     const char *str; WINDOW *win;
+ {
+   sizet i = 0, prod = siz*num;
+@@ -74,5 +74,5 @@
+   freewindow};
+ 
+-SCM mkwindow(win)
++static SCM mkwindow(win)
+      WINDOW *win;
+ {
+@@ -85,6 +85,6 @@
+ }
+ 
+-SCM *loc_stdscr = 0;
+-SCM linitscr()
++static SCM *loc_stdscr = NULL;
++static SCM linitscr(void)
+ {
+   WINDOW *win;
+@@ -96,5 +96,5 @@
+   return *loc_stdscr = mkwindow(win);
+ }
+-SCM lendwin()
++static SCM lendwin(void)
+ {
+   if (IMP(*loc_stdscr)) return BOOL_F;
+@@ -102,7 +102,7 @@
+ }
+ 
+-static char s_newwin[] = "newwin", s_subwin[] = "subwin", s_mvwin[] = "mvwin",
++static const char s_newwin[] = "newwin", s_subwin[] = "subwin", s_mvwin[] = "mvwin",
+ 	    s_overlay[] = "overlay", s_overwrite[] = "overwrite";
+-SCM lnewwin(lines, cols, args)
++static SCM lnewwin(lines, cols, args)
+      SCM lines, cols, args;
+ {
+@@ -121,5 +121,5 @@
+ }
+ 
+-SCM lmvwin(win, y, x)
++static SCM lmvwin(win, y, x)
+      SCM win, y, x;
+ {
+@@ -130,5 +130,5 @@
+ }
+ 
+-SCM lsubwin(win, lines, args)
++static SCM lsubwin(win, lines, args)
+      SCM win, lines, args;
+ {
+@@ -150,5 +150,5 @@
+ }
+ 
+-SCM loverlay(srcwin, dstwin)
++static SCM loverlay(srcwin, dstwin)
+      SCM srcwin, dstwin;
+ {
+@@ -158,5 +158,5 @@
+ }
+ 
+-SCM loverwrite(srcwin, dstwin)
++static SCM loverwrite(srcwin, dstwin)
+      SCM srcwin, dstwin;
+ {
+@@ -166,7 +166,7 @@
+ }
+ 
+-static char s_wmove[] = "wmove", s_wadd[] = "wadd", s_winsch[] = "winsch",
++static const char s_wmove[] = "wmove", s_wadd[] = "wadd", s_winsch[] = "winsch",
+ 	s_box[] = "box";
+-SCM lwmove(win, y, x)
++static SCM lwmove(win, y, x)
+      SCM win, y, x;
+ {
+@@ -177,5 +177,5 @@
+ }
+ 
+-SCM lwadd(win, obj)
++static SCM lwadd(win, obj)
+      SCM win, obj;
+ {
+@@ -189,5 +189,5 @@
+ }
+ 
+-SCM lwinsch(win, obj)
++static SCM lwinsch(win, obj)
+      SCM win, obj;
+ {
+@@ -199,5 +199,5 @@
+ }
+ 
+-SCM lbox(win, vertch, horch)
++static SCM lbox(win, vertch, horch)
+      SCM win, vertch, horch;
+ {
+@@ -217,6 +217,6 @@
+ }
+ 
+-static char s_getyx[] = "getyx", s_winch[] = "winch", s_unctrl[] = "unctrl";
+-SCM lgetyx(win)
++static const char s_getyx[] = "getyx", s_winch[] = "winch", s_unctrl[] = "unctrl";
++static SCM lgetyx(win)
+      SCM win;
+ {
+@@ -227,5 +227,5 @@
+ }
+ 
+-SCM lwinch(win)
++static SCM lwinch(win)
+      SCM win;
+ {
+@@ -234,16 +234,16 @@
+ }
+ 
+-SCM lunctrl(c)
++static SCM lunctrl(c)
+      SCM c;
+ {
+   ASRTER(ICHRP(c), c, ARG1, s_unctrl);
+   {
+-    char *str = unctrl(ICHR(c));
++    const char *str = unctrl(ICHR(c));
+     return makfrom0str(str);
+   }
+ }
+-static char s_owidth[] = "output-port-width";
+-static char s_oheight[] = "output-port-height";
+-SCM owidth(arg)
++static const char s_owidth[] = "output-port-width";
++static const char s_oheight[] = "output-port-height";
++static SCM owidth(arg)
+      SCM arg;
+ {
+@@ -256,20 +256,21 @@
+   return MAKINUM(80);
+ }
+-SCM oheight(arg)
++static SCM oheight(arg)
+      SCM arg;
+ {
+   if (UNBNDP(arg)) arg = cur_outp;
+   ASRTER(NIMP(arg) && OPOUTPORTP(arg), arg, ARG1, s_owidth);
+-  if (NIMP(*loc_stdscr))
++  if (NIMP(*loc_stdscr)) {
+     if (WINP(arg)) return MAKINUM(WIN(arg)->_maxy+1);
+     else return MAKINUM(LINES);
++  }
+   return MAKINUM(24);
+ }
+-SCM lrefresh()
++static SCM lrefresh()
+ {
+   return MAKINUM(wrefresh(curscr));
+ }
+ 
+-#define SUBR0(lname, name) SCM lname(){name();return UNSPECIFIED;}
++#define SUBR0(lname, name) static SCM lname(){name();return UNSPECIFIED;}
+ SUBR0(lnl, nl)
+ SUBR0(lnonl, nonl)
+@@ -283,5 +284,5 @@
+ SUBR0(lresetty, resetty)
+ 
+-static char s_nonl[] = "nonl", s_nocbreak[] = "nocbreak",
++static const char s_nonl[] = "nonl", s_nocbreak[] = "nocbreak",
+ 	    s_noecho[] = "noecho", s_noraw[] = "noraw";
+ 
+@@ -302,6 +303,6 @@
+ 	{0, 0}};
+ 
+-#define SUBRW(ln, n, s_n, sn) static char s_n[]=sn;\
+-	SCM ln(w)SCM w;\
++#define SUBRW(ln, n, s_n, sn) static const char s_n[]=sn;\
++	static SCM ln(w)SCM w;\
+ 	{ASRTER(NIMP(w) && WINP(w), w, ARG1, sn);\
+ 	return ERR==n(WIN(w))?BOOL_F:BOOL_T;}
+@@ -336,6 +337,6 @@
+ 	{0, 0}};
+ 
+-#define SUBROPT(ln, n, s_n, sn) static char s_n[]=sn;\
+-	SCM ln(w, b)SCM w, b;\
++#define SUBROPT(ln, n, s_n, sn) static const char s_n[]=sn;\
++	static SCM ln(w, b)SCM w, b;\
+ 	{ASRTER(NIMP(w) && WINP(w), w, ARG1, sn);\
+ 	return ERR==n(WIN(w), BOOL_F != b)?BOOL_F:BOOL_T;}
+@@ -347,6 +348,6 @@
+ 
+ /*  SUBROPT(lclearok, clearok, s_clearok, "clearok") */
+-static char s_clearok[] = "clearok";
+-SCM lclearok(w, b) SCM w, b;
++static const char s_clearok[] = "clearok";
++static SCM lclearok(w, b) SCM w, b;
+ {
+   if (BOOL_T==w) return ERR==clearok(curscr, BOOL_F != b)?BOOL_F:BOOL_T;
+--- debug.c	2008-01-30 22:31:48.000000000 -0500
++++ debug.c	2015-01-23 18:55:19.000000000 -0500
+@@ -291,5 +291,8 @@
+      int writing;
+ {
+-  SCM env, linum = UNDEFINED;
++  SCM env;
++#ifdef CAUTIOUS
++  SCM linum = UNDEFINED;
++#endif
+   proc = CODE(proc);
+   lputs("#<CLOSURE ", port);
+@@ -320,6 +323,6 @@
+ }
+ 
+-static char s_int2linum[] = "integer->line-number";
+-SCM scm_int2linum(n)
++static const char s_int2linum[] = "integer->line-number";
++static SCM scm_int2linum(n)
+      SCM n;
+ {
+@@ -329,6 +332,6 @@
+ }
+ 
+-static char s_linum2int[] = "line-number->integer";
+-SCM scm_linum2int(linum)
++static const char s_linum2int[] = "line-number->integer";
++static SCM scm_linum2int(linum)
+      SCM linum;
+ {
+@@ -337,5 +340,5 @@
+ }
+ 
+-SCM scm_linump(obj)
++static SCM scm_linump(obj)
+      SCM obj;
+ {
+@@ -343,6 +346,6 @@
+ }
+ 
+-static char s_remove_linums[] = "remove-line-numbers!";
+-SCM scm_remove_linums(x)
++static const char s_remove_linums[] = "remove-line-numbers!";
++static SCM scm_remove_linums(x)
+      SCM x;
+ {
+@@ -377,5 +380,5 @@
+ 
+ #ifdef CAUTIOUS
+-long num_frames(estk, i)
++static long num_frames(estk, i)
+      SCM estk;
+      int i;
+@@ -390,5 +393,5 @@
+ }
+ 
+-SCM *estk_frame(estk, i, nf)
++static SCM *estk_frame(estk, i, nf)
+      SCM estk;
+      int i, nf;
+@@ -408,5 +411,5 @@
+ }
+ 
+-SCM stacktrace1(estk, i)
++static SCM stacktrace1(estk, i)
+      SCM estk;
+      int i;
+@@ -444,5 +447,5 @@
+ }
+ 
+-SCM *cont_frame(contin, nf)
++static SCM *cont_frame(contin, nf)
+      SCM contin;
+      int nf;
+@@ -455,5 +458,5 @@
+ }
+ 
+-static char s_stack_trace[] = "stack-trace";
++static const char s_stack_trace[] = "stack-trace";
+ SCM scm_stack_trace(contin)
+      SCM contin;
+@@ -476,6 +479,6 @@
+ }
+ 
+-static char s_frame_trace[] = "frame-trace";
+-SCM scm_frame_trace(contin, nf)
++static const char s_frame_trace[] = "frame-trace";
++static SCM scm_frame_trace(contin, nf)
+      SCM contin, nf;
+ {
+@@ -493,6 +496,6 @@
+ }
+ 
+-static char s_frame2env[] = "frame->environment";
+-SCM scm_frame2env(contin, nf)
++static const char s_frame2env[] = "frame->environment";
++static SCM scm_frame2env(contin, nf)
+      SCM contin, nf;
+ {
+@@ -506,6 +509,6 @@
+ }
+ 
+-static char s_frame_eval[] = "frame-eval";
+-SCM scm_frame_eval(contin, nf, expr)
++static const char s_frame_eval[] = "frame-eval";
++static SCM scm_frame_eval(contin, nf, expr)
+      SCM contin, nf, expr;
+ {
+@@ -526,5 +529,5 @@
+ #endif
+ 
+-static char s_scope_trace[] = "scope-trace";
++static const char s_scope_trace[] = "scope-trace";
+ SCM scm_scope_trace(env)
+      SCM env;
+@@ -593,6 +596,6 @@
+ }
+ 
+-static char s_env_annotation[] = "environment-annotation";
+-SCM scm_env_annotation(var, stenv)
++static const char s_env_annotation[] = "environment-annotation";
++static SCM scm_env_annotation(var, stenv)
+      SCM var, stenv;
+ {
+--- differ.c	2010-08-21 22:12:34.000000000 -0400
++++ differ.c	2015-01-23 18:55:19.000000000 -0500
+@@ -24,69 +24,81 @@
+ #include "scm.h"
+ 
+-#ifdef __x86_64
+-# define I32 int
+-#else
+-# define I32 long
+-#endif
+-/* Currently A:fixZ32b are actually A:fixZ64b.  Remove next line when
++/* Currently A:fixZ32b are actually A:fixZ64b.  Use int64_t, when
+    this gets fixed. */
+-#define I32 long
+-
+-SCM_EXPORT SCM  array_dims P((SCM ra));
++#define I32 int64_t
+ 
+ typedef int (*int_function) ();
+ 
+ typedef struct {
+-  void* (*subarray) ();
++  const void * (*subarray)(const void *, int start, int end);
+   int_function array_refsEql_P;
+   int_function array_refs_revEql_P;
+ } fp_procs;
+ 
+-int fp_compare(I32 *fp,int fpoff,I32 *cc,void *a,int m,void *b,int n,int_function array_refsEql_P,int p_lim);
++static int fp_compare(I32 *fp, int fpoff, I32 *cc,
++    const void *a, int m,
++    const void *b, int n,
++    int_function array_refsEql_P, int p_lim);
+ 
+-int fp_run(I32 *fp,int fpoff,int k,void *a,int m,void *b,int n,int_function array_refsEql_P,I32 *cc,int p);
++static int fp_run(I32 *fp, int fpoff, int k,
++    const void *a, int m,
++    const void *b, int n,
++    int_function array_refsEql_P,
++    I32 *cc, int p);
+ 
+-int diff_mid_split(int n,I32 *rr,I32 *cc,int cost);
++static int diff_mid_split(int n, const I32 *rr, const I32 *cc,int cost);
+ 
+-void fp_init(I32 *fp,int fpoff,int fill,int mindx,int maxdx);
++static void fp_init(I32 *fp, int fpoff, int fill, int mindx, int maxdx);
+ 
+-int diff_divide_and_conquer(I32 *fp,int fpoff,I32 *ccrr,void *a,int start_a,int end_a,void *b,int start_b,int end_b,I32 *edits,int edx,int epo,fp_procs *procs,int p_lim);
++static int diff_divide_and_conquer(I32 *fp, int fpoff, I32 *ccrr,
++    const void *a, int start_a, int end_a,
++    const void *b, int start_b, int end_b,
++    I32 *edits, int edx, int epo, const fp_procs *procs, int p_lim);
+ 
+-int diff2et(I32 *fp,int fpoff,I32 *ccrr,void *a,int start_a,int end_a,void *b,int start_b,int end_b,I32 *edits,int edx,int epo,fp_procs *procs,int p_lim);
++static int diff2et(I32 *fp, int fpoff, I32 *ccrr,
++    const void *a, int start_a, int end_a,
++    const void *b, int start_b, int end_b,
++    I32 *edits, int edx, int epo, const fp_procs *procs, int p_lim);
+ 
+-int diff2ez(I32 *fp,int fpoff,I32 *ccrr,void *a,int start_a,int end_a,void *b,int start_b,int end_b,I32 *edits,int edx,int epo,fp_procs *procs,int p_lim);
++static int diff2ez(I32 *fp, int fpoff, I32 *ccrr,
++    const void *a, int start_a, int end_a,
++    const void *b, int start_b, int end_b,
++    I32 *edits, int edx, int epo, const fp_procs *procs, int p_lim);
+ 
+-void check_cost(unsigned char *name,int est,int cost);
++static void check_cost(const char *name, int est, int cost);
+ 
+-SCM_EXPORT SCM  diff2edits P((SCM Edits, SCM Fp, SCM Args));
++static SCM  diff2edits P((SCM Edits, SCM Fp, SCM Args));
+ 
+-SCM_EXPORT SCM  diff2editlen P((SCM Fp, SCM A, SCM Args));
++static SCM  diff2editlen P((SCM Fp, SCM A, SCM Args));
+ 
+ #define MAX(a,b)		(a<b ? b : a)
+ #define MIN(a,b)		(a>b ? b : a)
+ 
+-I32 *long_subarray(ra, start, end)
+-     I32 *ra; int start, end;
++static const void *I32_subarray(_ra, start, end)
++     const void *_ra; int start, end;
+ {
++  const I32 *ra = _ra;
+   return &(ra[start]);
+ }
+-short *short_subarray(ra, start, end)
+-     short *ra; int start, end;
++static const void *short_subarray(_ra, start, end)
++     const void *_ra; int start, end;
+ {
++  const short *ra = _ra;
+   return &(ra[start]);
+ }
+-char *char_subarray(ra, start, end)
+-     char *ra; int start, end;
++static const void *char_subarray(_ra, start, end)
++     const void *_ra; int start, end;
+ {
++  const char *ra = _ra;
+   return &(ra[start]);
+ }
+ 
+-int long_array_refsEql_P(a, x, m, b, y, n)
++static int long_array_refsEql_P(a, x, m, b, y, n)
+      I32 *a; int x, m; I32 *b; int y, n;
+ {
+   return (a[x])==(b[y]);
+ }
+-int long_array_refs_revEql_P(a, x, m, b, y, n)
+-     I32 *a; int x, m; I32 *b; int y, n;
++static int long_array_refs_revEql_P(a, x, m, b, y, n)
++     const I32 *a; int x, m; const I32 *b; int y, n;
+ {
+ /*   if (x > m) printf("long x(%d) > m(%d)\n", x, m); */
+@@ -94,11 +106,11 @@
+   return a[(m)-(x)-1]==b[(n)-(y)-1];
+ }
+-int short_array_refsEql_P(a, x, m, b, y, n)
+-     short *a; int x, m; short *b; int y, n;
++static int short_array_refsEql_P(a, x, m, b, y, n)
++     const short *a; int x, m; const short *b; int y, n;
+ {
+   return (a[x])==(b[y]);
+ }
+-int short_array_refs_revEql_P(a, x, m, b, y, n)
+-     short *a; int x, m; short *b; int y, n;
++static int short_array_refs_revEql_P(a, x, m, b, y, n)
++     const short *a; int x, m; const short *b; int y, n;
+ {
+ /*   if (x > m) printf("short x(%d) > m(%d)\n", x, m); */
+@@ -106,11 +118,11 @@
+   return a[(m)-(x)-1]==b[(n)-(y)-1];
+ }
+-int char_array_refsEql_P(a, x, m, b, y, n)
+-     char *a; int x, m; char *b; int y, n;
++static int char_array_refsEql_P(a, x, m, b, y, n)
++     const char *a; int x, m; const char *b; int y, n;
+ {
+   return (a[x])==(b[y]);
+ }
+-int char_array_refs_revEql_P(a, x, m, b, y, n)
+-     char *a; int x, m; char *b; int y, n;
++static int char_array_refs_revEql_P(a, x, m, b, y, n)
++     const char *a; int x, m; const char *b; int y, n;
+ {
+ /*   if (x > m) printf("char x(%d) > m(%d)\n", x, m); */
+@@ -120,5 +132,5 @@
+ 
+ fp_procs long_procs =
+-  {long_subarray,
++  {I32_subarray,
+    long_array_refsEql_P,
+    long_array_refs_revEql_P};
+@@ -136,7 +148,7 @@
+      int fpoff;
+      I32 *cc;
+-     void *a;
++     const void *a;
+      int m;
+-     void *b;
++     const void *b;
+      int n;
+      int_function array_refsEql_P;
+@@ -189,7 +201,7 @@
+      int fpoff;
+      int k;
+-     void *a;
++     const void *a;
+      int m;
+-     void *b;
++     const void *b;
+      int n;
+      int_function array_refsEql_P;
+@@ -228,6 +240,6 @@
+ int diff_mid_split(n, rr, cc, cost)
+      int n;
+-     I32 *rr;
+-     I32 *cc;
++     const I32 *rr;
++     const I32 *cc;
+      int cost;
+ {
+@@ -276,8 +288,8 @@
+      int fpoff;
+      I32 *ccrr;
+-     void *a;
++     const void *a;
+      int start_a;
+      int end_a;
+-     void *b;
++     const void *b;
+      int start_b;
+      int end_b;
+@@ -285,5 +297,5 @@
+      int edx;
+      int epo;
+-     fp_procs *procs;
++     const fp_procs *procs;
+      int p_lim;
+ {
+@@ -320,8 +332,8 @@
+      int fpoff;
+      I32 *ccrr;
+-     void *a;
++     const void *a;
+      int start_a;
+      int end_a;
+-     void *b;
++     const void *b;
+      int start_b;
+      int end_b;
+@@ -329,5 +341,5 @@
+      int edx;
+      int epo;
+-     fp_procs *procs;
++     const fp_procs *procs;
+      int p_lim;
+ {
+@@ -370,8 +382,8 @@
+      int fpoff;
+      I32 *ccrr;
+-     void *a;
++     const void *a;
+      int start_a;
+      int end_a;
+-     void *b;
++     const void *b;
+      int start_b;
+      int end_b;
+@@ -379,5 +391,5 @@
+      int edx;
+      int epo;
+-     fp_procs *procs;
++     const fp_procs *procs;
+      int p_lim;
+ {
+@@ -450,6 +462,6 @@
+ }
+ 
+-void check_cost(name, est, cost)
+-     unsigned char *name;
++static void check_cost(name, est, cost)
++     const char *name;
+      int est;
+      int cost;
+@@ -464,7 +476,7 @@
+ 
+ /* Return the fp_procs appropriate for SCM array prototype */
+-fp_procs *raprot2procs(prot, s_name)
++static fp_procs *raprot2procs(prot, s_name)
+      SCM prot;
+-     char *s_name;
++     const char *s_name;
+ {
+   fp_procs *procs;
+@@ -481,17 +493,17 @@
+ static SCM list_of_0;
+ 
+-void* array2addr(RA, prot, pos, s_name)
++static void* array2addr(RA, prot, pos, s_name)
+      SCM RA, prot;
+-     char *pos;
+-     char s_name[];
++     intptr_t pos;
++     const char s_name[];
+ {
+   ASRTER(BOOL_T==arrayp(RA, UNDEFINED) && array_prot(RA)==prot, RA,
+-	 pos, s_name);
++	 (const char *)pos, s_name);
+   return scm_addr(cons(RA, list_of_0), s_name);
+ }
+ 
+ /*  A not longer than B (M <= N) */
+-static char s_d2es[] = "diff2edits!";
+-static char s_incomp[] = "incompatible array types";
++static const char s_d2es[] = "diff2edits!";
++static const char s_incomp[] = "incompatible array types";
+ SCM diff2edits(Edits, Fp, Args)
+      SCM Edits, Fp, Args;	/* Ccrr, A, B; */
+@@ -533,5 +545,5 @@
+ /*  A not longer than B (M <= N) */
+ 
+-static char s_d2el[] = "diff2editlen";
++static const char s_d2el[] = "diff2editlen";
+ SCM diff2editlen(Fp, A, Args)
+      SCM Fp, A, Args;		/* B, P_lim */
+@@ -573,5 +585,5 @@
+ }
+ 
+-static char s_Idiffer[] = "Idiffer.scm";
++static const char s_Idiffer[] = "Idiffer.scm";
+ void init_differ()
+ {
+--- dynl.c	2013-04-06 21:49:18.000000000 -0400
++++ dynl.c	2015-01-23 18:55:19.000000000 -0500
+@@ -45,5 +45,5 @@
+ }
+ 
+-static char s_link[] = "dyn:link", s_call[] = "dyn:call";
++static const char s_link[] = "dyn:link", s_call[] = "dyn:call";
+ SCM l_dyn_link(fname)
+      SCM fname;
+@@ -82,5 +82,5 @@
+   return BOOL_T;
+ }
+-static char s_main_call[] = "dyn:main-call";
++static const char s_main_call[] = "dyn:main-call";
+ SCM l_dyn_main_call(symb, shl, args)
+      SCM symb, shl, args;
+@@ -113,5 +113,5 @@
+ }
+ 
+-static char s_unlink[] = "dyn:unlink";
++static const char s_unlink[] = "dyn:unlink";
+ SCM l_dyn_unlink(fname)
+      SCM fname;
+@@ -165,5 +165,5 @@
+ static smobfuns shlsmob = {mark0, free0, prinshl};
+ 
+-static char s_link[] = "dyn:link", s_call[] = "dyn:call";
++static const char s_link[] = "dyn:link", s_call[] = "dyn:call";
+ SCM l_dyn_link(fname)
+      SCM fname;
+@@ -207,5 +207,5 @@
+ }
+ 
+-static char s_main_call[] = "dyn:main-call";
++static const char s_main_call[] = "dyn:main-call";
+ SCM l_dyn_main_call(symb, shl, args)
+      SCM symb, shl, args;
+@@ -235,5 +235,5 @@
+ }
+ 
+-static char s_unlink[] = "dyn:unlink";
++static const char s_unlink[] = "dyn:unlink";
+ SCM l_dyn_unlink(shl)
+      SCM shl;
+@@ -288,5 +288,5 @@
+  return(x);}
+ 
+-static char s_dynl[] = "vms:dynamic-link-call";
++static const char s_dynl[] = "vms:dynamic-link-call";
+ SCM dynl(dir, symbol, fname)
+      SCM dir, symbol, fname;
+@@ -340,5 +340,5 @@
+ # endif
+ 
+-sizet frshl(ptr)
++static sizet frshl(ptr)
+ 	CELLPTR ptr;
+ {
+@@ -352,5 +352,5 @@
+ }
+ 
+-int prinshl(exp, port, writing)
++static int prinshl(exp, port, writing)
+ 	SCM exp; SCM port; int writing;
+ {
+@@ -363,6 +363,6 @@
+ static smobfuns shlsmob = {mark0, frshl, prinshl};
+ 
+-static char s_link[] = "dyn:link", s_call[] = "dyn:call";
+-SCM l_dyn_link(fname)
++static const char s_link[] = "dyn:link", s_call[] = "dyn:call";
++static SCM l_dyn_link(fname)
+ 	SCM fname;
+ {
+@@ -393,5 +393,5 @@
+ }
+ 
+-SCM l_dyn_call(symb, shl)
++static SCM l_dyn_call(symb, shl)
+ 	SCM symb, shl;
+ {
+@@ -419,6 +419,6 @@
+   return BOOL_T;
+ }
+-static char s_main_call[] = "dyn:main-call";
+-SCM l_dyn_main_call(symb, shl, args)
++static const char s_main_call[] = "dyn:main-call";
++static SCM l_dyn_main_call(symb, shl, args)
+ 	SCM symb, shl, args;
+ {
+@@ -453,6 +453,6 @@
+ }
+ 
+-static char s_unlink[] = "dyn:unlink";
+-SCM l_dyn_unlink(shl)
++static const char s_unlink[] = "dyn:unlink";
++static SCM l_dyn_unlink(shl)
+ 	SCM shl;
+ {
+@@ -490,5 +490,5 @@
+ # define SHL(obj) ((void*)CDR(obj))
+ 
+-sizet frshl(ptr)
++static sizet frshl(ptr)
+ 	CELLPTR ptr;
+ {
+@@ -502,5 +502,5 @@
+ }
+ 
+-int prinshl(exp, port, writing)
++static int prinshl(exp, port, writing)
+ 	SCM exp; SCM port; int writing;
+ {
+@@ -513,6 +513,6 @@
+ static smobfuns shlsmob = {mark0, frshl, prinshl};
+ 
+-static char s_link[] = "dyn:link", s_call[] = "dyn:call";
+-SCM l_dyn_link(fname)
++static const char s_link[] = "dyn:link", s_call[] = "dyn:call";
++static SCM l_dyn_link(fname)
+ 	SCM fname;
+ {
+@@ -545,5 +545,5 @@
+ }
+ 
+-SCM l_dyn_call(symb, shl)
++static SCM l_dyn_call(symb, shl)
+ 	SCM symb, shl;
+ {
+@@ -574,6 +574,6 @@
+   return BOOL_T;
+ }
+-static char s_main_call[] = "dyn:main-call";
+-SCM l_dyn_main_call(symb, shl, args)
++static const char s_main_call[] = "dyn:main-call";
++static SCM l_dyn_main_call(symb, shl, args)
+ 	SCM symb, shl, args;
+ {
+@@ -610,6 +610,6 @@
+ }
+ 
+-static char s_unlink[] = "dyn:unlink";
+-SCM l_dyn_unlink(shl)
++static const char s_unlink[] = "dyn:unlink";
++static SCM l_dyn_unlink(shl)
+ 	SCM shl;
+ {
+@@ -646,5 +646,5 @@
+ # include <windows.h>
+ # define SHL(obj) ((HINSTANCE)(CDR(obj)))
+-int prinshl(exp, port, writing)
++static int prinshl(exp, port, writing)
+ 	SCM exp; SCM port; int writing;
+ {
+@@ -658,6 +658,6 @@
+ static smobfuns shlsmob = {mark0, free0, prinshl};
+ 
+-static char s_link[] = "dyn:link";
+-SCM scm_dyn_link(fname)
++static const char s_link[] = "dyn:link";
++static SCM scm_dyn_link(fname)
+      SCM fname;
+ {
+@@ -677,6 +677,6 @@
+ }
+ 
+-static char s_unlink[] = "dyn:unlink";
+-SCM scm_dyn_unlink(shl)
++static const char s_unlink[] = "dyn:unlink";
++static SCM scm_dyn_unlink(shl)
+      SCM shl;
+ {
+@@ -689,6 +689,6 @@
+ }
+ 
+-static char s_call[] = "dyn:call";
+-SCM scm_dyn_call(symb, shl)
++static const char s_call[] = "dyn:call";
++static SCM scm_dyn_call(symb, shl)
+      SCM symb, shl;
+ {
+@@ -705,6 +705,6 @@
+ }
+ 
+-static char s_main_call[] = "dyn:main-call";
+-SCM scm_dyn_main_call(symb, shl, args)
++static const char s_main_call[] = "dyn:main-call";
++static SCM scm_dyn_main_call(symb, shl, args)
+ 	SCM symb, shl, args;
+ {
+--- edline.c	2008-01-30 22:31:53.000000000 -0500
++++ edline.c	2015-01-23 18:55:19.000000000 -0500
+@@ -20,11 +20,11 @@
+ 
+ #include "scm.h"
++#include <readline/readline.h>
++#include <readline/history.h>
+ 
+-char *readline   P((const char *prompt));
+-void add_history P((char *p));
+ 
+              /* Reads on stdin/stdout only */
+-static char s_readline[] = "read-edited-line";
+-SCM lreadline(prompt)
++static const char s_readline[] = "read-edited-line";
++static SCM lreadline(prompt)
+      SCM prompt;
+ {
+@@ -41,6 +41,6 @@
+   return res;
+ }
+-static char s_add_history[] = "add-history";
+-SCM ladd_history(line)
++static const char s_add_history[] = "add-history";
++static SCM ladd_history(line)
+      SCM line;
+ {
+@@ -49,15 +49,15 @@
+   return UNSPECIFIED;
+ }
+-static char s_def_inport[] = "default-input-port";
+-SCM def_inport()
++static const char s_def_inport[] = "default-input-port";
++static SCM def_inport()
+ {
+   return def_inp;
+ }
+-static char s_def_outport[] = "default-output-port";
+-SCM def_outport()
++static const char s_def_outport[] = "default-output-port";
++static SCM def_outport()
+ {
+   return def_outp;
+ }
+-static char s_Iedline[] = "Iedline.scm";
++static const char s_Iedline[] = "Iedline.scm";
+ void init_edline()
+ {
+--- eval.c	2013-04-06 21:52:40.000000000 -0400
++++ eval.c	2015-01-27 02:14:16.000000000 -0500
+@@ -92,37 +92,33 @@
+ 				   transformers. */
+ 
+-SCM nconc2copy P((SCM x));
+-SCM scm_cp_list P((SCM x, int minlen));
+-SCM scm_v2lst P((long argc, SCM *argv, SCM end));
+-SCM renamed_ident P((SCM id, SCM env));
+-SCM eqv P((SCM x, SCM y));
+-SCM scm_multi_set P((SCM syms, SCM vals));
+-SCM eval_args P((SCM x));
+-SCM m_quote P((SCM xorig, SCM env, SCM ctxt));
+-SCM m_begin P((SCM xorig, SCM env, SCM ctxt));
+-SCM m_if P((SCM xorig, SCM env, SCM ctxt));
+-SCM m_set P((SCM xorig, SCM env, SCM ctxt));
+-SCM m_and P((SCM xorig, SCM env, SCM ctxt));
+-SCM m_or P((SCM xorig, SCM env, SCM ctxt));
+-SCM m_cond P((SCM xorig, SCM env, SCM ctxt));
+-SCM m_case P((SCM xorig, SCM env, SCM ctxt));
+-SCM m_lambda P((SCM xorig, SCM env, SCM ctxt));
+-SCM m_letstar P((SCM xorig, SCM env, SCM ctxt));
+-SCM m_do P((SCM xorig, SCM env, SCM ctxt));
+-SCM m_quasiquote P((SCM xorig, SCM env, SCM ctxt));
+-SCM m_delay P((SCM xorig, SCM env, SCM ctxt));
+-SCM m_define P((SCM xorig, SCM env, SCM ctxt));
+-SCM m_letrec P((SCM xorig, SCM env, SCM ctxt));
+-SCM m_let P((SCM xorig, SCM env, SCM ctxt));
+-SCM m_apply P((SCM xorig, SCM env, SCM ctxt));
+-SCM m_syn_quote P((SCM xorig, SCM env, SCM ctxt));
+-SCM m_let_syntax P((SCM xorig, SCM env, SCM ctxt));
+-SCM m_letrec_syntax P((SCM xorig, SCM env, SCM ctxt));
+-SCM m_the_macro P((SCM xorig, SCM env, SCM ctxt));
+-void scm_dynthrow P((SCM cont, SCM arg1, SCM arg2, SCM rest));
+-void scm_egc P((void));
+-void scm_estk_grow P((void));
+-void scm_estk_shrink P((void));
+-int badargsp P((SCM formals, SCM args));
++static SCM nconc2copy P((SCM x));
++static SCM scm_cp_list P((SCM x, int minlen));
++static SCM scm_v2lst P((long argc, SCM *argv, SCM end));
++static SCM scm_multi_set P((SCM syms, SCM vals));
++static SCM eval_args P((SCM x));
++static SCM m_quote P((SCM xorig, SCM env, SCM ctxt));
++static SCM m_begin P((SCM xorig, SCM env, SCM ctxt));
++static SCM m_if P((SCM xorig, SCM env, SCM ctxt));
++static SCM m_set P((SCM xorig, SCM env, SCM ctxt));
++static SCM m_and P((SCM xorig, SCM env, SCM ctxt));
++static SCM m_or P((SCM xorig, SCM env, SCM ctxt));
++static SCM m_cond P((SCM xorig, SCM env, SCM ctxt));
++static SCM m_case P((SCM xorig, SCM env, SCM ctxt));
++static SCM m_lambda P((SCM xorig, SCM env, SCM ctxt));
++static SCM m_letstar P((SCM xorig, SCM env, SCM ctxt));
++static SCM m_do P((SCM xorig, SCM env, SCM ctxt));
++static SCM m_quasiquote P((SCM xorig, SCM env, SCM ctxt));
++static SCM m_delay P((SCM xorig, SCM env, SCM ctxt));
++static SCM m_define P((SCM xorig, SCM env, SCM ctxt));
++static SCM m_letrec P((SCM xorig, SCM env, SCM ctxt));
++static SCM m_let P((SCM xorig, SCM env, SCM ctxt));
++static SCM m_apply P((SCM xorig, SCM env, SCM ctxt));
++#ifdef MACRO
++static SCM m_syn_quote P((SCM xorig, SCM env, SCM ctxt));
++static SCM m_let_syntax P((SCM xorig, SCM env, SCM ctxt));
++static SCM m_letrec_syntax P((SCM xorig, SCM env, SCM ctxt));
++static SCM m_the_macro P((SCM xorig, SCM env, SCM ctxt));
++#endif
++static int badargsp P((SCM formals, SCM args));
+ 
+ static SCM *lookupcar P((SCM vloc));
+@@ -132,5 +128,9 @@
+ static SCM evalatomcar P((SCM x, int no_error));
+ static SCM evalcar P((SCM x));
++#ifdef MACRO
+ static SCM id2sym P((SCM id));
++static int topdenote_eq P((SCM sym, SCM id, SCM env));
++static int prinid P((SCM exp, SCM port, int writing));
++#endif
+ static SCM iqq P((SCM form));
+ static SCM m_body P((SCM xorig, SCM env, SCM ctxt));
+@@ -151,8 +151,6 @@
+ static SCM m_expr P((SCM x, SCM env, SCM ctxt));
+ static void checked_define P((SCM name, SCM val, const char *what));
+-static int topdenote_eq P((SCM sym, SCM id, SCM env));
+ static int constant_p P((SCM x));
+ static int prinenv P((SCM exp, SCM port, int writing));
+-static int prinid P((SCM exp, SCM port, int writing));
+ static int prinmacro P((SCM exp, SCM port, int writing));
+ static int prinprom P((SCM exp, SCM port, int writing));
+@@ -238,5 +236,5 @@
+ #ifdef MACRO
+ long tc16_ident;		/* synthetic macro identifier */
+-static char s_escaped[] = "escaped synthetic identifier";
++static const char s_escaped[] = "escaped synthetic identifier";
+ # define KEYWORDP(x) (NIMP(x) && IM_KEYWORD==CAR(x))
+ # define KEYWORD_MACRO CDR
+@@ -317,5 +315,5 @@
+      SCM x;
+ {
+-  register CELLPTR ptr;
++  CELLPTR ptr;
+   if (NCELLP(x)) return 0;
+   ptr = (CELLPTR)SCM2PTR(x);
+@@ -377,9 +375,9 @@
+ #endif /* CAREFUL_INTS */
+ 
+-SCM *ilookup(iloc)
++static SCM *ilookup(iloc)
+      SCM iloc;
+ {
+-  register int ir = IFRAME(iloc);
+-  register SCM er, *eloc;
++  int ir = IFRAME(iloc);
++  SCM er, *eloc;
+ #ifdef SCM_PROFILE
+   ilookup_cases[ir<10 ? ir : 9]
+@@ -398,9 +396,9 @@
+   return &CAR(*eloc);
+ }
+-SCM *farlookup(farloc)
++static SCM *farlookup(farloc)
+      SCM farloc;
+ {
+-  register int ir;
+-  register SCM er;
++  int ir;
++  SCM er;
+   SCM x = CDR(farloc);
+   DEFER_INTS_EGC;
+@@ -417,7 +415,9 @@
+ }
+ 
+-char s_badenv[] = "damaged environment";
+-static char  s_lookup[] = "scm_env_lookup",
++const char s_badenv[] = "damaged environment";
++static const char  s_lookup[] = "scm_env_lookup",
++#ifdef MACRO
+   s_badkey[] = "Use of keyword as variable",
++#endif
+   s_unbnd[] = "unbound variable: ",
+   s_wtap[] = "Wrong type to apply: ",
+@@ -861,6 +861,6 @@
+ }
+ 
+-static char s_values[] = "values";
+-static char s_call_wv[] = "call-with-values";
++static const char s_values[] = "values";
++static const char s_call_wv[] = "call-with-values";
+ SCM scm_values(arg1, arg2, rest, what)
+      SCM arg1, arg2, rest;
+@@ -877,15 +877,15 @@
+      * some memoized forms have different syntax */
+ 
+-static char s_expression[] = "missing or extra expression";
+-static char s_test[] = "bad test";
+-static char s_body[] = "bad body";
+-static char s_bindings[] = "bad bindings";
+-static char s_variable[] = "bad variable";
+-static char s_bad_else_clause[] = "bad ELSE clause";
+-static char s_clauses[] = "bad or missing clauses";
+-static char s_formals[] = "bad formals";
+-static char s_expr[] = "bad expression";
++static const char s_expression[] = "missing or extra expression";
++static const char s_test[] = "bad test";
++static const char s_body[] = "bad body";
++static const char s_bindings[] = "bad bindings";
++static const char s_variable[] = "bad variable";
++static const char s_bad_else_clause[] = "bad ELSE clause";
++static const char s_clauses[] = "bad or missing clauses";
++static const char s_formals[] = "bad formals";
++static const char s_expr[] = "bad expression";
+ #define ASSYNT(_cond, _arg, _pos, _subr)\
+-   if (!(_cond))scm_experr(_arg, (char *)_pos, _subr);
++   if (!(_cond))scm_experr(_arg, (const char *)_pos, _subr);
+ 
+ /* These symbols are needed by the reader, in repl.c */
+@@ -1157,5 +1157,5 @@
+ {
+   SCM v1, vs;
+-  char *opstr = ISYMCHARS(op) + 2;
++  const char *opstr = ISYMCHARS(op) + 2;
+   int argc = 0;
+   vars = scm_check_linum(vars, 0L);
+@@ -1218,6 +1218,6 @@
+ static int env_depth()
+ {
+-  register int depth = 0;
+-  register SCM env;
++  int depth = 0;
++  SCM env;
+   DEFER_INTS_EGC;
+   env = scm_env;
+@@ -1231,5 +1231,5 @@
+      int depth;
+ {
+-  register SCM env;
++  SCM env;
+   DEFER_INTS_EGC;
+   env = scm_env;
+@@ -1253,5 +1253,5 @@
+ #endif
+ 
+-static char s_nullenv_p[] = "scm_nullenv_p";
++static const char s_nullenv_p[] = "scm_nullenv_p";
+ int scm_nullenv_p(env)
+      SCM env;
+@@ -1468,7 +1468,6 @@
+ }
+ 
+-extern char s_redefining[];
+ #ifndef RECKLESS
+-char s_built_in_syntax[] = "built-in syntax ";
++static const char s_built_in_syntax[] = "built-in syntax ";
+ # define s_syntax (&s_built_in_syntax[9])
+ #endif
+@@ -1993,6 +1992,6 @@
+ #endif
+ 
+-char s_map[] = "map", s_for_each[] = "for-each", s_eval[] = "@eval";
+-char s_call_cc[] = "call-with-current-continuation"; /* s_apply[] = "apply"; */
++const char s_map[] = "map", s_for_each[] = "for-each", s_eval[] = "@eval";
++const char s_call_cc[] = "call-with-current-continuation"; /* s_apply[] = "apply"; */
+ 
+ /* static int checking_defines_p(ctxt) SCM ctxt; */
+@@ -2055,9 +2054,9 @@
+ }
+ 
+-SCM scm_apply_cxr(proc, arg1)
++static SCM scm_apply_cxr(proc, arg1)
+      SCM proc, arg1;
+ {
+-  double y;
+ #ifdef FLOATS
++  double y;
+   if (SUBRF(proc)) {
+     if (INUMP(arg1)) {
+@@ -2821,6 +2820,6 @@
+ }
+ 
+-static char s_proc_doc[] = "procedure-documentation";
+-SCM l_proc_doc(proc)
++static const char s_proc_doc[] = "procedure-documentation";
++static SCM l_proc_doc(proc)
+      SCM proc;
+ {
+@@ -3169,5 +3168,5 @@
+      int argc;
+ {
+-	register SCM z;
++	SCM z;
+ 	NEWCELL(z);
+ 	SETCODE(z, code);
+@@ -3186,5 +3185,5 @@
+      SCM code;
+ {
+-	register SCM z;
++	SCM z;
+ 	NEWCELL(z);
+ 	CDR(z) = code;
+@@ -3210,5 +3209,5 @@
+      const char *what;
+ {
+-  register SCM z;
++  SCM z;
+   ASRTER(scm_arity_check(code, (MAC_PRIMITIVE & flags ? 3L : 2L),
+ 			 (char *)0), code, ARG1, what);
+@@ -3218,5 +3217,5 @@
+   return z;
+ }
+-static char s_makacro[] = "procedure->syntax";
++static const char s_makacro[] = "procedure->syntax";
+ SCM makacro(code)
+      SCM code;
+@@ -3224,5 +3223,5 @@
+   return makro(code, MAC_ACRO, s_makacro);
+ }
+-static char s_makmacro[] = "procedure->macro";
++static const char s_makmacro[] = "procedure->macro";
+ SCM makmacro(code)
+      SCM code;
+@@ -3230,5 +3229,5 @@
+   return makro(code, MAC_MACRO, s_makmacro);
+ }
+-static char s_makmmacro[] = "procedure->memoizing-macro";
++static const char s_makmmacro[] = "procedure->memoizing-macro";
+ SCM makmmacro(code)
+      SCM code;
+@@ -3236,5 +3235,5 @@
+   return makro(code, MAC_MMACRO, s_makmmacro);
+ }
+-static char s_makidmacro[] = "procedure->identifier-macro";
++static const char s_makidmacro[] = "procedure->identifier-macro";
+ SCM makidmacro(code)
+      SCM code;
+@@ -3251,6 +3250,6 @@
+    (BEGIN #F) will be returned instead of #F if #F is the result.
+  */
+-static char s_macroexpand1[] = "@macroexpand1";
+-SCM scm_macroexpand1(x, env)
++static const char s_macroexpand1[] = "@macroexpand1";
++static SCM scm_macroexpand1(x, env)
+      SCM x, env;
+ {
+@@ -3276,6 +3275,6 @@
+ }
+ 
+-static char s_eval_syntax[] = "eval-syntax";
+-SCM scm_eval_syntax(x, env)
++static const char s_eval_syntax[] = "eval-syntax";
++static SCM scm_eval_syntax(x, env)
+      SCM x, env;
+ {
+@@ -3403,6 +3402,6 @@
+ }
+ 
+-static char s_definedp[] = "defined?";
+-SCM definedp(xorig, env, ctxt)
++static const char s_definedp[] = "defined?";
++static SCM definedp(xorig, env, ctxt)
+      SCM xorig, env, ctxt;
+ {
+@@ -3422,5 +3421,5 @@
+ 
+ #ifdef MACRO
+-static char s_identp[] = "identifier?";
++static const char s_identp[] = "identifier?";
+ SCM identp(obj)
+      SCM obj;
+@@ -3429,5 +3428,5 @@
+ }
+ 
+-static char s_ident_eqp[] = "identifier-equal?";
++static const char s_ident_eqp[] = "identifier-equal?";
+ SCM ident_eqp(id1, id2, env)
+      SCM id1, id2, env;
+@@ -3454,5 +3453,5 @@
+ }
+ 
+-static char s_ident2sym[] = "identifier->symbol";
++static const char s_ident2sym[] = "identifier->symbol";
+ SCM ident2sym(id)
+      SCM id;
+@@ -3463,5 +3462,5 @@
+ }
+ 
+-static char s_renamed_ident[] = "renamed-identifier";
++static const char s_renamed_ident[] = "renamed-identifier";
+ SCM renamed_ident(id, env)
+      SCM id, env;
+@@ -3500,5 +3499,5 @@
+ }
+ 
+-static char s_syn_quote[] = "syntax-quote";
++static const char s_syn_quote[] = "syntax-quote";
+ SCM m_syn_quote(xorig, env, ctxt)
+      SCM xorig, env, ctxt;
+@@ -3508,6 +3507,6 @@
+ }
+ 
+-static char s_defsyntax[] = "defsyntax";
+-SCM m_defsyntax(xorig, env, ctxt)
++static const char s_defsyntax[] = "defsyntax";
++static SCM m_defsyntax(xorig, env, ctxt)
+      SCM xorig, env, ctxt;
+ {
+@@ -3541,5 +3540,5 @@
+   return cons2(IM_LET_SYNTAX, env, m_body(body, env, ctxt));
+ }
+-static char s_letrec_syntax[] = "letrec-syntax";
++static const char s_letrec_syntax[] = "letrec-syntax";
+ SCM m_letrec_syntax(xorig, env, ctxt)
+      SCM xorig, env, ctxt;
+@@ -3564,5 +3563,5 @@
+ }
+ 
+-static char s_the_macro[] = "the-macro";
++static const char s_the_macro[] = "the-macro";
+ SCM m_the_macro(xorig, env, ctxt)
+      SCM xorig, env, ctxt;
+@@ -3624,5 +3623,5 @@
+ #endif
+ 
+-SCM make_synt(name, flags, fcn)
++static SCM make_synt(name, flags, fcn)
+      const char *name;
+      long flags;
+@@ -3638,10 +3637,10 @@
+   return CAR(symcell);
+ }
+-SCM make_specfun(name, typ, flags)
+-     char *name;
++static SCM make_specfun(name, typ, flags)
++     const char *name;
+      int typ, flags;
+ {
+   SCM symcell = sysintern(name, UNDEFINED);
+-  register SCM z;
++  SCM z;
+   NEWCELL(z);
+   CAR(z) = (long)typ | ((long)flags)<<16;
+--- findexec.c	2012-12-18 23:00:10.000000000 -0500
++++ findexec.c	2015-01-23 18:55:19.000000000 -0500
+@@ -132,4 +132,6 @@
+ # endif
+ 
++#include "scm.h"
++
+ static char *copy_of(s)
+      register const char *s;
+@@ -154,6 +156,6 @@
+      const char *name;
+ {
+-  char *search;
+-  register char *p;
++  const char *search;
++  const char *p;
+   char tbuf[MAXPATHLEN];
+ 
+@@ -173,6 +175,6 @@
+   }
+ 
+-  if (((search = (char *) getenv("DLDPATH")) == 0) &&
+-      ((search = (char *) getenv("PATH")) == 0))
++  if (((search = getenv("DLDPATH")) == 0) &&
++      ((search = getenv("PATH")) == 0))
+     search = DEFAULT_PATH;
+ 
+--- gmalloc.c	2008-01-30 22:44:00.000000000 -0500
++++ gmalloc.c	2015-01-23 18:55:19.000000000 -0500
+@@ -1622,5 +1622,5 @@
+ #endif
+ #else
+-#ifndef __osf__			/* declared in <unistd.h> */
++#ifndef __FreeBSD__			/* declared in <unistd.h> */
+ #ifndef hpux			/* declared in <unistd.h> */
+ #ifndef __svr4__		/* declared in <unistd.h> */
+--- gsubr.c	2008-01-30 22:32:00.000000000 -0500
++++ gsubr.c	2015-01-23 18:55:19.000000000 -0500
+@@ -31,35 +31,7 @@
+ 
+ static SCM f_gsubr_apply;
+-SCM make_gsubr(name, req, opt, rst, fcn)
+-     const char *name;
+-     int req, opt, rst;
+-     SCM (*fcn)();
+-{
+-  switch GSUBR_MAKTYPE(req, opt, rst) {
+-  case GSUBR_MAKTYPE(0, 0, 0): return make_subr(name, tc7_subr_0, fcn);
+-  case GSUBR_MAKTYPE(1, 0, 0): return make_subr(name, tc7_subr_1, fcn);
+-  case GSUBR_MAKTYPE(0, 1, 0): return make_subr(name, tc7_subr_1o, fcn);
+-  case GSUBR_MAKTYPE(1, 1, 0): return make_subr(name, tc7_subr_2o, fcn);
+-  case GSUBR_MAKTYPE(2, 0, 0): return make_subr(name, tc7_subr_2, fcn);
+-  case GSUBR_MAKTYPE(3, 0, 0): return make_subr(name, tc7_subr_3, fcn);
+-  case GSUBR_MAKTYPE(0, 0, 1): return make_subr(name, tc7_lsubr, fcn);
+-  case GSUBR_MAKTYPE(2, 0, 1): return make_subr(name, tc7_lsubr_2, fcn);
+-  default:
+-    {
+-      SCM symcell = sysintern(name, UNDEFINED);
+-      SCM z = scm_maksubr(name, tc7_subr_0, fcn);
+-      SCM cclo = makcclo(f_gsubr_apply, 3L);
+-      ASRTER(GSUBR_MAX >= req + opt + rst, MAKINUM(req + opt + rst),
+-	     OUTOFRANGE, "make_gsubr");
+-      GSUBR_PROC(cclo) = z;
+-      GSUBR_TYPE(cclo) = MAKINUM(GSUBR_MAKTYPE(req, opt, rst));
+-      CDR(symcell) = cclo;
+-      return cclo;
+-    }
+-  }
+-}
+ 
+-char s_gsubr_apply[] = " gsubr-apply";
+-SCM gsubr_apply(args)
++static const char s_gsubr_apply[] = " gsubr-apply";
++static SCM gsubr_apply(args)
+      SCM args;
+ {
+@@ -69,5 +41,4 @@
+   int i, n = GSUBR_REQ(typ) + GSUBR_OPT(typ) + GSUBR_REST(typ);
+   SCM v[10];
+-  if (n > 10) wta(self, "internal programming error", s_gsubr_apply);
+   args = CDR(args);
+   for (i = 0; i < GSUBR_REQ(typ); i++) {
+@@ -101,9 +72,8 @@
+   case 9: return (*fcn)(v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7], v[8]);
+   case 10: return (*fcn)(v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7], v[8], v[9]);
++  default: wta(self, "internal programming error", s_gsubr_apply);
+   }
+ }
+ 
+-SCM_DLL_EXPORT void init_gsubr P((void));
+-
+ void init_gsubr()
+ {
+--- ioext.c	2010-04-01 15:05:09.000000000 -0400
++++ ioext.c	2015-01-23 18:55:19.000000000 -0500
+@@ -35,5 +35,4 @@
+ #  include <io.h>
+ # endif
+-SCM	stat2scm P((struct stat *stat_temp));
+ /* int	mkdir P((const char *path, mode_t mode)); */
+ #endif
+@@ -107,6 +106,6 @@
+ #endif
+ 
+-static char s_read_line[] = "read-line";
+-SCM read_line(port)
++static const char s_read_line[] = "read-line";
++static SCM read_line(port)
+      SCM port;
+ {
+@@ -136,6 +135,6 @@
+   }
+ }
+-static char s_read_line1[] = "read-line!";
+-SCM read_line1(str, port)
++static const char s_read_line1[] = "read-line!";
++static SCM read_line1(str, port)
+      SCM str, port;
+ {
+@@ -166,6 +165,6 @@
+   }
+ }
+-static char s_write_line[] = "write-line";
+-SCM l_write_line(obj, port)
++static const char s_write_line[] = "write-line";
++static SCM l_write_line(obj, port)
+      SCM obj, port;
+ {
+@@ -174,6 +173,6 @@
+ }
+ 
+-static char s_reopen_file[] = "reopen-file";
+-SCM reopen_file(filename, modes, port)
++static const char s_reopen_file[] = "reopen-file";
++static SCM reopen_file(filename, modes, port)
+      SCM filename, modes, port;
+ {
+@@ -205,6 +204,6 @@
+ #ifndef MCH_AMIGA
+ # ifndef macintosh
+-static char s_dup[]="duplicate-port";
+-SCM l_dup(oldpt, modes)
++static const char s_dup[]="duplicate-port";
++static SCM l_dup(oldpt, modes)
+      SCM oldpt, modes;
+ {
+@@ -239,6 +238,6 @@
+   return newpt;
+ }
+-static char s_dup2[]="redirect-port!";
+-SCM l_dup2(into_pt, from_pt)
++static const char s_dup2[]="redirect-port!";
++static SCM l_dup2(into_pt, from_pt)
+      SCM into_pt, from_pt;
+ {
+@@ -257,11 +256,11 @@
+ 
+ # ifndef vms
+-static char s_opendir[]="opendir";
+-static char s_readdir[]="readdir";
+-static char s_rewinddir[]="rewinddir";
+-static char s_closedir[]="closedir";
++static const char s_opendir[]="opendir";
++static const char s_readdir[]="readdir";
++static const char s_rewinddir[]="rewinddir";
++static const char s_closedir[]="closedir";
+ #  ifndef _WIN32
+ #   include <dirent.h>
+-SCM l_opendir(dirname)
++static SCM l_opendir(dirname)
+      SCM dirname;
+ {
+@@ -279,5 +278,5 @@
+ }
+ 
+-SCM l_readdir(port)
++static SCM l_readdir(port)
+      SCM port;
+ {
+@@ -292,5 +291,5 @@
+ }
+ 
+-SCM l_rewinddir(port)
++static SCM l_rewinddir(port)
+      SCM port;
+ {
+@@ -300,5 +299,5 @@
+ }
+ 
+-SCM l_closedir(port)
++static SCM l_closedir(port)
+      SCM port;
+ {
+@@ -314,5 +313,5 @@
+ }
+ 
+-int dir_print(sexp, port, writing)
++static int dir_print(sexp, port, writing)
+      SCM sexp; SCM port; int writing;
+ {
+@@ -320,5 +319,5 @@
+   return !0;
+ }
+-sizet dir_free(p)
++static sizet dir_free(p)
+      CELLPTR p;
+ {
+@@ -334,5 +333,5 @@
+ };
+ 
+-SCM l_opendir(dirname)
++static SCM l_opendir(dirname)
+      SCM dirname;
+ {
+@@ -362,5 +361,5 @@
+ }
+ 
+-SCM l_readdir(port)
++static SCM l_readdir(port)
+      SCM port;
+ {
+@@ -382,5 +381,5 @@
+ }
+ 
+-SCM l_rewinddir(port)
++static SCM l_rewinddir(port)
+      SCM port;
+ {
+@@ -396,5 +395,5 @@
+ }
+ 
+-SCM l_closedir(port)
++static SCM l_closedir(port)
+      SCM port;
+ {
+@@ -429,5 +428,5 @@
+   return 0;
+ }
+-SCM dir_mark(ptr)
++static SCM dir_mark(ptr)
+      SCM ptr;
+ {
+@@ -439,6 +438,6 @@
+ # endif /* vms */
+ 
+-static char s_mkdir[] = "mkdir";
+-SCM l_mkdir(path, mode)
++static const char s_mkdir[] = "mkdir";
++static SCM l_mkdir(path, mode)
+      SCM path, mode;
+ {
+@@ -455,8 +454,8 @@
+ }
+ # ifdef vms
+-static char s_dot_dir[] = ".DIR";
++static const char s_dot_dir[] = ".DIR";
+ # endif
+-static char s_rmdir[] = "rmdir";
+-SCM l_rmdir(path)
++static const char s_rmdir[] = "rmdir";
++static SCM l_rmdir(path)
+      SCM path;
+ {
+@@ -473,6 +472,6 @@
+ 
+ #ifndef THINK_C
+-static char s_chdir[] = "chdir";
+-SCM lchdir(str)
++static const char s_chdir[] = "chdir";
++static SCM lchdir(str)
+      SCM str;
+ {
+@@ -486,5 +485,5 @@
+ #   include <dir.h>
+ #  endif
+-SCM l_getcwd()
++static SCM l_getcwd()
+ {
+   char *ans;
+@@ -500,6 +499,6 @@
+ 
+ #  ifndef __MWERKS__
+-static char s_chmod[] = "chmod";
+-SCM l_chmod(pathname, mode)
++static const char s_chmod[] = "chmod";
++static SCM l_chmod(pathname, mode)
+      SCM pathname, mode;
+ {
+@@ -522,6 +521,6 @@
+ #    endif
+ #   endif
+-static char s_utime[] = "utime";
+-SCM l_utime(pathname, acctime, modtime)
++static const char s_utime[] = "utime";
++static SCM l_utime(pathname, acctime, modtime)
+      SCM pathname, acctime, modtime;
+ {
+@@ -537,6 +536,6 @@
+ 
+ #  ifndef __MWERKS__
+-static char s_umask[] = "umask";
+-SCM l_umask(mode)
++static const char s_umask[] = "umask";
++static SCM l_umask(mode)
+      SCM mode;
+ {
+@@ -548,6 +547,6 @@
+ #endif /* THINK_C */
+ 
+-static char s_ren_fil[] = "rename-file";
+-SCM ren_fil(oldname, newname)
++static const char s_ren_fil[] = "rename-file";
++static SCM ren_fil(oldname, newname)
+      SCM oldname, newname;
+ {
+@@ -570,6 +569,6 @@
+ #endif
+ }
+-static char s_copy_file[] = "copy-file";
+-SCM scm_copy_file(oldname, newname)
++static const char s_copy_file[] = "copy-file";
++static SCM scm_copy_file(oldname, newname)
+      SCM oldname, newname;
+ {
+@@ -618,6 +617,6 @@
+ }
+ 
+-static char s_fileno[] = "fileno";
+-SCM l_fileno(port)
++static const char s_fileno[] = "fileno";
++static SCM l_fileno(port)
+      SCM port;
+ {
+@@ -634,6 +633,6 @@
+ #   define R_OK 04
+ #  endif
+-static char s_access[] = "access";
+-SCM l_access(pathname, mode)
++static const char s_access[] = "access";
++static SCM l_access(pathname, mode)
+      SCM pathname, mode;
+ {
+@@ -653,8 +652,6 @@
+ # endif /* __MWERKS__ */
+ 
+-SCM stat2scm P((struct stat *stat_temp));
+-
+-char s_stat[] = "stat";
+-SCM l_stat(str)
++static const char s_stat[] = "stat";
++static SCM l_stat(str)
+   SCM str;
+ {
+@@ -677,5 +674,5 @@
+ # ifdef MCH_AMIGA
+ SCM stat2scm(stat_temp)
+-     struct stat *stat_temp;
++     const struct stat *stat_temp;
+ {
+   SCM ans = make_vector(MAKINUM(3), UNSPECIFIED);
+@@ -688,5 +685,5 @@
+ # else
+ SCM stat2scm(stat_temp)
+-     struct stat *stat_temp;
++     const struct stat *stat_temp;
+ {
+   SCM ans = make_vector(MAKINUM(11), UNSPECIFIED);
+@@ -708,5 +705,5 @@
+ #   include <process.h>
+ #  endif
+-SCM l_getpid()
++static SCM l_getpid()
+ {
+   return MAKINUM((unsigned long)getpid());
+@@ -722,8 +719,8 @@
+ #     include <process.h>
+ #    endif
+-char s_execv[] = "execv";
+-char s_execvp[] = "execvp";
+-SCM i_execv(modes, path, args)
+-     char * modes;
++const char s_execv[] = "execv";
++const char s_execvp[] = "execvp";
++static SCM i_execv(modes, path, args)
++     const char * modes;
+      SCM path, args;
+ {
+@@ -743,26 +740,26 @@
+   return MAKINUM(errno);
+ }
+-SCM lexec(path, arg0, args)
++static SCM lexec(path, arg0, args)
+      SCM path, arg0, args;
+ {
+   return i_execv("", path, cons(arg0, args));
+ }
+-SCM lexecp(path, arg0, args)
++static SCM lexecp(path, arg0, args)
+      SCM path, arg0, args;
+ {
+   return i_execv("p", path, cons(arg0, args));
+ }
+-SCM lexecv(path, args)
++static SCM lexecv(path, args)
+      SCM path, args;
+ {
+   return i_execv("", path, args);
+ }
+-SCM lexecvp(path, args)
++static SCM lexecvp(path, args)
+      SCM path, args;
+ {
+   return i_execv("p", path, args);
+ }
+-static char s_putenv[] = "putenv";
+-SCM l_putenv(str)
++static const char s_putenv[] = "putenv";
++static SCM l_putenv(str)
+      SCM str;
+ {
+@@ -819,5 +816,5 @@
+ #include <fcntl.h>		/* for O_RDONLY, O_RDWR, O_EXCL */
+ #ifdef O_EXCL
+-SCM scm_try_create_file(fname, modes, perms)
++static SCM scm_try_create_file(fname, modes, perms)
+      SCM fname, modes, perms;
+ {
+@@ -865,6 +862,4 @@
+ 	{0, 0}};
+ 
+-SCM_DLL_EXPORT void init_ioext P((void));
+-
+ void init_ioext()
+ {
+--- posix.c	2008-01-30 22:32:26.000000000 -0500
++++ posix.c	2015-01-23 18:55:19.000000000 -0500
+@@ -46,6 +46,6 @@
+ #endif
+ 
+-static char s_chown[] = "chown";
+-SCM l_chown(path, owner, group)
++static const char s_chown[] = "chown";
++static SCM l_chown(path, owner, group)
+      SCM path, owner, group;
+ {
+@@ -58,6 +58,6 @@
+ }
+ 
+-static char s_link[] = "link";
+-SCM l_link(oldpath, newpath)
++static const char s_link[] = "link";
++static SCM l_link(oldpath, newpath)
+      SCM oldpath, newpath;
+ {
+@@ -69,5 +69,5 @@
+ }
+ 
+-SCM l_pipe()
++static SCM l_pipe()
+ {
+   int fd[2], ret;
+@@ -96,6 +96,6 @@
+ }
+ 
+-char	s_op_pipe[] = "open-pipe";
+-SCM open_pipe(pipestr, modes)
++const char	s_op_pipe[] = "open-pipe";
++static SCM open_pipe(pipestr, modes)
+      SCM pipestr, modes;
+ {
+@@ -118,6 +118,6 @@
+ }
+ 
+-static char scm_s_getgroups[] = "getgroups";
+-SCM scm_getgroups()
++static const char scm_s_getgroups[] = "getgroups";
++static SCM scm_getgroups()
+ {
+   SCM grps, ans;
+@@ -147,6 +147,6 @@
+    before access to that structure is completed */
+ 
+-static char s_pwinfo[] = "getpw";
+-SCM l_pwinfo(user)
++static const char s_pwinfo[] = "getpw";
++static SCM l_pwinfo(user)
+      SCM user;
+ {
+@@ -173,6 +173,6 @@
+ }
+ #include <grp.h>
+-static char s_grinfo[] = "getgr";
+-SCM l_grinfo(name)
++static const char s_grinfo[] = "getgr";
++static SCM l_grinfo(name)
+      SCM name;
+ {
+@@ -192,8 +192,8 @@
+   ve[ 1] = makfrom0str(entry->gr_passwd);
+   ve[ 2] = ulong2num((unsigned long)entry->gr_gid);
+-  ve[ 3] = makfromstrs(-1, entry->gr_mem);
++  ve[ 3] = makfromstrs(-1, (const char * const *)entry->gr_mem);
+   return ans;
+ }
+-SCM l_setgr(arg)
++static SCM l_setgr(arg)
+      SCM arg;
+ {
+@@ -202,5 +202,5 @@
+   return UNSPECIFIED;
+ }
+-SCM l_setpw(arg)
++static SCM l_setpw(arg)
+      SCM arg;
+ {
+@@ -210,6 +210,6 @@
+ }
+ 
+-static char s_kill[] = "kill";
+-SCM l_kill(pid, sig)
++static const char s_kill[] = "kill";
++static SCM l_kill(pid, sig)
+      SCM pid, sig;
+ {
+@@ -220,6 +220,6 @@
+   return MAKINUM(0L+i);
+ }
+-static char s_waitpid[] = "waitpid";
+-SCM l_waitpid(pid, options)
++static const char s_waitpid[] = "waitpid";
++static SCM l_waitpid(pid, options)
+      SCM pid, options;
+ {
+@@ -231,23 +231,23 @@
+ }
+ 
+-SCM l_getppid()
++static SCM l_getppid()
+ {
+   return MAKINUM(0L+getppid());
+ }
+ 
+-SCM l_getuid()
++static SCM l_getuid()
+ {
+   return MAKINUM(0L+getuid());
+ }
+-SCM l_getgid()
++static SCM l_getgid()
+ {
+   return MAKINUM(0L+getgid());
+ }
+ #ifndef LACK_E_IDs
+-SCM l_geteuid()
++static SCM l_geteuid()
+ {
+   return MAKINUM(0L+geteuid());
+ }
+-SCM l_getegid()
++static SCM l_getegid()
+ {
+   return MAKINUM(0L+getegid());
+@@ -255,6 +255,6 @@
+ #endif
+ 
+-static char s_setuid[] = "setuid";
+-SCM l_setuid(id)
++static const char s_setuid[] = "setuid";
++static SCM l_setuid(id)
+      SCM id;
+ {
+@@ -262,6 +262,6 @@
+   return setuid(INUM(id)) ? BOOL_F : BOOL_T;
+ }
+-static char s_setgid[] = "setgid";
+-SCM l_setgid(id)
++static const char s_setgid[] = "setgid";
++static SCM l_setgid(id)
+      SCM id;
+ {
+@@ -271,6 +271,6 @@
+ 
+ #ifndef LACK_E_IDs
+-static char s_seteuid[] = "seteuid";
+-SCM l_seteuid(id)
++static const char s_seteuid[] = "seteuid";
++static SCM l_seteuid(id)
+      SCM id;
+ {
+@@ -278,6 +278,6 @@
+   return seteuid(INUM(id)) ? BOOL_F : BOOL_T;
+ }
+-static char s_setegid[] = "setegid";
+-SCM l_setegid(id)
++static const char s_setegid[] = "setegid";
++static SCM l_setegid(id)
+      SCM id;
+ {
+@@ -287,6 +287,6 @@
+ #endif
+ 
+-static char s_ttyname[] = "ttyname";
+-SCM l_ttyname(port)
++static const char s_ttyname[] = "ttyname";
++static SCM l_ttyname(port)
+      SCM port;
+ {
+@@ -299,5 +299,5 @@
+ }
+ 
+-SCM l_fork()
++static SCM l_fork()
+ {
+   long pid = 0L + fork();
+@@ -306,5 +306,5 @@
+ 
+ #include <sys/utsname.h>
+-SCM l_uname()
++static SCM l_uname()
+ {
+   struct utsname buf;
+--- ramap.c	2013-03-12 23:30:27.000000000 -0400
++++ ramap.c	2015-01-23 18:55:19.000000000 -0500
+@@ -21,8 +21,8 @@
+ #include "scm.h"
+ 
+-SCM	sc2array P((SCM s, SCM ra, SCM prot));
++static SCM sc2array P((SCM s, SCM ra, SCM prot));
+ 
+ typedef struct {
+-  char *name;
++  const char *name;
+   SCM sproc;
+   int (* vproc)();
+@@ -64,5 +64,5 @@
+ 		    0 --> no match.
+    */
+-int ra_matchp(ra0, ras)
++static int ra_matchp(ra0, ras)
+      SCM ra0, ras;
+ {
+@@ -137,6 +137,6 @@
+ }
+ 
+-static char s_ra_mismatch[] = "array shape mismatch";
+-int ramapc(cproc, data, ra0, lra, what)
++static const char s_ra_mismatch[] = "array shape mismatch";
++static int ramapc(cproc, data, ra0, lra, what)
+      int (*cproc)();
+      SCM data, ra0, lra;
+@@ -258,5 +258,5 @@
+ }
+ 
+-SCM array_fill(ra, fill)
++static SCM array_fill(ra, fill)
+      SCM ra, fill;
+ {
+@@ -265,6 +265,6 @@
+ }
+ 
+-static char s_sarray_copy[] = "serial-array:copy!";
+-static char s_array_copy[] = "array:copy!";
++static const char s_sarray_copy[] = "serial-array:copy!";
++static const char s_array_copy[] = "array:copy!";
+ static int racp(src, dst)
+      SCM dst, src;
+@@ -466,5 +466,5 @@
+   return 1;
+ }
+-SCM array_copy(dst, src)
++static SCM array_copy(dst, src)
+      SCM dst;
+      SCM src;
+@@ -479,5 +479,5 @@
+ }
+ 
+-SCM ra2contig(ra, copy)
++static SCM ra2contig(ra, copy)
+      SCM ra;
+      int copy;
+@@ -511,6 +511,6 @@
+ }
+ 
+-static char s_ura_rd[] = "uniform-array-read!";
+-SCM ura_read(ra, port)
++static const char s_ura_rd[] = "uniform-array-read!";
++static SCM ura_read(ra, port)
+      SCM ra, port;
+ {
+@@ -525,6 +525,6 @@
+ }
+ 
+-static char s_ura_wr[] = "uniform-array-write";
+-SCM ura_write(ra, port)
++static const char s_ura_wr[] = "uniform-array-write";
++static SCM ura_write(ra, port)
+      SCM ra, port;
+ {
+@@ -535,5 +535,5 @@
+ }
+ 
+-static char s_sc2array[] = "scalar->array";
++static const char s_sc2array[] = "scalar->array";
+ SCM sc2array(s, ra, prot)
+      SCM s, ra, prot;
+@@ -604,5 +604,5 @@
+ 
+ /* Functions callable by ARRAY-MAP! */
+-int ra_eqp(ra0, ras)
++static int ra_eqp(ra0, ras)
+      SCM ra0, ras;
+ {
+@@ -725,20 +725,20 @@
+   return 1;
+ }
+-int ra_lessp(ra0, ras)
++static int ra_lessp(ra0, ras)
+      SCM ra0, ras;
+ {
+  return ra_compare(ra0, CAR(ras), CAR(CDR(ras)), 0);
+ }
+-int ra_leqp(ra0, ras)
++static int ra_leqp(ra0, ras)
+      SCM ra0, ras;
+ {
+   return ra_compare(ra0, CAR(CDR(ras)), CAR(ras), 1);
+ }
+-int ra_grp(ra0, ras)
++static int ra_grp(ra0, ras)
+      SCM ra0, ras;
+ {
+   return ra_compare(ra0, CAR(CDR(ras)), CAR(ras), 0);
+ }
+-int ra_greqp(ra0, ras)
++static int ra_greqp(ra0, ras)
+      SCM ra0, ras;
+ {
+@@ -746,5 +746,5 @@
+ }
+ 
+-int ra_sum(ra0, ras)
++static int ra_sum(ra0, ras)
+      SCM ra0, ras;
+ {
+@@ -832,5 +832,5 @@
+ }
+ 
+-int ra_difference(ra0, ras)
++static int ra_difference(ra0, ras)
+      SCM ra0, ras;
+ {
+@@ -963,5 +963,5 @@
+ }
+ 
+-int ra_product(ra0, ras)
++static int ra_product(ra0, ras)
+      SCM ra0, ras;
+ {
+@@ -1052,5 +1052,5 @@
+   return 1;
+ }
+-int ra_divide(ra0, ras)
++static int ra_divide(ra0, ras)
+      SCM ra0, ras;
+ {
+@@ -1209,5 +1209,8 @@
+   ra1 = ARRAY_V(ra1);
+   switch TYP7(ra0) {
+-  default: gencase:
++  default:
++#ifdef FLOATS
++  gencase:
++#endif
+     for (; n-- > 0; i0 += inc0, i1 += inc1) {
+       e1 = cvref(ra1, i1, e1);
+@@ -1369,7 +1372,7 @@
+   {0, 0, 0}};
+ 
+-static char s_sarray_map[] = "serial-array-map!";
++static const char s_sarray_map[] = "serial-array-map!";
+ # define s_array_map  (s_sarray_map + 7)
+-SCM array_map(ra0, proc, lra)
++static SCM array_map(ra0, proc, lra)
+      SCM ra0, proc, lra;
+ {
+@@ -1413,12 +1416,13 @@
+   case tc7_asubr:
+     if (NULLP(lra)) {
+-      SCM prot, fill = SUBRF(proc)(UNDEFINED, UNDEFINED);
++      SCM fill = SUBRF(proc)(UNDEFINED, UNDEFINED);
++# ifdef FLOATS
++      SCM prot;
+       if (INUMP(fill)) {
+ 	prot = array_prot(ra0);
+-# ifdef FLOATS
+ 	if (NIMP(prot) && INEXP(prot))
+ 	  fill = makdbl((double)INUM(fill), 0.0);
+-# endif
+       }
++# endif
+       array_fill(ra0, fill);
+     }
+@@ -1496,6 +1500,6 @@
+   return 1;
+ }
+-static char s_array_for_each[] = "array-for-each";
+-SCM array_for_each(proc, ra0, lra)
++static const char s_array_for_each[] = "array-for-each";
++static SCM array_for_each(proc, ra0, lra)
+      SCM proc, ra0, lra;
+ {
+@@ -1523,6 +1527,6 @@
+ }
+ 
+-static char s_array_index_for_each[] = "array-index-for-each";
+-SCM scm_array_index_for_each(ra, proc)
++static const char s_array_index_for_each[] = "array-index-for-each";
++static SCM scm_array_index_for_each(ra, proc)
+      SCM ra, proc;
+ {
+@@ -1594,6 +1598,6 @@
+ }
+ 
+-static char s_array_imap[] = "array-index-map!";
+-SCM array_imap(ra, proc)
++static const char s_array_imap[] = "array-index-map!";
++static SCM array_imap(ra, proc)
+      SCM ra, proc;
+ {
+@@ -1666,5 +1670,6 @@
+ }
+ 
+-SCM array_equal P((SCM ra0, SCM ra1));
++static SCM array_equal(SCM ra0, SCM ra1); /* Forward declaration */
++
+ static int raeql_1(ra0, as_equal, ra1)
+      SCM ra0, as_equal, ra1;
+@@ -1794,6 +1799,6 @@
+   return (raeql(ra0, BOOL_T, ra1) ? BOOL_T : BOOL_F);
+ }
+-static char s_array_equalp[] = "array-equal?";
+-SCM array_equal(ra0, ra1)
++static const char s_array_equalp[] = "array-equal?";
++static SCM array_equal(ra0, ra1)
+      SCM ra0, ra1;
+ {
+@@ -1846,6 +1851,4 @@
+ }
+ 
+-SCM_DLL_EXPORT void init_ramap P((void));
+-
+ void init_ramap()
+ {
+--- record.c	2008-10-30 11:55:09.000000000 -0400
++++ record.c	2015-01-23 18:55:19.000000000 -0500
+@@ -56,12 +56,12 @@
+ #endif
+ 
+-static char s_record[] = "record";
+-static char s_recordp[] = "record?";
+-SCM recordp(obj)
++static const char s_record[] = "record";
++static const char s_recordp[] = "record?";
++static SCM recordp(obj)
+      SCM obj;
+ {
+   return (NIMP(obj) && RECP(obj) ? BOOL_T : BOOL_F);
+ }
+-SCM rec_pred1(cclo, obj)
++static SCM rec_pred1(cclo, obj)
+      SCM cclo, obj;
+ {
+@@ -71,6 +71,6 @@
+ }
+ static SCM f_rec_pred1;
+-static char s_rec_pred[] = "record-predicate";
+-SCM rec_pred(rtd)
++static const char s_rec_pred[] = "record-predicate";
++static SCM rec_pred(rtd)
+      SCM rtd;
+ {
+@@ -81,6 +81,6 @@
+ }
+ 
+-static char s_rec_rtd[] = "record-type-descriptor";
+-SCM rec_rtd(rec)
++static const char s_rec_rtd[] = "record-type-descriptor";
++static SCM rec_rtd(rec)
+      SCM rec;
+ {
+@@ -90,6 +90,6 @@
+ 
+ static SCM f_rec_constr1;
+-static char s_rec_constr[] = "record-constructor";
+-SCM rec_constr(rtd, flds)
++static const char s_rec_constr[] = "record-constructor";
++static SCM rec_constr(rtd, flds)
+      SCM rtd, flds;
+ {
+@@ -130,5 +130,6 @@
+      SCM arg, rtd;
+      int i;
+-     char *pos, *what;
++     intptr_t pos;
++     const char *what;
+ {
+   SCM recname = RTD_NAME(rtd);
+@@ -143,9 +144,9 @@
+   else
+     mesg = st_append(cons2(mesg, recname, EOL));
+-  wta(arg, pos, CHARS(mesg));
++  wta(arg, (char *)pos, CHARS(mesg));
+ }
+ #endif
+-static char s_rec_constr1[] = "record constructor: ";
+-SCM rec_constr1(args)
++static const char s_rec_constr1[] = "record constructor: ";
++static SCM rec_constr1(args)
+      SCM args;
+ {
+@@ -193,6 +194,6 @@
+   return cclo;
+ }
+-static char s_rec_accessor1[] = "record accessor: ";
+-SCM rec_accessor1(cclo, rec)
++static const char s_rec_accessor1[] = "record accessor: ";
++static SCM rec_accessor1(cclo, rec)
+      SCM cclo, rec;
+ {
+@@ -204,6 +205,6 @@
+   return VELTS(rec)[i];
+ }
+-static char s_rec_modifier1[] = "record modifier: ";
+-SCM rec_modifier1(cclo, rec, val)
++static const char s_rec_modifier1[] = "record modifier: ";
++static SCM rec_modifier1(cclo, rec, val)
+      SCM cclo, rec, val;
+ {
+@@ -217,6 +218,6 @@
+ }
+ static SCM f_rec_accessor1;
+-static char s_rec_accessor[] = "record-accessor";
+-SCM rec_accessor(rtd, field)
++static const char s_rec_accessor[] = "record-accessor";
++static SCM rec_accessor(rtd, field)
+      SCM rtd, field;
+ {
+@@ -224,13 +225,13 @@
+ }
+ static SCM f_rec_modifier1;
+-static char s_rec_modifier[] = "record-modifier";
+-SCM rec_modifier(rtd, field)
++static const char s_rec_modifier[] = "record-modifier";
++static SCM rec_modifier(rtd, field)
+      SCM rtd, field;
+ {
+  return makrecclo(f_rec_modifier1, rtd, field, s_rec_accessor);
+ }
+-SCM *loc_makrtd;
+-static char s_makrectyp[] = "make-record-type";
+-SCM makrectyp(name, fields)
++static SCM *loc_makrtd;
++static const char s_makrectyp[] = "make-record-type";
++static SCM makrectyp(name, fields)
+      SCM name, fields;
+ {
+@@ -247,6 +248,6 @@
+ }
+ 
+-static char s_rec_prinset[] = "record-printer-set!";
+-SCM rec_prinset(rtd, printer)
++static const char s_rec_prinset[] = "record-printer-set!";
++static SCM rec_prinset(rtd, printer)
+      SCM rtd, printer;
+ {
+@@ -276,5 +277,8 @@
+      int writing;
+ {
+-  SCM names, printer = RTD_PRINTER(REC_RTD(exp));
++#ifdef SCM_SHOW_RECORD_FIELDS
++  SCM names;
++#endif
++  SCM printer = RTD_PRINTER(REC_RTD(exp));
+   SCM argv[3];
+   if (NIMP(printer)) {
+@@ -293,5 +297,7 @@
+     }
+   }
++#ifdef SCM_SHOW_RECORD_FIELDS
+   names = RTD_FIELDS(REC_RTD(exp));
++#endif
+   lputs("#s(", port);
+   scm_iprin1(RTD_NAME(REC_RTD(exp)), port, 0);
+@@ -316,5 +322,5 @@
+ 
+ static SCM f_rtdprin1;
+-SCM rec_rtdprin1(rtd, port, writing_p)
++static SCM rec_rtdprin1(rtd, port, writing_p)
+      SCM rtd, port, writing_p;
+ {
+@@ -332,5 +338,5 @@
+ }
+ 
+-SCM recequal(rec0, rec1)
++static SCM recequal(rec0, rec1)
+      SCM rec0, rec1;
+ {
+@@ -356,6 +362,4 @@
+   {0, 0}};
+ 
+-SCM_DLL_EXPORT void init_record P((void));
+-
+ void init_record()
+ {
+--- repl.c	2013-04-06 21:53:18.000000000 -0400
++++ repl.c	2015-01-27 01:03:08.000000000 -0500
+@@ -21,8 +21,4 @@
+ #include "scm.h"
+ #include "setjump.h"
+-void	igc P((const char *what, SCM basecont));
+-void	unexec P((char *new_name, char *a_name, unsigned data_start,
+-		  unsigned bss_start, unsigned entry_address));
+-void	scm_fill_freelist P((void));
+ 
+ #ifdef __CYGWIN__
+@@ -30,10 +26,6 @@
+ #endif
+ 
+-#ifdef __NetBSD__
+-# include <ctype.h>
+-# include <unistd.h>
+-#endif
+-
+-#ifdef __OpenBSD__
++#if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__) || \
++    defined(__DragonFlyBSD__)
+ # include <ctype.h>
+ # include <unistd.h>
+@@ -62,8 +54,12 @@
+ #endif
+ 
++#ifdef CAN_DUMP
++static const char s_unexec[] = "unexec";
++#endif
++
+ unsigned char upcase[CHAR_CODE_LIMIT];
+ unsigned char downcase[CHAR_CODE_LIMIT];
+-unsigned char lowers[] = "abcdefghijklmnopqrstuvwxyz";
+-unsigned char uppers[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
++static const unsigned char lowers[] = "abcdefghijklmnopqrstuvwxyz";
++static const unsigned char uppers[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+ void init_tables()
+ {
+@@ -77,5 +73,5 @@
+ 
+ #ifdef EBCDIC
+-char *charnames[] = {
++const char *charnames[] = {
+   "nul","soh","stx","etx", "pf", "ht", "lc","del",
+    0   , 0   ,"smm", "vt", "ff", "cr", "so", "si",
+@@ -87,5 +83,5 @@
+    0   , 0   , 0   , 0   ,"dc4","nak", 0   ,"sub",
+   "space", s_newline, "tab", "backspace", "return", "page", "null"};
+-char charnums[] =
++const char charnums[] =
+ "\000\001\002\003\004\005\006\007\
+ \010\011\012\013\014\015\016\017\
+@@ -99,5 +95,5 @@
+ #endif /* def EBCDIC */
+ #ifdef ASCII
+-char *charnames[] = {
++const char *charnames[] = {
+   "nul","soh","stx","etx","eot","enq","ack","bel",
+    "bs", "ht", "nl", "vt", "np", "cr", "so", "si",
+@@ -105,5 +101,5 @@
+   "can", "em","sub","esc", "fs", "gs", "rs", "us",
+   "space", s_newline, "tab", "backspace", "return", "page", "null", "del"};
+-char charnums[] =
++const char charnums[] =
+ "\000\001\002\003\004\005\006\007\
+ \010\011\012\013\014\015\016\017\
+@@ -112,5 +108,5 @@
+  \n\t\b\r\f\0\177";
+ #endif /* def ASCII */
+-char *isymnames[] = {
++const char *isymnames[] = {
+ 				/* Special Forms */
+ 				/*  NUM_ISPCSYMS ISPCSYMS here */
+@@ -128,19 +124,19 @@
+   };
+ 
+-static char	s_read_char[] = "read-char", s_peek_char[] = "peek-char";
+-char	        s_write[] = "write", s_newline[] = "newline";
+-static char	s_display[] = "display", s_write_char[] = "write-char";
+-static char	s_freshline[] = "freshline";
++static const char	s_read_char[] = "read-char", s_peek_char[] = "peek-char";
++const char	        s_write[] = "write", s_newline[] = "newline";
++static const char	s_display[] = "display", s_write_char[] = "write-char";
++static const char	s_freshline[] = "freshline";
+ 
+-static char	s_eofin[] = "end of file in ";
+-static char	s_unknown_sharp[] = "unknown # object";
++static const char	s_eofin[] = "end of file in ";
++static const char	s_unknown_sharp[] = "unknown # object";
+ 
+ static SCM scm_lread1 P((SCM port, int flgs, const char *what));
+ static SCM scm_lreadr P((SCM tok_buf, SCM port, int flgs));
+ static SCM scm_lreadpr P((SCM tok_buf, SCM port, int flgs));
+-static SCM scm_lreadparen P((SCM tok_buf, SCM port, int flgs, char *name));
++static SCM scm_lreadparen P((SCM tok_buf, SCM port, int flgs, const char *name));
+ static SCM scm_lread_rec P((SCM tok_buf, SCM port));
+ static sizet scm_read_token P((int ic, SCM tok_buf, SCM port, int flgs));
+-static void err_head P((char *str));
++static void err_head P((const char *str));
+ extern int case_sensitize_symbols; /* 0 or 8 */
+ 
+@@ -155,5 +151,5 @@
+ 
+ void scm_ipruk(hdr, ptr, port)
+-     char *hdr;
++     const char *hdr;
+      SCM ptr;
+      SCM port;
+@@ -173,6 +169,6 @@
+ }
+ 
+-void scm_iprlist(hdr, exp, tlr, port, writing)
+-     char *hdr, tlr;
++static void scm_iprlist(hdr, exp, tlr, port, writing)
++     const char *hdr, tlr;
+      SCM exp;
+      SCM port;
+@@ -383,5 +379,5 @@
+ }
+ 
+-static char s_char_readyp[]="char-ready?";
++static const char s_char_readyp[]="char-ready?";
+ 
+ #ifdef __IBMC__
+@@ -452,5 +448,5 @@
+ #endif
+ /* perhaps should undefine MSDOS from __IBMC__ here */
+-SCM char_readyp(port)
++static SCM char_readyp(port)
+      SCM port;
+ {
+@@ -476,6 +472,6 @@
+ # define timet long
+ #endif
+-static char s_wfi[] = "wait-for-input";
+-SCM wait_for_input(args)
++static const char s_wfi[] = "wait-for-input";
++static SCM wait_for_input(args)
+      SCM args;
+ {
+@@ -616,6 +612,6 @@
+     ;
+ }
+-static char	s_force_output[] = "force-output";
+-SCM scm_force_output(port)
++static const char	s_force_output[] = "force-output";
++static SCM scm_force_output(port)
+      SCM port;
+ {
+@@ -626,5 +622,5 @@
+ }
+ 
+-SCM scm_write(obj, port)
++static SCM scm_write(obj, port)
+      SCM obj, port;
+ {
+@@ -660,5 +656,5 @@
+ 	return UNSPECIFIED;
+ }
+-SCM scm_freshline(port)
++static SCM scm_freshline(port)
+      SCM port;
+ {
+@@ -716,5 +712,5 @@
+ }
+ sizet lfwrite(ptr, size, nitems, port)
+-     char *ptr;
++     const char *ptr;
+      sizet size;
+      sizet nitems;
+@@ -843,9 +839,9 @@
+ /* Top-level readers */
+ static SCM p_read_for_load, p_read;
+-static char s_read[] = "read";
+-static char s_read_for_load[] = "read-for-load";
++static const char s_read[] = "read";
++static const char s_read_for_load[] = "read-for-load";
+ #ifndef MEMOIZE_LOCALS
+ static SCM p_read_numbered;
+-static char s_read_numbered[] = "read-numbered";
++static const char s_read_numbered[] = "read-numbered";
+ #endif
+ SCM scm_read(port)
+@@ -855,5 +851,5 @@
+ }
+ 
+-SCM scm_read_for_load(port)
++static SCM scm_read_for_load(port)
+      SCM port;
+ {
+@@ -1134,5 +1130,5 @@
+      SCM port;
+      int flgs;
+-     char *name;
++     const char *name;
+ {
+   SCM lst, fst,
+@@ -1162,6 +1158,6 @@
+    with an atomic test-and-set instruction can use it here (and not
+    DEFER_INTS). */
+-char s_swapcar[] = "swap-car!";
+-SCM swapcar(pair, value)
++static const char s_swapcar[] = "swap-car!";
++static SCM swapcar(pair, value)
+      SCM pair, value;
+ {
+@@ -1174,8 +1170,8 @@
+   return ret;
+ }
+-char s_tryarb[] = "try-arbiter";
+-char s_relarb[] = "release-arbiter";
++static const char s_tryarb[] = "try-arbiter";
++static const char s_relarb[] = "release-arbiter";
+ long tc16_arbiter;
+-SCM tryarb(arb)
++static SCM tryarb(arb)
+      SCM arb;
+ {
+@@ -1202,5 +1198,5 @@
+      SCM name;
+ {
+-  register SCM z;
++  SCM z;
+   NEWCELL(z);
+   CDR(z) = name;
+@@ -1218,12 +1214,12 @@
+ }
+ 
+-static char s_tryload[] = "try-load";
++static const char s_tryload[] = "try-load";
+ #define s_load (&s_tryload[4])
+ 
+-struct errdesc {char *msg;char *s_response;short parent_err;};
++struct errdesc {const char *msg; const char *s_response; short parent_err;};
+ struct errdesc errmsgs[] = {
+-  {"Wrong number of args", 0, 0},
+-  {"numerical overflow", 0, FPE_SIGNAL},
+-  {"Argument out of range", 0, FPE_SIGNAL},
++  {"Wrong number of args", NULL, 0},
++  {"numerical overflow", NULL, FPE_SIGNAL},
++  {"Argument out of range", NULL, FPE_SIGNAL},
+   {"Could not allocate", "out-of-storage", 0},
+   {"Thrashing", "thrashing", 0},
+@@ -1232,6 +1228,6 @@
+   {"user interrupt", "user-interrupt", 0},
+   {"arithmetic error", "arithmetic-error", 0},
+-  {"bus error", 0, 0},
+-  {"segment violation", 0, 0},
++  {"bus error", NULL, 0},
++  {"segment violation", NULL, 0},
+   {"alarm", "alarm-interrupt", 0},
+   {"virtual alarm", "virtual-alarm-interrupt", 0},
+@@ -1240,5 +1236,5 @@
+ 
+ void (* deferred_proc) P((void)) = 0;
+-char *errjmp_bad = "init";
++const char *errjmp_bad = "init";
+ VOLATILE int ints_disabled = 1;
+ unsigned long SIG_deferred = 0;
+@@ -1248,5 +1244,5 @@
+ static int errobj_codep;
+ static SCM err_exp, err_env;
+-static char *err_pos, *err_s_subr;
++static const char *err_pos, *err_s_subr;
+ static cell tmp_errobj = {(SCM)UNDEFINED, (SCM)EOL};
+ static cell tmp_loadpath = {(SCM)BOOL_F, (SCM)EOL};
+@@ -1266,7 +1262,7 @@
+ {
+   SCM proc;
+-  char *name = errmsgs[i-WNA].s_response;
++  const char *name = errmsgs[i-WNA].s_response;
+   if (errjmp_bad || errjmp_recursive)
+-    wta(UNDEFINED, (char *)i, ""); /* sends it to def_err_response */
++    wta(UNDEFINED, (char *)(intptr_t)i, ""); /* sends it to def_err_response */
+   /* NEWCELL does not defer interrupts; so be careful to maintain the
+      freelist integrity. */
+@@ -1321,8 +1317,7 @@
+ 
+ SCM exitval = MAKINUM(EXIT_FAILURE); /* INUM return value */
+-extern char s_unexec[];
+ SCM scm_top_level(initpath, toplvl_fun)
+-     char *initpath;
+-     SCM (*toplvl_fun)();
++     const char *initpath;
++     SCM (*toplvl_fun)(void);
+ {
+   SCM ret;
+@@ -1342,5 +1337,5 @@
+   default:
+     {
+-      char *name = errmsgs[i-WNA].s_response;
++      const char *name = errmsgs[i-WNA].s_response;
+       if (name) {
+ 	SCM proc = CDR(intern(name, (sizet)strlen(name)));
+@@ -1354,5 +1349,5 @@
+   case 0:
+     exitval = MAKINUM(EXIT_SUCCESS);
+-    errjmp_bad = (char *)0;
++    errjmp_bad = NULL;
+     errjmp_recursive = 0;
+     if (NIMP(sys_errp) && OPOUTPORTP(sys_errp)) lfflush(sys_errp);
+@@ -1382,5 +1377,5 @@
+   reset_toplvl:
+     ints_disabled = 1;
+-    errjmp_bad = (char *)0;
++    errjmp_bad = NULL;
+     errjmp_recursive = 0;
+     if (NIMP(sys_errp) && OPOUTPORTP(sys_errp)) lfflush(sys_errp);
+@@ -1442,5 +1437,5 @@
+ }
+ 
+-SCM line_num()
++static SCM line_num()
+ {
+   if (IMP(loadports))
+@@ -1448,5 +1443,5 @@
+   return scm_port_line(CAR(loadports));
+ }
+-static char s_port_line[] = "port-line";
++static const char s_port_line[] = "port-line";
+ SCM scm_port_line(port)
+      SCM port;
+@@ -1466,5 +1461,5 @@
+   return MAKINUM(lnum);
+ }
+-static char s_port_col[] = "port-column";
++static const char s_port_col[] = "port-column";
+ SCM scm_port_col(port)
+      SCM port;
+@@ -1487,5 +1482,5 @@
+ }
+ 
+-static char	s_file_position[] = "file-position";
++static const char	s_file_position[] = "file-position";
+ SCM scm_file_position(port, pos)
+      SCM port, pos;
+@@ -1530,6 +1525,6 @@
+ }
+ 
+-static char s_port_filename[] = "port-filename";
+-SCM scm_port_filename(port)
++static const char s_port_filename[] = "port-filename";
++static SCM scm_port_filename(port)
+      SCM port;
+ {
+@@ -1549,7 +1544,7 @@
+ extern char s_heap[];
+ void growth_mon(obj, size, units, grewp)
+-     char *obj;
++     const char *obj;
+      long size;
+-     char *units;
++     const char *units;
+      int grewp;
+ {
+@@ -1648,7 +1643,7 @@
+     scm_init_brk = (unsigned long)sbrk(0);
+ }
+-void scm_brk_report()
++static void scm_brk_report()
+ {
+-  unsigned long scm_curbrk = (unsigned long)sbrk(0),
++  intptr_t scm_curbrk = (unsigned long)sbrk(0),
+     dif1 = ((dumped ? scm_dumped_brk : scm_curbrk) - scm_init_brk)/1024,
+     dif2 = (scm_curbrk - scm_dumped_brk)/1024;
+@@ -1798,11 +1793,11 @@
+   longjump(CONT(rootcont)->jmpbuf, COOKIE(-1));
+ }
+-SCM abrt()
++static SCM abrt()
+ {
+   if (errjmp_bad) exit(EXIT_FAILURE);
+   longjump(CONT(rootcont)->jmpbuf, COOKIE(-2));
+ }
+-char s_restart[] = "restart";
+-SCM restart()
++static const char s_restart[] = "restart";
++static SCM restart()
+ {
+   /* ASRTER(!dumped, UNDEFINED, "dumped can't", s_restart); */
+@@ -1811,5 +1806,4 @@
+ 
+ #ifdef CAN_DUMP
+-char s_unexec[] = "unexec";
+ SCM scm_unexec(newpath)
+      SCM newpath;
+@@ -1904,6 +1898,6 @@
+   return BOOL_T;
+ }
+-static char s_eval_string[] = "eval-string";
+-static char s_load_string[] = "load-string";
++static const char s_eval_string[] = "eval-string";
++static const char s_load_string[] = "load-string";
+ static SCM i_eval_string = 0;
+ SCM scm_eval_string(str)
+@@ -1969,5 +1963,5 @@
+ 
+ static void err_head(str)
+-     char *str;
++     const char *str;
+ {
+   SCM lps;
+@@ -1993,5 +1987,5 @@
+ }
+ void scm_warn(str1, str2, obj)
+-     char *str1, *str2;
++     const char *str1, *str2;
+      SCM obj;
+ {
+@@ -2010,5 +2004,5 @@
+ }
+ 
+-SCM lerrno(arg)
++static SCM lerrno(arg)
+      SCM arg;
+ {
+@@ -2020,6 +2014,6 @@
+   return MAKINUM(old);
+ }
+-static char s_perror[] = "perror";
+-SCM lperror(arg)
++static const char s_perror[] = "perror";
++static SCM lperror(arg)
+      SCM arg;
+ {
+@@ -2075,8 +2069,8 @@
+   else if (WNA > (long)err_pos) {
+     lputs("Wrong type in arg", cur_errp);
+-    lputc((long)err_pos <= ARGn ? ' ' : '1' + (int)err_pos - ARG1, cur_errp);
++    lputc((long)err_pos <= ARGn ? ' ' : '1' + (intptr_t)err_pos - ARG1, cur_errp);
+   }
+ #endif
+-  else lputs(errmsgs[((int)err_pos)-WNA].msg, cur_errp);
++  else lputs(errmsgs[((intptr_t)err_pos)-WNA].msg, cur_errp);
+   lputs(((long)err_pos==WNA)?" given ":" ", cur_errp);
+   err_pos = 0;
+@@ -2137,5 +2131,5 @@
+   longjump(CONT(rootcont)->jmpbuf,
+ 	   (~0x1fL) & (long)pos || (WNA > (long)pos) ?
+-	   COOKIE(1) : COOKIE((int)pos));
++	   COOKIE(1) : COOKIE((intptr_t)pos));
+   /* will do error processing at stack base */
+ }
+@@ -2160,20 +2154,20 @@
+ #endif
+ }
+-SCM cur_input_port()
++static SCM cur_input_port()
+ {
+   return cur_inp;
+ }
+-SCM cur_output_port()
++static SCM cur_output_port()
+ {
+   return cur_outp;
+ }
+-SCM cur_error_port()
++static SCM cur_error_port()
+ {
+   return cur_errp;
+ }
+-char s_cur_inp[] = "set-current-input-port";
+-char s_cur_outp[] = "set-current-output-port";
+-char s_cur_errp[] = "set-current-error-port";
+-SCM set_inp(port)
++static const char s_cur_inp[] = "set-current-input-port";
++static const char s_cur_outp[] = "set-current-output-port";
++static const char s_cur_errp[] = "set-current-error-port";
++static SCM set_inp(port)
+      SCM port;
+ {
+@@ -2186,5 +2180,5 @@
+   return oinp;
+ }
+-SCM set_outp(port)
++static SCM set_outp(port)
+      SCM port;
+ {
+@@ -2197,5 +2191,5 @@
+   return ooutp;
+ }
+-SCM set_errp(port)
++static SCM set_errp(port)
+      SCM port;
+ {
+@@ -2208,6 +2202,6 @@
+   return oerrp;
+ }
+-static char s_isatty[] = "isatty?";
+-SCM l_isatty(port)
++static const char s_isatty[] = "isatty?";
++static SCM l_isatty(port)
+      SCM port;
+ {
+@@ -2270,5 +2264,5 @@
+ 
+ static smobfuns arbsmob = {markcdr, free0, prinarb};
+-char s_ccl[] = "char-code-limit";
++const char s_ccl[] = "char-code-limit";
+ 
+ void init_repl( iverbose )
+--- rgx.c	2013-03-14 00:42:23.000000000 -0400
++++ rgx.c	2015-01-23 18:55:19.000000000 -0500
+@@ -21,5 +21,5 @@
+ #include "scm.h"
+ #ifdef __FreeBSD__
+-# include "gnuregex.h"
++# include "gnu/regex.h"
+ #else
+ # include "regex.h"
+@@ -31,7 +31,4 @@
+ #endif
+ 
+-static char rcsid[] =
+-   "$Id: rgx.c,v 1.20 2013/03/14 04:42:23 jaffer Exp $";
+-
+ #ifdef HAVE_ALLOCA
+ # include <alloca.h>
+@@ -54,17 +51,17 @@
+ /* forward function defs */
+ 
+-SCM lregsearch();
+-SCM lregsearchv();
++static SCM lregsearch();
++static SCM lregsearchv();
+ 
+ /* Posix regexp bindings.  */
+ 
+-static char s_regex[] = "regex";
+-static char s_regcomp[] = "regcomp", s_regerror[] = "regerror";
+-static char s_regexec[] = "regexec", s_regmatp[] = "regmatch?";
+-static char s_regsearch[] = "regsearch", s_regmatch[] = "regmatch";
+-static char s_regsearchv[] = "regsearchv", s_regmatchv[] = "regmatchv";
+-static char s_stringsplit[]  = "string-split";
+-static char s_stringsplitv[] = "string-splitv";
+-static char s_stringedit[] = "string-edit";
++static const char s_regex[] = "regex";
++static const char s_regcomp[] = "regcomp", s_regerror[] = "regerror";
++static const char s_regexec[] = "regexec", s_regmatp[] = "regmatch?";
++static const char s_regsearch[] = "regsearch", s_regmatch[] = "regmatch";
++static const char s_regsearchv[] = "regsearchv", s_regmatchv[] = "regmatchv";
++static const char s_stringsplit[]  = "string-split";
++static const char s_stringsplitv[] = "string-splitv";
++static const char s_stringedit[] = "string-edit";
+ 
+ #define s_error &s_regerror[3]
+@@ -95,5 +92,5 @@
+ } regex_info;
+ 
+-sizet fregex(ptr)
++static sizet fregex(ptr)
+      CELLPTR ptr;
+ {
+@@ -108,5 +105,5 @@
+ }
+ 
+-int prinregex(exp, port, writing)
++static int prinregex(exp, port, writing)
+      SCM exp; SCM port; int writing;
+ {
+@@ -119,5 +116,5 @@
+ }
+ 
+-SCM markregex(ptr)
++static SCM markregex(ptr)
+      SCM ptr;
+ {
+@@ -129,5 +126,5 @@
+ static smobfuns rgxsmob = {markregex, fregex, prinregex};
+ 
+-SCM lregerror(scode)
++static SCM lregerror(scode)
+      SCM scode;
+ {
+@@ -155,5 +152,5 @@
+ }
+ 
+-SCM lregcomp(pattern, flags)
++static SCM lregcomp(pattern, flags)
+      SCM pattern, flags;
+ {
+@@ -273,5 +270,5 @@
+ }
+ 
+-SCM lregexec(prog, str)
++static SCM lregexec(prog, str)
+      SCM prog, str;
+ {
+@@ -307,5 +304,5 @@
+ }
+ 
+-SCM lregmatp(prog, str)
++static SCM lregmatp(prog, str)
+      SCM prog, str;
+ {
+@@ -334,5 +331,5 @@
+ #define SEARCH 1
+ 
+-SCM lregsearchmatch(prog, str, args, search, vector)
++static SCM lregsearchmatch(prog, str, args, search, vector)
+      SCM prog, str, args;
+      int vector, search;
+@@ -446,5 +443,5 @@
+ }
+ 
+-SCM lregsearch(prog, str, args)
++static SCM lregsearch(prog, str, args)
+      SCM prog, str, args;
+ {
+@@ -452,5 +449,5 @@
+ }
+ 
+-SCM lregsearchv(prog, str, args)
++static SCM lregsearchv(prog, str, args)
+      SCM prog, str, args;
+ {
+@@ -458,5 +455,5 @@
+ }
+ 
+-SCM lregmatch(prog, str, args)
++static SCM lregmatch(prog, str, args)
+      SCM prog, str, args;
+ {
+@@ -464,5 +461,5 @@
+ }
+ 
+-SCM lregmatchv(prog, str, args)
++static SCM lregmatchv(prog, str, args)
+      SCM prog, str, args;
+ {
+@@ -470,5 +467,5 @@
+ }
+ 
+-SCM stringsplitutil(prog, str, vector)
++static SCM stringsplitutil(prog, str, vector)
+      SCM prog, str;
+      int vector;
+@@ -528,5 +525,5 @@
+ }
+ 
+-SCM lstringsplit(prog, str)
++static SCM lstringsplit(prog, str)
+      SCM prog, str;
+ {
+@@ -534,5 +531,5 @@
+ }
+ 
+-SCM lstringsplitv(prog, str)
++static SCM lstringsplitv(prog, str)
+      SCM prog, str;
+ {
+@@ -560,5 +557,5 @@
+ 
+ /*  (string-edit <re> <edit-spec> <string> [<count>]) */
+-SCM lstringedit(prog, editspec, args)
++static SCM lstringedit(prog, editspec, args)
+      SCM prog, editspec, args;
+ {
+--- rope.c	2013-03-24 21:58:34.000000000 -0400
++++ rope.c	2015-01-23 18:55:19.000000000 -0500
+@@ -59,5 +59,5 @@
+ unsigned char num2uchar(num, pos, s_caller)
+      SCM num;
+-     char *pos, *s_caller;
++     const char *pos, *s_caller;
+ {
+   unsigned long res = INUM(num);
+@@ -67,5 +67,5 @@
+ unsigned short num2ushort(num, pos, s_caller)
+      SCM num;
+-     char *pos, *s_caller;
++     const char *pos, *s_caller;
+ {
+   unsigned long res = INUM(num);
+@@ -75,5 +75,5 @@
+ unsigned long num2ulong(num, pos, s_caller)
+      SCM num;
+-     char *pos, *s_caller;
++     const char *pos, *s_caller;
+ {
+   unsigned long res;
+@@ -106,5 +106,5 @@
+ long num2long(num, pos, s_caller)
+      SCM num;
+-     char *pos, *s_caller;
++     const char *pos, *s_caller;
+ {
+   long res;
+@@ -138,5 +138,5 @@
+ short num2short(num, pos, s_caller)
+      SCM num;
+-     char *pos, *s_caller;
++     const char *pos, *s_caller;
+ {
+   long lres = INUM((long)num);
+@@ -147,5 +147,5 @@
+ signed char num2char(num, pos, s_caller)
+      SCM num;
+-     char *pos, *s_caller;
++     const char *pos, *s_caller;
+ {
+   long lres = INUM((long)num);
+@@ -157,5 +157,5 @@
+ double num2dbl(num, pos, s_caller)
+      SCM num;
+-     char *pos, *s_caller;
++     const char *pos, *s_caller;
+ {
+   if (INUMP(num)) return (double)INUM(num);
+@@ -235,5 +235,5 @@
+ 				/* Hooks to call SCM from C */
+ SCM scm_evstr(str)
+-     char *str;
++     const char *str;
+ {
+   SCM lsym;
+@@ -244,5 +244,5 @@
+ }
+ void scm_ldstr(str)
+-     char *str;
++     const char *str;
+ {
+   SCM lsym;
+@@ -253,5 +253,5 @@
+ }
+ int scm_ldfile(path)
+-     char *path;
++     const char *path;
+ {
+   SCM name = makfrom0str(path);
+@@ -260,5 +260,5 @@
+ }
+ int scm_ldprog(path)
+-     char *path;
++     const char *path;
+ {
+   SCM name = makfrom0str(path);
+@@ -270,5 +270,4 @@
+ 				/* Get byte address of SCM array */
+ #ifdef ARRAYS
+-long	aind P((SCM ra, SCM args, const char *what));
+ void* scm_addr(args, s_name)
+      SCM args;
+--- sc2.c	2008-01-30 22:32:35.000000000 -0500
++++ sc2.c	2015-01-23 18:55:19.000000000 -0500
+@@ -21,6 +21,6 @@
+ #include "scm.h"
+ 
+-static char s_last_pair[] = "last-pair";
+-SCM last_pair(sx)
++static const char s_last_pair[] = "last-pair";
++static SCM last_pair(sx)
+      SCM sx;
+ {
+@@ -40,6 +40,6 @@
+ }
+ 
+-static char s_subml[] = "substring-move-left!";
+-SCM subml(str1, start1, args)
++static const char s_subml[] = "substring-move-left!";
++static SCM subml(str1, start1, args)
+      SCM str1, start1, args;
+ {
+@@ -63,6 +63,6 @@
+   return UNSPECIFIED;
+ }
+-static char s_submr[] = "substring-move-right!";
+-SCM submr(str1, start1, args)
++static const char s_submr[] = "substring-move-right!";
++static SCM submr(str1, start1, args)
+      SCM str1, start1, args;
+ {
+@@ -86,6 +86,6 @@
+   return UNSPECIFIED;
+ }
+-static char s_subfl[] = "substring-fill!";
+-SCM subfl(str, start, args)
++static const char s_subfl[] = "substring-fill!";
++static SCM subfl(str, start, args)
+      SCM str, start, args;
+ {
+@@ -107,6 +107,6 @@
+ }
+ 
+-static char s_strnullp[] = "string-null?";
+-SCM strnullp(str)
++static const char s_strnullp[] = "string-null?";
++static SCM strnullp(str)
+      SCM str;
+ {
+@@ -116,6 +116,6 @@
+ }
+ 
+-static char s_appendb[] = "append!";
+-SCM appendb(args)
++static const char s_appendb[] = "append!";
++static SCM appendb(args)
+      SCM args;
+ {
+@@ -138,6 +138,4 @@
+   {0, 0}};
+ 
+-SCM_DLL_EXPORT void init_sc2 P((void));
+-
+ void init_sc2()
+ {
+--- scl.c	2015-01-02 22:43:33.000000000 -0500
++++ scl.c	2015-01-23 18:55:19.000000000 -0500
+@@ -35,5 +35,7 @@
+ static sizet pdbl2str P((double f, char *a, sizet ch));
+ static sizet iflo2str P((SCM flt, char *str));
++#if defined(FLOATS) && defined(BIGDIG) && !defined(DBL_DIG)
+ static void safe_add_1 P((double f, double *fsum));
++#endif
+ static long scm_twos_power P((SCM n));
+ static double mantexp2dbl P((SCM manstr, int expo));
+@@ -42,35 +44,37 @@
+ static SCM ilog P((unsigned long m, SCM b, SCM k, unsigned long *n));
+ 
+-static char s_makrect[] = "make-rectangular", s_makpolar[] = "make-polar",
++static const char s_makrect[] = "make-rectangular", s_makpolar[] = "make-polar",
+ 	    s_magnitude[] = "magnitude", s_angle[] = "angle",
+ 	    s_real_part[] = "real-part", s_imag_part[] = "imag-part",
+ 	    s_in2ex[] = "inexact->exact",s_ex2in[] = "exact->inexact";
+ 
+-static char s_expt[] = "real-expt", s_atan2[] = "$atan2";
++static const char s_expt[] = "real-expt", s_atan2[] = "$atan2";
+ #endif
+-static char s_memv[] = "memv", s_assv[] = "assv";
++static const char s_memv[] = "memv", s_assv[] = "assv";
+ 
+ SCM sys_protects[NUM_PROTECTS];
+ sizet num_protects = NUM_PROTECTS;
+ 
+-char		s_inexactp[] = "inexact?";
+-static char     s_zerop[] = "zero?", s_abs[] = "abs",
++const char		s_inexactp[] = "inexact?";
++static const char     s_zerop[] = "zero?", s_abs[] = "abs",
+ 		s_positivep[] = "positive?", s_negativep[] = "negative?";
+-static char     s_lessp[] = "<", s_grp[] = ">";
+-static char     s_leqp[] = "<=", s_greqp[] = ">=";
++static const char     s_lessp[] = "<", s_grp[] = ">";
++static const char     s_leqp[] = "<=", s_greqp[] = ">=";
+ #define s_eqp (&s_leqp[1])
+-static char     s_max[] = "max", s_min[] = "min";
+-char		s_sum[] = "+", s_difference[] = "-", s_product[] = "*",
++static const char     s_max[] = "max", s_min[] = "min";
++const char		s_sum[] = "+", s_difference[] = "-", s_product[] = "*",
+ 		s_divide[] = "/";
+-static char     s_number2string[] = "number->string",
++static const char     s_number2string[] = "number->string",
+ 		s_str2number[] = "string->number";
+ 
+-static char s_list_tail[] = "list-tail";
+-static char s_str2list[] = "string->list";
+-static char s_st_copy[] = "string-copy", s_st_fill[] = "string-fill!";
+-static char s_vect2list[] = "vector->list", s_ve_fill[] = "vector-fill!";
+-static char str_inf0[] = "inf.0", str_nan0[] = "nan.0", str_0[] = "0.0";
+-static char s_intexpt[] = "integer-expt", s_cintlog[] = "ceiling-integer-log";
+-static char s_dfloat_parts[] = "double-float-parts";
++static const char s_list_tail[] = "list-tail";
++static const char s_str2list[] = "string->list";
++static const char s_st_copy[] = "string-copy", s_st_fill[] = "string-fill!";
++static const char s_vect2list[] = "vector->list", s_ve_fill[] = "vector-fill!";
++#if defined(FLOATS) && defined(BIGDIG)
++static const char str_inf0[] = "inf.0", str_nan0[] = "nan.0", str_0[] = "0.0";
++static const char s_dfloat_parts[] = "double-float-parts";
++#endif
++static const char s_intexpt[] = "integer-expt", s_cintlog[] = "ceiling-integer-log";
+ #define s_intlog (&s_cintlog[8])
+ 
+@@ -81,5 +85,5 @@
+ 				    are representable exactly as doubles. */
+ 
+-int inf2str(f, a)
++static int inf2str(f, a)
+      double f;
+      char *a;
+@@ -114,5 +118,5 @@
+ 
+ /* There are also temporary strings used in number->string conversion. */
+-void strrecy(str)
++static void strrecy(str)
+      SCM str;
+ {
+@@ -209,5 +213,7 @@
+   while ((dp+1 < ch) && (point+9999)%3) { a[dp] = a[dp+1]; a[++dp] = '.'; point--; }
+ #  endif	/* ENGNOT */
+-  while ('0'==a[--ch]); ch++;
++  while ('0'==a[--ch])
++    ;
++  ch++;
+   if (point != 0) {
+     a[ch++] = 'e';
+@@ -521,5 +527,5 @@
+ #ifdef BIGDIG
+ SCM istr2int(str, len, radix)
+-     char *str;
++     const char *str;
+      long len;
+      register int radix;
+@@ -579,5 +585,5 @@
+ #else
+ SCM istr2int(str, len, radix)
+-     register char *str;
++     const char *str;
+      long len;
+      register int radix;
+@@ -743,7 +749,7 @@
+ 
+ SCM istr2flo(str, len, radix)
+-     register char *str;
+-     register long len;
+-     register long radix;
++     const char *str;
++     long len;
++     long radix;
+ {
+   register int c, i = 0, j = 0;
+@@ -951,5 +957,5 @@
+ 
+ SCM istring2number(str, len, radix)
+-     char *str;
++     const char *str;
+      long len;
+      long radix;
+@@ -1070,5 +1076,5 @@
+   return BOOL_F;
+ }
+-SCM assv(x, alist)		/* m.borza  12.2.91 */
++static SCM assv(x, alist)		/* m.borza  12.2.91 */
+ SCM x, alist;
+ {
+@@ -1088,5 +1094,5 @@
+ #endif
+ 
+-SCM list_tail(lst, k)
++static SCM list_tail(lst, k)
+      SCM lst, k;
+ {
+@@ -1118,5 +1124,5 @@
+   return makfromstr(CHARS(str), (sizet)LENGTH(str));
+ }
+-SCM string_fill(str, chr)
++static SCM string_fill(str, chr)
+      SCM str, chr;
+ {
+@@ -1141,5 +1147,5 @@
+   return res;
+ }
+-SCM vector_fill(v, fill)
++static SCM vector_fill(v, fill)
+      SCM v, fill;
+ {
+@@ -1228,5 +1234,5 @@
+ }
+ #ifdef FLOATS
+-SCM scm_complex_p(obj)
++static SCM scm_complex_p(obj)
+      SCM obj;
+ {
+@@ -1236,5 +1242,5 @@
+ 
+ # ifdef BIGDIG
+-static char twostab[] = {4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0};
++static const char twostab[] = {4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0};
+ static long scm_twos_power(n)
+      SCM n;
+@@ -1287,5 +1293,5 @@
+ }
+ # endif
+-SCM realp(x)
++static SCM realp(x)
+      SCM x;
+ {
+@@ -1298,5 +1304,5 @@
+   return BOOL_F;
+ }
+-SCM scm_rationalp(x)
++static SCM scm_rationalp(x)
+      SCM x;
+ {
+@@ -1313,5 +1319,5 @@
+   return BOOL_F;
+ }
+-SCM intp(x)
++static SCM intp(x)
+      SCM x;
+ {
+@@ -1331,5 +1337,5 @@
+ #endif				/* FLOATS */
+ 
+-SCM inexactp(x)
++static SCM inexactp(x)
+      SCM x;
+ {
+@@ -1586,6 +1592,8 @@
+ }
+ 
+-static char s_exactprob[] = "not representable as inexact";
+-SCM scm_max(x, y)
++#if defined(BIGDIG) && defined(FLOATS)
++static const char s_exactprob[] = "not representable as inexact";
++#endif
++static SCM scm_max(x, y)
+      SCM x, y;
+ {
+@@ -1671,5 +1679,5 @@
+ }
+ 
+-SCM scm_min(x, y)
++static SCM scm_min(x, y)
+      SCM x, y;
+ {
+@@ -2361,5 +2369,5 @@
+ }
+ 
+-SCM ilog(m, b, k, n)
++static SCM ilog(m, b, k, n)
+      unsigned long m;
+      SCM b, k;
+@@ -2378,5 +2386,5 @@
+ }
+ 
+-SCM scm_intlog(base, k)
++static SCM scm_intlog(base, k)
+      SCM base, k;
+ {
+@@ -2393,12 +2401,6 @@
+ # define eqv eqp
+ #endif
+-SCM scm_cintlog(base, k)
+-     SCM base, k;
+-{
+-  SCM il = scm_intlog(base, k);
+-  return (BOOL_T==eqv(k, scm_intexpt(base, il))) ? il : sum(MAKINUM(1L), il);
+-}
+ 
+-SCM scm_intexpt(z1, z2)
++static SCM scm_intexpt(z1, z2)
+      SCM z1, z2;
+ {
+@@ -2504,4 +2506,11 @@
+ }
+ 
++static SCM scm_cintlog(base, k)
++     SCM base, k;
++{
++  SCM il = scm_intlog(base, k);
++  return (BOOL_T==eqv(k, scm_intexpt(base, il))) ? il : sum(MAKINUM(1L), il);
++}
++
+ #ifdef FLOATS
+ # ifndef HAVE_ATANH
+@@ -2544,7 +2553,7 @@
+ struct dpair {double x, y;};
+ 
+-void two_doubles(z1, z2, sstring, xy)
++static void two_doubles(z1, z2, sstring, xy)
+      SCM z1, z2;
+-     char *sstring;
++     const char *sstring;
+      struct dpair *xy;
+ {
+@@ -2585,5 +2594,5 @@
+ }
+ 
+-SCM expt(z1, z2)
++static SCM expt(z1, z2)
+      SCM z1, z2;
+ {
+@@ -2592,5 +2601,5 @@
+   return makdbl(pow(xy.x, xy.y), 0.0);
+ }
+-SCM latan2(z1, z2)
++static SCM latan2(z1, z2)
+      SCM z1, z2;
+ {
+@@ -2599,5 +2608,5 @@
+   return makdbl(atan2(xy.x, xy.y), 0.0);
+ }
+-SCM makrect(z1, z2)
++static SCM makrect(z1, z2)
+      SCM z1, z2;
+ {
+@@ -2606,5 +2615,5 @@
+   return makdbl(xy.x, xy.y);
+ }
+-SCM makpolar(z1, z2)
++static SCM makpolar(z1, z2)
+      SCM z1, z2;
+ {
+@@ -2614,5 +2623,5 @@
+ }
+ 
+-SCM real_part(z)
++static SCM real_part(z)
+      SCM z;
+ {
+@@ -2632,5 +2641,5 @@
+   return z;
+ }
+-SCM imag_part(z)
++static SCM imag_part(z)
+      SCM z;
+ {
+@@ -2663,5 +2672,5 @@
+ }
+ 
+-SCM scm_magnitude(z)
++static SCM scm_magnitude(z)
+      SCM z;
+ {
+@@ -2691,5 +2700,5 @@
+ }
+ 
+-SCM angle(z)
++static SCM angle(z)
+      SCM z;
+ {
+@@ -2713,5 +2722,5 @@
+ 
+ 
+-SCM ex2in(z)
++static SCM ex2in(z)
+      SCM z;
+ {
+@@ -2724,5 +2733,5 @@
+  badz: wta(z, (char *)ARG1, s_ex2in);
+ }
+-SCM in2ex(z)
++static SCM in2ex(z)
+      SCM z;
+ {
+@@ -2757,6 +2766,6 @@
+ }
+ #else				/* ~FLOATS */
+-static char s_trunc[] = "truncate";
+-SCM numident(x)
++static const char s_trunc[] = "truncate";
++static SCM numident(x)
+      SCM x;
+ {
+@@ -2837,5 +2846,5 @@
+       sizet j = i - (dbl_mant_dig + BITSPERDIG - 1)/BITSPERDIG;
+       BIGDIG *digits = BDIGITS(quo);
+-      if (j < 0) j = 0;
++      if (i <= dbl_mant_dig + BITSPERDIG) j = 0;
+       while (i-- > j) ans = digits[i] + ldexp(ans, BITSPERDIG);
+       bex += j * BITSPERDIG;
+@@ -2915,5 +2924,5 @@
+ }
+ 
+-SCM scm_dfloat_parts(f)
++static SCM scm_dfloat_parts(f)
+      SCM f;
+ {
+@@ -2928,6 +2937,6 @@
+   return scm_values(dbl2big(mant), MAKINUM(expt), EOL, s_dfloat_parts);
+ }
+-static char s_make_dfloat[] = "make-double-float";
+-SCM scm_make_dfloat(mant, expt)
++static const char s_make_dfloat[] = "make-double-float";
++static SCM scm_make_dfloat(mant, expt)
+      SCM mant, expt;
+ {
+@@ -3014,6 +3023,5 @@
+ }
+ 
+-static char s_hashv[] = "hashv", s_hashq[] = "hashq";
+-extern char s_obunhash[];
++static const char s_hashv[] = "hashv", s_hashq[] = "hashq";
+ #define s_hash (&s_obunhash[9])
+ 
+@@ -3164,5 +3172,5 @@
+ #endif
+ 
+-#ifdef FLOATS
++#if defined(FLOATS) && defined(BIGDIG) && !defined(DBL_DIG)
+ static void safe_add_1(f, fsum)
+      double f, *fsum;
+--- scm.c	2014-11-18 17:04:42.000000000 -0500
++++ scm.c	2015-01-23 18:55:19.000000000 -0500
+@@ -25,4 +25,5 @@
+ #endif
+ #include "scm.h"
++#include "continue.h"
+ #include "patchlvl.h"
+ 
+@@ -58,33 +59,5 @@
+ #endif
+ 
+-void	init_sbrk P((void));
+-
+-void	init_dynl P((void));
+-void	init_edline P((void));
+-void	init_eval P((void));
+-void	init_features P((void));
+-void	init_gsubr P((void));
+-void	init_io P((void));
+-void	init_ioext P((void));
+-void	init_posix P((void));
+-void	init_ramap P((void));
+-void	init_record P((void));
+-void	init_rgx P((void));
+-void	init_rope P((void));
+-void	init_repl P((int iverbose));
+-void	init_sc2 P((void));
+-void	init_scl P((void));
+-void	init_signals P((void));
+-void	init_socket P((void));
+-void	init_subrs P((void));
+-void	init_tables P((void));
+-void	init_time P((void));
+-void	init_types P((void));
+-void	init_unif P((void));
+-void	init_debug P((void));
+-void	reset_time P((void));
+-void	final_repl P((void));
+-
+-void init_banner()
++static void init_banner()
+ {
+   fputs("SCM version "SCMVERSION", Copyright (C) 1990-2006 \
+@@ -162,5 +135,6 @@
+ void process_signals()
+ {
+-  int i, n;
++  intptr_t i;
++  int n;
+   unsigned long mask = 1L;
+   /* printf("process_signals; output_deferred=%d\n", output_deferred); fflush(stdout); */
+@@ -249,5 +223,5 @@
+ 
+ 
+-static char s_unksig[] = "unknown signal";
++static const char s_unksig[] = "unknown signal";
+ static SIGRETTYPE err_signal(sig)
+      int sig;
+@@ -264,5 +238,5 @@
+ {
+   int oerr = errno;
+-  int i = NUM_SIGNALS;
++  intptr_t i = NUM_SIGNALS;
+   while (i--)
+     if (sig == sigdesc[i].signo) break;
+@@ -315,6 +289,6 @@
+ #endif
+ #ifdef SIGALRM
+-static char s_alarm[] = "alarm";
+-SCM lalarm(i)
++static const char s_alarm[] = "alarm";
++static SCM lalarm(i)
+      SCM i;
+ {
+@@ -326,9 +300,9 @@
+ # ifdef SIGPROF
+ #  include <sys/time.h>
+-static char s_setitimer[] = "setitimer";
++static const char s_setitimer[] = "setitimer";
+ static struct {SCM sym; int which;} setitimer_tab[3] = {
+   {UNDEFINED, 0}, {UNDEFINED, 0}, {UNDEFINED, 0}};
+ /* VALUE and INTERVAL are milliseconds */
+-SCM scm_setitimer(which, value, interval)
++static SCM scm_setitimer(which, value, interval)
+      SCM which, value, interval;
+ {
+@@ -364,5 +338,5 @@
+ # endif
+ # ifndef AMIGA
+-SCM l_pause()
++static SCM l_pause(void)
+ {
+   pause();
+@@ -380,6 +354,6 @@
+ #ifndef AMIGA
+ # ifndef _Windows
+-static char s_sleep[] = "sleep";
+-SCM l_sleep(i)
++static const char s_sleep[] = "sleep";
++static SCM l_sleep(i)
+      SCM i;
+ {
+@@ -442,6 +416,6 @@
+ #endif
+ /* int raise P((int sig)); */
+-static char s_raise[] = "raise";
+-SCM l_raise(sig)
++static const char s_raise[] = "raise";
++static SCM l_raise(sig)
+      SCM sig;
+ {
+@@ -468,5 +442,5 @@
+   }
+ }
+-static char s_ticks[] = "ticks";
++static const char s_ticks[] = "ticks";
+ SCM lticks(i)
+      SCM i;
+@@ -485,12 +459,4 @@
+ int dumped = 0;			/* Is this an invocation of unexec exe? */
+ 
+-#ifdef SHORT_ALIGN
+-typedef short STACKITEM;
+-#else
+-typedef long STACKITEM;
+-#endif
+-/* See scm.h for definition of P */
+-void  init_storage P((STACKITEM *stack_start_ptr, long init_heap_size));
+-
+ void init_scm(iverbose, buf0stdin, init_heap_size)
+      int iverbose;
+@@ -666,5 +632,5 @@
+      int argc;
+      const char * const *argv;
+-     char *script_arg;
++     const char *script_arg;
+      int iverbose;
+      int buf0stdin;
+@@ -780,5 +746,5 @@
+ const char dirsep[] = DIRSEP;
+ 
+-SCM softtype()
++static SCM softtype()
+ {
+ #ifdef nosve
+@@ -843,8 +809,8 @@
+ }
+ 
+-char *execpath = 0;
+-char s_no_execpath[] = "no execpath";
++char *execpath = NULL;
++const char s_no_execpath[] = "no execpath";
+ #define s_execpath (s_no_execpath+3)
+-SCM scm_execpath(newpath)
++static SCM scm_execpath(newpath)
+      SCM newpath;
+ {
+@@ -870,5 +836,5 @@
+      const char *script_arg;
+ {
+-  char *exepath = 0;
++  char *exepath = NULL;
+ #ifndef macintosh
+ # ifdef HAVE_UNIX
+@@ -904,6 +870,6 @@
+ 
+ #ifndef _Windows
+-char s_system[] = "system";
+-SCM lsystem(cmd)
++const char s_system[] = "system";
++static SCM lsystem(cmd)
+      SCM cmd;
+ {
+@@ -922,7 +888,6 @@
+ extern char **environ;		/* The Linux man page says this
+ 				   declaration is necessary. */
+-char s_getenv[] = "getenv";
+-char *getenv();
+-SCM scm_getenv(nam)
++static const char s_getenv[] = "getenv";
++static SCM scm_getenv(nam)
+      SCM nam;
+ {
+@@ -949,6 +914,6 @@
+ # include <descrip.h>
+ # include <ssdef.h>
+-char s_ed[] = "ed";
+-SCM ed(fname)
++static const char s_ed[] = "ed";
++static SCM ed(fname)
+      SCM fname;
+ {
+@@ -1009,5 +974,5 @@
+ SCM *loc_features;
+ void add_feature(str)
+-     char* str;
++     const char* str;
+ {
+   *loc_features = cons(CAR(sysintern(str, UNDEFINED)), *loc_features);
+--- scm.h	2014-11-22 21:34:19.000000000 -0500
++++ scm.h	2015-01-27 01:33:21.000000000 -0500
+@@ -95,5 +95,5 @@
+ 
+ typedef struct {
+-  char  *name;
++  const char  *name;
+   SCM   (*mark)P((SCM ptr));
+   int   (*free)P((FILE *p));
+@@ -130,5 +130,5 @@
+ 
+ #ifdef FLOATS
+-typedef struct {char *string;double (*cproc)P((double));} dblproc;
++typedef struct {const char *string;double (*cproc)P((double));} dblproc;
+ # ifdef SINGLES
+ #  ifdef CDR_DOUBLES
+@@ -176,5 +176,5 @@
+ #define MAKSPCSYM2(work, look) ((127L & (work)) | ((127L<<9) & (look)))
+ 
+-SCM_EXPORT char *isymnames[];
++SCM_EXPORT const char *isymnames[];
+ #define NUM_ISPCSYM 14
+ #define IM_AND MAKSPCSYM(0)
+@@ -321,5 +321,5 @@
+ #define SCM_ESTK_PARENT_WRITABLEP(v) (VELTS(v)[1])
+ #define SCM_ESTK_PARENT_INDEX(v) (VELTS(v)[2])
+-SCM_EXPORT long tc16_env, tc16_ident;
++SCM_EXPORT long tc16_env, tc16_ident, tc16_promise;
+ #define ENVP(x) (tc16_env==TYP16(x))
+ #define SCM_ENV_FORMALS CAR
+@@ -408,5 +408,5 @@
+ #define SETNUMDIGS(x, v, t) CAR(x) = MAKE_NUMDIGS(v, t)
+ 
+-#define SNAME(x) ((char *)(subrs[NUMDIGS(x)].name))
++#define SNAME(x) ((const char *)(subrs[NUMDIGS(x)].name))
+ #define SUBRF(x) (((subr *)(SCM2PTR(x)))->cproc)
+ #define DSUBRF(x) (((dsubr *)(SCM2PTR(x)))->dproc)
+@@ -597,5 +597,4 @@
+ #define tc16_sfport (tc7_port + 3*256L)
+ SCM_EXPORT long tc16_dir;
+-SCM_EXPORT long tc16_clport;
+ 
+ SCM_EXPORT SCM sys_protects[];
+@@ -649,5 +648,5 @@
+ SCM_EXPORT SCM *loc_errobj;
+ SCM_EXPORT SCM loadport;
+-SCM_EXPORT char *errjmp_bad;
++SCM_EXPORT const char *errjmp_bad;
+ SCM_EXPORT VOLATILE int ints_disabled;
+ SCM_EXPORT int output_deferred, gc_hook_pending, gc_hook_active;
+@@ -658,5 +657,5 @@
+ SCM_EXPORT int dumped;
+ SCM_EXPORT char *execpath;
+-SCM_EXPORT char s_no_execpath[];
++SCM_EXPORT const char s_no_execpath[];
+ SCM_EXPORT int scm_verbose;
+ #define verbose (scm_verbose+0)
+@@ -666,20 +665,19 @@
+ /* strings used in several source files */
+ 
+-SCM_EXPORT char s_write[], s_newline[], s_system[];
+-SCM_EXPORT char s_make_string[], s_make_vector[], s_list[], s_op_pipe[];
++SCM_EXPORT const char s_write[], s_newline[], s_system[];
++SCM_EXPORT const char s_make_string[], s_make_vector[], s_list[], s_op_pipe[];
++SCM_EXPORT const char s_inexactp[], s_redefining[], s_obunhash[];
+ #define s_string (s_make_string+5)
+ #define s_vector (s_make_vector+5)
+ #define s_pipe (s_op_pipe+5)
+-SCM_EXPORT char s_make_sh_array[];
+-SCM_EXPORT char s_array_fill[];
+-#define s_array (s_make_sh_array+12)
+-SCM_EXPORT char s_ccl[];
++SCM_EXPORT const char s_array_fill[];
++SCM_EXPORT const char s_ccl[];
+ #define s_limit (s_ccl+10)
+-SCM_EXPORT char s_close_port[];
++SCM_EXPORT const char s_close_port[];
+ #define s_port_type (s_close_port+6)
+-SCM_EXPORT char s_call_cc[];
++SCM_EXPORT const char s_call_cc[];
+ #define s_cont (s_call_cc+18)
+-SCM_EXPORT char s_try_create_file[];
+-SCM_EXPORT char s_badenv[];
++SCM_EXPORT const char s_try_create_file[];
++SCM_EXPORT const char s_badenv[];
+ 
+ SCM_EXPORT void (*init_user_scm) P((void));
+@@ -702,22 +700,21 @@
+ SCM_EXPORT SCM  obhash P((SCM obj));
+ SCM_EXPORT SCM  obunhash P((SCM obj));
+-SCM_EXPORT unsigned long strhash P((unsigned char *str, sizet len, unsigned long n));
++SCM_EXPORT unsigned long strhash P((const unsigned char *str, sizet len, unsigned long n));
+ SCM_EXPORT unsigned long hasher P((SCM obj, unsigned long n, sizet d));
+ SCM_EXPORT SCM  lroom P((SCM args));
+ SCM_EXPORT void lfflush P((SCM port));
+-SCM_EXPORT SCM  scm_force_output P((SCM port));
+ SCM_EXPORT void scm_init_gra P((scm_gra *gra, sizet eltsize, sizet len,
+                         sizet maxlen, const char *what));
+-SCM_EXPORT int  scm_grow_gra P((scm_gra *gra, char *elt));
++SCM_EXPORT int  scm_grow_gra P((scm_gra *gra, const char *elt));
+ SCM_EXPORT void scm_trim_gra P((scm_gra *gra));
+ SCM_EXPORT void scm_free_gra P((scm_gra *gra));
+-SCM_EXPORT long newsmob P((smobfuns *smob));
+-SCM_EXPORT long newptob P((ptobfuns *ptob));
++SCM_EXPORT long newsmob P((const smobfuns *smob));
++SCM_EXPORT long newptob P((const ptobfuns *ptob));
+ SCM_EXPORT SCM  scm_port_entry P((FILE *stream, long ptype, long flags));
+ SCM_EXPORT SCM  scm_open_ports P((void));
+-SCM_EXPORT void prinport P((SCM exp, SCM port, char *type));
++SCM_EXPORT void prinport P((SCM exp, SCM port, const char *type));
+ SCM_EXPORT SCM  repl P((void));
+ SCM_EXPORT void repl_report P((void));
+-SCM_EXPORT void growth_mon P((char *obj, long size, char *units, int grewp));
++SCM_EXPORT void growth_mon P((const char *obj, long size, const char *units, int grewp));
+ SCM_EXPORT void gc_start P((const char *what));
+ SCM_EXPORT void gc_end P((void));
+@@ -735,27 +732,19 @@
+ SCM_EXPORT SCM  scm_stack_trace P((SCM contin));
+ SCM_EXPORT SCM  scm_scope_trace P((SCM env));
+-SCM_EXPORT SCM  scm_frame_trace P((SCM contin, SCM nf));
+-SCM_EXPORT SCM  scm_frame2env P((SCM contin, SCM nf));
+-SCM_EXPORT SCM  scm_frame_eval P((SCM contin, SCM nf, SCM expr));
+ SCM_EXPORT void scm_iprin1 P((SCM exp, SCM port, int writing));
+ SCM_EXPORT void scm_intprint P((long n, int radix, SCM port));
+-SCM_EXPORT void scm_iprlist P((char *hdr, SCM exp, int tlr, SCM port, int writing));
+ SCM_EXPORT SCM  scm_env_lookup P((SCM var, SCM stenv));
+ SCM_EXPORT SCM  scm_env_rlookup P((SCM addr, SCM stenv, const char *what));
+ SCM_EXPORT SCM  scm_env_getprop P((SCM prop, SCM env));
+ SCM_EXPORT SCM  scm_env_addprop P((SCM prop, SCM val, SCM env));
+-SCM_EXPORT long num_frames P((SCM estk, int i));
+-SCM_EXPORT SCM  *estk_frame P((SCM estk, int i, int nf));
+-SCM_EXPORT SCM  *cont_frame P((SCM contin, int nf));
+-SCM_EXPORT SCM  stacktrace1 P((SCM estk, int i));
+ SCM_EXPORT void scm_princode P((SCM code, SCM env, SCM port, int writing));
+ SCM_EXPORT void scm_princlosure P((SCM proc, SCM port, int writing));
+ SCM_EXPORT void lputc P((int c, SCM port));
+ SCM_EXPORT void lputs P((const char *s, SCM port));
+-SCM_EXPORT sizet        lfwrite P((char *ptr, sizet size, sizet nitems, SCM port));
++SCM_EXPORT sizet lfwrite P((const char *ptr, sizet size, sizet nitems, SCM port));
+ SCM_EXPORT int  lgetc P((SCM port));
+ SCM_EXPORT void lungetc P((int c, SCM port));
+ SCM_EXPORT char *grow_tok_buf P((SCM tok_buf));
+-SCM_EXPORT long mode_bits P((char *modes, char *cmodes));
++SCM_EXPORT long mode_bits P((const char *modes, char *cmodes));
+ SCM_EXPORT long time_in_msec P((long x));
+ SCM_EXPORT SCM  my_time P((void));
+@@ -764,10 +753,43 @@
+ 
+ SCM_EXPORT void final_scm P((int));
++
++SCM_EXPORT void init_byte P((void));
++SCM_EXPORT void init_bytenumb P((void));
++SCM_EXPORT void init_crs P((void));
++SCM_EXPORT void init_debug P((void));
++SCM_EXPORT void init_differ P((void));
++SCM_EXPORT void init_dynl P((void));
++SCM_EXPORT void init_edline P((void));
++SCM_EXPORT void init_eval P((void));
++SCM_EXPORT void init_features P((void));
++SCM_EXPORT void init_gsubr P((void));
++SCM_EXPORT void init_io P((void));
++SCM_EXPORT void init_ioext P((void));
++SCM_EXPORT void init_posix P((void));
++SCM_EXPORT void init_ramap P((void));
++SCM_EXPORT void init_record P((void));
++SCM_EXPORT void init_repl P((int iverbose));
++SCM_EXPORT void init_rgx P((void));
++SCM_EXPORT void init_rope P((void));
+ SCM_EXPORT void init_sbrk P((void));
++SCM_EXPORT void init_sc2 P((void));
++SCM_EXPORT void init_scl P((void));
++SCM_EXPORT void init_socket P((void));
++SCM_EXPORT void init_subrs P((void));
++SCM_EXPORT void init_tables P((void));
++SCM_EXPORT void init_time P((void));
++SCM_EXPORT void init_types P((void));
++SCM_EXPORT void init_unif P((void));
++SCM_EXPORT void init_unix P((void));
++
++SCM_EXPORT void reset_time P((void));
++SCM_EXPORT void final_repl P((void));
+ SCM_EXPORT int  init_buf0 P((FILE *inport));
+-SCM_EXPORT void scm_init_from_argv P((int argc, const char * const *argv, char *script_arg,
++
++SCM_EXPORT void scm_init_from_argv P((int argc, const char * const *argv,
++                              const char *script_arg,
+                               int iverbose, int buf0stdin));
+ SCM_EXPORT void init_signals P((void));
+-SCM_EXPORT SCM  scm_top_level P((char *initpath, SCM (*toplvl_fun)()));
++SCM_EXPORT SCM  scm_top_level P((const char *initpath, SCM (*toplvl_fun)(void)));
+ SCM_EXPORT void restore_signals P((void));
+ SCM_EXPORT void free_storage P((void));
+@@ -780,5 +802,5 @@
+ SCM_EXPORT void unignore_signals P((void));
+ 
+-SCM_EXPORT void add_feature P((char *str));
++SCM_EXPORT void add_feature P((const char *str));
+ SCM_EXPORT int  raprin1 P((SCM exp, SCM port, int writing));
+ SCM_EXPORT SCM  markcdr P((SCM ptr));
+@@ -786,9 +808,10 @@
+ SCM_EXPORT SCM  equal0 P((SCM ptr1, SCM ptr2));
+ SCM_EXPORT sizet        free0 P((CELLPTR ptr));
+-SCM_EXPORT void scm_warn P((char *str1, char *str2, SCM obj));
+-SCM_EXPORT void everr P((SCM exp, SCM env, SCM arg, const char *pos, const char *s_subr, int codep));
+-SCM_EXPORT void wta P((SCM arg, const char *pos, const char *s_subr));
++SCM_EXPORT void scm_warn P((const char *str1, const char *str2, SCM obj));
++SCM_EXPORT void everr P((SCM exp, SCM env, SCM arg, const char *pos, const char *s_subr, int codep))
++__attribute__((noreturn));
++SCM_EXPORT void wta P((SCM arg, const char *pos, const char *s_subr)) __attribute__((noreturn));
+ SCM_EXPORT void scm_experr P((SCM arg, const char *pos, const char *s_subr));
+-SCM_EXPORT SCM  intern P((char *name, sizet len));
++SCM_EXPORT SCM  intern P((const char *name, sizet len));
+ SCM_EXPORT SCM  sysintern P((const char *name, SCM val));
+ SCM_EXPORT SCM  sym2vcell P((SCM sym));
+@@ -796,12 +819,8 @@
+ SCM_EXPORT SCM  scm_maksubr P((const char *name, int type, SCM (*fcn)()));
+ SCM_EXPORT SCM  make_subr P((const char *name, int type, SCM (*fcn)()));
+-SCM_EXPORT SCM  make_synt P((const char *name, long flags, SCM (*fcn)()));
+-SCM_EXPORT SCM  make_gsubr P((const char *name, int req, int opt, int rst,
+-                      SCM (*fcn)()));
+ SCM_EXPORT SCM  closure P((SCM code, int nargs));
+ SCM_EXPORT SCM  makprom P((SCM code));
+ SCM_EXPORT SCM  force P((SCM x));
+ SCM_EXPORT SCM  makarb P((SCM name));
+-SCM_EXPORT SCM  tryarb P((SCM arb));
+ SCM_EXPORT SCM  relarb P((SCM arb));
+ SCM_EXPORT SCM  ceval P((SCM x, SCM static_env, SCM env));
+@@ -816,25 +835,15 @@
+ SCM_EXPORT SCM  cons2 P((SCM w, SCM x, SCM y));
+ SCM_EXPORT SCM  resizuve P((SCM vect, SCM len));
+-SCM_EXPORT SCM  lnot P((SCM x));
+ SCM_EXPORT SCM  booleanp P((SCM obj));
+ SCM_EXPORT SCM  eq P((SCM x, SCM y));
+ SCM_EXPORT SCM  equal P((SCM x, SCM y));
+-SCM_EXPORT SCM  consp P((SCM x));
+ SCM_EXPORT SCM  cons P((SCM x, SCM y));
+-SCM_EXPORT SCM  nullp P((SCM x));
+-SCM_EXPORT SCM  setcar P((SCM pair, SCM value));
+-SCM_EXPORT SCM  setcdr P((SCM pair, SCM value));
+-SCM_EXPORT SCM  listp P((SCM x));
+ SCM_EXPORT SCM  list P((SCM objs));
+ SCM_EXPORT SCM  length P((SCM x));
+ SCM_EXPORT SCM  append P((SCM args));
+ SCM_EXPORT SCM  reverse P((SCM lst));
+-SCM_EXPORT SCM  list_ref P((SCM lst, SCM k));
+ SCM_EXPORT SCM  memq P((SCM x, SCM lst));
+-SCM_EXPORT SCM  member P((SCM x, SCM lst));
+ SCM_EXPORT SCM  memv P((SCM x, SCM lst));
+ SCM_EXPORT SCM  assq P((SCM x, SCM alist));
+-SCM_EXPORT SCM  assoc P((SCM x, SCM alist));
+-SCM_EXPORT SCM  symbolp P((SCM x));
+ SCM_EXPORT SCM  symbol2string P((SCM s));
+ SCM_EXPORT SCM  string2symbol P((SCM s));
+@@ -842,5 +851,4 @@
+ SCM_EXPORT SCM  numberp P((SCM x));
+ SCM_EXPORT SCM  exactp P((SCM x));
+-SCM_EXPORT SCM  inexactp P((SCM x));
+ SCM_EXPORT SCM  eqp P((SCM x, SCM y));
+ SCM_EXPORT SCM  eqv P((SCM x, SCM y));
+@@ -854,6 +862,4 @@
+ SCM_EXPORT SCM  oddp P((SCM n));
+ SCM_EXPORT SCM  evenp P((SCM n));
+-SCM_EXPORT SCM  scm_max P((SCM x, SCM y));
+-SCM_EXPORT SCM  scm_min P((SCM x, SCM y));
+ SCM_EXPORT SCM  sum P((SCM x, SCM y));
+ SCM_EXPORT SCM  difference P((SCM x, SCM y));
+@@ -864,15 +870,12 @@
+ SCM_EXPORT SCM  scm_iabs P((SCM x));
+ SCM_EXPORT SCM  scm_abs P((SCM x));
+-SCM_EXPORT SCM  lremainder P((SCM x, SCM y));
+ SCM_EXPORT SCM  modulo P((SCM x, SCM y));
+-SCM_EXPORT SCM  lgcd P((SCM x, SCM y));
+-SCM_EXPORT SCM  llcm P((SCM n1, SCM n2));
+ SCM_EXPORT SCM  number2string P((SCM x, SCM radix));
+-SCM_EXPORT SCM  istring2number P((char *str, long len, long radix));
++SCM_EXPORT SCM  istring2number P((const char *str, long len, long radix));
+ SCM_EXPORT SCM  string2number P((SCM str, SCM radix));
+-SCM_EXPORT SCM  istr2flo P((char *str, long len, long radix));
++SCM_EXPORT SCM  istr2flo P((const char *str, long len, long radix));
+ SCM_EXPORT SCM  mkbig P((sizet nlen, int sign));
+ SCM_EXPORT void bigrecy P((SCM bgnm));
+-SCM_EXPORT SCM  mkstrport P((SCM pos, SCM str, long modes, char *caller));
++SCM_EXPORT SCM  mkstrport P((SCM pos, SCM str, long modes, const char *caller));
+ SCM_EXPORT SCM  mksafeport P((int maxlen, SCM port));
+ SCM_EXPORT int  reset_safeport P((SCM sfp, int maxlen, SCM port));
+@@ -887,48 +890,23 @@
+ SCM_EXPORT SCM  uve_write P((SCM v, SCM port));
+ SCM_EXPORT SCM  raequal P((SCM ra0, SCM ra1));
+-SCM_EXPORT SCM  array_equal P((SCM u, SCM v));
+ SCM_EXPORT SCM  array_rank P((SCM ra));
++SCM_EXPORT SCM  array_dims P((SCM ra));
++SCM_EXPORT SCM  dims2ura P((SCM dims, SCM prot, SCM fill));
+ SCM_EXPORT int  rafill P((SCM ra, SCM fill, SCM ignore));
+-SCM_EXPORT SCM  uve_fill P((SCM uve, SCM fill));
+-SCM_EXPORT SCM  array_fill P((SCM ra, SCM fill));
+ SCM_EXPORT SCM  array_prot P((SCM ra));
+-SCM_EXPORT SCM  array_rank P((SCM ra));
+ SCM_EXPORT SCM  array_contents P((SCM ra, SCM strict));
+ SCM_EXPORT int  bigprint P((SCM exp, SCM port, int writing));
+ SCM_EXPORT int  floprint P((SCM sexp, SCM port, int writing));
+-SCM_EXPORT SCM  istr2int P((char *str, long len, int radix));
+-SCM_EXPORT SCM  istr2bve P((char *str, long len));
+-SCM_EXPORT void scm_ipruk P((char *hdr, SCM ptr, SCM port));
+-SCM_EXPORT SCM  charp P((SCM x));
+-SCM_EXPORT SCM  char_lessp P((SCM x, SCM y));
+-SCM_EXPORT SCM  chci_eq P((SCM x, SCM y));
+-SCM_EXPORT SCM  chci_lessp P((SCM x, SCM y));
+-SCM_EXPORT SCM  char_alphap P((SCM chr));
+-SCM_EXPORT SCM  char_nump P((SCM chr));
+-SCM_EXPORT SCM  char_whitep P((SCM chr));
+-SCM_EXPORT SCM  char_upperp P((SCM chr));
+-SCM_EXPORT SCM  char_lowerp P((SCM chr));
+-SCM_EXPORT SCM  char2int P((SCM chr));
+-SCM_EXPORT SCM  int2char P((SCM n));
+-SCM_EXPORT SCM  char_upcase P((SCM chr));
+-SCM_EXPORT SCM  char_downcase P((SCM chr));
+-SCM_EXPORT SCM  stringp P((SCM x));
++SCM_EXPORT SCM  istr2int P((const char *str, long len, int radix));
++SCM_EXPORT SCM  istr2bve P((const char *str, long len));
++SCM_EXPORT void scm_ipruk P((const char *hdr, SCM ptr, SCM port));
+ SCM_EXPORT SCM  string P((SCM chrs));
+ SCM_EXPORT SCM  make_string P((SCM k, SCM chr));
+ SCM_EXPORT SCM  string2list P((SCM str));
+-SCM_EXPORT SCM  st_length P((SCM str));
+-SCM_EXPORT SCM  st_ref P((SCM str, SCM k));
+-SCM_EXPORT SCM  st_set P((SCM str, SCM k, SCM chr));
+ SCM_EXPORT SCM  st_equal P((SCM s1, SCM s2));
+-SCM_EXPORT SCM  stci_equal P((SCM s1, SCM s2));
+-SCM_EXPORT SCM  st_lessp P((SCM s1, SCM s2));
+-SCM_EXPORT SCM  stci_lessp P((SCM s1, SCM s2));
+ SCM_EXPORT SCM  substring P((SCM str, SCM start, SCM end));
+ SCM_EXPORT SCM  st_append P((SCM args));
+-SCM_EXPORT SCM  vectorp P((SCM x));
+ SCM_EXPORT SCM  vector_length P((SCM v));
+ SCM_EXPORT SCM  vector P((SCM l));
+-SCM_EXPORT SCM  vector_ref P((SCM v, SCM k));
+-SCM_EXPORT SCM  vector_set P((SCM v, SCM k, SCM obj));
+ SCM_EXPORT SCM  make_vector P((SCM k, SCM fill));
+ SCM_EXPORT SCM  vector2list P((SCM v));
+@@ -952,12 +930,6 @@
+ SCM_EXPORT SCM  scm_check_linum P((SCM x, SCM *linum));
+ SCM_EXPORT SCM  scm_add_linum P((SCM linum, SCM x));
+-SCM_EXPORT SCM  input_portp P((SCM x));
+-SCM_EXPORT SCM  output_portp P((SCM x));
+-SCM_EXPORT SCM  cur_input_port P((void));
+-SCM_EXPORT SCM  cur_output_port P((void));
+ SCM_EXPORT SCM  i_setbuf0 P((SCM port));
+-SCM_EXPORT SCM  try_open_file P((SCM filename, SCM modes));
+ SCM_EXPORT SCM  open_file P((SCM filename, SCM modes));
+-SCM_EXPORT SCM  open_pipe P((SCM pipestr, SCM modes));
+ SCM_EXPORT SCM  close_port P((SCM port));
+ SCM_EXPORT SCM	scm_file_position P((SCM port, SCM pos));
+@@ -969,5 +941,4 @@
+ SCM_EXPORT SCM  eof_objectp P((SCM x));
+ SCM_EXPORT int  scm_io_error P((SCM port, const char *what));
+-SCM_EXPORT SCM  scm_write P((SCM obj, SCM port));
+ SCM_EXPORT SCM  scm_display P((SCM obj, SCM port));
+ SCM_EXPORT SCM  scm_newline P((SCM port));
+@@ -977,5 +948,4 @@
+ SCM_EXPORT void scm_line_msg P((SCM file, SCM linum, SCM port));
+ SCM_EXPORT void scm_err_line P((const char *what, SCM file, SCM linum, SCM port));
+-SCM_EXPORT SCM  scm_getenv P((SCM nam));
+ SCM_EXPORT SCM  prog_args P((void));
+ SCM_EXPORT SCM  makacro P((SCM code));
+@@ -997,5 +967,5 @@
+ #ifdef CAREFUL_INTS
+ SCM_EXPORT void ints_viol P((ints_infot *info, int sense));
+-SCM_EXPORT void    ints_warn P((char *s1, char* s2, char *fname, int linum));
++SCM_EXPORT void    ints_warn P((const char *s1, const char* s2, const char *fname, int linum));
+ #endif
+ SCM_EXPORT void add_final P((void (*final)(void)));
+@@ -1007,18 +977,12 @@
+ SCM_EXPORT SCM  scm_load_string P((SCM str));
+ SCM_EXPORT SCM  scm_unexec P((const SCM pathname));
+-SCM_EXPORT SCM     scm_logbitp  P((SCM index, SCM j1));
+-SCM_EXPORT SCM     scm_logtest  P((SCM x, SCM y));
+-SCM_EXPORT SCM     scm_logxor P((SCM x, SCM y));
+-SCM_EXPORT SCM     scm_logand P((SCM x, SCM y));
+-SCM_EXPORT SCM     scm_logior P((SCM x, SCM y));
+-SCM_EXPORT SCM     scm_lognot P((SCM n));
+-SCM_EXPORT SCM     scm_intexpt P((SCM z1, SCM z2));
+-SCM_EXPORT SCM     scm_intlog P((SCM base, SCM k));
+-SCM_EXPORT SCM     scm_cintlog P((SCM base, SCM k));
+-SCM_EXPORT SCM     scm_ash P((SCM n, SCM cnt));
+-SCM_EXPORT SCM     scm_bitfield P((SCM n, SCM start, SCM end));
+-SCM_EXPORT SCM     scm_logcount P((SCM n));
+-SCM_EXPORT SCM     scm_intlength P((SCM n));
+-SCM_EXPORT SCM     scm_copybit P((SCM index, SCM j1, SCM bit));
++SCM_EXPORT SCM  scm_logbitp  P((SCM index, SCM j1));
++SCM_EXPORT SCM  scm_logtest  P((SCM x, SCM y));
++SCM_EXPORT SCM  scm_logxor P((SCM x, SCM y));
++SCM_EXPORT SCM  scm_logand P((SCM x, SCM y));
++SCM_EXPORT SCM  scm_logior P((SCM x, SCM y));
++SCM_EXPORT SCM  scm_lognot P((SCM n));
++SCM_EXPORT SCM  scm_ash P((SCM n, SCM cnt));
++SCM_EXPORT SCM  scm_intlength P((SCM n));
+ SCM_EXPORT SCM  scm_bitif P((SCM mask, SCM n0, SCM n1));
+ SCM_EXPORT SCM  scm_copybitfield P((SCM to, SCM start, SCM rest));
+@@ -1027,11 +991,11 @@
+ SCM_EXPORT SCM   long2num P((long n));
+ SCM_EXPORT SCM  ulong2num P((unsigned long n));
+-SCM_EXPORT unsigned char  num2uchar  P((SCM num, char *pos, char *s_caller));
+-SCM_EXPORT   signed char  num2char   P((SCM num, char *pos, char *s_caller));
+-SCM_EXPORT unsigned short num2ushort P((SCM num, char *pos, char *s_caller));
+-SCM_EXPORT          short num2short  P((SCM num, char *pos, char *s_caller));
+-SCM_EXPORT unsigned long  num2ulong  P((SCM num, char *pos, char *s_caller));
+-SCM_EXPORT          long  num2long   P((SCM num, char *pos, char *s_caller));
+-SCM_EXPORT         double num2dbl    P((SCM num, char *pos, char *s_caller));
++SCM_EXPORT unsigned char  num2uchar  P((SCM num, const char *pos, const char *s_caller));
++SCM_EXPORT   signed char  num2char   P((SCM num, const char *pos, const char *s_caller));
++SCM_EXPORT unsigned short num2ushort P((SCM num, const char *pos, const char *s_caller));
++SCM_EXPORT          short num2short  P((SCM num, const char *pos, const char *s_caller));
++SCM_EXPORT unsigned long  num2ulong  P((SCM num, const char *pos, const char *s_caller));
++SCM_EXPORT          long  num2long   P((SCM num, const char *pos, const char *s_caller));
++SCM_EXPORT         double num2dbl    P((SCM num, const char *pos, const char *s_caller));
+ SCM_EXPORT SCM  makfromstr  P((const char *src, sizet len));
+ SCM_EXPORT SCM  makfromstrs P((int argc, const char * const *argv));
+@@ -1039,8 +1003,8 @@
+ SCM_EXPORT char **makargvfrmstrs P((SCM args, const char *s_v));
+ SCM_EXPORT void must_free_argv P((char **argv));
+-SCM_EXPORT SCM  scm_evstr  P((char *str));
+-SCM_EXPORT void scm_ldstr  P((char *str));
+-SCM_EXPORT int  scm_ldfile P((char *path));
+-SCM_EXPORT int  scm_ldprog P((char *path));
++SCM_EXPORT SCM  scm_evstr  P((const char *str));
++SCM_EXPORT void scm_ldstr  P((const char *str));
++SCM_EXPORT int  scm_ldfile P((const char *path));
++SCM_EXPORT int  scm_ldprog P((const char *path));
+ SCM_EXPORT void* scm_addr P((SCM args, const char *name));
+ SCM_EXPORT void* scm_base_addr P((SCM v, const char *name));
+@@ -1061,9 +1025,8 @@
+ SCM_EXPORT SCM  normbig P((SCM b));
+ SCM_EXPORT SCM  copybig P((SCM b, int sign));
+-SCM_EXPORT SCM  addbig P((BIGDIG *x, sizet nx, int xsgn, SCM bigy, int sgny));
+-SCM_EXPORT SCM  mulbig P((BIGDIG *x, sizet nx, BIGDIG *y, sizet ny, int sgn));
++SCM_EXPORT SCM  addbig P((const BIGDIG *x, sizet nx, int xsgn, SCM bigy, int sgny));
++SCM_EXPORT SCM  mulbig P((const BIGDIG *x, sizet nx, const BIGDIG *y, sizet ny, int sgn));
+ SCM_EXPORT UBIGLONG divbigdig P((BIGDIG *ds, sizet h, BIGDIG div));
+-SCM_EXPORT SCM  divbigint P((SCM x, long z, int sgn, int mode));
+-SCM_EXPORT SCM  divbigbig P((BIGDIG *x, sizet nx, BIGDIG *y, sizet ny, int sgn,
++SCM_EXPORT SCM  divbigbig P((const BIGDIG *x, sizet nx, BIGDIG *y, sizet ny, int sgn,
+                    int mode));
+ SCM_EXPORT long  pseudolong P((long x));
+@@ -1077,6 +1040,6 @@
+ SCM_EXPORT char *       scm_try_path P((char *path));
+ SCM_EXPORT char *       script_find_executable P((const char *command));
+-SCM_EXPORT char **      script_process_argv P((int argc, const char **argv));
+-SCM_EXPORT int  script_count_argv P((const char **argv));
++SCM_EXPORT const char * const * script_process_argv P((int argc, const char * const *argv));
++SCM_EXPORT int  script_count_argv P((const char * const *argv));
+ SCM_EXPORT char *       find_impl_file P((const char *exec_path, const char *generic_name,
+                           const char *initname, const char *sep));
+@@ -1085,4 +1048,6 @@
+ SCM_EXPORT void scm_ecache_report P((void));
+ SCM_EXPORT void scm_estk_reset P((sizet size));
++SCM_EXPORT void scm_estk_grow P((void));
++SCM_EXPORT void scm_estk_shrink P((void));
+ SCM_EXPORT void scm_env_cons P((SCM x, SCM y));
+ SCM_EXPORT void scm_env_cons2 P((SCM w, SCM x, SCM y));
+@@ -1091,4 +1056,5 @@
+ SCM_EXPORT void scm_extend_env P((void));
+ SCM_EXPORT void scm_egc P((void));
++SCM_EXPORT void scm_dynthrow P((SCM cont, SCM arg1, SCM arg2, SCM rest));
+ 
+ /* Global state for environment cache */
+@@ -1109,8 +1075,15 @@
+ # define ASRTGO(_cond, _label) ;
+ #else
+-# define ASRTER(_cond, _arg, _pos, _subr) if (SCM_EXPECT_FALSE(!(_cond))) wta(_arg, (char *)(_pos), _subr);
++# define ASRTER(_cond, _arg, _pos, _subr) if (SCM_EXPECT_FALSE(!(_cond))) wta(_arg, (const char *)(_pos), _subr);
+ # define ASRTGO(_cond, _label) if (SCM_EXPECT_FALSE(!(_cond))) goto _label;
+ #endif
+ 
++SCM_EXPORT void igc P((const char *what, SCM basecont));
++SCM_EXPORT void unexec P((const char *new_name, const char *a_name, unsigned data_start,
++    unsigned bss_start, unsigned entry_address));
++SCM_EXPORT void scm_fill_freelist P((void));
++struct stat;
++SCM_EXPORT SCM stat2scm P((const struct stat *stat_temp));
++
+ #define ARGn            1L
+ #define ARG1            2L
+--- scmmain.c	2013-04-06 21:52:41.000000000 -0400
++++ scmmain.c	2015-01-23 18:55:19.000000000 -0500
+@@ -19,9 +19,4 @@
+ /* Author: Aubrey Jaffer */
+ 
+-/* added by Dai Inukai 2001-03-21*/
+-#ifdef __FreeBSD__
+-# include <floatingpoint.h>
+-#endif
+-
+ #ifdef _WIN32
+ # include <io.h>
+@@ -47,5 +42,5 @@
+ #endif
+ 
+-char *scm_find_implpath(execpath)
++static char *scm_find_implpath(execpath)
+      const char *execpath;
+ {
+@@ -84,14 +79,11 @@
+ int main(argc, argv)
+      int argc;
+-     const char **argv;
++     const char * const *argv;
+ {
+-  char *script_arg = 0;		/* location of SCSH style script file or 0. */
+-  char *implpath = 0, **nargv;
++  const char *script_arg = NULL;	/* location of SCSH style script file or 0. */
++  char *implpath = NULL;
++  const char * const * nargv;
+   int nargc, iverbose = 0, buf0stdin;
+   SCM retval;
+-/* added by Dai Inukai 2001-03-21 */
+-#ifdef __FreeBSD__
+-  fp_prec_t fpspec;
+-#endif
+ 
+ #ifdef WINSIGNALS
+@@ -111,9 +103,5 @@
+   init_sbrk();			/* Do this before malloc()s. */
+ #endif
+-/* added by Dai Inukai 2001-03-21 */
+-#ifdef __FreeBSD__
+-   fpspec = fpsetprec(FP_PE); /* IEEE 64 bit FP mantissa*/
+-#endif
+-  execpath = 0;			/* even when dumped */
++  execpath = NULL;		/* even when dumped */
+   if ((nargv = script_process_argv(argc, argv))) { /* SCSH style scripts */
+     script_arg = argv[2];	/* Save for scm_find_execpath() call */
+@@ -152,10 +140,4 @@
+   if (execpath) free(execpath);
+   execpath = 0;
+-/* added by Dai Inukai 2001-03-27 */
+-#ifdef __FreeBSD__
+-  fpspec = fpsetprec(fpspec); /* Set back to FP_PD which is 53 bit FP. */
+-                              /* This may not be needed because the    */
+-                              /* kernel is set to FP_PD by default.    */
+-#endif
+   return (int)INUM(retval);
+ }
+--- script.c	2008-01-30 22:32:55.000000000 -0500
++++ script.c	2015-01-23 18:55:19.000000000 -0500
+@@ -54,10 +54,10 @@
+     {
+       long len = strlen(str1);
+-      str1 = (char *)realloc(str1, (sizet)(len + n + 1));
++      str1 = realloc(str1, (sizet)(len + n + 1));
+       if (!str1) return 0L;
+       strncat(str1 + len, str2, n);
+       return str1;
+     }
+-  str1 = (char *)malloc((sizet)(n + 1));
++  str1 = malloc((sizet)(n + 1));
+   if (!str1) return 0L;
+   str1[0] = 0;
+@@ -81,5 +81,5 @@
+ }
+ 
+-char *scm_sep_init_try(path, sep, initname)
++static char *scm_sep_init_try(path, sep, initname)
+      char *path;
+      const char *sep, *initname;
+@@ -147,6 +147,6 @@
+ {
+   char *sepptr = strrchr(exec_path, sep[0]);
+-  char *extptr = exec_path + strlen(exec_path);
+-  char *path = 0;
++  const char *extptr = exec_path + strlen(exec_path);
++  char *path = NULL;
+ 
+ #ifdef _WIN32
+@@ -189,5 +189,5 @@
+     if (!strcmp(sepptr, "exe") || !strcmp(sepptr, "bin") ||
+ 	!strcmp(sepptr, "EXE") || !strcmp(sepptr, "BIN")) {
+-      char *peer;
++      const char *peer;
+ 
+       /* Look for initname in peer directory "lib". */
+@@ -279,10 +279,10 @@
+ }
+ 
+-char *script_read_arg(f)
++static const char *script_read_arg(f)
+      FILE *f;
+ {
+   sizet tlen = 1;
+   int tind = 0, qted = 0, chr;
+-  char *tbuf = (char *)malloc((1 + tlen) * sizeof(char));
++  char *tbuf = malloc((1 + tlen) * sizeof(char));
+   if (!tbuf) return 0L;
+   while (1) switch (chr = getc(f)) {
+@@ -337,5 +337,5 @@
+ }
+ 
+-int script_meta_arg_P(arg)
++static int script_meta_arg_P(arg)
+      const char *arg;
+ {
+@@ -352,12 +352,12 @@
+ }
+ 
+-char **script_process_argv(argc, argv)
++const char * const *script_process_argv(argc, argv)
+      int argc;
+-     const char **argv;
++     const char * const *argv;
+ {
+   int nargc = argc, argi = 1, nargi = 1;
+-  char *narg, **nargv;
+-  if (!(argc > 2 && script_meta_arg_P(argv[1]))) return 0L;
+-  if (!(nargv = (char **)malloc((1 + nargc) * sizeof(char *)))) return 0L;
++  const char *narg, **nargv;
++  if (!(argc > 2 && script_meta_arg_P(argv[1]))) return NULL;
++  if (!(nargv = malloc((1 + nargc) * sizeof(char *)))) return NULL;
+   nargv[0] = argv[0];
+   while (((argi+1) < argc) && (script_meta_arg_P(argv[argi]))) {
+@@ -366,10 +366,10 @@
+       nargc--;		/* to compensate for replacement of '\\' */
+       while (1) switch (getc(f)) {
+-      case EOF: return 0L;
++      case EOF: return NULL;
+       default: continue;
+       case '\n': goto found_args;
+       }
+     found_args: while ((narg = script_read_arg(f)))
+-      if (!(nargv = (char **)realloc(nargv, (1 + ++nargc) * sizeof(char *))))
++      if (!(nargv = realloc(nargv, (1 + ++nargc) * sizeof(char *))))
+ 	return 0L;
+       else nargv[nargi++] = narg;
+@@ -383,5 +383,5 @@
+ 
+ int script_count_argv(argv)
+-     const char **argv;
++     const char * const *argv;
+ {
+   int argc = 0;
+--- socket.c	2008-01-30 22:32:57.000000000 -0500
++++ socket.c	2015-01-23 18:55:19.000000000 -0500
+@@ -54,6 +54,6 @@
+ #endif /* STDC_HEADERS */
+ 
+-static char s_inetaddr[] = "inet:string->address";
+-SCM l_inetaddr (host)
++static const char s_inetaddr[] = "inet:string->address";
++static SCM l_inetaddr (host)
+      SCM host;
+ {
+@@ -72,6 +72,6 @@
+ }
+ 
+-static char s_inetstr[] = "inet:address->string";
+-SCM l_inetstr (inetid)
++static const char s_inetstr[] = "inet:address->string";
++static SCM l_inetstr (inetid)
+      SCM inetid;
+ {
+@@ -83,6 +83,6 @@
+ }
+ 
+-static char s_network[] = "inet:network";
+-SCM l_network (host)
++static const char s_network[] = "inet:network";
++static SCM l_network (host)
+      SCM host;
+ {
+@@ -93,6 +93,6 @@
+ 
+ #ifndef __CYGWIN__
+-static char s_lna[] = "inet:local-network-address";
+-SCM l_lna (host)
++static const char s_lna[] = "inet:local-network-address";
++static SCM l_lna (host)
+      SCM host;
+ {
+@@ -103,6 +103,6 @@
+ #endif
+ 
+-static char s_makaddr[] = "inet:make-address";
+-SCM l_makaddr (net, lna)
++static const char s_makaddr[] = "inet:make-address";
++static SCM l_makaddr (net, lna)
+      SCM net, lna;
+ {
+@@ -115,6 +115,6 @@
+ 
+ #ifndef __CYGWIN__
+-static char s_hostinfo[] = "gethost";
+-SCM l_hostinfo(name)
++static const char s_hostinfo[] = "gethost";
++static SCM l_hostinfo(name)
+      SCM name;
+ {
+@@ -124,5 +124,5 @@
+   struct hostent *entry;
+   struct in_addr inad;
+-  const char **argv;
++  const char * const *argv;
+   int i = 0;
+ # ifndef linux
+@@ -145,12 +145,13 @@
+   if (!entry) return BOOL_F;
+   ve[ 0] = makfrom0str(entry->h_name);
+-  ve[ 1] = makfromstrs(-1, entry->h_aliases);
++  ve[ 1] = makfromstrs(-1, (const char * const *)entry->h_aliases);
+   ve[ 2] = MAKINUM(entry->h_addrtype + 0L);
+   ve[ 3] = MAKINUM(entry->h_length + 0L);
+   if (sizeof(struct in_addr) != entry->h_length)
+     {ve[ 4] = BOOL_F; return ans;}
+-  for (argv = entry->h_addr_list; argv[i]; i++);
++  for (argv = (const char * const *)entry->h_addr_list; argv[i]; i++)
++    ;
+   while (i--) {
+-    inad = *(struct in_addr *)argv[i];
++    inad = *(const struct in_addr *)argv[i];
+     lst = cons(ulong2num(ntohl(inad.s_addr)), lst);
+   }
+@@ -158,6 +159,6 @@
+   return ans;
+ }
+-static char s_netinfo[] = "getnet";
+-SCM l_netinfo(name)
++static const char s_netinfo[] = "getnet";
++static SCM l_netinfo(name)
+      SCM name;
+ {
+@@ -182,5 +183,5 @@
+   if (!entry) return BOOL_F;
+   ve[ 0] = makfrom0str(entry->n_name);
+-  ve[ 1] = makfromstrs(-1, entry->n_aliases);
++  ve[ 1] = makfromstrs(-1, (const char * const *)entry->n_aliases);
+   ve[ 2] = MAKINUM(entry->n_addrtype + 0L);
+   ve[ 3] = ulong2num(entry->n_net + 0L);
+@@ -188,6 +189,6 @@
+ }
+ #endif
+-static char s_protoinfo[] = "getproto";
+-SCM l_protoinfo(name)
++static const char s_protoinfo[] = "getproto";
++static SCM l_protoinfo(name)
+      SCM name;
+ {
+@@ -212,10 +213,10 @@
+   if (!entry) return BOOL_F;
+   ve[ 0] = makfrom0str(entry->p_name);
+-  ve[ 1] = makfromstrs(-1, entry->p_aliases);
++  ve[ 1] = makfromstrs(-1, (const char * const *)entry->p_aliases);
+   ve[ 2] = MAKINUM(entry->p_proto + 0L);
+   return ans;
+ }
+-static char s_servinfo[] = "getserv";
+-SCM l_servinfo(args)
++static const char s_servinfo[] = "getserv";
++static SCM l_servinfo(args)
+      SCM args;
+ {
+@@ -245,5 +246,5 @@
+   if (!entry) return BOOL_F;
+   ve[ 0] = makfrom0str(entry->s_name);
+-  ve[ 1] = makfromstrs(-1, entry->s_aliases);
++  ve[ 1] = makfromstrs(-1, (const char * const *)entry->s_aliases);
+   ve[ 2] = MAKINUM(ntohs(entry->s_port) + 0L);
+   ve[ 3] = makfrom0str(entry->s_proto);
+@@ -251,5 +252,5 @@
+ }
+ 
+-SCM l_sethost(arg)
++static SCM l_sethost(arg)
+      SCM arg;
+ {
+@@ -259,5 +260,5 @@
+ }
+ #ifndef __CYGWIN__
+-SCM l_setnet(arg)
++static SCM l_setnet(arg)
+      SCM arg;
+ {
+@@ -267,5 +268,5 @@
+ }
+ #endif
+-SCM l_setproto(arg)
++static SCM l_setproto(arg)
+      SCM arg;
+ {
+@@ -274,5 +275,5 @@
+   return UNSPECIFIED;
+ }
+-SCM l_setserv(arg)
++static SCM l_setserv(arg)
+      SCM arg;
+ {
+@@ -282,6 +283,6 @@
+ }
+ 
+-static char s_socket[] = "make-stream-socket";
+-SCM l_socket(fam, proto)
++static const char s_socket[] = "make-stream-socket";
++static SCM l_socket(fam, proto)
+      SCM fam, proto;
+ {
+@@ -316,6 +317,6 @@
+   return port;
+ }
+-static char s_socketpair[] = "make-stream-socketpair";
+-SCM l_socketpair(fam, proto)
++static const char s_socketpair[] = "make-stream-socketpair";
++static SCM l_socketpair(fam, proto)
+      SCM fam, proto;
+ {
+@@ -349,6 +350,6 @@
+ }
+ 
+-static char s_shutdown[] = "socket:shutdown";
+-SCM l_shutdown(port, how)
++static const char s_shutdown[] = "socket:shutdown";
++static SCM l_shutdown(port, how)
+      SCM port, how;
+ {
+@@ -369,7 +370,7 @@
+   return port;
+ }
+-static char s_unkfam[] = "unknown-family";
+-static char s_connect[] = "socket:connect";
+-SCM l_connect (sockpt, address, arg)
++static const char s_unkfam[] = "unknown-family";
++static const char s_connect[] = "socket:connect";
++static SCM l_connect (sockpt, address, arg)
+      SCM sockpt, address, arg;
+ {
+@@ -414,6 +415,6 @@
+ }
+ 
+-static char s_bind[] = "socket:bind";
+-SCM l_bind(sockpt, address)
++static const char s_bind[] = "socket:bind";
++static SCM l_bind(sockpt, address)
+      SCM sockpt, address;
+ {
+@@ -450,6 +451,6 @@
+ }
+ 
+-static char s_listen[] = "socket:listen";
+-SCM l_listen(port, backlog)
++static const char s_listen[] = "socket:listen";
++static SCM l_listen(port, backlog)
+      SCM port, backlog;
+ {
+@@ -468,9 +469,10 @@
+ }
+ 
+-static char s_accept[] = "socket:accept";
+-SCM l_accept(sockpt)
++static const char s_accept[] = "socket:accept";
++static SCM l_accept(sockpt)
+      SCM sockpt;
+ {
+-  int newsd, sadlen;
++  int newsd;
++  socklen_t sadlen;
+   struct sockaddr sad;
+   FILE *newfd;
+@@ -499,5 +501,5 @@
+ }
+ 
+-int sknm_print(exp, port, writing)
++static int sknm_print(exp, port, writing)
+      SCM exp; SCM port; int writing;
+ {
+@@ -521,5 +523,5 @@
+   return !0;
+ }
+-sizet sknm_free(p)
++static sizet sknm_free(p)
+      CELLPTR p;
+ {
+@@ -530,6 +532,6 @@
+ static smobfuns sknm_smob = {mark0, sknm_free, sknm_print, 0};
+ 
+-char s_sknm_family[] = "socket-name:family";
+-SCM l_sknm_family(snm)
++const char s_sknm_family[] = "socket-name:family";
++static SCM l_sknm_family(snm)
+      SCM snm;
+ {
+@@ -537,6 +539,6 @@
+   return MAKINUM(((struct sockaddr *)CDR(snm))->sa_family + 0L);
+ }
+-char s_sknm_port_num[] = "socket-name:port-number";
+-SCM l_sknm_port_num(snm)
++const char s_sknm_port_num[] = "socket-name:port-number";
++static SCM l_sknm_port_num(snm)
+      SCM snm;
+ {
+@@ -550,6 +552,6 @@
+   }
+ }
+-char s_sknm_addr[] = "socket-name:address";
+-SCM l_sknm_addr(snm)
++const char s_sknm_addr[] = "socket-name:address";
++static SCM l_sknm_addr(snm)
+      SCM snm;
+ {
+@@ -566,12 +568,12 @@
+ }
+ 
+-SCM maksknm(sad)
+-     struct sockaddr *sad;
++static SCM maksknm(sad)
++     struct sockaddr_in *sad;
+ {
+   SCM sknm;
+-  struct sockaddr *msknm;
++  struct sockaddr_in *msknm;
+   DEFER_INTS;
+   sknm = must_malloc_cell(0L+sizeof(struct sockaddr), (SCM)tc16_sknm, "sknm");
+-  msknm = (struct sockaddr *)CDR(sknm);
++  msknm = (struct sockaddr_in *)CDR(sknm);
+   *msknm = *sad;
+   ALLOW_INTS;
+@@ -579,10 +581,11 @@
+ }
+ 
+-static char s_getpeername[] = "getpeername";
+-SCM l_getpeername(sockpt)
++static const char s_getpeername[] = "getpeername";
++static SCM l_getpeername(sockpt)
+      SCM sockpt;
+ {
+   struct sockaddr_in sad;
+-  int sts, sadlen = sizeof(sad);
++  int sts;
++  socklen_t sadlen = sizeof(sad);
+   bzero((char *) &sad, sizeof(sad));
+   ASRTER(NIMP(sockpt) && OPFPORTP(sockpt), sockpt, ARG1, s_getpeername);
+@@ -593,11 +596,12 @@
+   return maksknm(&sad);
+ }
+-static char s_getsockname[] = "getsockname";
+-SCM l_getsockname(sockpt)
++static const char s_getsockname[] = "getsockname";
++static SCM l_getsockname(sockpt)
+      SCM sockpt;
+ {
+   struct sockaddr_in sad;
+-  int sts, sadlen = sizeof(sad);
+-  bzero((char *) &sad, sizeof(sad));
++  int sts;
++  socklen_t sadlen = sizeof(sad);
++  bzero(&sad, sizeof(sad));
+   ASRTER(NIMP(sockpt) && OPFPORTP(sockpt), sockpt, ARG1, s_getsockname);
+   SYSCALL(sts = getsockname(fileno(STREAM(sockpt)),
+--- subr.c	2014-05-02 20:06:08.000000000 -0400
++++ subr.c	2015-01-23 18:55:19.000000000 -0500
+@@ -25,14 +25,13 @@
+ #define s_append (s_st_append+7)
+ 
+-char	s_make_string[] = "make-string";
+-char	s_list[] = "list";
++const char	s_make_string[] = "make-string";
++const char	s_list[] = "list";
+ 
+-static char	s_setcar[] = "set-car!", s_setcdr[] = "set-cdr!",
++static const char	s_setcar[] = "set-car!", s_setcdr[] = "set-cdr!",
+ 	s_reverse[] = "reverse", s_list_ref[] = "list-ref";
+-static char	s_memq[] = "memq", s_member[] = "member",
++static const char	s_memq[] = "memq", s_member[] = "member",
+ 	s_assq[] = "assq", s_assoc[] = "assoc";
+-static char	s_symbol2string[] = "symbol->string",
++static const char	s_symbol2string[] = "symbol->string",
+ 	s_str2symbol[] = "string->symbol";
+-extern char s_inexactp[];
+ #define s_exactp (s_inexactp+2)
+ static char	s_oddp[] = "odd?", s_evenp[] = "even?";
+@@ -64,5 +63,9 @@
+ 	s_ve_ref[] = "vector-ref", s_ve_set[] = "vector-set!";
+ 
+-SCM lnot(x)
++#ifdef BIGDIG
++static SCM divbigint(SCM x, long z, int sgn, int mode); /* Forward declaration */
++#endif
++
++static SCM lnot(x)
+      SCM x;
+ {
+@@ -83,5 +86,5 @@
+ }
+ 
+-SCM consp(x)
++static SCM consp(x)
+      SCM x;
+ {
+@@ -89,5 +92,5 @@
+ 	return CONSP(x) ? BOOL_T : BOOL_F;
+ }
+-SCM setcar(pair, value)
++static SCM setcar(pair, value)
+      SCM pair, value;
+ {
+@@ -96,5 +99,5 @@
+ 	return UNSPECIFIED;
+ }
+-SCM setcdr(pair, value)
++static SCM setcdr(pair, value)
+      SCM pair, value;
+ {
+@@ -103,5 +106,5 @@
+ 	return UNSPECIFIED;
+ }
+-SCM nullp(x)
++static SCM nullp(x)
+      SCM x;
+ {
+@@ -127,5 +130,5 @@
+ 	return -1;
+ }
+-SCM listp(x)
++static SCM listp(x)
+      SCM x;
+ {
+@@ -184,5 +187,5 @@
+ 	return res;
+ }
+-SCM list_ref(lst, k)
++static SCM list_ref(lst, k)
+      SCM lst, k;
+ {
+@@ -209,5 +212,5 @@
+ 	return BOOL_F;
+ }
+-SCM member(x, lst)
++static SCM member(x, lst)
+      SCM x, lst;
+ {
+@@ -232,5 +235,5 @@
+ 	return BOOL_F;
+ }
+-SCM assoc(x, alist)
++static SCM assoc(x, alist)
+      SCM x, alist;
+ {
+@@ -246,6 +249,5 @@
+ }
+ 
+-extern long tc16_promise;
+-SCM promisep(x)
++static SCM promisep(x)
+      SCM x;
+ {
+@@ -253,5 +255,5 @@
+ }
+ 
+-SCM symbolp(x)
++static SCM symbolp(x)
+      SCM x;
+ {
+@@ -475,5 +477,5 @@
+   return MAKINUM(z);
+ }
+-SCM lremainder(x, y)
++static SCM lremainder(x, y)
+      SCM x, y;
+ {
+@@ -553,5 +555,5 @@
+ }
+ 
+-SCM lgcd(x, y)
++static SCM lgcd(x, y)
+      SCM x, y;
+ {
+@@ -611,5 +613,5 @@
+   return MAKINUM(u);
+ }
+-SCM llcm(n1, n2)
++static SCM llcm(n1, n2)
+      SCM n1, n2;
+ {
+@@ -662,11 +664,11 @@
+ #ifdef BIGDIG
+ 
+-SCM	scm_big_ior P((BIGDIG *x, sizet nx, int xsgn, SCM bigy));
+-SCM	scm_big_and P((BIGDIG *x, sizet nx, int xsgn, SCM bigy, int zsgn));
+-SCM	scm_big_xor P((BIGDIG *x, sizet nx, int xsgn, SCM bigy));
+-SCM	scm_big_test P((BIGDIG *x, sizet nx, int xsgn, SCM bigy));
+-SCM	scm_big_ash P((SCM x, int cnt));
++static SCM scm_big_ior P((const BIGDIG *x, sizet nx, int xsgn, SCM bigy));
++static SCM scm_big_and P((const BIGDIG *x, sizet nx, int xsgn, SCM bigy, int zsgn));
++static SCM scm_big_xor P((const BIGDIG *x, sizet nx, int xsgn, SCM bigy));
++static SCM scm_big_test P((const BIGDIG *x, sizet nx, int xsgn, SCM bigy));
++static SCM scm_big_ash P((SCM x, int cnt));
+ 
+-SCM scm_copy_big_dec(b, sign)
++static SCM scm_copy_big_dec(b, sign)
+      SCM b;
+      int sign;
+@@ -687,6 +689,6 @@
+ }
+ 
+-SCM scm_copy_smaller(x, nx, zsgn)
+-     BIGDIG *x;
++static SCM scm_copy_smaller(x, nx, zsgn)
++     const BIGDIG *x;
+      sizet nx;
+      int zsgn;
+@@ -706,5 +708,5 @@
+ 
+ SCM scm_big_ior(x, nx, xsgn, bigy)
+-     BIGDIG *x;
++     const BIGDIG *x;
+      SCM bigy;
+      sizet nx;		/* Assumes nx <= NUMDIGS(bigy) */
+@@ -738,5 +740,5 @@
+ 
+ SCM scm_big_xor(x, nx, xsgn, bigy)
+-     BIGDIG *x;
++     const BIGDIG *x;
+      SCM bigy;
+      sizet nx;		/* Assumes nx <= NUMDIGS(bigy) */
+@@ -770,5 +772,5 @@
+ 
+ SCM scm_big_and(x, nx, xsgn, bigy, zsgn)
+-     BIGDIG *x;
++     const BIGDIG *x;
+      SCM bigy;
+      sizet nx;		/* Assumes nx <= NUMDIGS(bigy) */
+@@ -814,5 +816,5 @@
+ 
+ SCM scm_big_test(x, nx, xsgn, bigy)
+-     BIGDIG *x;
++     const BIGDIG *x;
+      SCM bigy;
+      sizet nx;		/* Assumes nx <= NUMDIGS(bigy) */
+@@ -1221,5 +1223,5 @@
+ }
+ 
+-SCM scm_copybit(index, j1, bit)
++static SCM scm_copybit(index, j1, bit)
+      SCM index, j1, bit;
+ {
+@@ -1296,8 +1298,10 @@
+ }
+ 
+-SCM scm_bitfield(n, start, end)
++static SCM scm_bitfield(n, start, end)
+      SCM n, start, end;
+ {
++#ifdef BIGDIG
+   int sign;
++#endif
+   int istart = INUM(start);
+   int iend = INUM(end);
+@@ -1388,6 +1392,6 @@
+ }
+ 
+-char logtab[] = {0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
+-SCM scm_bitwise_bit_count(n)
++static const char logtab[] = {0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
++static SCM scm_bitwise_bit_count(n)
+      SCM n;
+ {
+@@ -1421,5 +1425,5 @@
+ }
+ 
+-SCM scm_logcount(n)
++static SCM scm_logcount(n)
+      SCM n;
+ {
+@@ -1445,5 +1449,5 @@
+ }
+ 
+-char ilentab[] = {0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4};
++static const char ilentab[] = {0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4};
+ SCM scm_intlength(n)
+      SCM n;
+@@ -1475,10 +1479,10 @@
+ }
+ 
+-SCM charp(x)
++static SCM charp(x)
+      SCM x;
+ {
+ 	return ICHRP(x) ? BOOL_T : BOOL_F;
+ }
+-SCM char_lessp(x, y)
++static SCM char_lessp(x, y)
+      SCM x, y;
+ {
+@@ -1487,5 +1491,5 @@
+ 	return (ICHR(x) < ICHR(y)) ? BOOL_T : BOOL_F;
+ }
+-SCM char_leqp(x, y)
++static SCM char_leqp(x, y)
+      SCM x, y;
+ {
+@@ -1494,5 +1498,5 @@
+ 	return (ICHR(x) <= ICHR(y)) ? BOOL_T : BOOL_F;
+ }
+-SCM char_grp(x, y)
++static SCM char_grp(x, y)
+      SCM x, y;
+ {
+@@ -1501,5 +1505,5 @@
+ 	return (ICHR(x) > ICHR(y)) ? BOOL_T : BOOL_F;
+ }
+-SCM char_geqp(x, y)
++static SCM char_geqp(x, y)
+      SCM x, y;
+ {
+@@ -1508,5 +1512,5 @@
+ 	return (ICHR(x) >= ICHR(y)) ? BOOL_T : BOOL_F;
+ }
+-SCM chci_eq(x, y)
++static SCM chci_eq(x, y)
+      SCM x, y;
+ {
+@@ -1515,5 +1519,5 @@
+ 	return (upcase[ICHR(x)]==upcase[ICHR(y)]) ? BOOL_T : BOOL_F;
+ }
+-SCM chci_lessp(x, y)
++static SCM chci_lessp(x, y)
+      SCM x, y;
+ {
+@@ -1522,5 +1526,5 @@
+ 	return (upcase[ICHR(x)] < upcase[ICHR(y)]) ? BOOL_T : BOOL_F;
+ }
+-SCM chci_leqp(x, y)
++static SCM chci_leqp(x, y)
+      SCM x, y;
+ {
+@@ -1529,5 +1533,5 @@
+ 	return (upcase[ICHR(x)] <= upcase[ICHR(y)]) ? BOOL_T : BOOL_F;
+ }
+-SCM chci_grp(x, y)
++static SCM chci_grp(x, y)
+      SCM x, y;
+ {
+@@ -1536,5 +1540,5 @@
+ 	return (upcase[ICHR(x)] > upcase[ICHR(y)]) ? BOOL_T : BOOL_F;
+ }
+-SCM chci_geqp(x, y)
++static SCM chci_geqp(x, y)
+      SCM x, y;
+ {
+@@ -1543,5 +1547,5 @@
+ 	return (upcase[ICHR(x)] >= upcase[ICHR(y)]) ? BOOL_T : BOOL_F;
+ }
+-SCM char_alphap(chr)
++static SCM char_alphap(chr)
+      SCM chr;
+ {
+@@ -1549,5 +1553,5 @@
+ 	return (isascii(ICHR(chr)) && isalpha(ICHR(chr))) ? BOOL_T : BOOL_F;
+ }
+-SCM char_nump(chr)
++static SCM char_nump(chr)
+      SCM chr;
+ {
+@@ -1555,5 +1559,5 @@
+ 	return (isascii(ICHR(chr)) && isdigit(ICHR(chr))) ? BOOL_T : BOOL_F;
+ }
+-SCM char_whitep(chr)
++static SCM char_whitep(chr)
+      SCM chr;
+ {
+@@ -1561,5 +1565,5 @@
+ 	return (isascii(ICHR(chr)) && isspace(ICHR(chr))) ? BOOL_T : BOOL_F;
+ }
+-SCM char_upperp(chr)
++static SCM char_upperp(chr)
+      SCM chr;
+ {
+@@ -1567,5 +1571,5 @@
+ 	return (isascii(ICHR(chr)) && isupper(ICHR(chr))) ? BOOL_T : BOOL_F;
+ }
+-SCM char_lowerp(chr)
++static SCM char_lowerp(chr)
+      SCM chr;
+ {
+@@ -1573,5 +1577,5 @@
+ 	return (isascii(ICHR(chr)) && islower(ICHR(chr))) ? BOOL_T : BOOL_F;
+ }
+-SCM char2int(chr)
++static SCM char2int(chr)
+      SCM chr;
+ {
+@@ -1579,5 +1583,5 @@
+ 	return MAKINUM(ICHR(chr));
+ }
+-SCM int2char(n)
++static SCM int2char(n)
+      SCM n;
+ {
+@@ -1587,5 +1591,5 @@
+   return MAKICHR(INUM(n));
+ }
+-SCM char_upcase(chr)
++static SCM char_upcase(chr)
+      SCM chr;
+ {
+@@ -1593,5 +1597,5 @@
+ 	return MAKICHR(upcase[ICHR(chr)]);
+ }
+-SCM char_downcase(chr)
++static SCM char_downcase(chr)
+      SCM chr;
+ {
+@@ -1600,5 +1604,5 @@
+ }
+ 
+-SCM stringp(x)
++static SCM stringp(x)
+      SCM x;
+ {
+@@ -1637,5 +1641,5 @@
+ 	return res;
+ }
+-SCM st_length(str)
++static SCM st_length(str)
+      SCM str;
+ {
+@@ -1643,5 +1647,5 @@
+ 	return MAKINUM(LENGTH(str));
+ }
+-SCM st_ref(str, k)
++static SCM st_ref(str, k)
+      SCM str, k;
+ {
+@@ -1651,5 +1655,5 @@
+ 	return MAKICHR(UCHARS(str)[INUM(k)]);
+ }
+-SCM st_set(str, k, chr)
++static SCM st_set(str, k, chr)
+      SCM str, k, chr;
+ {
+@@ -1675,5 +1679,5 @@
+ 	return BOOL_T;
+ }
+-SCM stci_equal(s1, s2)
++static SCM stci_equal(s1, s2)
+      SCM s1, s2;
+ {
+@@ -1689,5 +1693,5 @@
+ 	return BOOL_T;
+ }
+-SCM st_lessp(s1, s2)
++static SCM st_lessp(s1, s2)
+      SCM s1, s2;
+ {
+@@ -1709,20 +1713,20 @@
+ 	return (LENGTH(s2) != len) ? BOOL_T : BOOL_F;
+ }
+-SCM st_leqp(s1, s2)
++static SCM st_leqp(s1, s2)
+      SCM s1, s2;
+ {
+   return BOOL_NOT(st_lessp(s2, s1));
+ }
+-SCM st_grp(s1, s2)
++static SCM st_grp(s1, s2)
+      SCM s1, s2;
+ {
+   return st_lessp(s2, s1);
+ }
+-SCM st_geqp(s1, s2)
++static SCM st_geqp(s1, s2)
+      SCM s1, s2;
+ {
+   return BOOL_NOT(st_lessp(s1, s2));
+ }
+-SCM stci_lessp(s1, s2)
++static SCM stci_lessp(s1, s2)
+      SCM s1, s2;
+ {
+@@ -1744,15 +1748,15 @@
+ 	return (LENGTH(s2) != len) ? BOOL_T : BOOL_F;
+ }
+-SCM stci_leqp(s1, s2)
++static SCM stci_leqp(s1, s2)
+      SCM s1, s2;
+ {
+   return BOOL_NOT(stci_lessp(s2, s1));
+ }
+-SCM stci_grp(s1, s2)
++static SCM stci_grp(s1, s2)
+      SCM s1, s2;
+ {
+   return stci_lessp(s2, s1);
+ }
+-SCM stci_geqp(s1, s2)
++static SCM stci_geqp(s1, s2)
+      SCM s1, s2;
+ {
+@@ -1796,5 +1800,5 @@
+ }
+ 
+-SCM vectorp(x)
++static SCM vectorp(x)
+      SCM x;
+ {
+@@ -1820,5 +1824,5 @@
+ 	return res;
+ }
+-SCM vector_ref(v, k)
++static SCM vector_ref(v, k)
+      SCM v, k;
+ {
+@@ -1828,5 +1832,5 @@
+   return VELTS(v)[((long) INUM(k))];
+ }
+-SCM vector_set(v, k, obj)
++static SCM vector_set(v, k, obj)
+      SCM v, k, obj;
+ {
+@@ -1837,5 +1841,5 @@
+   return UNSPECIFIED;
+ }
+-char	s_make_vector[] = "make-vector";
++const char	s_make_vector[] = "make-vector";
+ SCM make_vector(k, fill)
+      SCM k, fill;
+@@ -1860,6 +1864,6 @@
+ }
+ #ifdef BIGDIG
+-char s_big_OVFLOW[] = "numerical overflow; NUMDIGS_MAX <";
+-char s_bignum[] = "bignum";
++static const char s_big_OVFLOW[] = "numerical overflow; NUMDIGS_MAX <";
++static const char s_bignum[] = "bignum";
+ SCM mkbig(nlen, sign)
+      sizet nlen;
+@@ -1894,5 +1898,5 @@
+   return b;
+ }
+-char s_adjbig[] = "adjbig";
++static const char s_adjbig[] = "adjbig";
+ SCM adjbig(b, nlen)
+      SCM b;
+@@ -1918,5 +1922,7 @@
+ # endif
+   BIGDIG *zds = BDIGITS(b);
+-  while (nlen-- && !zds[nlen]); nlen++;
++  while (nlen-- && !zds[nlen])
++    ;
++  nlen++;
+   if (nlen * BITSPERDIG/CHAR_BIT <= sizeof(SCM))
+     if (INUMP(b = big2inum(b, (sizet)nlen))) return b;
+@@ -2005,5 +2011,5 @@
+ 
+ SCM addbig(x, nx, xsgn, bigy, sgny)
+-     BIGDIG *x;
++     const BIGDIG *x;
+      SCM bigy;
+      sizet nx;		/* Assumes nx <= NUMDIGS(bigy) */
+@@ -2053,5 +2059,5 @@
+ 
+ SCM mulbig(x, nx, y, ny, sgn)
+-     BIGDIG *x, *y;
++     const BIGDIG *x, *y;
+      sizet nx, ny;
+      int sgn;
+@@ -2075,4 +2081,5 @@
+   return normbig(z);
+ }
++
+ UBIGLONG divbigdig(ds, h, div)
+      BIGDIG *ds;
+@@ -2088,5 +2095,5 @@
+   return t2;
+ }
+-SCM divbigint(x, z, sgn, mode)
++static SCM divbigint(x, z, sgn, mode)
+      SCM x;
+      long z;
+@@ -2115,8 +2122,7 @@
+ }
+ 
+-static SCM scm_copy_big_ash1 P((BIGDIG *xds, sizet xlen, BIGDIG dscl));
+ /* Make a copy of 2*xds and divide by dscl if dscl > 0 */
+-SCM scm_copy_big_ash1 (xds, xlen, dscl)
+-     BIGDIG *xds;
++static SCM scm_copy_big_ash1 (xds, xlen, dscl)
++     const BIGDIG *xds;
+      sizet xlen;
+      BIGDIG dscl;
+@@ -2140,5 +2146,6 @@
+ 
+ SCM divbigbig(x, xlen, y, ylen, sgn, mode)
+-     BIGDIG *x, *y;
++     const BIGDIG *x;
++     BIGDIG *y;
+      sizet xlen, ylen;
+      int sgn, mode;
+--- sys.c	2014-04-24 23:01:53.000000000 -0400
++++ sys.c	2015-01-27 01:32:50.000000000 -0500
+@@ -26,7 +26,6 @@
+ #endif
+ 
+-void	igc P((const char *what, SCM basecont));
+-SCM	*loc_open_file;		/* for open-file callback */
+-SCM	*loc_try_create_file;
++static SCM	*loc_open_file;		/* for open-file callback */
++static SCM	*loc_try_create_file;
+ 
+ /* ttyname() etc. should be defined in <unistd.h>.  But unistd.h is
+@@ -64,15 +63,15 @@
+ static void gc_sweep P((int contin_bad));
+ 
+-char	s_nogrow[] = "could not grow", s_heap[] = "heap",
++const char	s_nogrow[] = "could not grow", s_heap[] = "heap",
+   s_hplims[] = "hplims", s_try_create_file[] = "try-create-file";
+ 
+-static char s_segs[] = "segments", s_numheaps[] = "number of heaps";
+-static char	s_input_portp[] = "input-port?",
++static const char s_segs[] = "segments", s_numheaps[] = "number of heaps";
++static const char	s_input_portp[] = "input-port?",
+ 		s_output_portp[] = "output-port?";
+ #define s_portp (&s_input_portp[6])
+-static char	s_port_closedp[] = "port-closed?";
+-static char	s_try_open_file[] = "try-open-file";
++static const char	s_port_closedp[] = "port-closed?";
++static const char	s_try_open_file[] = "try-open-file";
+ #define	s_open_file (&s_try_open_file[4])
+-char	s_close_port[] = "close-port";
++const char	s_close_port[] = "close-port";
+ 
+ #ifdef __IBMC__
+@@ -127,5 +126,6 @@
+    which are allowed by ANSI C. */
+ long mode_bits(modes, cmodes)
+-     char *modes, *cmodes;
++     const char *modes;
++     char *cmodes;
+ {
+   int iout = 0;
+@@ -150,8 +150,8 @@
+ }
+ 
+-SCM try_open_file(filename, modes)
++static SCM try_open_file(filename, modes)
+      SCM filename, modes;
+ {
+-  register SCM port;
++  SCM port;
+   FILE *f;
+   char cmodes[4];
+@@ -187,5 +187,5 @@
+ }
+ 
+-long tc16_clport;
++static long tc16_clport;
+ SCM close_port(port)
+      SCM port;
+@@ -213,5 +213,5 @@
+ 	return ret;
+ }
+-SCM scm_portp(x)
++static SCM scm_portp(x)
+      SCM x;
+ {
+@@ -219,5 +219,5 @@
+ 	return PORTP(x) ? BOOL_T : BOOL_F;
+ }
+-SCM input_portp(x)
++static SCM input_portp(x)
+      SCM x;
+ {
+@@ -225,5 +225,5 @@
+ 	return INPORTP(x) ? BOOL_T : BOOL_F;
+ }
+-SCM output_portp(x)
++static SCM output_portp(x)
+      SCM x;
+ {
+@@ -231,5 +231,5 @@
+ 	return OUTPORTP(x) ? BOOL_T : BOOL_F;
+ }
+-SCM port_closedp(port)
++static SCM port_closedp(port)
+      SCM port;
+ {
+@@ -238,5 +238,5 @@
+   return BOOL_F;
+ }
+-SCM scm_port_type(port)
++static SCM scm_port_type(port)
+      SCM port;
+ {
+@@ -261,5 +261,5 @@
+ 
+ #ifdef L_tmpnam
+-SCM ltmpnam()
++static SCM ltmpnam()
+ {
+   char name[L_tmpnam];
+@@ -291,7 +291,7 @@
+ # endif /* AMIGA */
+ 
+-char template[] = TEMPTEMPLATE;
++static const char template[] = TEMPTEMPLATE;
+ # define TEMPLEN (sizeof template/sizeof(char) - 1)
+-SCM ltmpnam()
++static SCM ltmpnam()
+ {
+   SCM name;
+@@ -319,6 +319,6 @@
+ # define remove unlink
+ #endif
+-static char s_del_fil[] = "delete-file";
+-SCM del_fil(str)
++static const char s_del_fil[] = "delete-file";
++static SCM del_fil(str)
+      SCM str;
+ {
+@@ -334,5 +334,5 @@
+ 
+ void prinport(exp, port, type)
+-     SCM exp; SCM port; char *type;
++     SCM exp; SCM port; const char *type;
+ {
+   int filn = fileno(STREAM(exp));
+@@ -391,7 +391,7 @@
+   return c;
+ }
+-sizet stwrite(str, siz, num, p)
++static sizet stwrite(str, siz, num, p)
+      sizet siz, num;
+-     char *str; SCM p;
++     const char *str; SCM p;
+ {
+   sizet ind = INUM(CAR(p));
+@@ -406,5 +406,5 @@
+ }
+ static int stputs(s, p)
+-     char *s; SCM p;
++     const char *s; SCM p;
+ {
+   stwrite(s, 1, strlen(s), p);
+@@ -437,5 +437,5 @@
+   return c;
+ }
+-int noop0(stream)
++static int noop0(stream)
+      FILE *stream;
+ {
+@@ -446,5 +446,5 @@
+      SCM str;
+      long modes;
+-     char *caller;
++     const char *caller;
+ {
+   SCM z;
+@@ -460,7 +460,7 @@
+   return z;
+ }
+-static char s_cwos[] = "call-with-output-string";
+-static char s_cwis[] = "call-with-input-string";
+-SCM cwos(proc)
++static const char s_cwos[] = "call-with-output-string";
++static const char s_cwis[] = "call-with-input-string";
++static SCM cwos(proc)
+      SCM proc;
+ {
+@@ -471,5 +471,5 @@
+   return resizuve(CDR(CDR(p)), CAR(CDR(p)));
+ }
+-SCM cwis(str, proc)
++static SCM cwis(str, proc)
+      SCM str, proc;
+ {
+@@ -557,5 +557,5 @@
+   return c;
+ }
+-sizet sfwrite(str, siz, num, p)
++static sizet sfwrite(str, siz, num, p)
+      sizet siz, num;
+      const void *str; SCM p;
+@@ -573,5 +573,5 @@
+   return 0;
+ }
+-int sfflush(stream)
++static int sfflush(stream)
+      SCM stream;
+ {
+@@ -601,6 +601,6 @@
+   return BOOL_F==f ? EOF : 0;
+ }
+-static char s_mksfpt[] = "make-soft-port";
+-SCM mksfpt(pv, modes)
++static const char s_mksfpt[] = "make-soft-port";
++static SCM mksfpt(pv, modes)
+      SCM pv, modes;
+ {
+@@ -614,10 +614,10 @@
+   for (i = 0; i < 5; i++) {
+     ASRTGO(FALSEP(VELTS(pv)[i]) ||
+-	   scm_arity_check(VELTS(pv)[i], arities[i], (char *)0),
++	   scm_arity_check(VELTS(pv)[i], arities[i], NULL),
+ 	   badarg);
+   }
+ #endif
+   ASRTER(NIMP(modes) && (STRINGP(modes) || SYMBOLP(modes)), modes, ARG2, s_mksfpt);
+-  flags = mode_bits(CHARS(modes), (char *)0);
++  flags = mode_bits(CHARS(modes), NULL);
+   ASRTER(flags, modes, ARG2, s_mksfpt);
+   DEFER_INTS;
+@@ -649,5 +649,5 @@
+ static sizet clwrite(str, siz, num, p)
+      sizet siz, num;
+-     char *str; FILE *p;
++     const void *str; FILE *p;
+ {
+   return 0;
+@@ -689,5 +689,5 @@
+ static sizet syswrite(str, siz, num, p)
+      sizet siz, num;
+-     char *str; FILE *p;
++     const char *str; FILE *p;
+ {
+   sizet src, dst = errbuf_end;
+@@ -757,5 +757,5 @@
+    A setjmp must be done before each use of the safeport. */
+ 
+-static char s_msp[] = "mksafeport";
++static const char s_msp[] = "mksafeport";
+ int tc16_safeport;
+ SCM mksafeport(maxlen, port)
+@@ -895,5 +895,5 @@
+ 
+ scm_gra finals_gra;
+-static char s_final[] = "final";
++static const char s_final[] = "final";
+ 
+ /* statically allocated ports for diagnostic messages */
+@@ -948,5 +948,5 @@
+ 
+ static SCM gc_finalizers = EOL, gc_finalizers_pending = EOL;
+-static char s_add_finalizer[] = "add-finalizer";
++static const char s_add_finalizer[] = "add-finalizer";
+ SCM scm_add_finalizer(value, finalizer)
+      SCM value, finalizer;
+@@ -965,5 +965,5 @@
+ }
+ 
+-static char s_estk[] = "environment stack";
++static const char s_estk[] = "environment stack";
+ static cell ecache_v[ECACHE_SIZE];
+ SCM scm_egc_roots[ECACHE_SIZE/20];
+@@ -1063,6 +1063,6 @@
+      SCM x, y;
+ {
+-   register SCM z;
+-   register int i;
++   SCM z;
++   int i;
+    DEFER_INTS_EGC;
+    i = scm_ecache_index;
+@@ -1082,5 +1082,5 @@
+ {
+    SCM z1, z2;
+-   register int i;
++   int i;
+    DEFER_INTS_EGC;
+    i = scm_ecache_index;
+@@ -1103,5 +1103,5 @@
+ {
+    SCM z1, z2;
+-   register int i;
++   int i;
+    DEFER_INTS_EGC;
+    i = scm_ecache_index;
+@@ -1128,5 +1128,5 @@
+ {
+    SCM z1, z2;
+-   register int i;
++   int i;
+    DEFER_INTS_EGC;
+    i = scm_ecache_index;
+@@ -1150,5 +1150,5 @@
+ {
+    SCM z;
+-   register int i;
++   int i;
+    DEFER_INTS_EGC;
+    i = scm_ecache_index;
+@@ -1163,9 +1163,11 @@
+    scm_ecache_index = i;
+ }
++
++#if 0
+ void old_scm_extend_env(names)
+      SCM names;
+ {
+    SCM z1, z2;
+-   register int i;
++   int i;
+    DEFER_INTS_EGC;
+    i = scm_ecache_index;
+@@ -1183,6 +1185,8 @@
+    scm_ecache_index = i;
+ }
+-char s_obunhash[] = "object-unhash", s_cache_gc[] = "cache_gc";
+-char s_recursive[] = "recursive";
++#endif
++
++const char s_obunhash[] = "object-unhash";
++static const char s_recursive[] = "recursive", s_cache_gc[] = "cache_gc";
+ #define s_gc (s_cache_gc+6)
+ static iproc subr0s[] = {
+@@ -1212,5 +1216,5 @@
+ 	{0, 0}};
+ 
+-SCM dynwind P((SCM thunk1, SCM thunk2, SCM thunk3));
++static SCM dynwind P((SCM thunk1, SCM thunk2, SCM thunk3));
+ void init_io()
+ {
+@@ -1232,5 +1236,5 @@
+ }
+ 
+-void grew_lim(nm)
++static void grew_lim(nm)
+      long nm;
+ {
+@@ -1263,6 +1267,6 @@
+     else grew_lim(mtrigger + mtrigger/2);
+   }
+-  if (where) SYSCALL(ptr = (char *)realloc(where, size););
+-  else SYSCALL(ptr = (char *)malloc(size););
++  if (where) SYSCALL(ptr = realloc(where, size););
++  else SYSCALL(ptr = malloc(size););
+   ASRTER(ptr, MAKINUM(size), NALLOC, what);
+   if (nm > mltrigger) {
+@@ -1395,14 +1399,15 @@
+   }
+   wta(sym, "uninterned symbol? ", "");
++  return -1;
+ }
+ /* intern() and sysintern() return a pair;
+    CAR is the symbol, CDR is the value. */
+ SCM intern(name, len)
+-     char *name;
++     const char *name;
+      sizet len;
+ {
+   SCM lsym, z;
+-  register sizet i = len;
+-  register unsigned char *tmp = (unsigned char *)name;
++  sizet i = len;
++  const unsigned char *tmp = (const unsigned char *)name;
+   sizet hash = strhash(tmp, i, (unsigned long)symhash_dim);
+   /* printf("intern %s len=%d\n",name,len); fflush(stdout); */
+@@ -1413,5 +1418,5 @@
+     tmp = UCHARS(z);
+     if (LENGTH(z) != len) goto trynext;
+-    for (i = len;i--;) if (((unsigned char *)name)[i] != tmp[i]) goto trynext;
++    for (i = len;i--;) if (((const unsigned char *)name)[i] != tmp[i]) goto trynext;
+     ALLOW_INTS;
+     return CAR(lsym);
+@@ -1436,6 +1441,6 @@
+   SCM lsym, z;
+   sizet len = strlen(name);
+-  register sizet i = len;
+-  register unsigned char *tmp = (unsigned char *)name;
++  sizet i = len;
++  const unsigned char *tmp = (const unsigned char *)name;
+   sizet hash = strhash(tmp, i, (unsigned long)symhash_dim);
+   for (lsym = VELTS(symhash)[hash];NIMP(lsym);lsym = CDR(lsym)) {
+@@ -1444,5 +1449,5 @@
+     tmp = UCHARS(z);
+     if (LENGTH(z) != len) goto trynext;
+-    for (i = len;i--;) if (((unsigned char *)name)[i] != tmp[i]) goto trynext;
++    for (i = len;i--;) if (((const unsigned char *)name)[i] != tmp[i]) goto trynext;
+     lsym = CAR(lsym);
+     if (!UNBNDP(val)) CDR(lsym) = val;
+@@ -1464,5 +1469,5 @@
+      SCM x, y;
+ {
+-	register SCM z;
++	SCM z;
+ 	NEWCELL(z);
+ 	CAR(z) = x;
+@@ -1473,5 +1478,5 @@
+      SCM w, x, y;
+ {
+-	register SCM z;
++	SCM z;
+ 	NEWCELL(z);
+ 	CAR(z) = x;
+@@ -1486,5 +1491,5 @@
+      SCM w, x, y;
+ {
+-	register SCM z;
++	SCM z;
+ 	NEWCELL(z);
+ 	CAR(z) = w;
+@@ -1511,5 +1516,5 @@
+ }
+ 
+-char s_redefining[] = "redefining ";
++const char s_redefining[] = "redefining ";
+ scm_gra subrs_gra;
+ SCM scm_maksubr(name, type, fcn)
+@@ -1520,9 +1525,9 @@
+ 	subr_info info;
+ 	int isubr;
+-	register SCM z;
++	SCM z;
+ 	info.name = name;
+ 	for (isubr = subrs_gra.len; 0 < isubr--;) {
+ 	  if (0==strcmp(((char **)subrs_gra.elts)[isubr], name)) {
+-	    scm_warn(s_redefining, (char *)name, UNDEFINED);
++	    scm_warn(s_redefining, name, UNDEFINED);
+ 	    goto foundit;
+ 	  }
+@@ -1536,5 +1541,5 @@
+ 	  while (*++p != 'r')
+ 	    switch (*p) {
+-	    default: wta(UNDEFINED, "bad cxr name", (char *)name);
++	    default: wta(UNDEFINED, "bad cxr name", name);
+ 	    case 'a': code = (code<<2) + 1; continue;
+ 	    case 'd': code = (code<<2) + 2; continue;
+@@ -1555,5 +1560,5 @@
+ 
+ #ifdef CCLO
+-char s_comp_clo[] = "compiled-closure";
++static const char s_comp_clo[] = "compiled-closure";
+ SCM makcclo(proc, len)
+      SCM proc;
+@@ -1601,5 +1606,5 @@
+ }
+ 
+-SCM dynwind(thunk1, thunk2, thunk3)
++static SCM dynwind(thunk1, thunk2, thunk3)
+      SCM thunk1, thunk2, thunk3;
+ {
+@@ -1612,5 +1617,5 @@
+   return ans;
+ }
+-void downd(to, delta)
++static void downd(to, delta)
+      SCM to;
+      long delta;
+@@ -1640,11 +1645,12 @@
+ SCM scm_make_cont()
+ {
+-  SCM cont, estk, *from;
++  SCM cont, estk;
+   CONTINUATION *ncont;
+-  sizet n;
++#ifndef CHEAP_CONTINUATIONS
++  SCM *from = VELTS(scm_estk);
++  sizet n = scm_estk_ptr - from + SCM_ESTK_FRLEN;
++#endif
+   VERIFY_INTS("scm_make_cont", 0L);
+   NEWCELL(cont);
+-  from = VELTS(scm_estk);
+-  n = scm_estk_ptr - from + SCM_ESTK_FRLEN;
+ #ifdef CHEAP_CONTINUATIONS
+   estk = scm_estk;
+@@ -1678,5 +1684,5 @@
+   return cont;
+ }
+-static char s_sstale[] = "strangely stale";
++static const char s_sstale[] = "strangely stale";
+ void scm_dynthrow(tocont, arg1, arg2, rest)
+      SCM tocont;
+@@ -1758,6 +1764,6 @@
+        scm_cell_p() in "rope.c", which means that changes to these
+        routines must be coordinated. */
+-    register CELLPTR ptr = (CELLPTR)SCM2PTR(obj);
+-    register sizet i = 0, j = hplim_ind;
++    CELLPTR ptr = (CELLPTR)SCM2PTR(obj);
++    sizet i = 0, j = hplim_ind;
+     do {
+       if (PTR_GT(hplims[i++], ptr)) break;
+@@ -1774,5 +1780,5 @@
+ 
+ unsigned long strhash(str, len, n)
+-     unsigned char *str;
++     const unsigned char *str;
+      sizet len;
+      unsigned long n;
+@@ -1794,5 +1800,5 @@
+ 
+ static void fixconfig(s1, s2, s)
+-     char *s1, *s2;
++     const char *s1, *s2;
+      int s;
+ {
+@@ -1823,11 +1829,11 @@
+     }}
+ }
+-sizet init_heap_seg(seg_org, size)
++static sizet init_heap_seg(seg_org, size)
+      CELLPTR seg_org;
+      sizet size;
+ {
+-  register CELLPTR ptr = seg_org;
++  CELLPTR ptr = seg_org;
+ #ifdef POINTERS_MUNGED
+-  register SCM scmptr;
++  SCM scmptr;
+ #else
+ # define scmptr ptr
+@@ -1918,5 +1924,5 @@
+ int scm_grow_gra(gra, elt)
+      scm_gra *gra;
+-     char *elt;
++     const char *elt;
+ {
+   int i;
+@@ -1964,6 +1970,6 @@
+   mallocated -= gra->maxlen*gra->eltsize;
+ }
+-void gra_report1(gra)
+-     scm_gra *gra;
++static void gra_report1(gra)
++     const scm_gra *gra;
+ {
+   scm_intprint((long)gra->len, -10, cur_errp);
+@@ -1986,17 +1992,17 @@
+ scm_gra smobs_gra;
+ long newsmob(smob)
+-     smobfuns *smob;
++     const smobfuns *smob;
+ {
+-  return tc7_smob + 256*scm_grow_gra(&smobs_gra, (char *)smob);
++  return tc7_smob + 256*scm_grow_gra(&smobs_gra, (const char *)smob);
+ }
+ scm_gra ptobs_gra;
+ long newptob(ptob)
+-     ptobfuns *ptob;
++     const ptobfuns *ptob;
+ {
+-  return tc7_port + 256*scm_grow_gra(&ptobs_gra, (char *)ptob);
++  return tc7_port + 256*scm_grow_gra(&ptobs_gra, (const char *)ptob);
+ }
+-port_info *scm_port_table = 0;
++port_info *scm_port_table = NULL;
+ static sizet scm_port_table_len = 0;
+-static char s_port_table[] = "port table";
++static const char s_port_table[] = "port table";
+ SCM scm_port_entry(stream, ptype, flags)
+      FILE *stream;
+@@ -2073,5 +2079,5 @@
+ }
+ 
+-static char remsg[] = "remove\n#define ", addmsg[] = "add\n#define ",
++static const char remsg[] = "remove\n#define ", addmsg[] = "add\n#define ",
+   rdmsg[] = "reduce";
+ void init_storage(stack_start_ptr, init_heap_size)
+@@ -2249,5 +2255,5 @@
+ Cambridge, MA 02138
+ */
+-char s_cells[] = "cells";
++static const char s_cells[] = "cells";
+ SCM gc_for_newcell()
+ {
+@@ -2285,6 +2291,5 @@
+ }
+ 
+-static char	s_bad_type[] = "unknown type in ";
+-void mark_locations P((STACKITEM x[], sizet n));
++static const char	s_bad_type[] = "unknown type in ";
+ static void mark_syms P((SCM v));
+ static void mark_sym_values P((SCM v));
+@@ -2357,5 +2363,5 @@
+   int j = num_protects;
+   long oheap_cells = heap_cells;
+-  STACKITEM * stackbase = IMP(basecont) ? 0 : CONT(basecont)->stkbse;
++  STACKITEM * stackbase = IMP(basecont) ? NULL : CONT(basecont)->stkbse;
+ #ifdef DEBUG_GMALLOC
+   int err = check_frag_blocks();
+@@ -2419,5 +2425,5 @@
+   egc_sweep();
+   estk_pool = EOL;
+-  errjmp_bad = (char *)0;
++  errjmp_bad = NULL;
+   gc_end();
+   if (oheap_cells != heap_cells) {
+@@ -2430,5 +2436,5 @@
+ }
+ 
+-static char s_not_free[] = "not freed";
++static const char s_not_free[] = "not freed";
+ void free_storage()
+ {
+@@ -2488,10 +2494,10 @@
+ }
+ 
+-static char s_gc_sym[] = "mark_syms", s_wrong_length[] = "wrong length";
++static const char s_gc_sym[] = "mark_syms", s_wrong_length[] = "wrong length";
+ void gc_mark(p)
+      SCM p;
+ {
+-  register long i;
+-  register SCM ptr = p;
++  long i;
++  SCM ptr = p;
+   CHECK_STACK;
+  gc_mark_loop:
+@@ -2619,15 +2625,19 @@
+    code is duplicated by obunhash() in "sys.c" and scm_cell_p() in
+    "rope.c", which means that changes to these routines must be
+-   coordinated. */
++   coordinated.
++   XXX Actually, the old code ran from x[-1:n-1] (down)... It now runs
++   XXX up from 0 to n-1, as seems to be correct. Is it?
++*/
+ 
+ void mark_locations(x, n)
+-     STACKITEM x[];
++     const STACKITEM x[];
+      sizet n;
+ {
+-	register long m = n;
+-	register int i, j;
+-	register CELLPTR ptr;
+-	while(0 <= --m) if (CELLP(*(SCM **)&x[m])) {
+-		ptr = (CELLPTR)SCM2PTR((SCM)(*(SCM **)&x[m]));
++	int i, j;
++	CELLPTR ptr;
++	for (; n; x++, n--) {
++		if (NCELLP(*x))
++			continue;
++		ptr = (CELLPTR)SCM2PTR((SCM)(*x));
+ 		i = 0;
+ 		j = hplim_ind;
+@@ -2638,5 +2648,5 @@
+ 			    && PTR_LE(hplims[i++], ptr)
+ 			    && PTR_GT(hplims[--j], ptr)) continue;
+-			/* if (NFREEP(*(SCM **)&x[m])) */ gc_mark(*(SCM *)&x[m]);
++			gc_mark(*x);
+ 			break;
+ 		} while(i<j);
+@@ -2647,13 +2657,13 @@
+      int contin_bad;
+ {
+-  register CELLPTR ptr;
++  CELLPTR ptr;
+ #ifdef POINTERS_MUNGED
+-  register SCM scmptr;
++  SCM scmptr;
+ #else
+ # define scmptr (SCM)ptr
+ #endif
+-  register SCM nfreelist = EOL;
+-  register long n = 0;
+-  register sizet j, minc;
++  SCM nfreelist = EOL;
++  long n = 0;
++  sizet j, minc;
+   long pre_m = mallocated;
+   sizet i = 0;
+@@ -3087,5 +3097,5 @@
+   }
+ }
+-extern long tc16_env, tc16_promise;
++
+ static void egc_copy_roots()
+ {
+@@ -3192,4 +3202,4 @@
+     scm_egc_end();
+   }
+-  errjmp_bad = (char *)0;
++  errjmp_bad = NULL;
+ }
+--- time.c	2014-02-08 19:38:23.000000000 -0500
++++ time.c	2015-01-23 18:55:19.000000000 -0500
+@@ -94,5 +94,4 @@
+ # include <sys/types.h>
+ # include <sys/time.h>
+-# include <sys/timeb.h>
+ # define USE_GETTIMEOFDAY
+ #endif
+@@ -169,10 +168,6 @@
+ #endif
+ 
+-#ifndef LACK_FTIME
+-# ifdef HAVE_UNIX
+-#  ifndef GO32
++#if !defined(LACK_FTIME) && defined(HAVE_UNIX) && !defined(GO32) && !defined(USE_GETTIMEOFDAY)
+ #   include <sys/timeb.h>
+-#  endif
+-# endif
+ #endif
+ 
+@@ -307,5 +302,5 @@
+ #else /* LACK_FTIME */
+ # ifdef USE_GETTIMEOFDAY
+-int scm_ftime(time_buffer)
++static int scm_ftime(time_buffer)
+      struct timeval *time_buffer;
+ {
+@@ -377,5 +372,5 @@
+ }
+ 
+-SCM curtime()
++static SCM curtime()
+ {
+   timet timv = time((timet*)0);
+--- unexec.c	2008-01-30 22:44:09.000000000 -0500
++++ unexec.c	2015-01-23 18:55:19.000000000 -0500
+@@ -371,5 +371,5 @@
+  */
+ unexec (new_name, a_name, data_start, bss_start, entry_address)
+-     char *new_name, *a_name;
++     const char *new_name, *a_name;
+      unsigned data_start, bss_start, entry_address;
+ {
+@@ -417,6 +417,6 @@
+      int new, a_out;
+      unsigned data_start, bss_start, entry_address;
+-     char *a_name;
+-     char *new_name;
++     const char *a_name;
++     const char *new_name;
+ {
+   int tem;
+--- unexelf.c	2008-01-30 22:44:11.000000000 -0500
++++ unexelf.c	2015-01-23 18:55:19.000000000 -0500
+@@ -403,7 +403,10 @@
+    Instead we read the whole file, modify it, and write it out.  */
+ 
++#include "scm.h"
++
+ #ifndef emacs
+-#define fatal(a, b, c) fprintf (stderr, a, b, c), exit (1)
++#define fatal(...) fprintf (stderr, __VA_ARGS__), exit (1)
+ #include <string.h>
++#include <stdlib.h>	/* Where exit(3) is declared */
+ #else
+ #include <config.h>
+@@ -608,7 +611,7 @@
+ static int
+ find_section (name, section_names, file_name, old_file_h, old_section_h, noerror)
+-     char *name;
+-     char *section_names;
+-     char *file_name;
++     const char *name;
++     const char *section_names;
++     const char *file_name;
+      ElfW(Ehdr) *old_file_h;
+      ElfW(Shdr) *old_section_h;
+@@ -649,5 +652,5 @@
+ void
+ unexec (new_name, old_name, data_start, bss_start, entry_address)
+-     char *new_name, *old_name;
++     const char *new_name, *old_name;
+      unsigned data_start, bss_start, entry_address;
+ {
+@@ -680,5 +683,7 @@
+   int old_bss_index, old_sbss_index;
+   int old_data_index, new_data2_index;
++#if defined (__sony_news) && defined (_SYSTYPE_SYSV) || defined(__sgi)
+   int old_mdebug_index;
++#endif
+   struct stat stat_buf;
+   int old_file_size;
+@@ -709,8 +714,8 @@
+ 		   MAP_ANON | MAP_PRIVATE, mmap_fd, 0);
+   if (old_base == MAP_FAILED)
+-    fatal ("Can't allocate buffer for %s\n", old_name, 0);
++    fatal("Can't allocate buffer for %s\n", old_name);
+ 
+   if (read (old_file, old_base, stat_buf.st_size) != stat_buf.st_size)
+-    fatal ("Didn't read all of %s: errno %d\n", old_name, errno);
++    fatal("Didn't read all of %s: errno %d\n", old_name, errno);
+ 
+   /* Get pointers to headers & section names */
+@@ -724,6 +729,8 @@
+   /* Find the mdebug section, if any.  */
+ 
++#if defined (__sony_news) && defined (_SYSTYPE_SYSV) || defined(__sgi)
+   old_mdebug_index = find_section (".mdebug", old_section_names,
+ 				   old_name, old_file_h, old_section_h, 1);
++#endif
+ 
+   /* Find the old .bss section.  Figure out parameters of the new
+@@ -780,5 +787,5 @@
+ 
+   if ((unsigned) new_bss_addr < (unsigned) old_bss_addr + old_bss_size)
+-    fatal (".bss shrank when undumping???\n", 0, 0);
++    fatal (".bss shrank when undumping???\n");
+ 
+   /* Set the output file to the right size.  Allocate a buffer to hold
+@@ -798,5 +805,5 @@
+ 		   MAP_ANON | MAP_PRIVATE, mmap_fd, 0);
+   if (new_base == MAP_FAILED)
+-    fatal ("Can't allocate buffer for %s\n", old_name, 0);
++    fatal ("Can't allocate buffer for %s\n", old_name);
+ 
+   new_file_h = (ElfW(Ehdr) *) new_base;
+@@ -853,5 +860,5 @@
+ 	     ? old_bss_addr
+ 	     : round_up (old_bss_addr, alignment)))
+-	  fatal ("Program segment above .bss in %s\n", old_name, 0);
++	  fatal ("Program segment above .bss in %s\n", old_name);
+ 
+       if (NEW_PROGRAM_H (n).p_type == PT_LOAD
+@@ -863,5 +870,5 @@
+     }
+   if (n < 0)
+-    fatal ("Couldn't find segment next to .bss in %s\n", old_name, 0);
++    fatal ("Couldn't find segment next to .bss in %s\n", old_name);
+ 
+   /* Make sure that the size includes any padding before the old .bss
+@@ -893,5 +900,5 @@
+       break;
+   if (old_data_index == old_file_h->e_shnum)
+-    fatal ("Can't find .data in %s.\n", old_name, 0);
++    fatal ("Can't find .data in %s.\n", old_name);
+ 
+   /* Walk through all section headers, insert the new data2 section right
+--- unif.c	2010-10-17 22:44:29.000000000 -0400
++++ unif.c	2015-01-27 00:55:00.000000000 -0500
+@@ -114,6 +114,5 @@
+ # ifdef FLOATS
+ #  ifdef SINGLES
+-SCM makflo (x)
+-     float x;
++SCM makflo (float x)
+ {
+   SCM z;
+@@ -254,5 +253,5 @@
+   }
+ }
+-static char s_array_dims[] = "array-dimensions";
++static const char s_array_dims[] = "array-dimensions";
+ SCM array_dims(ra)
+      SCM ra;
+@@ -278,5 +277,5 @@
+   }
+ }
+-static char s_bad_ind[] = "Bad array index";
++static const char s_bad_ind[] = "Bad array index";
+ long aind(ra, args, what)
+      SCM ra, args;
+@@ -323,7 +322,7 @@
+ }
+ 
+-static char s_bad_spec[] = "Bad array dimension";
++static const char s_bad_spec[] = "Bad array dimension";
+ /* Increments will still need to be set. */
+-SCM shap2ra(args, what)
++static SCM shap2ra(args, what)
+      SCM args;
+      const char *what;
+@@ -358,5 +357,5 @@
+ }
+ 
+-char s_array_fill[] = "array-fill!";
++const char s_array_fill[] = "array-fill!";
+ int rafill(ra, fill, ignore)
+      SCM ra, fill, ignore;
+@@ -487,5 +486,5 @@
+ }
+ 
+-static char s_dims2ura[] = "dimensions->uniform-array";
++static const char s_dims2ura[] = "dimensions->uniform-array";
+ SCM dims2ura(dims, prot, fill)
+      SCM dims, prot, fill;
+@@ -545,5 +544,5 @@
+ }
+ 
+-void ra_set_contp(ra)
++static void ra_set_contp(ra)
+      SCM ra;
+ {
+@@ -560,6 +559,7 @@
+   CAR(ra) |= ARRAY_CONTIGUOUS;
+ }
+-char s_make_sh_array[] = "make-shared-array";
+-SCM make_sh_array(oldra, mapfunc, dims)
++static const char s_make_sh_array[] = "make-shared-array";
++#define s_array (s_make_sh_array+12)
++static SCM make_sh_array(oldra, mapfunc, dims)
+      SCM oldra;
+      SCM mapfunc;
+@@ -660,6 +660,6 @@
+ 
+ /* args are RA . DIMS */
+-static char s_trans_array[] = "transpose-array";
+-SCM trans_array(args)
++static const char s_trans_array[] = "transpose-array";
++static SCM trans_array(args)
+      SCM args;
+ {
+@@ -723,6 +723,6 @@
+ 
+ /* args are RA . AXES */
+-static char s_encl_array[] = "enclose-array";
+-SCM encl_array(axes)
++static const char s_encl_array[] = "enclose-array";
++static SCM encl_array(axes)
+      SCM axes;
+ {
+@@ -781,6 +781,6 @@
+ }
+ 
+-static char s_array_inbp[] = "array-in-bounds?";
+-SCM array_inbp(args)
++static const char s_array_inbp[] = "array-in-bounds?";
++static SCM array_inbp(args)
+   SCM args;
+ {
+@@ -823,5 +823,5 @@
+   }
+ }
+-static char s_aref[] = "array-ref";
++static const char s_aref[] = "array-ref";
+ SCM aref(v, args)
+      SCM v, args;
+@@ -1026,5 +1026,5 @@
+ }
+ 
+-static char s_aset[] = "array-set!";
++static const char s_aset[] = "array-set!";
+ SCM aset(v, obj, args)
+      SCM v, obj, args;
+@@ -1115,5 +1115,5 @@
+ }
+ 
+-static char s_array_contents[] = "array-contents";
++static const char s_array_contents[] = "array-contents";
+ SCM array_contents(ra, strict)
+      SCM ra, strict;
+@@ -1152,5 +1152,5 @@
+ }
+ 
+-static char s_uve_rd[] = "uniform-vector-read!";
++static const char s_uve_rd[] = "uniform-vector-read!";
+ SCM uve_read(v, port)
+      SCM v, port;
+@@ -1225,5 +1225,5 @@
+ }
+ 
+-static char s_uve_wr[] = "uniform-vector-write";
++static const char s_uve_wr[] = "uniform-vector-write";
+ SCM uve_write(v, port)
+      SCM v, port;
+@@ -1288,7 +1288,7 @@
+ }
+ 
+-static char cnt_tab[16] = {0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
+-static char s_count[] = "bit-count";
+-SCM lcount(item, seq)
++static const char cnt_tab[16] = {0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
++static const char s_count[] = "bit-count";
++static SCM lcount(item, seq)
+      SCM item, seq;
+ {
+@@ -1349,6 +1349,6 @@
+   }
+ }
+-static char s_uve_pos[] = "bit-position";
+-SCM bit_position(item, v, k)
++static const char s_uve_pos[] = "bit-position";
++static SCM bit_position(item, v, k)
+      SCM item, v, k;
+ {
+@@ -1418,6 +1418,6 @@
+ }
+ 
+-static char s_bit_set[] = "bit-set*!";
+-SCM bit_set(v, kv, obj)
++static const char s_bit_set[] = "bit-set*!";
++static SCM bit_set(v, kv, obj)
+      SCM v, kv, obj;
+ {
+@@ -1460,6 +1460,6 @@
+ }
+ 
+-static char s_bit_count[] = "bit-count*";
+-SCM bit_count(v, kv, obj)
++static const char s_bit_count[] = "bit-count*";
++static SCM bit_count(v, kv, obj)
+      SCM v, kv, obj;
+ {
+@@ -1506,6 +1506,6 @@
+ }
+ 
+-static char s_bit_inv[] = "bit-invert!";
+-SCM bit_inv(v)
++static const char s_bit_inv[] = "bit-invert!";
++static SCM bit_inv(v)
+      SCM v;
+ {
+@@ -1523,6 +1523,6 @@
+ }
+ 
+-static char s_strup[] = "string-upcase!";
+-SCM strup(v)
++static const char s_strup[] = "string-upcase!";
++static SCM strup(v)
+      SCM v;
+ {
+@@ -1541,6 +1541,6 @@
+ }
+ 
+-static char s_strdown[] = "string-downcase!";
+-SCM strdown(v)
++static const char s_strdown[] = "string-downcase!";
++static SCM strdown(v)
+      SCM v;
+ {
+@@ -1560,6 +1560,6 @@
+ 
+ # include <ctype.h>
+-static char s_strcap[] = "string-capitalize!";
+-SCM strcap(v)
++static const char s_strcap[] = "string-capitalize!";
++static SCM strcap(v)
+      SCM v;
+ {
+@@ -1588,5 +1588,5 @@
+ 
+ SCM istr2bve(str, len)
+-     char *str;
++     const char *str;
+      long len;
+ {
+@@ -1634,6 +1634,6 @@
+ }
+ 
+-static char s_array2list[] = "array->list";
+-SCM array2list(v)
++static const char s_array2list[] = "array->list";
++static SCM array2list(v)
+      SCM v;
+ {
+@@ -1716,6 +1716,6 @@
+ 
+ static int l2ra P((SCM lst, SCM ra, sizet base, sizet k));
+-static char s_bad_ralst[] = "Bad array contents list";
+-static char s_list2ura[] = "list->uniform-array";
++static const char s_bad_ralst[] = "Bad array contents list";
++static const char s_list2ura[] = "list->uniform-array";
+ SCM list2ura(ndim, prot, lst)
+      SCM ndim;
+@@ -1729,8 +1729,10 @@
+   int k = INUM(ndim);
+   ASRTER(INUMP(ndim) && k >= 0, ndim, ARG1, s_list2ura);
+-  for (; --k >= 0 ; (NIMP(row) && (row = CAR(row)))) {
++  while (--k >= 0) {
+     n = ilength(row);
+     ASRTER(n>=0, lst, ARG3, s_list2ura);
+     shp = cons(MAKINUM(n), shp);
++    if (NIMP(row))
++      row = CAR(row);
+   }
+   ra = dims2ura(reverse(shp), prot, EOL);
+@@ -1978,5 +1980,5 @@
+ }
+ 
+-static char s_array_prot[] = "array-prototype";
++static const char s_array_prot[] = "array-prototype";
+ SCM array_prot(ra)
+      SCM ra;
+@@ -2015,6 +2017,6 @@
+    position in an integer element.
+ */
+-static char s_logaref[] = "logaref";
+-SCM scm_logaref(args)
++static const char s_logaref[] = "logaref";
++static SCM scm_logaref(args)
+      SCM args;
+ {
+@@ -2051,6 +2053,6 @@
+ }
+ 
+-static char s_logaset[] = "logaset!";
+-SCM scm_logaset(ra, obj, args)
++static const char s_logaset[] = "logaset!";
++static SCM scm_logaset(ra, obj, args)
+      SCM ra, obj, args;
+ {
+@@ -2175,5 +2177,5 @@
+ 
+ SCM istr2bve(str, len)
+-     char *str;
++     const char *str;
+      long len;
+ {
+@@ -2181,10 +2183,4 @@
+ }
+ 
+-SCM array_equal(ra0, ra1)
+-     SCM ra0, ra1;
+-{
+-  return BOOL_F;
+-}
+-
+ void init_unif()
+ {
+--- unix.c	2008-01-30 22:33:13.000000000 -0500
++++ unix.c	2015-01-23 18:55:19.000000000 -0500
+@@ -26,13 +26,11 @@
+ #include <sys/stat.h>
+ 
+-extern SCM stat2scm P((struct stat *stat_temp));
+-
+-SCM scm_mknod P((SCM path, SCM mode, SCM dev));
+-SCM scm_acct P((SCM path));
+-SCM scm_nice P((SCM incr));
+-SCM scm_sync P((void));
+-SCM scm_symlink P((SCM oldpath, SCM newpath));
+-SCM scm_readlink P((SCM path));
+-SCM scm_lstat P((SCM str));
++static SCM scm_mknod P((SCM path, SCM mode, SCM dev));
++static SCM scm_acct P((SCM path));
++static SCM scm_nice P((SCM incr));
++static SCM scm_sync P((void));
++static SCM scm_symlink P((SCM oldpath, SCM newpath));
++static SCM scm_readlink P((SCM path));
++static SCM scm_lstat P((SCM str));
+ 
+ #ifndef STDC_HEADERS
+--- x.c	2013-03-12 23:30:26.000000000 -0400
++++ x.c	2015-01-23 18:55:19.000000000 -0500
+@@ -335,5 +335,5 @@
+   xcm->dpy = DISPLAY(xcm->display)->dpy;
+   xcm->cm = cmp;
+-  XSaveContext(XDISPLAY(sdpy), (XID)cmp, xtc_cmp, z);
++  XSaveContext(XDISPLAY(sdpy), (XID)cmp, xtc_cmp, (char *)(intptr_t)z);
+   ALLOW_INTS;
+   return z;
+@@ -583,5 +583,5 @@
+     CAR(s_ccc) = tc16_xccc;
+     SETCDR(s_ccc, ccc);
+-    XSaveContext(ccc->dpy, (XID)ccc, xtc_ccc, s_ccc);
++    XSaveContext(ccc->dpy, (XID)ccc, xtc_ccc, (char *)(intptr_t)s_ccc);
+     ALLOW_INTS;
+   }
+@@ -630,5 +630,5 @@
+      SCM dat;
+      XPoint *ipr;
+-     char *pos, *s_caller;
++     const char *pos, *s_caller;
+ {
+   SCM x, y;
+@@ -710,5 +710,5 @@
+ int scm2xpointslen(sara, s_caller)
+      SCM sara;
+-     char *s_caller;
++     const char *s_caller;
+ {
+   array_dim *adm;
+@@ -728,5 +728,5 @@
+      SCM optidx;
+      struct display_screen *dspscn;
+-     char *s_caller;
++     const char *s_caller;
+ {
+   ASRTGO(NIMP(dat), badarg);
+@@ -762,5 +762,5 @@
+ Pixmap thepxmap(obj, s_caller)
+      SCM obj;
+-     char *s_caller;
++     const char *s_caller;
+ {
+   if (FALSEP(obj) || (INUM0==obj)) return 0L;
+@@ -771,5 +771,5 @@
+ Font thefont(obj, s_caller)
+      SCM obj;
+-     char *s_caller;
++     const char *s_caller;
+ {
+   ASRTER(NIMP(obj) && FONTP(obj), obj, ARGn, s_caller);
+@@ -778,5 +778,5 @@
+ Colormap thecmap(obj, s_caller)
+      SCM obj;
+-     char *s_caller;
++     const char *s_caller;
+ {
+   if (FALSEP(obj) || (INUM0==obj)) return 0L;
+@@ -786,5 +786,5 @@
+ Cursor thecsr(obj, s_caller)
+      SCM obj;
+-     char *s_caller;
++     const char *s_caller;
+ {
+   if (FALSEP(obj) || (INUM0==obj)) return 0L;
+@@ -794,5 +794,5 @@
+ Bool thebool(obj, s_caller)
+      SCM obj;
+-     char *s_caller;
++     const char *s_caller;
+ {
+   SCM val = thevalue(obj);
+@@ -802,5 +802,5 @@
+ int theint(obj, s_caller)
+      SCM obj;
+-     char *s_caller;
++     const char *s_caller;
+ {
+   SCM val = thevalue(obj);
+@@ -810,5 +810,5 @@
+ int theuint(obj, s_caller)
+      SCM obj;
+-     char *s_caller;
++     const char *s_caller;
+ {
+   SCM val = thevalue(obj);
+@@ -819,5 +819,5 @@
+ static int args2valmask(oargs, s_caller)
+      SCM oargs;
+-     char *s_caller;
++     const char *s_caller;
+ {
+   SCM args = oargs;
+@@ -840,5 +840,5 @@
+   SCM sval, args = oargs;
+   int attr, len, attr_mask = 0;
+-/*    (void)memset((char *)vlu, 0, sizeof(XGCValues)); */
++/*    (void)memset(vlu, 0, sizeof(XGCValues)); */
+   if (!(len = ilength(args))) return 0;
+   ASRTER(len > 0 && (! (len & 1)), oargs, WNA, s_gc);
+@@ -984,8 +984,9 @@
+   return (display ? make_xdisplay(display) : BOOL_F);
+ }
++
++static int (*previous_after_function)(); /* Might be useful under debugger? */
+ SCM x_display_debug(sd, si)
+      SCM sd, si;
+ {
+-  int (*previous_after_function)();
+   struct display_screen dspscn;
+   scm2display_screen(sd, UNDEFINED, &dspscn, s_x_display_debug);
+@@ -1289,5 +1290,5 @@
+       if (NNULLP(sargs)) contig = thebool(CAR(sargs), s_x_alloc_color_cells);
+       sts = XAllocColorPlanes(xcm->dpy, xcm->cm, contig,
+-			      VELTS(pxra), npixels,
++			      (unsigned long *)VELTS(pxra), npixels,
+ 			      xclr.red, xclr.green, xclr.blue,
+ 			      &rmask_return, &gmask_return, &bmask_return);
+@@ -1302,5 +1303,6 @@
+     plra = make_uve(nplanes, MAKINUM(32L)); /* Uniform vector of long */
+     sts = XAllocColorCells(xcm->dpy, xcm->cm, contig,
+-			   VELTS(plra), nplanes, VELTS(pxra), npixels);
++			   (unsigned long *)VELTS(plra), nplanes,
++			   (unsigned long *)VELTS(pxra), npixels);
+     if (!sts) return BOOL_F;
+     return cons2(pxra, plra, EOL);
+@@ -1321,5 +1323,5 @@
+     planes = theuint(CAR(sargs), s_x_free_color_cells);
+   case 3:
+-    XFreeColors(xcm->dpy, xcm->cm, VELTS(spxls), INUM(spxls), planes);
++    XFreeColors(xcm->dpy, xcm->cm, (unsigned long *)VELTS(spxls), INUM(spxls), planes);
+     return UNSPECIFIED;
+   }
+@@ -1907,5 +1909,5 @@
+      int format;
+      unsigned long nitems;
+-     unsigned char* data;
++     const void* data;
+ {
+   SCM datum = EOL;
+@@ -1918,19 +1920,19 @@
+     case XA_CARDINAL:
+       switch (format) {
+-      case 8: datum = MAKINUM(((unsigned char *)data)[cnt]); break;
+-      case 16: datum = MAKINUM(((unsigned short *)data)[cnt]); break;
+-      case 32: datum = ulong2num(((unsigned long *)data)[cnt]); break;
++      case 8: datum = MAKINUM(((const unsigned char *)data)[cnt]); break;
++      case 16: datum = MAKINUM(((const unsigned short *)data)[cnt]); break;
++      case 32: datum = ulong2num(((const unsigned long *)data)[cnt]); break;
+       default: return MAKINUM(format);
+       } break;
+     case XA_INTEGER:
+       switch (format) {
+-      case 8: datum = MAKINUM(((char *)data)[cnt]); break;
+-      case 16: datum = MAKINUM(((short *)data)[cnt]); break;
+-      case 32: datum = long2num(((long *)data)[cnt]); break;
++      case 8: datum = MAKINUM(((const char *)data)[cnt]); break;
++      case 16: datum = MAKINUM(((const short *)data)[cnt]); break;
++      case 32: datum = long2num(((const long *)data)[cnt]); break;
+       default: return MAKINUM(format);
+       } break;
+     case XA_STRING:
+       switch (format) {
+-      case 8: return makfrom0str(data);
++      case 8: return makfrom0str((const char *)data);
+       default: return MAKINUM(format);
+       } break;
+@@ -2052,5 +2054,5 @@
+      SCM sdbl, sgc, sargs;
+      int (*proc)();
+-     char *s_caller;
++     const char *s_caller;
+ {
+   XPoint position;
+@@ -2113,5 +2115,5 @@
+      SCM sdbl, sgc, sargs;
+      int funcod;
+-     char *s_caller;
++     const char *s_caller;
+ {
+   XPoint pos[2];
+@@ -2228,5 +2230,5 @@
+ static struct {
+   int type;
+-  char *name;
++  const char *name;
+ } event_names[] = {
+ #undef SCM_EVENT_FIELDS
+@@ -2234,5 +2236,5 @@
+ };
+ 
+-static char *x__event_name(type)
++static const char *x__event_name(type)
+      int type;
+ {
+@@ -2340,5 +2342,5 @@
+ }
+ 
+-char *xvisualclass2name(class)
++const char *xvisualclass2name(class)
+      int class;
+ {
+--- x.h	2002-01-28 22:31:55.000000000 -0500
++++ x.h	2015-01-23 18:55:19.000000000 -0500
+@@ -11,16 +11,16 @@
+ SCM make_xevent(XEvent *e);
+ size_t x_free_xevent(CELLPTR ptr);
+-void scm2XPoint(int signp, SCM dat, XPoint *ipr, char *pos, char *s_caller);
++void scm2XPoint(int signp, SCM dat, XPoint *ipr, const char *pos, const char *s_caller);
+ int scm2XColor(SCM s_dat, XColor *xclr);
+-int scm2xpointslen(SCM sara, char *s_caller);
+-void scm2display_screen(SCM dat, SCM optidx, struct display_screen *dspscn, char *s_caller);
++int scm2xpointslen(SCM sara, const char *s_caller);
++void scm2display_screen(SCM dat, SCM optidx, struct display_screen *dspscn, const char *s_caller);
+ SCM thevalue(SCM obj);
+-Pixmap thepxmap(SCM obj, char *s_caller);
+-Font thefont(SCM obj, char *s_caller);
+-Colormap thecmap(SCM obj, char *s_caller);
+-Cursor thecsr(SCM obj, char *s_caller);
+-int thebool(SCM obj, char *s_caller);
+-int theint(SCM obj, char *s_caller);
+-int theuint(SCM obj, char *s_caller);
++Pixmap thepxmap(SCM obj, const char *s_caller);
++Font thefont(SCM obj, const char *s_caller);
++Colormap thecmap(SCM obj, const char *s_caller);
++Cursor thecsr(SCM obj, const char *s_caller);
++int thebool(SCM obj, const char *s_caller);
++int theint(SCM obj, const char *s_caller);
++int theuint(SCM obj, const char *s_caller);
+ SCM x_open_display(SCM dpy_name);
+ SCM x_display_debug(SCM sd, SCM si);
+@@ -78,14 +78,14 @@
+ SCM x_default_visual(SCM sdpy, SCM sscr);
+ SCM x_default_ccc(SCM sdpy, SCM sscr);
+-SCM x_propdata2scm(Atom type, int format, unsigned long nitems, unsigned char *data);
++SCM x_propdata2scm(Atom type, int format, unsigned long nitems, const void *data);
+ SCM x_get_window_property(SCM swin, SCM sprop, SCM sargs);
+ SCM x_list_properties(SCM swin);
+ SCM x_clear_area(SCM swin, SCM spos, SCM sargs);
+ SCM x_fill_rectangle(SCM swin, SCM sgc, SCM sargs);
+-void xldraw_string(SCM sdbl, SCM sgc, SCM sargs, int (*proc)(void), char *s_caller);
++void xldraw_string(SCM sdbl, SCM sgc, SCM sargs, int (*proc)(), const char *s_caller);
+ SCM x_draw_string(SCM sdbl, SCM sgc, SCM sargs);
+ SCM x_image_string(SCM sdbl, SCM sgc, SCM sargs);
+ SCM x_draw_points(SCM sdbl, SCM sgc, SCM sargs);
+-SCM xldraw_lines(SCM sdbl, SCM sgc, SCM sargs, int funcod, char *s_caller);
++SCM xldraw_lines(SCM sdbl, SCM sgc, SCM sargs, int funcod, const char *s_caller);
+ SCM x_draw_segments(SCM sdbl, SCM sgc, SCM sargs);
+ SCM x_draw_lines(SCM sdbl, SCM sgc, SCM sargs);
+@@ -95,5 +95,5 @@
+ SCM x_event_ref(SCM sevent, SCM sfield);
+ SCM x_event_keysym(SCM sevent);
+-char *xvisualclass2name(int class);
++const char *xvisualclass2name(int class);
+ void x_scm_final(void);
+ void init_x(void);