Constified a bunch of stuff.... it was bound to happen anyway.

git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk/SWIG@263 626c5289-ae23-0410-ae9c-e8d60b6d4f22

7 files changed, 80 insertions, 80 deletions

diff --git a/Source/DOH/Doh/base.c b/Source/DOH/Doh/base.c
index 6c4dcf0bc..b8f2dd81a 100644
--- a/Source/DOH/Doh/base.c
+++ b/Source/DOH/Doh/base.c
@@ -112,14 +112,14 @@ DohIntern(DOH *obj) {
  * ----------------------------------------------------------------------------- */
 
 DOH *
-DohCopy(DOH *obj) {
+DohCopy(const DOH *obj) {
   DohBase *b = (DohBase *) obj;
   DohTrace(DOH_CALLS,"DohCopy %x\n",obj);
   if (!DohCheck(b)) {
     DohTrace(DOH_UNKNOWN,"Unknown object %x passed to Copy.\n", obj);
     return 0;
   }
-  if (b->objinfo->doh_copy) return (b->objinfo->doh_copy)(obj);
+  if (b->objinfo->doh_copy) return (b->objinfo->doh_copy)(b);
   DohTrace(DOH_UNSUPPORTED,"No copy method defined for type '%s'\n", b->objinfo->objname);
   return 0;
 }
@@ -175,7 +175,7 @@ DohSetScope(DOH *obj, int s) {
  * ----------------------------------------------------------------------------- */
 
 DOH *
-DohStr(DOH *obj) {
+DohStr(const DOH *obj) {
   DOH *s;
   DohBase *b = (DohBase *) obj; 
   DohTrace(DOH_CALLS,"DohStr %x\n",obj);
@@ -200,7 +200,7 @@ DohStr(DOH *obj) {
  * ----------------------------------------------------------------------------- */
 
 int
-DohDump(DOH *obj, DOH *out) {
+DohDump(const DOH *obj, DOH *out) {
   DohBase *b = (DohBase *) obj;
   DohTrace(DOH_CALLS,"DohDump %x, %x\n",obj,out);
   if (DohCheck(obj)) {
@@ -221,13 +221,13 @@ DohDump(DOH *obj, DOH *out) {
  * is invoked on it.
  * ----------------------------------------------------------------------------- */
 int
-DohLen(DOH *obj) {
+DohLen(const DOH *obj) {
   DohBase *b = (DohBase *) obj;
   DohTrace(DOH_CALLS,"DohLen %x\n",obj);
   if (!b) return 0;
   if (DohCheck(b)) {
     if (b->objinfo->doh_len) {
-      return (b->objinfo->doh_len)(obj);
+      return (b->objinfo->doh_len)(b);
     }
     DohTrace(DOH_UNSUPPORTED, "No len method defined for type '%s'\n", b->objinfo->objname);
   } else {
@@ -245,12 +245,12 @@ DohLen(DOH *obj) {
  * ----------------------------------------------------------------------------- */
 
 int
-DohHashval(DOH *obj) {
+DohHashval(const DOH *obj) {
   DohBase *b = (DohBase *) obj;
   DohTrace(DOH_CALLS,"DohHashval %x\n",obj);
   if (DohCheck(b)) {
     if (b->objinfo->doh_hash) {
-      return (b->objinfo->doh_hash)(obj);
+      return (b->objinfo->doh_hash)(b);
     }
     DohTrace(DOH_UNSUPPORTED,"No hash method defined for type '%s'\n", b->objinfo->objname);
   } else {
@@ -266,13 +266,13 @@ DohHashval(DOH *obj) {
  * ----------------------------------------------------------------------------- */
 
 void *
-DohData(DOH *obj) {
+DohData(const DOH *obj) {
   DohBase *b = (DohBase *) obj;
   DohTrace(DOH_CALLS,"DohData %x\n",obj);
   if (DohCheck(obj)) {
     if (b->objinfo) {
       if (b->objinfo->doh_data) {
-	return (b->objinfo->doh_data)(obj);
+	return (b->objinfo->doh_data)(b);
       }
     }
     DohTrace(DOH_UNSUPPORTED,"No data method defined for type '%s'\n", b->objinfo->objname);
@@ -294,7 +294,7 @@ DohGetline(DOH *obj) {
   DohTrace(DOH_CALLS,"DohGetline %x\n",obj);
   if (DohCheck(obj)) {
     if (b->objinfo->doh_position && b->objinfo->doh_position->doh_getline) {
-      return (b->objinfo->doh_position->doh_getline)(obj);
+      return (b->objinfo->doh_position->doh_getline)(b);
     } else {
       DohTrace(DOH_UNSUPPORTED,"No getline method defined for type '%s'\n", b->objinfo->objname);
       return -1;
@@ -337,7 +337,7 @@ DohGetfile(DOH *obj) {
   DohTrace(DOH_CALLS,"DohGetfile %x\n",obj);
   if (DohCheck(obj)) {
     if (b->objinfo->doh_position && b->objinfo->doh_position->doh_getfile) {
-      return (b->objinfo->doh_position->doh_getfile)(obj);
+      return (b->objinfo->doh_position->doh_getfile)(b);
     }
     DohTrace(DOH_UNSUPPORTED,"No getfile method defined for type '%s'\n", b->objinfo->objname);
   } else {
@@ -375,7 +375,7 @@ DohSetfile(DOH *obj, DOH *file) {
  * ----------------------------------------------------------------------------- */
  
 int
-DohCmp(DOH *obj1, DOH *obj2) {
+DohCmp(const DOH *obj1, const DOH *obj2) {
   DohBase *b1, *b2;
   DohTrace(DOH_CALLS,"DohCmp %x, %x\n",obj1,obj2);
   b1 = (DohBase *) obj1;
@@ -401,7 +401,7 @@ DohCmp(DOH *obj1, DOH *obj2) {
  * ----------------------------------------------------------------------------- */
 
 int 
-DohIsMapping(DOH *obj) {
+DohIsMapping(const DOH *obj) {
   DohBase *b = (DohBase *) obj;
   if (!DohCheck(b)) return 0;
   if (b->objinfo->doh_mapping) return 1;
@@ -415,12 +415,12 @@ DohIsMapping(DOH *obj) {
  * ----------------------------------------------------------------------------- */
 
 DOH *
-DohGetattr(DOH *obj, DOH *name) {
+DohGetattr(DOH *obj, const DOH *name) {
   DohBase *b = (DohBase *) obj;
   DohTrace(DOH_CALLS,"DohGetattr %x, %x\n",obj,name);
   if (DohIsMapping(b)) {
     if (b->objinfo->doh_mapping->doh_getattr) {
-      return (b->objinfo->doh_mapping->doh_getattr)(obj,name);
+      return (b->objinfo->doh_mapping->doh_getattr)(b,(DOH *) name);
     }
   }
   if (DohCheck(b)) {
@@ -438,12 +438,12 @@ DohGetattr(DOH *obj, DOH *name) {
  * ----------------------------------------------------------------------------- */
 
 int 
-DohSetattr(DOH *obj, DOH *name, DOH *value) {
+DohSetattr(DOH *obj, const DOH *name, const DOH *value) {
   DohBase *b = (DohBase *) obj;
   DohTrace(DOH_CALLS,"DohSetattr %x, %x, %x\n",obj,name, value);
   if (DohIsMapping(b)) {
     if (b->objinfo->doh_mapping->doh_setattr) {
-      return (b->objinfo->doh_mapping->doh_setattr)(obj,name,value);
+      return (b->objinfo->doh_mapping->doh_setattr)(b,(DOH *) name,(DOH *) value);
     }
   }
   if (DohCheck(b)) {
@@ -461,12 +461,12 @@ DohSetattr(DOH *obj, DOH *name, DOH *value) {
  * ----------------------------------------------------------------------------- */
 
 void
-DohDelattr(DOH *obj, DOH *name) {
+DohDelattr(DOH *obj, const DOH *name) {
   DohBase *b = (DohBase *) obj;
   DohTrace(DOH_CALLS,"DohDelattr %x, %x\n",obj,name);
   if (DohIsMapping(obj)) {
     if (b->objinfo->doh_mapping->doh_delattr) {
-      (b->objinfo->doh_mapping->doh_delattr)(obj,name);
+      (b->objinfo->doh_mapping->doh_delattr)(b,(DOH *) name);
       return;
     }
   }
@@ -530,10 +530,10 @@ DohNextkey(DOH *obj) {
  * ----------------------------------------------------------------------------- */
 
 int 
-DohGetInt(DOH *obj, DOH *name) {
+DohGetInt(DOH *obj, const DOH *name) {
   DOH *val;
   DohTrace(DOH_CALLS,"DohGetInt %x, %x\n",obj,name);  
-  val = Getattr(obj,name);
+  val = Getattr(obj,(DOH *) name);
   if (!val) return 0;
   if (DohIsString(val)) {
     return atoi(Data(val));
@@ -548,10 +548,10 @@ DohGetInt(DOH *obj, DOH *name) {
  * ----------------------------------------------------------------------------- */
 
 double
-DohGetDouble(DOH *obj, DOH *name) {
+DohGetDouble(DOH *obj, const DOH *name) {
   DOH *val;
   DohTrace(DOH_CALLS,"DohGetDouble %x, %x\n",obj,name);  
-  val = Getattr(obj,name);
+  val = Getattr(obj,(DOH *) name);
   if (!val) return 0;
   if (DohIsString(val)) {
     return atof(Data(val));
@@ -566,10 +566,10 @@ DohGetDouble(DOH *obj, DOH *name) {
  * ----------------------------------------------------------------------------- */
 
 char *
-DohGetChar(DOH *obj, DOH *name) {
+DohGetChar(DOH *obj, const DOH *name) {
   DOH *val;
   DohTrace(DOH_CALLS,"DohGetChar %x, %x\n",obj,name);  
-  val = Getattr(obj,name);
+  val = Getattr(obj,(DOH *) name);
   if (!val) return 0;
   if (DohIsString(val)) {
     return (char *) Data(val);
@@ -584,12 +584,12 @@ DohGetChar(DOH *obj, DOH *name) {
  * ----------------------------------------------------------------------------- */
 
 void
-DohSetInt(DOH *obj, DOH *name, int value) {
+DohSetInt(DOH *obj, const DOH *name, int value) {
   DOH *temp;
   DohTrace(DOH_CALLS,"DohSetInt %x, %x, %d\n", obj, name, value);
   temp = NewString("");
   Printf(temp,"%d",value);
-  Setattr(obj,name,temp);
+  Setattr(obj,(DOH *) name,temp);
 }
 
 /* ----------------------------------------------------------------------------- 
@@ -599,12 +599,12 @@ DohSetInt(DOH *obj, DOH *name, int value) {
  * ----------------------------------------------------------------------------- */
 
 void
-DohSetDouble(DOH *obj, DOH *name, double value) {
+DohSetDouble(DOH *obj, const DOH *name, double value) {
   DOH *temp;
   DohTrace(DOH_CALLS,"DohSetDouble %x, %x, %g\n", obj, name, value);
   temp = NewString("");
   Printf(temp,"%0.17f",value);
-  Setattr(obj,name,temp);
+  Setattr(obj,(DOH *) name,temp);
 }
 
 /* -----------------------------------------------------------------------------
@@ -614,11 +614,11 @@ DohSetDouble(DOH *obj, DOH *name, double value) {
  * ----------------------------------------------------------------------------- */
 
 void
-DohSetChar(DOH *obj, DOH *name, char *value) {
+DohSetChar(DOH *obj, const DOH *name, char *value) {
   DOH *temp;
   DohTrace(DOH_CALLS,"DohSetChar %x, %x, %g\n", obj, name, value);
   temp = NewString(value);
-  Setattr(obj,name,temp);
+  Setattr(obj,(DOH *) name,temp);
 }
 
 /* ----------------------------------------------------------------------
@@ -632,7 +632,7 @@ DohSetChar(DOH *obj, DOH *name, char *value) {
  * ----------------------------------------------------------------------------- */
 
 int 
-DohIsSequence(DOH *obj) {
+DohIsSequence(const DOH *obj) {
   DohBase *b = (DohBase *) obj;
   if (!DohCheck(b)) return 0;
   if (b->objinfo->doh_sequence) return 1;
@@ -669,12 +669,12 @@ DohGetitem(DOH *obj, int index) {
  * ----------------------------------------------------------------------------- */
    
 int 
-DohSetitem(DOH *obj, int index, DOH *value) {
+DohSetitem(DOH *obj, int index, const DOH *value) {
   DohBase *b = (DohBase *) obj;
   DohTrace(DOH_CALLS,"DohSetitem %x, %d, %x\n",obj,index, value);  
   if (DohIsSequence(obj)) {
     if (b->objinfo->doh_sequence->doh_setitem) {
-      return (b->objinfo->doh_sequence->doh_setitem)(obj,index,value);
+      return (b->objinfo->doh_sequence->doh_setitem)(obj,index,(DOH *) value);
     }
   }
   if (DohCheck(obj)) {
@@ -713,13 +713,13 @@ DohDelitem(DOH *obj, int index) {
  * ----------------------------------------------------------------------------- */
 
 int 
-DohInsertitem(DOH *obj, int index, DOH *value) {
+DohInsertitem(DOH *obj, int index, const DOH *value) {
   int  no = 0;
   DohBase *b = (DohBase *) obj;
   DohTrace(DOH_CALLS,"DohInsertitem %x, %d, %x\n",obj,index, value);
   if (DohIsSequence(obj)) {
     if (b->objinfo->doh_sequence->doh_insitem) {
-      return (b->objinfo->doh_sequence->doh_insitem)(obj,index,value);
+      return (b->objinfo->doh_sequence->doh_insitem)(obj,index,(DOH *) value);
     }
   }
   if (DohCheck(obj)) {
@@ -786,7 +786,7 @@ DohNextitem(DOH *obj) {
  * ----------------------------------------------------------------------------- */
 
 int 
-DohIsFile(DOH *obj) {
+DohIsFile(const DOH *obj) {
   DohBase *b = (DohBase *) obj;
   if (!DohCheck(b)) return 0;
   if (b->objinfo->doh_file) return 1;
@@ -989,7 +989,7 @@ DohClose(DOH *obj) {
  * ----------------------------------------------------------------------------- */
 
 int 
-DohIsString(DOH *obj) {
+DohIsString(const DOH *obj) {
   DohBase *b = (DohBase *) obj;
   if (!DohCheck(b)) return 0;
   if (b->objinfo->doh_string) return 1;
@@ -1003,12 +1003,12 @@ DohIsString(DOH *obj) {
  * ----------------------------------------------------------------------------- */
 
 int 
-DohReplace(DOH *src, DOH *token, DOH *rep, int flags) {
+DohReplace(DOH *src, const DOH *token, const DOH *rep, int flags) {
   DohBase *b = (DohBase *) src;
   DohTrace(DOH_CALLS, "DohReplace %x\n", src);
   if (DohIsString(src)) {
     if (b->objinfo->doh_string->doh_replace) {
-      return (b->objinfo->doh_string->doh_replace)(src,token,rep,flags);
+      return (b->objinfo->doh_string->doh_replace)(src,(DOH *) token, (DOH *) rep,flags);
     }
   }
   if (DohCheck(b)) {
@@ -1052,7 +1052,7 @@ DohChop(DOH *src) {
  * ----------------------------------------------------------------------------- */
 
 int 
-DohIsCallable(DOH *obj) {
+DohIsCallable(const DOH *obj) {
   DohBase *b = (DohBase *) obj;
   if (!DohCheck(b)) return 0;
   if (b->objinfo->doh_callable) return 1;
diff --git a/Source/DOH/Doh/fio.c b/Source/DOH/Doh/fio.c
index dec8b73d4..9dc4921f9 100644
--- a/Source/DOH/Doh/fio.c
+++ b/Source/DOH/Doh/fio.c
@@ -85,11 +85,11 @@ static DOH *encode(char *name,  DOH *s) {
  * ----------------------------------------------------------------------------- */
 
 int
-DohvPrintf(DOH *so, char *format, va_list ap)
+DohvPrintf(DOH *so, const char *format, va_list ap)
 {
   static char *fmt_codes = "dioxXucsSfeEgGpn";
   int state = 0;
-  char *p = format;
+  const char *p = format;
   char  newformat[256];
   char  obuffer[OBUFLEN];
   char *fmt = 0;
@@ -376,7 +376,7 @@ DohvPrintf(DOH *so, char *format, va_list ap)
  * ----------------------------------------------------------------------------- */
 
 int
-DohPrintf(DOH *obj, char *format, ...) {
+DohPrintf(DOH *obj, const char *format, ...) {
   va_list ap;
   int ret;
   va_start(ap,format);
diff --git a/Source/DOH/Doh/hash.c b/Source/DOH/Doh/hash.c
index c293ee2fb..b9dae989f 100644
--- a/Source/DOH/Doh/hash.c
+++ b/Source/DOH/Doh/hash.c
@@ -525,7 +525,7 @@ static DohObjInfo HashType = {
  * ----------------------------------------------------------------------------- */
 
 int
-Hash_check(DOH *so) {
+Hash_check(const DOH *so) {
     Hash *h = (Hash *) so;
     if (!h) return 0;
     if (!DohCheck(so)) return 0;
diff --git a/Source/DOH/Doh/list.c b/Source/DOH/Doh/list.c
index 31a16421c..a73409b0f 100644
--- a/Source/DOH/Doh/list.c
+++ b/Source/DOH/Doh/list.c
@@ -364,7 +364,7 @@ static DohObjInfo ListType = {
  * Return 1 if an object is a List object.
  * ----------------------------------------------------------------------------- */
 int
-List_check(DOH *lo) {
+List_check(const DOH *lo) {
     List *l = (List *) lo;
     if (!l) return 0;
     if (!DohCheck(lo)) return 0;
diff --git a/Source/DOH/Doh/memory.c b/Source/DOH/Doh/memory.c
index 5ab8580d3..3d603e6bf 100644
--- a/Source/DOH/Doh/memory.c
+++ b/Source/DOH/Doh/memory.c
@@ -105,7 +105,7 @@ InitPools() {
  * ---------------------------------------------------------------------- */
 
 int 
-DohCheck(DOH *ptr) {
+DohCheck(const DOH *ptr) {
   Pool *p = Pools;
   char *cptr = (char *) ptr;
   while (p) {
diff --git a/Source/DOH/Doh/string.c b/Source/DOH/Doh/string.c
index 61862527b..98aa6392b 100644
--- a/Source/DOH/Doh/string.c
+++ b/Source/DOH/Doh/string.c
@@ -182,7 +182,7 @@ NewString(const DOH *so)
  * ----------------------------------------------------------------------------- */
 
 DOH *
-NewStringf(DOH *fmt, ...)
+NewStringf(const DOH *fmt, ...)
 {
   va_list ap;
   DOH *r;
@@ -239,7 +239,7 @@ DelString(DOH *so) {
  * int String_check(DOH *s) - Check if s is a string
  * ----------------------------------------------------------------------------- */
 int
-String_check(DOH *s)
+String_check(const DOH *s)
 {
   char *c = (char *) s;
   if (!s) return 0;
diff --git a/Source/DOH/Include/doh.h b/Source/DOH/Include/doh.h
index f91cdc5fa..996fa5fe3 100644
--- a/Source/DOH/Include/doh.h
+++ b/Source/DOH/Include/doh.h
@@ -139,7 +139,7 @@ typedef struct DohObjInfo {
   extern int     DohObjFreeCheck(DOH *ptr);          /* Check if already free */
   extern void    DohInit(DOH *obj);                  /* Initialize an object  */
   extern void    DohXInit(DOH *obj);                 /* Initialize extended object */
-  extern int     DohCheck(DOH *ptr);                 /* Check if a DOH object */
+  extern int     DohCheck(const DOH *ptr);           /* Check if a DOH object */
   extern int     DohPoolSize(int);                   /* Set memory alloc size */
   extern int     DohNewScope();                      /* Create a new scope    */
   extern void    DohDelScope(int);                   /* Delete a scope        */
@@ -150,35 +150,35 @@ typedef struct DohObjInfo {
   /* Basic object methods.  Common to most objects */
 
   extern void    DohDelete(DOH *obj);                /* Delete an object      */
-  extern DOH    *DohCopy(DOH *obj);
+  extern DOH    *DohCopy(const DOH *obj);
   extern void    DohClear(DOH *obj);
   extern void    DohSetScope(DOH *, int scp);        /* Set scope of object   */
-  extern DOH    *DohStr(DOH *obj);
-  extern void   *DohData(DOH *obj);
-  extern int     DohDump(DOH *obj, DOH *out);
-  extern int     DohLen(DOH *obj);
-  extern int     DohHashval(DOH *obj);
-  extern int     DohCmp(DOH *obj1, DOH *obj2);
+  extern DOH    *DohStr(const DOH *obj);
+  extern void   *DohData(const DOH *obj);
+  extern int     DohDump(const DOH *obj, DOH *out);
+  extern int     DohLen(const DOH *obj);
+  extern int     DohHashval(const DOH *obj);
+  extern int     DohCmp(const DOH *obj1, const DOH *obj2);
 
   /* Mapping methods */
 
-  extern DOH    *DohGetattr(DOH *obj, DOH *name);
-  extern int     DohSetattr(DOH *obj, DOH *name, DOH *value);
-  extern void    DohDelattr(DOH *obj, DOH *name);
+  extern DOH    *DohGetattr(DOH *obj, const DOH *name);
+  extern int     DohSetattr(DOH *obj, const DOH *name, const DOH *value);
+  extern void    DohDelattr(DOH *obj, const DOH *name);
   extern DOH    *DohFirstkey(DOH *obj);
   extern DOH    *DohNextkey(DOH *obj);
-  extern int     DohGetInt(DOH *obj, DOH *name);
-  extern double  DohGetDouble(DOH *obj, DOH *name);
-  extern char   *DohGetChar(DOH *obj, DOH *name);
-  extern void    DohSetInt(DOH *obj, DOH *name, int);
-  extern void    DohSetDouble(DOH *obj, DOH *name, double);
+  extern int     DohGetInt(DOH *obj, const DOH *name);
+  extern double  DohGetDouble(DOH *obj, const DOH *name);
+  extern char   *DohGetChar(DOH *obj, const DOH *name);
+  extern void    DohSetInt(DOH *obj, const DOH *name, int);
+  extern void    DohSetDouble(DOH *obj, const DOH *name, double);
 
   /* Sequence methods */
 
   extern DOH    *DohGetitem(DOH *obj, int index);
-  extern int     DohSetitem(DOH *obj, int index, DOH *value);
+  extern int     DohSetitem(DOH *obj, int index, const DOH *value);
   extern int     DohDelitem(DOH *obj, int index);
-  extern int     DohInsertitem(DOH *obj, int index, DOH *value);
+  extern int     DohInsertitem(DOH *obj, int index, const DOH *value);
   extern DOH    *DohFirstitem(DOH *obj);
   extern DOH    *DohNextitem(DOH *obj);
 
@@ -205,14 +205,14 @@ typedef struct DohObjInfo {
 
   /* String Methods */
 
-  extern int     DohReplace(DOH *src, DOH *token, DOH *rep, int flags);
+  extern int     DohReplace(DOH *src, const DOH *token, const DOH *rep, int flags);
   extern void    DohChop(DOH *src);
 
   /* Utility functions */
 
   extern void    DohEncoding(char *name, DOH *(*fn)(DOH *s));
-  extern int     DohPrintf(DOH *obj, char *format, ...);
-  extern int     DohvPrintf(DOH *obj, char *format, va_list ap);
+  extern int     DohPrintf(DOH *obj, const char *format, ...);
+  extern int     DohvPrintf(DOH *obj, const char *format, va_list ap);
   extern DOH    *DohReadline(DOH *in);
 
   /* Miscellaneous */
@@ -220,11 +220,11 @@ typedef struct DohObjInfo {
   extern void    DohTrace(int level, char *fmt,...);
   extern void    DohDebug(int d);
 
-  extern int     DohIsMapping(DOH *obj);
-  extern int     DohIsSequence(DOH *obj);
-  extern int     DohIsString(DOH *obj);
-  extern int     DohIsFile(DOH *obj);
-  extern int     DohIsCallable(DOH *obj);
+  extern int     DohIsMapping(const DOH *obj);
+  extern int     DohIsSequence(const DOH *obj);
+  extern int     DohIsString(const DOH *obj);
+  extern int     DohIsFile(const DOH *obj);
+  extern int     DohIsCallable(const DOH *obj);
 
 #ifndef DOH_LONG_NAMES
 /* Macros to invoke the above functions.  Includes the location of
@@ -327,9 +327,9 @@ typedef struct {
  * ----------------------------------------------------------------------------- */
 
 extern DOH   *NewString(const DOH *c);
-extern DOH   *NewStringf(DOH *fmt, ...);
+extern DOH   *NewStringf(const DOH *fmt, ...);
 
-extern int    String_check(DOH *s);
+extern int    String_check(const DOH *s);
 
 /* String replacement flags */
 
@@ -354,7 +354,7 @@ extern int  DohCopyto(DOH *input, DOH *output);
  * ----------------------------------------------------------------------------- */
 
 extern DOH  *NewList();
-extern int  List_check(DOH *);
+extern int  List_check(const DOH *);
 extern void List_sort(DOH *);
 
 /* -----------------------------------------------------------------------------
@@ -362,7 +362,7 @@ extern void List_sort(DOH *);
  * ----------------------------------------------------------------------------- */
 
 extern DOH   *NewHash();
-extern int    Hash_check(DOH *h);
+extern int    Hash_check(const DOH *h);
 extern DOH   *Hash_keys(DOH *);
 
 /* -----------------------------------------------------------------------------