Pass const pointers into all write routines.

git-svn-id: http://svn.cactuscode.org/arrangements/CactusExternal/FlexIO/trunk@17 21a6bef8-4479-4f54-8f8d-0db94a2919ef

12 files changed, 113 insertions, 101 deletions

diff --git a/src/H5IO.cc b/src/H5IO.cc
index f41471b..91c460c 100644
--- a/src/H5IO.cc
+++ b/src/H5IO.cc
@@ -347,7 +347,7 @@ H5IO::~H5IO(){
 
 int H5IO::isValid() { return filevalid; }
 
-int H5IO::write(IObase::DataType typeID,int rank,CONST int *dims,void *data){
+int H5IO::write(IObase::DataType typeID,int rank,CONST int *dims,const void *data){
   hasread=0;
   //printf("++Write index=%u\n",index);
   createdataset(typeID,rank,dims);
@@ -466,7 +466,7 @@ int H5IO::nAnnotations(){
   return 1;
 }
 
-int H5IO::writeAttribute(CONST char *name,IObase::DataType typeID,Long length,void *data){
+int H5IO::writeAttribute(CONST char *name,IObase::DataType typeID,Long length,const void *data){
   //printf("writeAttrib index=%u\n",index);
   selectdataset(index); // make sure it is selected
   //printf("\tindex=%u\n",index);
@@ -580,7 +580,7 @@ int H5IO::reserveChunk(IObase::DataType typeID,int rank,CONST int *dims){
   return 1;
 }
 
-int H5IO::writeChunk(CONST int *dims,CONST int *origin,void *data){
+int H5IO::writeChunk(CONST int *dims,CONST int *origin,const void *data){
 #if 0
   int32 horigin[5]={0,0,0,0,0};
   int32 stride[5]={1,1,1,1,1}; // kludge... we'll fix later
diff --git a/src/H5IO.hh b/src/H5IO.hh
index 97ded33..de6f144 100644
--- a/src/H5IO.hh
+++ b/src/H5IO.hh
@@ -71,7 +71,7 @@ public:
   H5IO(CONST char *fname,AccessMode access);
   virtual ~H5IO();
   virtual int isValid();
-  virtual int write(IObase::DataType typeID,int rank,CONST int *dims,void *data); 
+  virtual int write(IObase::DataType typeID,int rank,CONST int *dims,const void *data); 
   // virtual int write(char *name,IObase::DataType typeID,int rank,CONST int *dims,void *data);
   virtual int readInfo(IObase::DataType &typeID,int &rank,int *dims,int maxdims=3);
   virtual int readInfo(char *name,IObase::DataType &typeID,int &rank,int *dims,int maxdims=3);
@@ -83,7 +83,7 @@ public:
   virtual int readAnnotation(int index,char *annotation,int maxlen); // changed
   virtual int nAnnotations(); // New
 
-  virtual int writeAttribute(CONST char *name,IObase::DataType typeID,Long length,void *data); // New
+  virtual int writeAttribute(CONST char *name,IObase::DataType typeID,Long length,const void *data); // New
   virtual int readAttributeInfo(int number,char *name,IObase::DataType &typeID,Long &nelem,int maxnamelen=128); // New
   virtual int readAttributeInfo(CONST char *name,IObase::DataType &typeID,Long &nelem); // New
   virtual int readAttribute(int number,void *data); // New
@@ -92,11 +92,11 @@ public:
   
   //-----------------Chunking Utilities..................
   virtual int reserveChunk(IObase::DataType typeID,int rank,CONST int *dims);
-  virtual int writeChunk(CONST int *chunkdims,CONST int *chunkorigin,void *data);
+  virtual int writeChunk(CONST int *chunkdims,CONST int *chunkorigin,const void *data);
   virtual int readChunk(CONST int *chunkdims,CONST int *chunkorigin,void *data);
   //-----------------Streaming interface (for PANDA, Sockets & MPIO).........
   virtual int reserveStream(IObase::DataType typeID,int rank,CONST int *dims) {return -1; }
-  virtual int writeStream(void *data,int length){ return -1; } // not implemented yet
+  virtual int writeStream(const void *data,int length){ return -1; } // not implemented yet
   virtual int readStream(void *data,int length) { return -1; } // not implemented yet
   //----------------Special HDF5-specific methods.........
   // will put some hyperslab definition stuff here
diff --git a/src/HDFIO.cc b/src/HDFIO.cc
index 5005c70..c7fd568 100644
--- a/src/HDFIO.cc
+++ b/src/HDFIO.cc
@@ -118,7 +118,7 @@ HDFIO::~HDFIO(){
 
 int HDFIO::isValid() { if(fid>=0) return 1; else return 0; }
 
-int HDFIO::write(IObase::DataType typeID,int rank,CONST int *dims,void *data){
+int HDFIO::write(IObase::DataType typeID,int rank,CONST int *dims,const void *data){
   int32 origin[5]={0,0,0,0,0};
   int32 stride[5]={1,1,1,1,1}; // kludge... we'll fix later
   int32 hdims[5]={0,0,0,0,0};
@@ -212,7 +212,7 @@ int HDFIO::nAnnotations(){
   return 1; // always 1 annotation per object limit for HDF is appears 
 }
 
-int HDFIO::writeAttribute(CONST char *name,IObase::DataType typeID,Long length,void *data){
+int HDFIO::writeAttribute(CONST char *name,IObase::DataType typeID,Long length,const void *data){
   select(index); // select if not already selected
   //printf("write attrib: sdsid=%u index=%u\n",sid,index);
   return (int)SDsetattr(sid,(char*)name,DataType2HDF(typeID),(int32)length,data);
@@ -261,7 +261,7 @@ int HDFIO::reserveChunk(IObase::DataType typeID,int rank,CONST int *dims){
   return 1;
 }
 
-int HDFIO::writeChunk(CONST int *dims,CONST int *origin,void *data){
+int HDFIO::writeChunk(CONST int *dims,CONST int *origin,const void *data){
   int32 horigin[5]={0,0,0,0,0};
   int32 stride[5]={1,1,1,1,1}; // kludge... we'll fix later
   int32 hdims[5]={0,0,0,0,0};
@@ -314,7 +314,7 @@ int HDFIO::readDim(int dimnumber, void *dim){
   return 1;
 }
 
-int HDFIO::writeDim(int dimnumber,IObase::DataType datatype,int length,void *dim){
+int HDFIO::writeDim(int dimnumber,IObase::DataType datatype,int length,const void *dim){
   if(sid<0) return -1;
   int32 dim_id = SDgetdimid(sid,dimnumber);
   if(dim_id<0) return -1;
diff --git a/src/HDFIO.hh b/src/HDFIO.hh
index 5041030..6840e6c 100644
--- a/src/HDFIO.hh
+++ b/src/HDFIO.hh
@@ -17,7 +17,7 @@ public:
   HDFIO(CONST char *fname,AccessMode access);
   virtual ~HDFIO();
   virtual int isValid();
-  virtual int write(IObase::DataType typeID,int rank,CONST int *dims,void *data);
+  virtual int write(IObase::DataType typeID,int rank,CONST int *dims,const void *data);
   virtual int readInfo(IObase::DataType &typeID,int &rank,int *dims,int maxdims=3);
   virtual int readInfo(char *name,IObase::DataType &typeID,int &rank,int *dims,int maxdims=3);
   virtual int read(void *data);
@@ -28,7 +28,7 @@ public:
   virtual int readAnnotation(int index,char *annotation,int maxlen); // changed
   virtual int nAnnotations(); // New
 
-  virtual int writeAttribute(CONST char *name,IObase::DataType typeID,Long length,void *data); // New
+  virtual int writeAttribute(CONST char *name,IObase::DataType typeID,Long length,const void *data); // New
   virtual int readAttributeInfo(int number,char *name,IObase::DataType &typeID,Long &nelem,int maxnamelen=128); // New
   virtual int readAttributeInfo(CONST char *name,IObase::DataType &typeID,Long &nelem); // New
   virtual int readAttribute(int number,void *data); // New
@@ -37,17 +37,17 @@ public:
   
   //-----------------Chunking Utilities..................
   virtual int reserveChunk(IObase::DataType typeID,int rank,CONST int *dims);
-  virtual int writeChunk(CONST int *chunkdims,CONST int *chunkorigin,void *data);
+  virtual int writeChunk(CONST int *chunkdims,CONST int *chunkorigin,const void *data);
   virtual int readChunk(CONST int *chunkdims,CONST int *chunkorigin,void *data);
   //-----------------Streaming interface (for PANDA, Sockets & MPIO).........
   virtual int reserveStream(IObase::DataType typeID,int rank,CONST int *dims) {return -1; }
-  virtual int writeStream(void *data,int length){ return -1; } // not implemented yet
+  virtual int writeStream(const void *data,int length){ return -1; } // not implemented yet
   virtual int readStream(void *data,int length) { return -1; } // not implemented yet
   //----------------Special HDF-specific methods.........
   int isCoord(); // Tells whether the dataset is a coordinate or a dataset
   int readDimInfo(int dimnumber,char *name, IObase::DataType &datatype, int &length);
   int readDim(int dimnumber, void *dim);
-  int writeDim(int dimnumber,IObase::DataType datatype,int length,void *dim);
+  int writeDim(int dimnumber,IObase::DataType datatype,int length,const void *dim);
   int writeDimName(int dimnumber,CONST char *name);
 };
 
diff --git a/src/IEEEIO.cc b/src/IEEEIO.cc
index c2f653b..a71e381 100644
--- a/src/IEEEIO.cc
+++ b/src/IEEEIO.cc
@@ -445,8 +445,9 @@ void IEEEIO::buildRecordTable(){
   appendRecordTable();
 }
 
-void IEEEIO::openFile(CONST char *fname,IObase::AccessMode access,int swbytes){
-  switch(access){
+void IEEEIO::openFile(CONST char *fname,IObase::AccessMode amode,int swbytes){
+  swbytes = swbytes;
+  switch(amode){
   case IObase::Read:
     fid=open(fname,O_RDONLY,0644);
     if(fid<0){
@@ -549,14 +550,14 @@ IEEEIO::IEEEIO(IEEEIO *file): // read only dup
 }
 
 
-IEEEIO::IEEEIO(CONST char *fname, ExtendedAccessMode access,int swbytes):
-  IObase(fname,mode(access)),fid(-1),datasetnumber(0),
+IEEEIO::IEEEIO(CONST char *fname, ExtendedAccessMode amode,int swbytes):
+  IObase(fname,mode(amode)),fid(-1),datasetnumber(0),
   ndatasets(0),swapbytes(swbytes),hasread(0),masterfile(0),
   writebuffersize(0),writebuffercount(0),writebuffer(0),
   savedposition(-1),virtual_position(-1),actual_position(-1),
   file_length(-1)
 {
-  if(access==IEEEIO::SharedRead){
+  if(amode==IEEEIO::SharedRead){
     masterfile=this; // we are multi-reading
     fid=open(fname,O_RDONLY,0644);
     if(fid<0){
@@ -576,17 +577,17 @@ IEEEIO::IEEEIO(CONST char *fname, ExtendedAccessMode access,int swbytes):
     nextRecord(); // prime the recordnumber
   }
   else
-    openFile(fname,mode(access),swbytes);
+    openFile(fname,mode(amode),swbytes);
 }
 
-IEEEIO::IEEEIO(CONST char *fname,IObase::AccessMode access,int swbytes):
-  IObase(fname,access),fid(-1),datasetnumber(0),
+IEEEIO::IEEEIO(CONST char *fname,IObase::AccessMode amode,int swbytes):
+  IObase(fname,amode),fid(-1),datasetnumber(0),
   ndatasets(0),swapbytes(swbytes),hasread(0),masterfile(0),
   writebuffersize(0),writebuffercount(0),writebuffer(0),
   savedposition(-1)
 {
   //  Long8 fpos;
-  openFile(fname,access,swbytes);
+  openFile(fname,amode,swbytes);
 }
 
 IEEEIO::~IEEEIO(){
@@ -612,7 +613,7 @@ int IEEEIO::isValid(){
   else return 0;
 }
 
-int IEEEIO::write(IObase::DataType typeID,int rank,CONST int *dims,void *data){
+int IEEEIO::write(IObase::DataType typeID,int rank,CONST int *dims,const void *data){
   int i;
   RecordHdr rec;
   DataRecordHdr hdr;
@@ -651,16 +652,19 @@ int IEEEIO::write(IObase::DataType typeID,int rank,CONST int *dims,void *data){
   current_dat_offset=current_rec_offset=getPosition();
   DataRecordHdr::write(this,hdr);
   // write the dims.... (byteswap if necessary)
-  if(swapbytes) byteswapBuffer(chunkdims.getData(),rank,sizeof(Int));
-  IEEEIO::write(chunkdims.getData(),sizeof(Int)*rank);
-  if(swapbytes) byteswapBuffer(chunkdims.getData(),rank,sizeof(Int)); // swap back
-  if(swapbytes) byteswapBuffer(data,hdr.datasize/sizeOf(typeID),sizeOf(typeID));
+  union { void *data; const void *const_data;} cast_union;
+  cast_union.const_data = chunkdims.getData();
+  if(swapbytes) byteswapBuffer(cast_union.data,rank,sizeof(Int));
+  IEEEIO::write(cast_union.const_data,sizeof(Int)*rank);
+  if(swapbytes) byteswapBuffer(cast_union.data,rank,sizeof(Int)); // swap back
+  cast_union.const_data = data;
+  if(swapbytes) byteswapBuffer(cast_union.data,hdr.datasize/sizeOf(typeID),sizeOf(typeID));
   int sz = IEEEIO::write(data,hdr.datasize);
   // yeah! double bytswap seem stupid, but consider the alternatives
   // write one byte at a time (swapping as we go) == systemcall overhead
   // copy to a temporary buffer and swap bytes == malloc, copy, and free!
   // strangely its faster to swap twice
-  if(swapbytes) byteswapBuffer(data,hdr.datasize/sizeOf(typeID),sizeOf(typeID));
+  if(swapbytes) byteswapBuffer(cast_union.data,hdr.datasize/sizeOf(typeID),sizeOf(typeID));
   DataRef dref;
   dref.rec=current_rec;
   // Must find exact size!!!
@@ -847,7 +851,7 @@ int IEEEIO::nAnnotations(){
 }
 
 // for attributes
-int IEEEIO::writeAttribute(CONST char *name,IObase::DataType typeID,Long length,void *data){
+int IEEEIO::writeAttribute(CONST char *aname,IObase::DataType typeID,Long length,const void *data){
   int stringlen;
   AttribRef aref;
   RecordHdr rec;
@@ -858,7 +862,7 @@ int IEEEIO::writeAttribute(CONST char *name,IObase::DataType typeID,Long length,
     return 0;
   }
   if(accessmode==IObase::Read) return 0;
-  stringlen=strlen(name)+1;
+  stringlen=strlen(aname)+1;
 
   if(rec_table.getSize()>0){
     Long8 endpos = rec_table[rec_table.getSize()-1].end_offset;
@@ -882,37 +886,39 @@ int IEEEIO::writeAttribute(CONST char *name,IObase::DataType typeID,Long length,
     int lastindex;
     rec_table[datasetnumber].attributes.append(aref);
     lastindex=rec_table[datasetnumber].attributes.getSize()-1;
-    strcpy(rec_table[datasetnumber].attributes[lastindex].name,name);
+    strcpy(rec_table[datasetnumber].attributes[lastindex].name,aname);
   }
   // T3E Kludge
   RecordHdr::write(this,rec);
   AttributeRecordHdr::write(this,attrib);
   //printf("\tnow write the string\n");
-  IEEEIO::write(name,stringlen);
+  IEEEIO::write(aname,stringlen);
   //printf("\tdone IEEEIO::stringlen=%u typeid=%u\n",attrib.namesize,attrib.numbertype);
   // data is not byte-reversed...
   int sz=0;
-  if(swapbytes) byteswapBuffer(data,length,sizeOf(typeID));
-  IEEEIO::write(data,length*sizeOf(typeID));
-  if(swapbytes) byteswapBuffer(data,length,sizeOf(typeID)); // swap back
+  union { void *data; const void *const_data;} cast_union;
+  cast_union.const_data = data;
+  if(swapbytes) byteswapBuffer(cast_union.data,length,sizeOf(typeID));
+  IEEEIO::write(cast_union.const_data,length*sizeOf(typeID));
+  if(swapbytes) byteswapBuffer(cast_union.data,length,sizeOf(typeID)); // swap back
   if(accessmode != IObase::Write)
     rec_table[datasetnumber].end_offset=getPosition();
   // doesn't appear to store attributes properly
   return sz;
 }
 
-int IEEEIO::readAttributeInfo(int number,char *name,IObase::DataType &typeID,
+int IEEEIO::readAttributeInfo(int number,char *aname,IObase::DataType &typeID,
 			      Long &nelem,int maxnamelen){
   if(accessmode==IObase::Write) return -1;
   FlexArray<AttribRef> *attribs= &(rec_table[datasetnumber].attributes);
   if(number>=(*attribs).getSize()) return -1; // > number of attributes
   AttribRef *attrib=&((*attribs)[number]);
   if(strlen(attrib->name)>(size_t)maxnamelen){
-    strncpy(name,attrib->name,maxnamelen); // don't we want to copy the other way?
-    name[maxnamelen-1]='\0';
+    strncpy(aname,attrib->name,maxnamelen); // don't we want to copy the other way?
+    aname[maxnamelen-1]='\0';
   }
-  else strcpy(name,attrib->name);
-  name[maxnamelen-1]='\0'; // make certain it is null capped
+  else strcpy(aname,attrib->name);
+  aname[maxnamelen-1]='\0'; // make certain it is null capped
   AttributeRecordHdr attribhdr;
   IEEEIO::lseek((*attribs)[number].offset,L_SET);
   RecordHdr::read(this,current_rec);
@@ -926,12 +932,12 @@ int IEEEIO::readAttributeInfo(int number,char *name,IObase::DataType &typeID,
   return -1;
 }
 
-int IEEEIO::readAttributeInfo(CONST char *name,IObase::DataType &typeID,Long &nelem){
+int IEEEIO::readAttributeInfo(CONST char *aname,IObase::DataType &typeID,Long &nelem){
   // by name
   if(accessmode==IObase::Write) return -1;
   FlexArray<AttribRef> *attribs= &(rec_table[datasetnumber].attributes);
   for(int i=0;i<attribs->getSize();i++){
-    if(!strcmp(name,(*attribs)[i].name)){
+    if(!strcmp(aname,(*attribs)[i].name)){
       // must read the record to get this info
       AttributeRecordHdr attribhdr;
       IEEEIO::lseek((*attribs)[i].offset,L_SET);
@@ -1009,7 +1015,7 @@ int IEEEIO::reserveChunk(IObase::DataType typeID,int rank,CONST int *dims){
 
 // should also check for contiguous data (eg. slicing) and optimize for that layout
 // for now, the streaming interface best serves contiguous data.
-int IEEEIO::writeChunk(CONST int *dims,CONST int *origin,void *data){
+int IEEEIO::writeChunk(CONST int *dims,CONST int *origin,const void *data){
   int i,sz=-1;
   // make sure its the EOF
   if(accessmode==IObase::Read) {
@@ -1051,8 +1057,10 @@ int IEEEIO::writeChunk(CONST int *dims,CONST int *origin,void *data){
   maxindex=basefileoffset+current_dat.datasize;
   int ncolumns; // computed in loop below
   for(ncolumns=1,i=1;i<rank;i++) ncolumns*=dims[i];
+  union { void *data; const void *const_data; } cast_union;
+  cast_union.const_data = data;
   if(swapbytes) 
-    byteswapBuffer(data,IObase::nElements(rank,dims),typesize);
+    byteswapBuffer(cast_union.data,IObase::nElements(rank,dims),typesize);
   for(i=0;i<ncolumns;i++){ // read the columns
     if(originoffset<minindex){
       fprintf(stderr,"WriteChunk() inconsistency. Writing less than min index\n");
@@ -1070,7 +1078,7 @@ int IEEEIO::writeChunk(CONST int *dims,CONST int *origin,void *data){
 	      i,(unsigned int)originoffset,(unsigned int)maxindex,(unsigned int)chunkcolumnsize,(unsigned int)(originoffset+chunkcolumnsize));
     }
     IEEEIO::lseek(originoffset,L_SET);
-    sz=IEEEIO::write(((char*)data)+i*chunkcolumnsize,(int)chunkcolumnsize);
+    sz=IEEEIO::write(((const char*)data)+i*chunkcolumnsize,(int)chunkcolumnsize);
     originoffset+=filecolumnsize;
     for(Long8 j=1,idx=dims[1],planesize=filecolumnsize;
 	j<(rank-1) && !((i+1)%idx);
@@ -1082,7 +1090,7 @@ int IEEEIO::writeChunk(CONST int *dims,CONST int *origin,void *data){
   }
   // now swap the data back to native order...
   if(swapbytes) 
-    byteswapBuffer(data,IObase::nElements(rank,dims),typesize);
+    byteswapBuffer(cast_union.data,IObase::nElements(rank,dims),typesize);
 
   return sz;
 }
@@ -1169,9 +1177,11 @@ int IEEEIO::reserveStream(IObase::DataType typeID,int rank,CONST int *dims){
   RecordHdr::write(this,rec);
   current_dat_offset = current_rec_offset = getPosition();
   DataRecordHdr::write(this,hdr);
-  if(swapbytes) byteswapBuffer(chunkdims.getData(),rank,sizeof(Int));
-  IEEEIO::write(chunkdims.getData(),sizeof(Int)*rank); // for better for worse...
-  if(swapbytes) byteswapBuffer(chunkdims.getData(),rank,sizeof(Int)); // swap back
+  union { void *data; const void *const_data;} cast_union;
+  cast_union.const_data = chunkdims.getData();
+  if(swapbytes) byteswapBuffer(cast_union.data,rank,sizeof(Int));
+  IEEEIO::write(cast_union.const_data,sizeof(Int)*rank); // for better for worse...
+  if(swapbytes) byteswapBuffer(cast_union.data,rank,sizeof(Int)); // swap back
   // OK, now writing 8k at a time, reserve the space with 0's
   current_reserved_chunk=datasetnumber;
   DataRef dref;
@@ -1186,7 +1196,7 @@ int IEEEIO::reserveStream(IObase::DataType typeID,int rank,CONST int *dims){
   return 1;
 }
 
-int IEEEIO::writeStream(void *data,int length){
+int IEEEIO::writeStream(const void *data,int length){
   Long8 len;
   if(!streaming){// seek to starting offset
     Long8 basefileoffset = stream_offset +
@@ -1196,7 +1206,7 @@ int IEEEIO::writeStream(void *data,int length){
   }
   // need to do a bounds check on the stream... for now it'll play dumb...
   Long8 nbytes=cur_type_size * length;
-  len = IEEEIO::write((char *)data,nbytes); // record file position??
+  len = IEEEIO::write(data,nbytes); // record file position??
   if(len<0)
     return -1; // write failure
   return len;
@@ -1332,7 +1342,7 @@ int IEEEIO::reserveStream(IObase::DataType typeID,int rank,CONST int *dims,Long8
 // different file offsets.  It remains to be seen how
 // well this works without O_DIRECT.  We can use timing
 // loops to stagger the writes somewhat though.
-int IEEEIO::writeStream(void *data,int length,Long8 soffset){
+int IEEEIO::writeStream(const void *data,int length,Long8 soffset){
   IEEEIO::lseek(soffset,L_SET);
   streaming=1;
   return writeStream(data,length);
@@ -1340,6 +1350,8 @@ int IEEEIO::writeStream(void *data,int length,Long8 soffset){
 
 /*********************Fortran Interface**********************/
 Long8 f_ieee_open (char *file,char *accessname,int flen,int alen){
+  alen = alen;
+  flen = flen;
   // would have used tolower(), but it doesn't exist everywhere.... :(
   IObase::AccessMode mode;
   if(*accessname=='R' || *accessname=='r')
diff --git a/src/IEEEIO.hh b/src/IEEEIO.hh
index 1b81dbb..b06f1c1 100644
--- a/src/IEEEIO.hh
+++ b/src/IEEEIO.hh
@@ -470,7 +470,7 @@ public:
   virtual ~IEEEIO();
   virtual int isValid();
   // could use overloading to differentiate type here... (but I'm going simple)
-  virtual int write(IObase::DataType typeID,int rank,CONST int *dims,void *data);
+  virtual int write(IObase::DataType typeID,int rank,CONST int *dims,const void *data);
   virtual int readInfo(IObase::DataType &typeID,int &rank,int *dims,int maxdims=3);
   virtual int read(void *data);
   //virtual int readChunk(int dims,int origin,int stride,void *data)=0;
@@ -482,7 +482,7 @@ public:
   virtual int readAnnotation(int number,char *annotation,int maxsize=128);
   virtual int nAnnotations();
 
-  virtual int writeAttribute(CONST char *name,IObase::DataType typeID,Long length,void *data);
+  virtual int writeAttribute(CONST char *name,IObase::DataType typeID,Long length,const void *data);
   // returns number
   virtual int readAttributeInfo(int number,char *name,IObase::DataType &typeID,Long &nelem,int maxnamelen=128);
   virtual int readAttributeInfo(CONST char *name,IObase::DataType &typeID,Long &nelem); // returns number
@@ -492,11 +492,11 @@ public:
 
   //-----------------Chunking Utilities..................
   virtual int reserveChunk(IObase::DataType typeID,int rank,CONST int *dims);
-  virtual int writeChunk(CONST int *chunkdims,CONST int *chunkorigin,void *data);
+  virtual int writeChunk(CONST int *chunkdims,CONST int *chunkorigin,const void *data);
   virtual int readChunk(CONST int *chunkdims,CONST int *chunkorigin,void *data);
   // Streaming interface is for support of PANDA, Sockets etc..
   virtual int reserveStream(IObase::DataType typeID,int rank,CONST int *dims);
-  virtual int writeStream(void *data,int length);
+  virtual int writeStream(const void *data,int length);
   virtual int readStream(void *data,int length);
   virtual int pause();
   virtual int resume();
@@ -505,7 +505,7 @@ public:
   //---------------------MPIO Experimental Methods------------
   void getFilename(char *fn,int maxlen=256);
   int reserveStream(IObase::DataType typeID,int rank,CONST int *dims,Long8 &offset);
-  int writeStream(void *data,int length,Long8 offset);
+  int writeStream(const void *data,int length,Long8 offset);
 };
 /*
 int bcopy(char *src,char *dst,int len){
@@ -563,7 +563,7 @@ int IEEEIO::write(const void *data,size_t size){
   }
   // otherwise, do a buffered write
   int retval=0;
-  char *datap = (char *)data;
+  const char *datap = (const char *)data;
   if(writebuffercount>0){
     // copy as much as you can to the writebuffer
     // should use bcopy... its a whole lot faster!!!
diff --git a/src/IO.cc b/src/IO.cc
index 0287a9d..c0860c1 100644
--- a/src/IO.cc
+++ b/src/IO.cc
@@ -94,7 +94,7 @@ int f_io_nbytes(int *type,int *rank,int *dims){
   return IObase::nBytes(IObase::Int2DataType(*type),*rank,dims);
 }
 
-int f_io_write(Long8 *deviceID,int *typeID,int *rank,int *dims,void *data){
+int f_io_write(Long8 *deviceID,int *typeID,int *rank,int *dims,const void *data){
   IObase *dev=(IObase*)(*deviceID);
   dev->write(dev->Int2DataType(*typeID),*rank,dims,data);
   return 1;
@@ -130,14 +130,14 @@ int f_io_writenote(Long8 *deviceID,char *annotation,int size){
   return dev->writeAnnotation(annotation);
 }
 
-int f_io_readnote(Long8 *deviceID,int *index,char *annotation,int maxsize){ 
+int f_io_readnote(Long8 *deviceID,int *idx,char *annotation,int maxsize){ 
   IObase *dev=(IObase*)(*deviceID);
-  return dev->readAnnotation(*index,annotation,maxsize);
+  return dev->readAnnotation(*idx,annotation,maxsize);
 }
 
-int f_io_noteinfo(Long8 *deviceID,int *index,int *length){ 
+int f_io_noteinfo(Long8 *deviceID,int *idx,int *length){ 
   IObase *dev=(IObase*)(*deviceID);
-  return dev->readAnnotationInfo(*index,*length);
+  return dev->readAnnotationInfo(*idx,*length);
 }
 
 int f_io_numnote(Long8 *deviceID){ 
@@ -147,7 +147,7 @@ int f_io_numnote(Long8 *deviceID){
 
 //---------------Attributes
 int f_io_writeatt(Long8 *deviceID,char *name,
-		 int *datatype,Long *nelements,void *data,int namesize){
+		 int *datatype,Long *nelements,const void *data,int namesize){
   IObase *dev=(IObase*)(*deviceID);
   name[namesize]='\0'; // cap name (to be certain).. unsafe but it works
   // should copy into a flexarray which will be destroyed on return
@@ -166,19 +166,19 @@ int f_io_attinfo(Long8 *deviceID,char *name,
   return i;
 }
 
-int f_io_iattinfo(Long8 *deviceID,int *index,char *name,
+int f_io_iattinfo(Long8 *deviceID,int *idx,char *name,
 		 int *datatype,Long *nelements,int namesize){
   int i;
   IObase *dev=(IObase*)(*deviceID);
   IObase::DataType typeID;
   for(i=0;i<namesize;i++) name[i]='\0';
   //printf("io_iattinfo(): Namesize=%u Name=[%s]\n",namesize,name);
-  i=dev->readAttributeInfo(*index,name,typeID,*nelements,namesize);
+  i=dev->readAttributeInfo(*idx,name,typeID,*nelements,namesize);
   // need to zero the array
   //printf("io_iattinfo(): Newname=[%s]\n",name); 
   *datatype=typeID;
   //printf("io_iattinfo(): attribs are index=%u type=%u nelements=%u namesize=%u\n",
-  //	 *index,*datatype,*nelements,namesize);
+  //	 *idx,*datatype,*nelements,namesize);
   return i;
 }
 
@@ -198,7 +198,7 @@ int f_io_reserveck(Long8 *deviceID,int *typeID,int *rank,int *dims){
   return dev->reserveChunk(dev->Int2DataType(*typeID),*rank,dims);
 }
 
-int f_io_writeck(Long8 *deviceID,int *chunkdims,int *chunkorigin,void *data){
+int f_io_writeck(Long8 *deviceID,int *chunkdims,int *chunkorigin,const void *data){
   IObase *dev=(IObase*)(*deviceID);
   return dev->writeChunk(chunkdims,chunkorigin,data);
 }
@@ -207,7 +207,7 @@ int f_io_readck(Long8 *deviceID,int *chunkdims,int *chunkorigin,void *data){
   IObase *dev=(IObase*)(*deviceID);
   return dev->readChunk(chunkdims,chunkorigin,data);
 }
-int f_io_writestrm(Long8 *deviceID,void *data,int *length){
+int f_io_writestrm(Long8 *deviceID,const void *data,int *length){
   IObase *dev=(IObase*)(deviceID);
   return dev->writeStream(data,*length);
 }
@@ -253,7 +253,7 @@ int IOnBytes(int type,int rank,int *dims){
   return IObase::nBytes(IObase::Int2DataType(type),rank,dims);
 }
 
-int IOwrite(IOFile deviceID,int typeID,int rank,int *dims,void *data){
+int IOwrite(IOFile deviceID,int typeID,int rank,int *dims,const void *data){
   IObase *dev=(IObase*)(deviceID);
   return dev->write(dev->Int2DataType(typeID),rank,dims,data);
 }
@@ -287,14 +287,14 @@ int IOwriteAnnotation(IOFile deviceID,char *annotation){
   return dev->writeAnnotation(annotation);
 }
  
-int IOreadAnnotation(IOFile deviceID,int index,char *annotation,int maxsize){
+int IOreadAnnotation(IOFile deviceID,int idx,char *annotation,int maxsize){
   IObase *dev=(IObase*)(deviceID);
-  return dev->readAnnotation(index,annotation,maxsize);
+  return dev->readAnnotation(idx,annotation,maxsize);
 }
 
-int IOreadAnnotationInfo(IOFile deviceID,int index,int *size){
+int IOreadAnnotationInfo(IOFile deviceID,int idx,int *size){
   IObase *dev=(IObase*)(deviceID);
-  return dev->readAnnotationInfo(index,*size);
+  return dev->readAnnotationInfo(idx,*size);
 }
 
 int IOnAnnotations(IOFile deviceID){
@@ -341,7 +341,7 @@ int IOreserveChunk(IOFile deviceID,int typeID,int rank,int *dims){
   return dev->reserveChunk(dev->Int2DataType(typeID),rank,dims);
 }
 
-int IOwriteChunk(IOFile deviceID,int *chunkdims,int *chunkorigin,void *data){
+int IOwriteChunk(IOFile deviceID,int *chunkdims,int *chunkorigin,const void *data){
   IObase *dev=(IObase*)(deviceID);
   return dev->writeChunk(chunkdims,chunkorigin,data);
 }
@@ -351,7 +351,7 @@ int IOreadChunk(IOFile deviceID,int *chunkdims,int *chunkorigin,void *data){
   return dev->readChunk(chunkdims,chunkorigin,data);
 }
 
-int IOwriteStream(IOFile deviceID,void *data,int length){
+int IOwriteStream(IOFile deviceID,const void *data,int length){
   IObase *dev=(IObase*)(deviceID);
   return dev->writeStream(data,length);
 }
diff --git a/src/IO.hh b/src/IO.hh
index 0d4ec6a..2857cbc 100644
--- a/src/IO.hh
+++ b/src/IO.hh
@@ -23,7 +23,7 @@ public:
   virtual ~IObase() {}
   virtual int isValid() { return 0; }
   // could use overloading to differentiate type here... (but I'm going simple)
-  virtual int write(DataType typeID,int rank,CONST int *dims,void *data)=0;
+  virtual int write(DataType typeID,int rank,CONST int *dims,const void *data)=0;
   virtual int readInfo(DataType &typeID,int &rank,int *dims,int maxdims=3)=0;
   virtual int read(void *data)=0;
   virtual int seek(int dataset_index)=0;
@@ -33,7 +33,7 @@ public:
   virtual int readAnnotation(int number,char *annotation,int maxsize=128)=0;
   virtual int nAnnotations()=0;
   
-  virtual int writeAttribute(CONST char *name,IObase::DataType typeID,Long length,void *data)=0;
+  virtual int writeAttribute(CONST char *name,IObase::DataType typeID,Long length,const void *data)=0;
   // returns number
   virtual int readAttributeInfo(int number,char *name,IObase::DataType &typeID,Long &nelem,int maxnamelen=128)=0;
   virtual int readAttributeInfo(CONST char *name,IObase::DataType &typeID,Long &nelem)=0; // returns number
@@ -62,7 +62,7 @@ public:
   //-----------------Chunking Features (for MPI/HPF)................
   virtual int reserveChunk(IObase::DataType typeID,int rank,CONST int *dims)=0;
   
-  virtual int writeChunk(CONST int *chunkdims,CONST int *chunkorigin,void *data)=0;
+  virtual int writeChunk(CONST int *chunkdims,CONST int *chunkorigin,const void *data)=0;
   // virtual int writeStridedChunk()=0;
   // virtual int writeHPF(int processorID,int *proclayout,IObase::HPFlayout *arraylayout,void *data)=0;
   virtual int readChunk(CONST int *chunkdims,CONST int *chunkorigin,void *data)=0;
@@ -70,7 +70,7 @@ public:
   // virtual int readHPF(int processorID,int *proclayout,IObase::HPFlayout *arraylayout,void *data)=0;
   //-----------------Streaming interface (for PANDA, Sockets & MPIO).........
   virtual int reserveStream(IObase::DataType typeID,int rank,CONST int *dims)=0;
-  virtual int writeStream(void *data,int length)=0;
+  virtual int writeStream(const void *data,int length)=0;
   virtual int readStream(void *data,int length)=0;
   //-----------------------Utilities........................
   // unfortunately you can cast enums to int but not the reverse
@@ -123,7 +123,7 @@ extern "C"{
   int f_io_sizeof (int *datatype);
   int f_io_nelements (int *rank,int *dims);
   int f_io_nbytes (int *datatype,int *rank,int *dims);
-  int f_io_write (Long8 *deviceID,int *typeID,int *rank,int *dims,void *data);
+  int f_io_write (Long8 *deviceID,int *typeID,int *rank,int *dims,const void *data);
   int f_io_readinfo (Long8 *deviceID,int *typeID,int *rank,int *dims,int *maxdims);
   int f_io_read (Long8 *deviceID,void *data);
   int f_io_seek (Long8 *deviceID,int *dataset_index);
@@ -134,7 +134,7 @@ extern "C"{
   int f_io_numnote (Long8 *deviceID);
 
   int f_io_writeatt (Long8 *deviceID,_fcd fcname,
-		   int *datatype,Long *nelements,void *data);
+		   int *datatype,Long *nelements,const void *data);
   int f_io_attinfo (Long8 *deviceID,_fcd fcname,
 		  int *datatype,Long *nelements);
   int f_io_iattinfo (Long8 *deviceID,int *index,_fcd fcname,
@@ -142,9 +142,9 @@ extern "C"{
   int f_io_readatt (Long8 *deviceID,int *number,void *data);
   int f_io_numatt (Long8 *deviceID);
   int f_io_reserveck(Long8 *deviceID,int *typeID,int *rank,int *dims);
-  int f_io_writeck(Long8 *deviceID,int *chunkdims,int *chunkorigin,void *data);
+  int f_io_writeck(Long8 *deviceID,int *chunkdims,int *chunkorigin,const void *data);
   int f_io_readck(Long8 *deviceID,int *chunkdims,int *chunkorigin,void *data); 
-  int f_io_writestrm(Long8 *deviceID,void *data,int *length);
+  int f_io_writestrm(Long8 *deviceID,const void *data,int *length);
   int f_io_readstrm(Long8 *deviceID,void *data,int *length);
   int f_io_pause(Long8 *deviceID);
   int f_io_resume(Long8 *deviceID);
@@ -154,7 +154,7 @@ extern "C"{
   int f_io_sizeof (int *datatype);
   int f_io_nelements (int *rank,int *dims);
   int f_io_nbytes (int *datatype,int *rank,int *dims);
-  int f_io_write (Long8 *deviceID,int *typeID,int *rank,int *dims,void *data);
+  int f_io_write (Long8 *deviceID,int *typeID,int *rank,int *dims,const void *data);
   int f_io_readinfo (Long8 *deviceID,int *typeID,int *rank,int *dims,int *maxdims);
   int f_io_read (Long8 *deviceID,void *data);
   int f_io_seek (Long8 *deviceID,int *dataset_index);
@@ -166,7 +166,7 @@ extern "C"{
   int f_io_numnote (Long8 *deviceID);
 
   int f_io_writeatt (Long8 *deviceID,char *name,
-		   int *datatype,Long *nelements,void *data,int namesize);
+		   int *datatype,Long *nelements,const void *data,int namesize);
   int f_io_attinfo (Long8 *deviceID,char *name,
 		  int *datatype,Long *nelements,int namesize);
   int f_io_iattinfo (Long8 *deviceID,int *index,char *name,
@@ -174,9 +174,9 @@ extern "C"{
   int f_io_readatt (Long8 *deviceID,int *number,void *data);
   int f_io_numatt (Long8 *deviceID);
   int f_io_reserveck(Long8 *deviceID,int *typeID,int *rank,int *dims);
-  int f_io_writeck(Long8 *deviceID,int *chunkdims,int *chunkorigin,void *data);
+  int f_io_writeck(Long8 *deviceID,int *chunkdims,int *chunkorigin,const void *data);
   int f_io_readck(Long8 *deviceID,int *chunkdims,int *chunkorigin,void *data);
-  int f_io_writestrm(Long8 *deviceID,void *data,int *length);
+  int f_io_writestrm(Long8 *deviceID,const void *data,int *length);
   int f_io_readstrm(Long8 *deviceID,void *data,int *length);
   int f_io_pause(Long8 *deviceID);
   int f_io_resume(Long8 *deviceID);
diff --git a/src/IOProtos.h b/src/IOProtos.h
index abbf36b..881d21c 100644
--- a/src/IOProtos.h
+++ b/src/IOProtos.h
@@ -42,7 +42,7 @@ int IOisValid PROTO((IOFile deviceID));
 int IOsizeOf PROTO((int datatype));
 int IOnElements PROTO((int rank,int *dims));
 int IOnBytes PROTO((int datatype,int rank,int *dims));
-int IOwrite PROTO((IOFile deviceID,int typeID,int rank,int *dims,void *data));
+int IOwrite PROTO((IOFile deviceID,int typeID,int rank,int *dims,const void *data));
 int IOreadInfo PROTO((IOFile deviceID,int *typeID,int *rank,int *dims,int maxdims));
 int IOread PROTO((IOFile deviceID,void *data));
 int IOseek PROTO((IOFile deviceID,int dataset_index));
@@ -59,9 +59,9 @@ int IOreadAttributeInfo PROTO((IOFile deviceID,char *name,int *type,Long *nelem)
 int IOreadAttribute PROTO((IOFile deviceID,int number,void *data));
 int IOnAttributes PROTO((IOFile deviceID));
 int IOreserveChunk PROTO((IOFile deviceID,int typeID,int rank,int *dims));
-int IOwriteChunk PROTO((IOFile deviceID,int *chunkdims,int *chunkorigin,void *data));
+int IOwriteChunk PROTO((IOFile deviceID,int *chunkdims,int *chunkorigin,const void *data));
 int IOreadChunk PROTO((IOFile deviceID,int *chunkdims,int *chunkorigin,void *data));
-int IOwriteStream PROTO((IOFile deviceID,void *data,int length));
+int IOwriteStream PROTO((IOFile deviceID,const void *data,int length));
 int IOreadStream PROTO((IOFile deviceID,void *data,int length));
 int IOpause PROTO((IOFile deviceID));
 int IOresume PROTO((IOFile deviceID));
diff --git a/src/SockIOreader.hh b/src/SockIOreader.hh
index 19f16bf..af29bb7 100644
--- a/src/SockIOreader.hh
+++ b/src/SockIOreader.hh
@@ -102,7 +102,7 @@ public:
   // Make this functionality inacessible since this class is read-only.
   virtual int write(IObase::DataType typeID,int rank,CONST int *dims,void *data){return 0;}
   virtual int writeAnnotation(CONST char *annotation){return 0;}
-  virtual int writeAttribute(CONST char *name,IObase::DataType typeID,Long length,void *data){return 0;}
+  virtual int writeAttribute(CONST char *name,IObase::DataType typeID,Long length,const void *data){return 0;}
   virtual int reserveChunk(IObase::DataType typeID,int rank,CONST int *dims){return 0;}
   virtual int reserveStream(IObase::DataType typeID,int rank,CONST int *dims){return 0;}
   virtual int writeChunk(CONST int *chunkdims,CONST int *chunkorigin,void *data){return 0;}
diff --git a/src/SockIOwriter.cc b/src/SockIOwriter.cc
index c68c557..72db978 100644
--- a/src/SockIOwriter.cc
+++ b/src/SockIOwriter.cc
@@ -30,7 +30,7 @@ int SockIOwriter::isValid(){
 }
 
 // could use overloading to differentiate type here... (but I'm going simple)
-int SockIOwriter::write(IObase::DataType typeID,int rank,CONST int *dims,void *data){
+int SockIOwriter::write(IObase::DataType typeID,int rank,CONST int *dims,const void *data){
   register int i;
   Int sdims[5];
   for (i = 0; i < rank ; i++)
@@ -75,7 +75,7 @@ int SockIOwriter::writeAnnotation(CONST char *annotation){
 }
 
 // Write a NetCDF attribute across the socket connection
-int SockIOwriter::writeAttribute(CONST char *name,IObase::DataType typeID,Long length,void *data){
+int SockIOwriter::writeAttribute(CONST char *name,IObase::DataType typeID,Long length,const void *data){
   int i;
   AttributeRecordHdr attrib;
   RecordHdr rec;
diff --git a/src/SockIOwriter.hh b/src/SockIOwriter.hh
index 96a6223..0719180 100644
--- a/src/SockIOwriter.hh
+++ b/src/SockIOwriter.hh
@@ -159,9 +159,9 @@ public:
   virtual ~SockIOwriter();
   virtual int isValid();
   // could use overloading to differentiate type here... (but I'm going simple)
-  virtual int write(IObase::DataType typeID,int rank,CONST int *dims,void *data);
+  virtual int write(IObase::DataType typeID,int rank,CONST int *dims,const void *data);
   virtual int writeAnnotation(CONST char *annotation);
-  virtual int writeAttribute(CONST char *name,IObase::DataType typeID,Long length,void *data);
+  virtual int writeAttribute(CONST char *name,IObase::DataType typeID,Long length,const const void *data);
   //-----------------Chunking Utilities..................
   virtual int reserveChunk(IObase::DataType typeID,int rank,CONST int *dims){
     return 0; // this will require a fourth data descriptor type
@@ -169,11 +169,11 @@ public:
   virtual int reserveStream(IObase::DataType typeID,int rank,CONST int *dims){
     return 0; // this will require a fourth data descriptor type
   }
-  virtual int writeChunk(CONST int *chunkdims,CONST int *chunkorigin,void *data){
+  virtual int writeChunk(CONST int *chunkdims,CONST int *chunkorigin,const void *data){
   	// need to fix this
     return 0;
   }
-  virtual int writeStream(void *data,int length){return 0;}
+  virtual int writeStream(const void *data,int length){return 0;}
 
   RawTCPclient*TCPclient()  const { return clientsock; }
 };