Copious const cleanup

Removes 1554 gcc warnings of "discards ‘const’ qualifier"

Signed-off-by: Alan Coopersmith <alan.coopersmith@oracle.com>

25 files changed, 238 insertions, 232 deletions

diff --git a/commands.c b/commands.c
index 2af7ec4..e64fe30 100644
--- a/commands.c
+++ b/commands.c
@@ -187,7 +187,7 @@ DoSave(Widget w, XtPointer client_data, XtPointer call_data)
     Widget source = XawTextGetSource(textwindow);
     char buffer[BUFSIZ];
     struct stat st;
-    static char *nothing_saved = " -- nothing saved.\n";
+    static const char *nothing_saved = " -- nothing saved.\n";
 
     if (!filename) {
 	XmuSnprintf(buffer, sizeof(buffer), "%s%s",
diff --git a/hash.c b/hash.c
index 4f3e14a..699161d 100644
--- a/hash.c
+++ b/hash.c
@@ -53,7 +53,6 @@
  * Prototypes
  */
 static int hash_equal(hash_table *hash, hash_key *left, hash_key *right);
-static unsigned int hash_data(char *value, unsigned int length);
 static unsigned int hash_value(hash_key *key);
 
 
@@ -75,9 +74,9 @@ hash_equal(hash_table *hash, hash_key *left, hash_key *right)
 }
 
 static unsigned int
-hash_data(char *value, unsigned int length)
+hash_data(const char *value, unsigned int length)
 {
-    char		*ptr;
+    const char		*ptr;
     unsigned int	i, key;
 
     for (i = key = 0, ptr = value; i < length; i++)
@@ -181,7 +180,7 @@ hash_get(hash_table *hash, hash_key *name)
 }
 
 hash_entry *
-hash_check(hash_table *hash, char *name, unsigned int length)
+hash_check(hash_table *hash, const char *name, unsigned int length)
 {
     unsigned int	key;
     hash_entry		*entry;
diff --git a/hook.c b/hook.c
index 7dd6da0..105134c 100644
--- a/hook.c
+++ b/hook.c
@@ -1142,59 +1142,60 @@ print:
 
 fail:
     if (etype != T_NONE) {
+	const char *errptr;
 	switch (etype) {
 	    case T_OPTION:
-		ptr = "Option needs a command";
+		errptr = "Option needs a command";
 		break;
 	    case T_ICASE:
-		ptr = "Icase needs an command defined or none for search";
+		errptr = "Icase needs an command defined or none for search";
 		break;
 	    case T_COMMAND:
-		ptr = "Command incorrectly specified";
+		errptr = "Command incorrectly specified";
 		break;
 	    case T_REPLACE:
-		ptr = "Can only search backwards";
+		errptr = "Can only search backwards";
 		break;
 	    case T_SEARCH:
-		ptr = "Badly placed search/replace specifier";
+		errptr = "Badly placed search/replace specifier";
 		break;
 	    case T_BACKSLASH:
-		ptr = "A single backslash cannot be the last command character";
+		errptr = "A single backslash cannot be the last command character";
 		break;
 	    case T_DIRECTION:
-		ptr = "Regular expression must be separeted by / or ? not both";
+		errptr = "Regular expression must be separeted by / or ? not both";
 		break;
 	    case T_COMMA:
-		ptr = "Badly placed comma";
+		errptr = "Badly placed comma";
 		break;
 	    case T_OFFSET:
-		ptr = "Badly placed line offset specifier";
+		errptr = "Badly placed line offset specifier";
 		break;
 	    case T_INCREMENT:
-		ptr = "Badly placed line offset increment specifier";
+		errptr = "Badly placed line offset increment specifier";
 		break;
 	    case T_NUMBER:
-		ptr = "Numeric argument not expected";
+		errptr = "Numeric argument not expected";
 		break;
 	    case T_UNFINISHED:
-		ptr = "Unfinished command";
+		errptr = "Unfinished command";
 		break;
 	    case T_RANGE:
-		ptr = "Bad line range";
+		errptr = "Bad line range";
 		break;
 	    case T_BACKREF:
 		/* This may be an internal re error, but most likely the
 		 * user asked for something like "s/re0(re1)re2/\2/" */
-		ptr = "Bad backreference";
+		errptr = "Bad backreference";
 		break;
 	    case T_EDIT:
-		ptr = "Failed to replace text";
+		errptr = "Failed to replace text";
 		break;
 	    default:
-		ptr = "Unknown error";
+		errptr = "Unknown error";
 		break;
 	}
-	XeditPrintf("Error: %s.\n", ptr);
+	XeditPrintf("Error: %s.\n", errptr);
     }
     if (redisplay)
 	XawTextEnableRedisplay(w);
diff --git a/lisp/compile.c b/lisp/compile.c
index 829baea..474aac5 100644
--- a/lisp/compile.c
+++ b/lisp/compile.c
@@ -144,7 +144,7 @@ Com_C_r(LispCom *com, LispBuiltin *builtin)
  */
 {
     LispObj *list;
-    char *desc;
+    const char *desc;
 
     list = ARGUMENT(0);
 
diff --git a/lisp/core.c b/lisp/core.c
index a9792e9..46930a2 100644
--- a/lisp/core.c
+++ b/lisp/core.c
@@ -1853,7 +1853,8 @@ Lisp_Gensym(LispBuiltin *builtin)
  gensym &optional arg
  */
 {
-    char *preffix = "G", name[132];
+    const char *preffix = "G";
+    char name[132];
     long counter = LONGINT_VALUE(Ogensym_counter->data.atom->property->value);
     LispObj *symbol;
 
diff --git a/lisp/debugger.c b/lisp/debugger.c
index c9de39d..f07824b 100644
--- a/lisp/debugger.c
+++ b/lisp/debugger.c
@@ -64,9 +64,9 @@ static void LispDebuggerCommand(LispObj *obj);
  * Initialization
  */
 static struct {
-    char *name;
+    const char *name;
     int action;
-} commands[] = {
+} const commands[] = {
     {"help",		DebuggerHelp},
     {"abort",		DebuggerAbort},
     {"backtrace",	DebuggerBacktrace},
@@ -91,15 +91,15 @@ static struct {
 };
 
 static struct {
-    char *name;
+    const char *name;
     int subaction;
-} info_commands[] = {
+} const info_commands[] = {
     {"breakpoints",	DebuggerInfoBreakpoints},
     {"stack",		DebuggerInfoBacktrace},
     {"watchpoints",	DebuggerInfoBreakpoints},
 };
 
-static char debugger_help[] =
+static const char *debugger_help =
 "Available commands are:\n\
 \n\
 help		- This message.\n\
@@ -120,7 +120,7 @@ up		- Set environment to frame that called the current one.\n\
 \n\
 Commands may be abbreviated.\n";
 
-static char debugger_info_help[] =
+static const char *debugger_info_help =
 "Available subcommands are:\n\
 \n\
 breakpoints	- List and prints status of breakpoints, and watchpoints.\n\
@@ -407,7 +407,7 @@ LispDebuggerCommand(LispObj *args)
 	else {
 	    for (i = matches = 0; i < sizeof(commands) / sizeof(commands[0]);
 		 i++) {
-		char *str = commands[i].name;
+		const char *str = commands[i].name;
 
 		ptr = cmd;
 		while (*ptr && *ptr == *str) {
@@ -450,7 +450,7 @@ LispDebuggerCommand(LispObj *args)
 		for (i = matches = 0;
 		     i < sizeof(info_commands) / sizeof(info_commands[0]);
 		     i++) {
-		    char *str = info_commands[i].name;
+		    const char *str = info_commands[i].name;
 
 		    ptr = arg;
 		    while (*ptr && *ptr == *str) {
diff --git a/lisp/format.c b/lisp/format.c
index ab85565..733ca9a 100644
--- a/lisp/format.c
+++ b/lisp/format.c
@@ -118,12 +118,12 @@ typedef struct {
 /*
  * Prototypes
  */
-static void merge_arguments(FmtArgs*, FmtDefs*, int*);
+static void merge_arguments(FmtArgs*, const FmtDefs*, int*);
 static char *parse_arguments(char*, FmtArgs*, int*, LispObj**, int*);
 static void merge_error(FmtArgs*, int);
 static void parse_error(FmtArgs*, int);
 static void generic_error(FmtArgs*, int);
-static void format_error(FmtArgs*, char*);
+static void format_error(FmtArgs*, const char*);
 
 static int format_object(LispObj*, LispObj*);
 
@@ -155,7 +155,7 @@ static void LispFormat(LispObj*, FmtInfo*);
 /*
  * Initialization
  */
-static FmtDefs AsciiDefs = {
+static const FmtDefs AsciiDefs = {
     4,
     {
 	{0, 0},			/* mincol */
@@ -165,7 +165,7 @@ static FmtDefs AsciiDefs = {
     },
 };
 
-static FmtDefs IntegerDefs = {
+static const FmtDefs IntegerDefs = {
     4,
     {
 	{0, 0},			/* mincol */
@@ -175,7 +175,7 @@ static FmtDefs IntegerDefs = {
     },
 };
 
-static FmtDefs RadixDefs = {
+static const FmtDefs RadixDefs = {
     5,
     {
 	{0, 10},		/* radix */
@@ -186,11 +186,11 @@ static FmtDefs RadixDefs = {
     },
 };
 
-static FmtDefs NoneDefs = {
+static const FmtDefs NoneDefs = {
     0,
 };
 
-static FmtDefs FixedFloatDefs = {
+static const FmtDefs FixedFloatDefs = {
     5,
     {
 	{0, 0},			/* w */
@@ -201,7 +201,7 @@ static FmtDefs FixedFloatDefs = {
     },
 };
 
-static FmtDefs ExponentialFloatDefs = {
+static const FmtDefs ExponentialFloatDefs = {
     7,
     {
 	{0, 0},			/* w */
@@ -216,7 +216,7 @@ static FmtDefs ExponentialFloatDefs = {
     },
 };
 
-static FmtDefs DollarFloatDefs = {
+static const FmtDefs DollarFloatDefs = {
     4,
     {
 	{0, 2},			/* d */
@@ -226,14 +226,14 @@ static FmtDefs DollarFloatDefs = {
     },
 };
 
-static FmtDefs OneDefs = {
+static const FmtDefs OneDefs = {
     1,
     {
 	{0, 1},
     },
 };
 
-static FmtDefs TabulateDefs = {
+static const FmtDefs TabulateDefs = {
     2,
     {
 	{0, 0},			/* colnum */
@@ -247,10 +247,10 @@ extern LispObj *Oprint_escape;
  * Implementation
  */
 static void
-merge_arguments(FmtArgs *arguments, FmtDefs *defaults, int *code)
+merge_arguments(FmtArgs *arguments, const FmtDefs *defaults, int *code)
 {
     int count;
-    FmtDef *defaul;
+    const FmtDef *defaul;
     FmtArg *argument;
 
     defaul = &(defaults->defaults[0]);
@@ -428,7 +428,7 @@ parse_arguments(char *format, FmtArgs *arguments,
 static void
 parse_error(FmtArgs *args, int code)
 {
-    static char *errors[] = {
+    static const char * const errors[] = {
 	NULL,
 	"too many parameters to directive",
 	"too many @ parameters",
@@ -445,7 +445,7 @@ parse_error(FmtArgs *args, int code)
 static void
 merge_error(FmtArgs *args, int code)
 {
-    static char *errors[] = {
+    static const char * const errors[] = {
 	NULL,
 	"too many parameters to directive",
 	"argument must be a character",
@@ -458,7 +458,7 @@ merge_error(FmtArgs *args, int code)
 static void
 generic_error(FmtArgs *args, int code)
 {
-    static char *errors[] = {
+    static const char * const errors[] = {
 	NULL,
 	"radix must be in the range 2 to 36, inclusive",
 	"parameter must be positive",
@@ -470,7 +470,7 @@ generic_error(FmtArgs *args, int code)
 }
 
 static void
-format_error(FmtArgs *args, char *str)
+format_error(FmtArgs *args, const char *str)
 {
     char *message;
     int errorlen, formatlen;
@@ -565,7 +565,7 @@ format_ascii(LispObj *stream, LispObj *object, FmtArgs *args)
 	    length = format_object(stream, object);
 	else {
 	    int size;
-	    char *str = LispGetSstring(SSTREAMP(string), &size);
+	    const char *str = LispGetSstring(SSTREAMP(string), &size);
 
 	    LispWriteStr(stream, str, size);
 	}
@@ -1499,7 +1499,8 @@ format_justify(LispObj *stream, FmtInfo *info)
 {
     GC_ENTER();
     FmtInfo justify_info;
-    char **formats, *format, *next_format, *str;
+    char **formats, *format, *next_format;
+    const char *str;
     LispObj *string, *strings = NIL, *cons;
     int atsign = info->args.atsign,
 	collon = info->args.collon,
@@ -1723,7 +1724,7 @@ static void
 LispFormat(LispObj *stream, FmtInfo *info)
 {
     FmtArgs *args;
-    FmtDefs *defs = NULL;
+    const FmtDefs *defs = NULL;
     LispObj *object, *arguments;
     char stk[256], *format, *next_format;
     int length, num_arguments, code, need_update, need_argument, hash, head;
@@ -2109,7 +2110,7 @@ Lisp_Format(LispBuiltin *builtin)
     /* else if printing to string-stream, return a string */
     else if (stream->data.stream.type == LispStreamString) {
 	int length;
-	char *string;
+	const char *string;
 
 	string = LispGetSstring(SSTREAMP(stream), &length);
 	stream = LSTRING(string, length);
diff --git a/lisp/internal.h b/lisp/internal.h
index 2ca4991..988c0dc 100644
--- a/lisp/internal.h
+++ b/lisp/internal.h
@@ -78,13 +78,13 @@ typedef struct _LispMac LispMac;
 	/* make a gc never released variable with a static string argument */
 #define STATIC_ATOM(string)	LispNewStaticAtom(string)
 
-#define STRING(str)		LispNewString(str, strlen(str), 0)
-#define LSTRING(str, size)	LispNewString(str, size, 0)
+#define STRING(str)		LispNewString(str, strlen(str))
+#define LSTRING(str, size)	LispNewString(str, size)
 
 	/* string must be from the LispXXX allocation functions,
 	 * and LispMused not yet called on it */
-#define STRING2(str)		LispNewString(str, strlen(str), 1)
-#define LSTRING2(str, size)	LispNewString(str, size, 1)
+#define STRING2(str)		LispNewStringAlloced(str, strlen(str))
+#define LSTRING2(str, size)	LispNewStringAlloced(str, size)
 
 #define VECTOR(objects)		LispNewVector(objects)
 
@@ -92,13 +92,13 @@ typedef struct _LispMac LispMac;
 	 * string be allocated from the LispXXX allocation functions,
 	 * and LispMused not yet called on it */
 #define STRINGSTREAM(str, flag)			\
-	LispNewStringStream(str, flag, strlen(str), 0)
+	LispNewStringStream(str, flag, strlen(str))
 #define STRINGSTREAM2(str, flag)		\
-	LispNewStringStream(str, flag, strlen(str), 1)
+	LispNewStringStreamAlloced(str, flag, strlen(str))
 #define LSTRINGSTREAM(str, flag, length)	\
-	LispNewStringStream(str, flag, length, 0)
+	LispNewStringStream(str, flag, length)
 #define LSTRINGSTREAM2(str, flag, length)	\
-	LispNewStringStream(str, flag, length, 1)
+	LispNewStringStreamAlloced(str, flag, length)
 
 #define FILESTREAM(file, path, flag)	\
 	LispNewFileStream(file, path, flag)
@@ -664,7 +664,7 @@ struct _LispBuiltin {
     /* these fields must be set */
     LispFunType type;
     LispFunPtr function;
-    char *declaration;
+    const char *declaration;
 
     /* this field is optional, set if the function returns multiple values */
     int multiple_values;
@@ -700,12 +700,13 @@ LispObj *LispApply3(LispObj*, LispObj*, LispObj*, LispObj*);
 
 LispObj *LispNew(LispObj*, LispObj*);
 LispObj *LispNewSymbol(LispAtom*);
-LispObj *LispNewAtom(char*, int);
+LispObj *LispNewAtom(const char*, int);
 LispObj *LispNewFunction(LispObj*);
 LispObj *LispNewFunctionQuote(LispObj*);
-LispObj *LispNewStaticAtom(char*);
+LispObj *LispNewStaticAtom(const char*);
 LispObj *LispNewDFloat(double);
-LispObj *LispNewString(char*, long, int);
+LispObj *LispNewString(const char*, long);
+LispObj *LispNewStringAlloced(char*, long);
 LispObj *LispNewInteger(long);
 LispObj *LispNewRatio(long, long);
 LispObj *LispNewVector(LispObj*);
@@ -717,24 +718,25 @@ LispObj *LispNewLambda(LispObj*, LispObj*, LispObj*, LispFunType);
 LispObj *LispNewStruct(LispObj*, LispObj*);
 LispObj *LispNewComplex(LispObj*, LispObj*);
 LispObj *LispNewOpaque(void*, int);
-LispObj *LispNewKeyword(char*);
+LispObj *LispNewKeyword(const char*);
 LispObj *LispNewPathname(LispObj*);
-LispObj *LispNewStringStream(char*, int, long, int);
+LispObj *LispNewStringStream(const char*, int, long);
+LispObj *LispNewStringStreamAlloced(char*, int, long);
 LispObj *LispNewFileStream(LispFile*, LispObj*, int);
 LispObj *LispNewPipeStream(LispPipe*, LispObj*, int);
 LispObj *LispNewBignum(mpi*);
 LispObj *LispNewBigratio(mpr*);
 
-LispAtom *LispGetAtom(char*);
+LispAtom *LispGetAtom(const char*);
 
 /* This function does not allocate a copy of it's argument, but the argument
  * itself. The argument string should never change. */
-LispAtom *LispGetPermAtom(char*);
+LispAtom *LispGetPermAtom(const char*);
 
 void *LispMalloc(size_t);
 void *LispCalloc(size_t, size_t);
 void *LispRealloc(void*, size_t);
-char *LispStrdup(char*);
+char *LispStrdup(const char*);
 void LispFree(void*);
 /* LispMused means memory is now safe from LispDestroy, and should not be
  * freed in case of an error */
@@ -749,18 +751,16 @@ char *LispStrObj(LispObj*);
 #else
 #define PRINTF_FORMAT	/**/
 #endif
-void LispDestroy(char *fmt, ...) PRINTF_FORMAT;
+void LispDestroy(const char *fmt, ...) PRINTF_FORMAT;
 	/* continuable error */
-void LispContinuable(char *fmt, ...) PRINTF_FORMAT;
-void LispMessage(char *fmt, ...) PRINTF_FORMAT;
-void LispWarning(char *fmt, ...) PRINTF_FORMAT;
+void LispContinuable(const char *fmt, ...) PRINTF_FORMAT;
+void LispMessage(const char *fmt, ...) PRINTF_FORMAT;
+void LispWarning(const char *fmt, ...) PRINTF_FORMAT;
 #undef PRINTF_FORMAT
 
-LispObj *LispSetVariable(LispObj*, LispObj*, char*, int);
+LispObj *LispSetVariable(LispObj*, LispObj*, const char*, int);
 
-int LispRegisterOpaqueType(char*);
-
-int LispPrintString(LispObj*, char*);
+int LispRegisterOpaqueType(const char*);
 
 void LispProtect(LispObj*, LispObj*);
 void LispUProtect(LispObj*, LispObj*);
diff --git a/lisp/io.c b/lisp/io.c
index 9db73ee..3ec9cf5 100644
--- a/lisp/io.c
+++ b/lisp/io.c
@@ -44,11 +44,6 @@
 #define UNBUFFERED_BIT	0x10
 #define BINARY_BIT	0x20
 
-/*
- * Prototypes
- */
-static int calculate_line(void*, int);
-static int calculate_column(void*, int, int);
 
 /*
  * Initialization
@@ -160,12 +155,13 @@ LispPopInput(LispObj *stream)
  * Low level functions
  */
 static int
-calculate_line(void *data, int size)
+calculate_line(const void *data, int size)
 {
     int line = 0;
-    char *str, *ptr;
+    const char *str, *ptr;
 
-    for (str = (char*)data, ptr = (char*)data + size; str < ptr; str++)
+    for (str = (const char *)data, ptr = (const char *)data + size;
+         str < ptr; str++)
 	if (*ptr == '\n')
 	    ++line;
 
@@ -173,12 +169,13 @@ calculate_line(void *data, int size)
 }
 
 static int
-calculate_column(void *data, int size, int column)
+calculate_column(const void *data, int size, int column)
 {
-    char *str, *ptr;
+    const char *str, *ptr;
 
     /* search for newline in data */
-    for (str = (char*)data, ptr = (char*)data + size - 1; ptr >= str; ptr--)
+    for (str = (const char *)data, ptr = (const char *)data + size - 1;
+         ptr >= str; ptr--)
 	if (*ptr == '\n')
 	    break;
 
@@ -225,7 +222,7 @@ LispFdopen(int descriptor, int mode)
 }
 
 LispFile *
-LispFopen(char *path, int mode)
+LispFopen(const char *path, int mode)
 {
     LispFile *file;
     int descriptor;
@@ -467,13 +464,13 @@ LispFgets(LispFile *file, char *string, int size)
 }
 
 int
-LispFputs(LispFile *file, char *buffer)
+LispFputs(LispFile *file, const char *buffer)
 {
     return (LispFwrite(file, buffer, strlen(buffer)));
 }
 
 int
-LispSputs(LispString *string, char *buffer)
+LispSputs(LispString *string, const char *buffer)
 {
     return (LispSwrite(string, buffer, strlen(buffer)));
 }
@@ -557,7 +554,7 @@ LispFread(LispFile *file, void *data, int size)
 }
 
 int
-LispFwrite(LispFile *file, void *data, int size)
+LispFwrite(LispFile *file, const void *data, int size)
 {
     if (!file->writable || size < 0)
 	return (EOF);
@@ -567,7 +564,7 @@ LispFwrite(LispFile *file, void *data, int size)
 
     if (file->buffered) {
 	int length, bytes;
-	char *buffer = (char*)data;
+	const char *buffer = (const char *)data;
 
 	length = 0;
 	if (size + file->length > pagesize) {
@@ -633,7 +630,7 @@ LispFwrite(LispFile *file, void *data, int size)
 }
 
 int
-LispSwrite(LispString *string, void *data, int size)
+LispSwrite(LispString *string, const void *data, int size)
 {
     int bytes;
 
@@ -676,7 +673,7 @@ LispSwrite(LispString *string, void *data, int size)
     return (size);
 }
 
-char *
+const char *
 LispGetSstring(LispString *string, int *length)
 {
     if (string->string == NULL || string->length <= 0) {
@@ -707,13 +704,13 @@ LispGetSstring(LispString *string, int *length)
 }
 
 int
-LispRename(char *from, char *to)
+LispRename(const char *from, const char *to)
 {
     return (rename(from, to));
 }
 
 int
-LispUnlink(char *name)
+LispUnlink(const char *name)
 {
     return (unlink(name));
 }
diff --git a/lisp/io.h b/lisp/io.h
index 2bb8c4d..84fb754 100644
--- a/lisp/io.h
+++ b/lisp/io.h
@@ -88,18 +88,18 @@ void LispPopInput(LispObj*);
 
 	/* functions that read/write using the LispFile structure */
 LispFile *LispFdopen(int, int);
-LispFile *LispFopen(char*, int);
+LispFile *LispFopen(const char*, int);
 void LispFclose(LispFile*);
 int LispFflush(LispFile*);
 int LispFungetc(LispFile*, int);
 int LispFgetc(LispFile*);
 int LispFputc(LispFile*, int);
 char *LispFgets(LispFile*, char*, int);
-int LispFputs(LispFile*, char*);
+int LispFputs(LispFile*, const char*);
 int LispFread(LispFile*, void*, int);
-int LispFwrite(LispFile*, void*, int);
-int LispRename(char*, char*);
-int LispUnlink(char*);
+int LispFwrite(LispFile*, const void*, int);
+int LispRename(const char*, const char*);
+int LispUnlink(const char*);
 
 	/* io wrappers */
 io_write_fn LispSetFileWrite(LispFile*, io_write_fn);
@@ -107,9 +107,9 @@ io_write_fn LispSetFileWrite(LispFile*, io_write_fn);
 	/* functions that read/write using the LispString structure */
 int LispSgetc(LispString*);
 int LispSputc(LispString*, int);
-int LispSputs(LispString*, char*);
-int LispSwrite(LispString*, void*, int);
+int LispSputs(LispString*, const char*);
+int LispSwrite(LispString*, const void*, int);
 
-char *LispGetSstring(LispString*, int*);
+const char *LispGetSstring(LispString*, int*);
 
 #endif /* Lisp_io_h */
diff --git a/lisp/lisp.c b/lisp/lisp.c
index 411240a..b999b8a 100644
--- a/lisp/lisp.c
+++ b/lisp/lisp.c
@@ -662,7 +662,7 @@ LispGetPageSize(void)
 }
 
 void
-LispDestroy(char *fmt, ...)
+LispDestroy(const char *fmt, ...)
 {
     static char Error[] = "*** ";
 
@@ -720,7 +720,7 @@ LispDestroy(char *fmt, ...)
     LispTopLevel();
 
     if (!lisp__data.running) {
-	static char Fatal[] = "*** Fatal: nowhere to longjmp.\n";
+	static const char *Fatal = "*** Fatal: nowhere to longjmp.\n";
 
 	LispFputs(Stderr, Fatal);
 	LispFflush(Stderr);
@@ -731,11 +731,11 @@ LispDestroy(char *fmt, ...)
 }
 
 void
-LispContinuable(char *fmt, ...)
+LispContinuable(const char *fmt, ...)
 {
     va_list ap;
     char string[128];
-    static char Error[] = "*** Error: ";
+    static const char *Error = "*** Error: ";
 
     if (Stderr->column)
 	LispFputc(Stderr, '\n');
@@ -757,7 +757,7 @@ LispContinuable(char *fmt, ...)
 }
 
 void
-LispMessage(char *fmt, ...)
+LispMessage(const char *fmt, ...)
 {
     va_list ap;
     char string[128];
@@ -773,11 +773,11 @@ LispMessage(char *fmt, ...)
 }
 
 void
-LispWarning(char *fmt, ...)
+LispWarning(const char *fmt, ...)
 {
     va_list ap;
     char string[128];
-    static char Warning[] = "*** Warning: ";
+    static const char *Warning = "*** Warning: ";
 
     if (Stderr->column)
 	LispFputc(Stderr, '\n');
@@ -1229,7 +1229,7 @@ index_found:
 }
 
 char *
-LispStrdup(char *str)
+LispStrdup(const char *str)
 {
     char *ptr = LispMalloc(strlen(str) + 1);
 
@@ -1264,7 +1264,7 @@ free_done:
 }
 
 LispObj *
-LispSetVariable(LispObj *var, LispObj *val, char *fname, int eval)
+LispSetVariable(LispObj *var, LispObj *val, const char *fname, int eval)
 {
     if (!SYMBOLP(var))
 	LispDestroy("%s: %s is not a symbol", fname, STROBJ(var));
@@ -1275,7 +1275,7 @@ LispSetVariable(LispObj *var, LispObj *val, char *fname, int eval)
 }
 
 int
-LispRegisterOpaqueType(char *desc)
+LispRegisterOpaqueType(const char *desc)
 {
     int length;
     LispOpaque *opaque;
@@ -1317,7 +1317,7 @@ LispIntToOpaqueType(int type)
 }
 
 hash_key *
-LispGetAtomKey(char *string, int perm)
+LispGetAtomKey(const char *string, int perm)
 {
     int length;
     hash_entry *entry;
@@ -1328,7 +1328,7 @@ LispGetAtomKey(char *string, int perm)
 	entry = LispCalloc(1, sizeof(hash_entry));
 	entry->key = LispCalloc(1, sizeof(hash_key));
 	if (perm)
-	    entry->key->value = string;
+	    entry->key->value = (char *) string;
 	else
 	    entry->key->value = LispStrdup(string);
 	entry->key->length = length;
@@ -1344,7 +1344,7 @@ LispGetAtomKey(char *string, int perm)
 }
 
 LispAtom *
-LispDoGetAtom(char *str, int perm)
+LispDoGetAtom(const char *str, int perm)
 {
     int length;
     LispAtom *atom;
@@ -1618,13 +1618,13 @@ LispRemAtomStructProperty(LispAtom *atom)
 }
 
 LispAtom *
-LispGetAtom(char *str)
+LispGetAtom(const char *str)
 {
     return (LispDoGetAtom(str, 0));
 }
 
 LispAtom *
-LispGetPermAtom(char *str)
+LispGetPermAtom(const char *str)
 {
     return (LispDoGetAtom(str, 1));
 }
@@ -1863,15 +1863,15 @@ LispListProtectedArguments(LispArgList *alist)
 }
 
 LispArgList *
-LispCheckArguments(LispFunType type, LispObj *list, char *name, int builtin)
+LispCheckArguments(LispFunType type, LispObj *list, const char *name, int builtin)
 {
-    static char *types[4] = {"LAMBDA-LIST", "FUNCTION", "MACRO", "SETF-METHOD"};
-    static char *fnames[4] = {"LAMBDA", "DEFUN", "DEFMACRO", "DEFSETF"};
+    static const char *types[4] = {"LAMBDA-LIST", "FUNCTION", "MACRO", "SETF-METHOD"};
+    static const char *fnames[4] = {"LAMBDA", "DEFUN", "DEFMACRO", "DEFSETF"};
 #define IKEY		0
 #define IOPTIONAL	1
 #define IREST		2
 #define IAUX		3
-    static char *keys[4] = {"&KEY", "&OPTIONAL", "&REST", "&AUX"};
+    static const char *keys[4] = {"&KEY", "&OPTIONAL", "&REST", "&AUX"};
     int rest, optional, key, aux, count;
     LispArgList *alist;
     LispObj *spec, *sform, *defval, *default_value;
@@ -2633,7 +2633,7 @@ LispNew(LispObj *car, LispObj *cdr)
 }
 
 LispObj *
-LispNewAtom(char *str, int intern)
+LispNewAtom(const char *str, int intern)
 {
     LispObj *object;
     LispAtom *atom = LispDoGetAtom(str, 0);
@@ -2661,7 +2661,7 @@ LispNewAtom(char *str, int intern)
 }
 
 LispObj *
-LispNewStaticAtom(char *str)
+LispNewStaticAtom(const char *str)
 {
     LispObj *object;
     LispAtom *atom = LispDoGetAtom(str, 1);
@@ -2778,9 +2778,17 @@ LispNewDFloat(double value)
 }
 
 LispObj *
-LispNewString(char *str, long length, int alloced)
+LispNewString(const char *str, long length)
+{
+    char *cstring = LispMalloc(length + 1);
+    memcpy(cstring, str, length);
+    cstring[length] = '\0';
+    return LispNewStringAlloced(cstring, length);
+}
+
+LispObj *
+LispNewStringAlloced(char *cstring, long length)
 {
-    char *cstring;
     LispObj *string = objseg.freeobj;
 
     if (string == NIL)
@@ -2789,13 +2797,6 @@ LispNewString(char *str, long length, int alloced)
 	objseg.freeobj = CDR(string);
 	--objseg.nfree;
     }
-    if (alloced)
-	cstring = str;
-    else {
-	cstring = LispMalloc(length + 1);
-	memcpy(cstring, str, length);
-	cstring[length] = '\0';
-    }
     LispMused(cstring);
     string->type = LispString_t;
     THESTR(string) = cstring;
@@ -2976,7 +2977,7 @@ LispNewOpaque(void *data, int type)
 
 /* string argument must be static, or allocated */
 LispObj *
-LispNewKeyword(char *string)
+LispNewKeyword(const char *string)
 {
     LispObj *keyword;
 
@@ -3027,18 +3028,22 @@ LispNewPathname(LispObj *obj)
 }
 
 LispObj *
-LispNewStringStream(char *string, int flags, long length, int alloced)
+LispNewStringStream(const char *string, int flags, long length)
+{
+    char *newstring = LispMalloc(length + 1);
+    memcpy(newstring, string, length);
+    newstring[length] = '\0';
+
+    return LispNewStringStreamAlloced(newstring, flags, length);
+}
+
+LispObj *
+LispNewStringStreamAlloced(char *string, int flags, long length)
 {
     LispObj *stream = LispNew(NIL, NIL);
 
     SSTREAMP(stream) = LispCalloc(1, sizeof(LispString));
-    if (alloced)
-	SSTREAMP(stream)->string = string;
-    else {
-	SSTREAMP(stream)->string = LispMalloc(length + 1);
-	memcpy(SSTREAMP(stream)->string, string, length);
-	SSTREAMP(stream)->string[length] = '\0';
-    }
+    SSTREAMP(stream)->string = string;
 
     stream->type = LispStream_t;
 
@@ -5012,7 +5017,7 @@ LispSignalHandler(int signum)
 void
 LispSignal(int signum)
 {
-    char *errstr;
+    const char *errstr;
     char buffer[32];
 
     if (lisp__disable_int) {
@@ -5387,15 +5392,15 @@ LispBegin(void)
 #ifdef LISPDIR
     {
 	int length;
-	char *pathname = LISPDIR;
+	const char *pathname = LISPDIR;
 
 	length = strlen(pathname);
 	if (length && pathname[length - 1] != '/') {
-	    pathname = LispMalloc(length + 2);
+	    char *fixed_pathname = LispMalloc(length + 2);
 
-	    strcpy(pathname, LISPDIR);
-	    strcpy(pathname + length, "/");
-	    path = LSTRING2(pathname, length + 1);
+	    strcpy(fixed_pathname, LISPDIR);
+	    strcpy(fixed_pathname + length, "/");
+	    path = LSTRING2(fixed_pathname, length + 1);
 	}
 	else
 	    path = LSTRING(pathname, length);
@@ -5447,7 +5452,7 @@ LispEnd(void)
 }
 
 void
-LispSetPrompt(char *prompt)
+LispSetPrompt(const char *prompt)
 {
     lisp__data.prompt = prompt;
 }
diff --git a/lisp/lisp.h b/lisp/lisp.h
index baabb85..39d702a 100644
--- a/lisp/lisp.h
+++ b/lisp/lisp.h
@@ -36,7 +36,7 @@ void LispBegin(void);
 void LispEnd(void);
 void *LispExecute(char*);
 void LispMachine(void);
-void LispSetPrompt(char*);
+void LispSetPrompt(const char*);
 void LispSetInteractive(int);
 void LispSetExitOnError(int);
 void LispDebug(int);		/* argument is boolean to enable/disable */
diff --git a/lisp/mathimp.c b/lisp/mathimp.c
index 5f8bd4d..0433968 100644
--- a/lisp/mathimp.c
+++ b/lisp/mathimp.c
@@ -436,7 +436,7 @@ static INLINE int cmp_br_br(mpr*, mpr*);
  */
 static n_real zero, one, two;
 
-static char *fatal_error_strings[] = {
+static const char *fatal_error_strings[] = {
 #define DIVIDE_BY_ZERO			0
     "divide by zero",
 #define FLOATING_POINT_OVERFLOW		1
@@ -445,7 +445,7 @@ static char *fatal_error_strings[] = {
     "floating point exception"
 };
 
-static char *fatal_object_error_strings[] = {
+static const char *fatal_object_error_strings[] = {
 #define NOT_A_NUMBER			0
     "is not a number",
 #define NOT_A_REAL_NUMBER		1
diff --git a/lisp/package.c b/lisp/package.c
index 8b941ec..9e39048 100644
--- a/lisp/package.c
+++ b/lisp/package.c
@@ -61,7 +61,7 @@ LispPackageInit(void)
 }
 
 LispObj *
-LispFindPackageFromString(char *string)
+LispFindPackageFromString(const char *string)
 {
     LispObj *list, *package, *nick;
 
@@ -97,9 +97,9 @@ LispFindPackage(LispObj *name)
 }
 
 int
-LispCheckAtomString(char *string)
+LispCheckAtomString(const char *string)
 {
-    char *ptr;
+    const char *ptr;
 
     if (*string == '\0')
 	return (0);
diff --git a/lisp/package.h b/lisp/package.h
index f6940c8..6fcfd1e 100644
--- a/lisp/package.h
+++ b/lisp/package.h
@@ -36,9 +36,9 @@
 
 void LispPackageInit(void);
 LispObj *LispFindPackage(LispObj*);
-LispObj *LispFindPackageFromString(char*);
+LispObj *LispFindPackageFromString(const char*);
 /* returns 1 if string can safely be read back */
-int LispCheckAtomString(char*);
+int LispCheckAtomString(const char*);
 
 LispObj *Lisp_DoAllSymbols(LispBuiltin*);
 LispObj *Lisp_DoExternalSymbols(LispBuiltin*);
diff --git a/lisp/pathname.c b/lisp/pathname.c
index 5d991fe..a8c2108 100644
--- a/lisp/pathname.c
+++ b/lisp/pathname.c
@@ -484,7 +484,8 @@ Lisp_ParseNamestring(LispBuiltin *builtin)
     if (STRINGP(object)) {
 	LispObj *cons, *cdr;
 	char *name = THESTR(object), *ptr, *str, data[PATH_MAX + 1],
-	      string[PATH_MAX + 1], *namestr, *typestr, *send;
+	      string[PATH_MAX + 1], *send;
+	const char *namestr, *typestr;
 	long start, end, length, alength, namelen, typelen;
 
 	LispCheckSequenceStartEnd(builtin, object, ostart, oend,
diff --git a/lisp/private.h b/lisp/private.h
index 2e5b634..f6aeff0 100644
--- a/lisp/private.h
+++ b/lisp/private.h
@@ -373,7 +373,7 @@ struct _LispMac {
     } mem;		/* memory from Lisp*Alloc, to be release in error */
     LispModule *module;
     LispObj *modules;
-    char *prompt;
+    const char *prompt;
 
     LispObj *features;
 
@@ -407,7 +407,7 @@ struct _LispMac {
 };
 
 struct _LispCharInfo {
-    char **names;
+    const char * const *names;
 };
 
 
@@ -416,7 +416,7 @@ struct _LispCharInfo {
  */
 void LispUseArgList(LispArgList*);
 void LispFreeArgList(LispArgList*);
-LispArgList *LispCheckArguments(LispFunType, LispObj*, char*, int);
+LispArgList *LispCheckArguments(LispFunType, LispObj*, const char*, int);
 LispObj *LispListProtectedArguments(LispArgList*);
 
 LispObj *LispGetDoc(LispObj*);
@@ -441,8 +441,7 @@ void LispExportSymbol(LispObj*);
 void LispImportSymbol(LispObj*);
 
 	/* always returns the same string */
-hash_key *LispGetAtomKey(char*, int);
-char *LispGetAtomString(char*, int);
+hash_key *LispGetAtomKey(const char*, int);
 
 /* destructive fast reverse, note that don't receive a LispMac* argument */
 LispObj *LispReverse(LispObj *list);
@@ -464,7 +463,7 @@ void LispBlockUnwind(LispBlock*);
 void LispUpdateResults(LispObj*, LispObj*);
 void LispTopLevel(void);
 
-LispAtom *LispDoGetAtom(char *str, int);
+LispAtom *LispDoGetAtom(const char *str, int);
 	/* get value from atom's property list */
 LispObj *LispGetAtomProperty(LispAtom*, LispObj*);
 	/* put value in atom's property list */
@@ -515,7 +514,7 @@ void LispMoreProtects(void);
 
 /* Initialization */
 extern int LispArgList_t;
-extern LispCharInfo LispChars[256];
+extern const LispCharInfo LispChars[256];
 
 /* This function will return if the interpreter cannot be stopped */
 extern void LispSignal(int);
diff --git a/lisp/re/re.c b/lisp/re/re.c
index f4c1246..55ba17b 100644
--- a/lisp/re/re.c
+++ b/lisp/re/re.c
@@ -1665,7 +1665,7 @@ done:
 int
 reerror(int ecode, const re_cod *preg, char *ebuffer, int ebuffer_size)
 {
-    static char *errors[] = {
+    static const char *errors[] = {
 	"No error",
 	"Failed to match",			/* NOMATCH */
 
@@ -1687,7 +1687,7 @@ reerror(int ecode, const re_cod *preg, char *ebuffer, int ebuffer_size)
 	"Assertion error - you found a bug",	/* ASSERT */
 	"Invalid argument"			/* INVARG */
     };
-    char *str;
+    const char *str;
 
     if (ecode >= 0 && ecode < sizeof(errors) / sizeof(errors[0]))
 	str = errors[ecode];
diff --git a/lisp/read.c b/lisp/read.c
index a49e240..02f71f6 100644
--- a/lisp/read.c
+++ b/lisp/read.c
@@ -106,7 +106,7 @@ static int LispGetLine(LispObj*);
 #else
 #define PRINTF_FORMAT	/**/
 #endif
-static void LispReadError(LispObj*, int, char*, ...);
+static void LispReadError(LispObj*, int, const char*, ...);
 #undef PRINTF_FORMAT
 static void LispReadFixCircle(LispObj*, read_info*);
 static LispObj *LispReadLabelCircle(LispObj*, read_info*);
@@ -140,42 +140,42 @@ static LispObj *LispEvalFeature(LispObj*);
 /*
  * Initialization
  */
-static char *Char_Nul[] = {"Null", "Nul", NULL};
-static char *Char_Soh[] = {"Soh", NULL};
-static char *Char_Stx[] = {"Stx", NULL};
-static char *Char_Etx[] = {"Etx", NULL};
-static char *Char_Eot[] = {"Eot", NULL};
-static char *Char_Enq[] = {"Enq", NULL};
-static char *Char_Ack[] = {"Ack", NULL};
-static char *Char_Bel[] = {"Bell", "Bel", NULL};
-static char *Char_Bs[]  = {"Backspace", "Bs", NULL};
-static char *Char_Tab[] = {"Tab", NULL};
-static char *Char_Nl[]  = {"Newline", "Nl", "Lf", "Linefeed", NULL};
-static char *Char_Vt[]  = {"Vt", NULL};
-static char *Char_Np[]  = {"Page", "Np", NULL};
-static char *Char_Cr[]  = {"Return", "Cr", NULL};
-static char *Char_Ff[]  = {"So", "Ff", NULL};
-static char *Char_Si[]  = {"Si", NULL};
-static char *Char_Dle[] = {"Dle", NULL};
-static char *Char_Dc1[] = {"Dc1", NULL};
-static char *Char_Dc2[] = {"Dc2", NULL};
-static char *Char_Dc3[] = {"Dc3", NULL};
-static char *Char_Dc4[] = {"Dc4", NULL};
-static char *Char_Nak[] = {"Nak", NULL};
-static char *Char_Syn[] = {"Syn", NULL};
-static char *Char_Etb[] = {"Etb", NULL};
-static char *Char_Can[] = {"Can", NULL};
-static char *Char_Em[]  = {"Em", NULL};
-static char *Char_Sub[] = {"Sub", NULL};
-static char *Char_Esc[] = {"Escape", "Esc", NULL};
-static char *Char_Fs[]  = {"Fs", NULL};
-static char *Char_Gs[]  = {"Gs", NULL};
-static char *Char_Rs[]  = {"Rs", NULL};
-static char *Char_Us[]  = {"Us", NULL};
-static char *Char_Sp[]  = {"Space", "Sp", NULL};
-static char *Char_Del[] = {"Rubout", "Del", "Delete", NULL};
-
-LispCharInfo LispChars[256] = {
+static const char * const Char_Nul[] = {"Null", "Nul", NULL};
+static const char * const Char_Soh[] = {"Soh", NULL};
+static const char * const Char_Stx[] = {"Stx", NULL};
+static const char * const Char_Etx[] = {"Etx", NULL};
+static const char * const Char_Eot[] = {"Eot", NULL};
+static const char * const Char_Enq[] = {"Enq", NULL};
+static const char * const Char_Ack[] = {"Ack", NULL};
+static const char * const Char_Bel[] = {"Bell", "Bel", NULL};
+static const char * const Char_Bs[]  = {"Backspace", "Bs", NULL};
+static const char * const Char_Tab[] = {"Tab", NULL};
+static const char * const Char_Nl[]  = {"Newline", "Nl", "Lf", "Linefeed", NULL};
+static const char * const Char_Vt[]  = {"Vt", NULL};
+static const char * const Char_Np[]  = {"Page", "Np", NULL};
+static const char * const Char_Cr[]  = {"Return", "Cr", NULL};
+static const char * const Char_Ff[]  = {"So", "Ff", NULL};
+static const char * const Char_Si[]  = {"Si", NULL};
+static const char * const Char_Dle[] = {"Dle", NULL};
+static const char * const Char_Dc1[] = {"Dc1", NULL};
+static const char * const Char_Dc2[] = {"Dc2", NULL};
+static const char * const Char_Dc3[] = {"Dc3", NULL};
+static const char * const Char_Dc4[] = {"Dc4", NULL};
+static const char * const Char_Nak[] = {"Nak", NULL};
+static const char * const Char_Syn[] = {"Syn", NULL};
+static const char * const Char_Etb[] = {"Etb", NULL};
+static const char * const Char_Can[] = {"Can", NULL};
+static const char * const Char_Em[]  = {"Em", NULL};
+static const char * const Char_Sub[] = {"Sub", NULL};
+static const char * const Char_Esc[] = {"Escape", "Esc", NULL};
+static const char * const Char_Fs[]  = {"Fs", NULL};
+static const char * const Char_Gs[]  = {"Gs", NULL};
+static const char * const Char_Rs[]  = {"Rs", NULL};
+static const char * const Char_Us[]  = {"Us", NULL};
+static const char * const Char_Sp[]  = {"Space", "Sp", NULL};
+static const char * const Char_Del[] = {"Rubout", "Del", "Delete", NULL};
+
+const LispCharInfo LispChars[256] = {
     {Char_Nul},
     {Char_Soh},
     {Char_Stx},
@@ -597,9 +597,10 @@ LispGetLine(LispObj *stream)
 }
 
 static void
-LispReadError(LispObj *stream, int line, char *fmt, ...)
+LispReadError(LispObj *stream, int line, const char *fmt, ...)
 {
-    char string[128], *buffer_string;
+    char string[128];
+    const char *buffer_string;
     LispObj *buffer = LSTRINGSTREAM("", STREAM_READ | STREAM_WRITE, 0);
     int length;
     va_list ap;
@@ -1721,7 +1722,7 @@ LispReadCharacter(read_info *info)
 	    stk[len++] = ch;
     }
     if (len > 1) {
-	char **names;
+	const char * const *names;
 	int found = 0;
 	stk[len] = '\0';
 
diff --git a/lisp/stream.c b/lisp/stream.c
index aad89cf..98d6d3e 100644
--- a/lisp/stream.c
+++ b/lisp/stream.c
@@ -613,7 +613,7 @@ Lisp_GetOutputStreamString(LispBuiltin *builtin)
  */
 {
     int length;
-    char *string;
+    const char *string;
     LispObj *string_output_stream, *result;
 
     string_output_stream = ARGUMENT(0);
diff --git a/lisp/write.c b/lisp/write.c
index 6c7d979..9201d68 100644
--- a/lisp/write.c
+++ b/lisp/write.c
@@ -90,7 +90,7 @@ static int LispWriteCharacter(LispObj*, LispObj*, write_info*);
 static int LispWriteString(LispObj*, LispObj*, write_info*);
 static int LispWriteFloat(LispObj*, LispObj*);
 static int LispWriteAtom(LispObj*, LispObj*, write_info*);
-static int LispDoWriteAtom(LispObj*, char*, int, int);
+static int LispDoWriteAtom(LispObj*, const char*, int, int);
 static int LispWriteList(LispObj*, LispObj*, write_info*, int);
 static int LispWriteArray(LispObj*, LispObj*, write_info*);
 static int LispWriteStruct(LispObj*, LispObj*, write_info*);
@@ -861,7 +861,8 @@ LispDoWriteObject(LispObj *stream, LispObj *object, write_info *info, int paren)
 {
     long print_level;
     int length = 0;
-    char stk[64], *string = NULL;
+    char stk[64];
+    const char *string = NULL;
 
 write_again:
     switch (OBJECT_TYPE(object)) {
@@ -1195,7 +1196,7 @@ LispWriteChars(LispObj *stream, int character, int count)
 
 /* write a string to stream */
 int
-LispWriteStr(LispObj *stream, char *buffer, long length)
+LispWriteStr(LispObj *stream, const char *buffer, long length)
 {
     LispFile *file;
     LispString *string;
@@ -1207,7 +1208,7 @@ LispWriteStr(LispObj *stream, char *buffer, long length)
 }
 
 static int
-LispDoWriteAtom(LispObj *stream, char *string, int length, int print_case)
+LispDoWriteAtom(LispObj *stream, const char *string, int length, int print_case)
 {
     int bytes = 0, cap = 0;
     char buffer[128], *ptr;
@@ -1653,30 +1654,30 @@ LispFormatRomanInteger(LispObj *stream, long value, int new_roman)
 int
 LispFormatEnglishInteger(LispObj *stream, long number, int ordinal)
 {
-    static char *ds[] = {
+    static const char *ds[] = {
 	"",	      "one",	   "two",	 "three",      "four",
 	"five",       "six",	   "seven",	 "eight",      "nine",
 	"ten",	      "eleven",    "twelve",	 "thirteen",   "fourteen",
 	"fifteen",    "sixteen",   "seventeen",  "eighteen",   "nineteen"
     };
-    static char *dsth[] = {
+    static const char *dsth[] = {
 	"",	      "first",	   "second",	  "third",	"fourth",
 	"fifth",      "sixth",	   "seventh",	  "eighth",	"ninth",
 	"tenth",      "eleventh",  "twelfth",	  "thirteenth", "fourteenth",
 	 "fifteenth", "sixteenth", "seventeenth", "eighteenth", "nineteenth"
     };
-    static char *hs[] = {
+    static const char *hs[] = {
 	"",	      "",	   "twenty",	  "thirty",	"forty",
 	"fifty",      "sixty",	   "seventy",	  "eighty",	"ninety"
     };
-    static char *hsth[] = {
+    static const char *hsth[] = {
 	"",	      "",	   "twentieth",   "thirtieth",	"fortieth",
        "fiftieth",    "sixtieth",  "seventieth",  "eightieth",	"ninetieth"
     };
-    static char *ts[] = {
+    static const char *ts[] = {
 	"",	      "thousand",   "million"
     };
-    static char *tsth[] = {
+    static const char *tsth[] = {
 	"",	     "thousandth", "millionth"
     };
     char stk[256];
@@ -1704,7 +1705,7 @@ LispFormatEnglishInteger(LispObj *stream, long number, int ordinal)
     }
     for (;;) {
 	int count, temp;
-	char *t, *h, *d;
+	const char *t, *h, *d;
 	long value = number;
 
 	for (count = 0; value >= 1000; value /= 1000, count++)
@@ -1811,7 +1812,7 @@ LispFormatCharacter(LispObj *stream, LispObj *object,
     if (atsign && !collon)
 	length += LispWriteStr(stream, "#\\", 2);
     if ((atsign || collon) && (ch <= ' ' || ch == 0177)) {
-	char *name = LispChars[ch].names[0];
+	const char *name = LispChars[ch].names[0];
 
 	length += LispWriteStr(stream, name, strlen(name));
     }
diff --git a/lisp/write.h b/lisp/write.h
index b66ba6b..57d7227 100644
--- a/lisp/write.h
+++ b/lisp/write.h
@@ -53,7 +53,7 @@ int LispGetColumn(LispObj*);
 
 int LispWriteChar(LispObj*, int);
 int LispWriteChars(LispObj*, int, int);
-int LispWriteStr(LispObj*, char*, long);
+int LispWriteStr(LispObj*, const char*, long);
 
 	/* write any lisp object to stream */
 int LispWriteObject(LispObj*, LispObj*);
diff --git a/util.c b/util.c
index 2378b40..bbc8ea9 100644
--- a/util.c
+++ b/util.c
@@ -184,7 +184,7 @@ GetString(Widget w)
  */
 
 FileAccess
-MaybeCreateFile(char *file)
+MaybeCreateFile(const char *file)
 {
     Boolean exists;
     int fd;
@@ -200,7 +200,7 @@ MaybeCreateFile(char *file)
 
 
 FileAccess
-CheckFilePermissions(char *file, Boolean *exists)
+CheckFilePermissions(const char *file, Boolean *exists)
 {
     char temp[BUFSIZ], *ptr;
 
@@ -230,7 +230,7 @@ CheckFilePermissions(char *file, Boolean *exists)
 }
 
 xedit_flist_item *
-AddTextSource(Widget source, char *name, char *filename, int flags,
+AddTextSource(Widget source, const char *name, const char *filename, int flags,
 	      FileAccess file_access)
 {
     xedit_flist_item *item;
@@ -367,7 +367,7 @@ KillTextSource(xedit_flist_item *item)
 }
 
 xedit_flist_item *
-FindTextSource(Widget source, char *filename)
+FindTextSource(Widget source, const char *filename)
 {
     unsigned i;
 
diff --git a/util.h b/util.h
index 9717589..0bbe93d 100644
--- a/util.h
+++ b/util.h
@@ -64,7 +64,7 @@ struct _hash_table {
 hash_table *hash_new(unsigned int length, hash_compare compare);
 hash_entry *hash_put(hash_table *hash, hash_entry *entry);
 hash_entry *hash_get(hash_table *hash, hash_key *name);
-hash_entry * hash_check(hash_table *hash, char *name, unsigned int length);
+hash_entry * hash_check(hash_table *hash, const char *name, unsigned int length);
 void hash_rem(hash_table *hash, hash_entry *entry);
 /* Removes from hash table but doesn't release any memory */
 hash_entry *hash_rem_no_free(hash_table *hash, hash_entry *entry);
diff --git a/xedit.h b/xedit.h
index 4a9a468..7166798 100644
--- a/xedit.h
+++ b/xedit.h
@@ -122,9 +122,9 @@ void XeditPrintf(const char *format, ...);
 Widget MakeCommandButton(Widget, char*, XtCallbackProc);
 Widget MakeStringBox(Widget, String, String);
 String GetString(Widget);
-FileAccess MaybeCreateFile(char*), CheckFilePermissions(char*, Boolean*);
-xedit_flist_item *AddTextSource(Widget, String, String, int, FileAccess);
-xedit_flist_item *FindTextSource(Widget, char*);
+FileAccess MaybeCreateFile(const char*), CheckFilePermissions(const char*, Boolean*);
+xedit_flist_item *AddTextSource(Widget, const char *, const char *, int, FileAccess);
+xedit_flist_item *FindTextSource(Widget, const char*);
 Bool KillTextSource(xedit_flist_item*);
 char *ResolveName(char*);
 void DeleteWindow(Widget, XEvent*, String*, Cardinal*);