From 9f0f4a2c5495eec2d81a4381fb962fad93b2ddde Mon Sep 17 00:00:00 2001 From: Alan Coopersmith Date: Tue, 9 Sep 2014 20:05:27 -0700 Subject: Copious const cleanup MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Removes 1554 gcc warnings of "discards ‘const’ qualifier" Signed-off-by: Alan Coopersmith --- lisp/compile.c | 2 +- lisp/core.c | 3 +- lisp/debugger.c | 16 +++++----- lisp/format.c | 43 ++++++++++++------------- lisp/internal.h | 50 ++++++++++++++--------------- lisp/io.c | 37 ++++++++++------------ lisp/io.h | 16 +++++----- lisp/lisp.c | 97 ++++++++++++++++++++++++++++++--------------------------- lisp/lisp.h | 2 +- lisp/mathimp.c | 4 +-- lisp/package.c | 6 ++-- lisp/package.h | 4 +-- lisp/pathname.c | 3 +- lisp/private.h | 13 ++++---- lisp/re/re.c | 4 +-- lisp/read.c | 81 +++++++++++++++++++++++------------------------ lisp/stream.c | 2 +- lisp/write.c | 25 ++++++++------- lisp/write.h | 2 +- 19 files changed, 208 insertions(+), 202 deletions(-) (limited to 'lisp') 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*); -- cgit v1.2.3