Index: libsm/memccpy.c
===================================================================
--- libsm/memccpy.c	(revision 05806159f2593192d6ed2fca28358480a2383c67)
+++ libsm/memccpy.c	(revision 5c13d6473fc3b87b0f3add3efa9e24cfc9622d76)
@@ -4,5 +4,5 @@
 	Version 1 -- 1987-06-12
 
-	Copy s2 to s1, stopping if character c is copied.
+	Copy vp2 to vp1, stopping if character c is copied.
 	Copy no more than n bytes.
 	Return a pointer to the byte after character c in the copy,
@@ -11,9 +11,13 @@
 */
 
-char *memccpy(char *s1, char *s2, char c, int n)
+void *memccpy(void *vp1, void *vp2, char c, int n)
 {
-        while (--n >= 0)
-                if ((*s1++ = *s2++) == c)
-                        return(s1);
-        return((char *)0);
+	char *cp1 = vp1;
+	char *cp2 = vp2;
+
+	while (--n >= 0)
+		if ((*cp1++ = *cp2++) == c)
+			return(cp1);
+
+	return((void *)0);
 }
Index: libsm/memchr.c
===================================================================
--- libsm/memchr.c	(revision 05806159f2593192d6ed2fca28358480a2383c67)
+++ libsm/memchr.c	(revision 5c13d6473fc3b87b0f3add3efa9e24cfc9622d76)
@@ -4,14 +4,17 @@
 	Version 1 -- 1987-06-12
 
-	Return the ptr in sp at which the character c appears;
+	Return the ptr in vp at which the character c appears;
 	NULL if not found in n chars; don't stop at \0.
    =============================================================================
 */
 
-char *memchr(char *sp, char c, int n)
+void *memchr(void *vp, char c, int n)
 {
-        while (--n >= 0)
-                if (*sp++ == c)
-                        return(--sp);
-        return((char *)0);
+	char *cp = vp;
+
+	while (--n >= 0)
+		if (*cp++ == c)
+			return(--cp);
+
+	return((void *)0);
 }
Index: libsm/memcmp.c
===================================================================
--- libsm/memcmp.c	(revision 05806159f2593192d6ed2fca28358480a2383c67)
+++ libsm/memcmp.c	(revision 5c13d6473fc3b87b0f3add3efa9e24cfc9622d76)
@@ -4,16 +4,19 @@
 	Version 2 -- 1987-06-15
 
-	Compare n bytes:  s1>s2: >0  s1==s2: 0  s1<s2: <0
+	Compare n bytes:  vp1>vp2: >0  vp1==vp2: 0  vp1<vp2: <0
    =============================================================================
 */
 
-int memcmp(char *s1, char *s2, int n)
+int memcmp(void *vp1, void *vp2, int n)
 {
+	char *cp1 = vp1;
+	char *cp2 = vp2;
 	register int	diff;
 
-        if (s1 != s2)
-                while (--n >= 0)
-                        if (diff = *s1++ - *s2++)
-                                return(diff);
-        return(0);
+	if (cp1 != cp2)
+		while (--n >= 0)
+			if (diff = *cp1++ - *cp2++)
+				return(diff);
+
+	return(0);
 }
Index: libsm/memcmpu.c
===================================================================
--- libsm/memcmpu.c	(revision 05806159f2593192d6ed2fca28358480a2383c67)
+++ libsm/memcmpu.c	(revision 5c13d6473fc3b87b0f3add3efa9e24cfc9622d76)
@@ -8,12 +8,14 @@
 #include "ctype.h"
 
-int memcmpu(char *s1, char *s2, int n)
+int memcmpu(void *vp1, void *vp2, int n)
 {
+	char *cp1 = vp1;
+	char *cp2 = vp2;
 	register char c1, c2;
 
 	while (n) {
 
-		c1 = *s1++;
-		c2 = *s2++;
+		c1 = *cp1++;
+		c2 = *cp2++;
 
 		if (isascii(c1) && islower(c1))
Index: libsm/memcpy.c
===================================================================
--- libsm/memcpy.c	(revision 05806159f2593192d6ed2fca28358480a2383c67)
+++ libsm/memcpy.c	(revision 5c13d6473fc3b87b0f3add3efa9e24cfc9622d76)
@@ -4,15 +4,17 @@
 	Version 1 -- 1987-06-12
 
-	Copy s2 to s1, always copy n bytes.
-	Return s1.
+	Copy vp2 to vp1, always copy n bytes.
+	Return vp1.
    =============================================================================
  */
 
-char *memcpy(char *s1, char *s2, int n)
+void *memcpy(void *vp1, void *vp2, int n)
 {
-        register char *os1 = s1;
+	char *cp1 = vp1;
+	char *cp2 = vp2;
 
-        while (--n >= 0)
-                *s1++ = *s2++;
-        return (os1);
+	while (--n >= 0)
+		*cp1++ = *cp2++;
+
+	return(vp1);
 }
Index: libsm/memcpyw.c
===================================================================
--- libsm/memcpyw.c	(revision 05806159f2593192d6ed2fca28358480a2383c67)
+++ libsm/memcpyw.c	(revision 5c13d6473fc3b87b0f3add3efa9e24cfc9622d76)
@@ -4,15 +4,17 @@
 	Version 2 -- 1987-06-15 -- D.N. Lynx Crowe
 
-	Copy s2 to s1, always copy n words.
-	Return pointer to s1.
+	Copy vp2 to vp1, always copy n words.
+	Return pointer to vp1.
    =============================================================================
 */
 
-short *memcpyw(short *s1, short *s2, int n)
+void *memcpyw(void *vp1, void *vp2, int n)
 {
-        register short *os1 = s1;
+	short *sp1 = vp1;
+	short *sp2 = vp2;
 
-        while (--n >= 0)
-                *s1++ = *s2++;
-        return (os1);
+	while (--n >= 0)
+		*sp1++ = *sp2++;
+
+	return(vp1);
 }
Index: libsm/memset.c
===================================================================
--- libsm/memset.c	(revision 05806159f2593192d6ed2fca28358480a2383c67)
+++ libsm/memset.c	(revision 5c13d6473fc3b87b0f3add3efa9e24cfc9622d76)
@@ -4,16 +4,16 @@
 	Version 1 -- 1987-06-12
 
-	Set an array of n chars starting at sp to the character c.
-	Return sp.
+	Set an array of n chars starting at vp to the character c.
+	Return vp.
    =============================================================================
 */
 
-char *memset(char *sp, char c, int n)
+void *memset(void *vp, char c, int n)
 {
-        register char *sp0 = sp;
+	char *cp = vp;
 
-        while (--n >= 0)
-                *sp++ = c;
+	while (--n >= 0)
+		*cp++ = c;
 		
-        return(sp0);
+	return(vp);
 }
Index: libsm/memsetw.c
===================================================================
--- libsm/memsetw.c	(revision 05806159f2593192d6ed2fca28358480a2383c67)
+++ libsm/memsetw.c	(revision 5c13d6473fc3b87b0f3add3efa9e24cfc9622d76)
@@ -4,16 +4,16 @@
 	Version 1 -- 1987-03-18 -- D.N. Lynx Crowe
 
-	Set an array of n shorts starting at sp to the short w.
-	Return pointer to sp.
+	Set an array of n shorts starting at vp to the short s.
+	Return pointer to vp.
    =============================================================================
 */
 
-short *memsetw(short *sp, short w, short n)
+void *memsetw(void *vp, short s, short n)
 {
-        register short *sp0 = sp;
+	short *sp = vp;
 
-        while (--n >= 0)
-                *sp++ = w;
+	while (--n >= 0)
+		*sp++ = s;
 
-        return(sp0);
+	return(vp);
 }