@@ -169,7 +169,7 @@ redata_getused(redata_t *redata)

 }

 int

-redata_getposptr(redata_t *redata, long pos, int *numchunk, long *offset)

+redata_getposptr(redata_t *redata, long pos, int *numchunk, int *offset)

 {

         long used;

         int i;

@@ -624,8 +624,8 @@ redata_undo_new(redata_t *redata, undostack_t *stack, char type)

 undo_t *

 redata_undo_newfromchunks(redata_t *redata, undostack_t *stack, char type, int pos1, int len)

 {

-        int startpos,endpos;

-        long startoff,endoff;

+        int startchunkno,endchunkno;

+        int startoff,endoff;

         undo_t *undo;

         int k;

         long used;

@@ -633,8 +633,8 @@ redata_undo_newfromchunks(redata_t *redata, undostack_t *stack, char type, int p

         if(redata==NULL || len<=0

           || (stack!=&(redata->undostack) && stack!=&(redata->redostack)))

                 return(NULL); /* sanity check failed */

-        if(redata_getposptr(redata,pos1,&startpos,&startoff)==-1 ||

-          redata_getposptr(redata,pos1+len,&endpos,&endoff)==-1) {

+        if(redata_getposptr(redata,pos1,&startchunkno,&startoff)==-1 ||

+          redata_getposptr(redata,pos1+len,&endchunkno,&endoff)==-1) {

                 return(NULL); /* chunk data out of bounds */

         }

         if(redata_undobuf_reserve(redata,stack,len)!=0)

@@ -643,14 +643,14 @@ redata_undo_newfromchunks(redata_t *redata, undostack_t *stack, char type, int p

                 return(NULL); /* insuf. mem. */

         undo->off=stack->usedbuf;

         /* copy contents */

-        for(k=startpos,used=0;k<=endpos;k++) {

-                if(k==startpos && k==endpos) {

+        for(k=startchunkno,used=0;k<=endchunkno;k++) {

+                if(k==startchunkno && k==endchunkno) {

                         copyfrom=startoff;

                         copysize=endoff-startoff;

-                } else if(k==startpos) {

+                } else if(k==startchunkno) {

                         copyfrom=startoff;

                         copysize=redata->chunks[k]->useddata-startoff;

-                } else if(k==endpos) {

+                } else if(k==endchunkno) {

                         copyfrom=0;

                         copysize=endoff;

                 } else {

@@ -763,7 +763,7 @@ int

 redata_op_add(redata_t *redata, long insertpos, char *buf, long buflen, undostack_t *fromhere)

 {

         int chunkno;

-        long pos;

+        int offset;

         undo_t *undo;

         rechunk_t *chunk,*nextchunk;

         long avail,nextavail;

@@ -774,7 +774,7 @@ redata_op_add(redata_t *redata, long insertpos, char *buf, long buflen, undostac

           || insertpos>redata_getused(redata)

           || (fromhere!=NULL && (fromhere!=&(redata->undostack) && fromhere!=&(redata->redostack))))

                 return(-1); /* sanity check failed */

-        if(redata_getposptr(redata,insertpos,&chunkno,&pos)==-1)

+        if(redata_getposptr(redata,insertpos,&chunkno,&offset)==-1)

                 return(-1); /* invalid pos */

         if(fromhere!=&(redata->undostack)) {

                 if((undo=redata_undo_newfrombuf(redata,&(redata->undostack),'A',buf,buflen))==NULL)

@@ -789,24 +789,24 @@ redata_op_add(redata_t *redata, long insertpos, char *buf, long buflen, undostac

         nextavail=(nextchunk==NULL)?0:redata->chunkdatasize-nextchunk->useddata;

         if(avail>=buflen) {

                 /* fits in current chunk */

-                redata_chunk_insertdata(redata,chunkno,pos,buf,buflen);

+                redata_chunk_insertdata(redata,chunkno,offset,buf,buflen);

                 redata_fix_nl(redata,chunkno);

                 nextchunk=chunk;

         } else if((avail+nextavail)>=buflen) {

                 /* part fits in current chunk, part in next chunk */

                 int bothering;

-                bothering=chunk->useddata-pos;

+                bothering=chunk->useddata-offset;

                 bothering=(bothering>nextavail)?nextavail:bothering;

                 redata_chunk_movedata(redata,chunkno,chunk->useddata-bothering,chunkno+1,0,bothering);

                 avail=redata->chunkdatasize-chunk->useddata;

                 avail=(avail>buflen)?buflen:avail;

-                redata_chunk_insertdata(redata,chunkno,pos,buf,avail);

+                redata_chunk_insertdata(redata,chunkno,offset,buf,avail);

                 redata_chunk_insertdata(redata,chunkno+1,0,buf+avail,buflen-avail);

         } else {

                 /* will need to add more chunks */

                 needed=(buflen+redata->chunkdatasize-1)/redata->chunkdatasize;

                 needed*=redata->chunkdatasize;

-                needed+=(chunk->useddata-pos);

+                needed+=(chunk->useddata-offset);

                 if(redata_preallocate(redata,redata_getsize(redata)+needed)!=0) {

                         if(undo!=NULL) {

                                 redata->undostack.usedundo--;

@@ -816,7 +816,7 @@ redata_op_add(redata_t *redata, long insertpos, char *buf, long buflen, undostac

                         return(-1); /* insuf. mem. */

                 }

                 redata_chunk_insertnew(redata,chunkno);

-                redata_chunk_movedata(redata,chunkno,pos,chunkno+1,0,chunk->useddata-pos);

+                redata_chunk_movedata(redata,chunkno,offset,chunkno+1,0,chunk->useddata-offset);

                 nextchunk=redata->chunks[chunkno+1];

                 avail=redata->chunkdatasize-chunk->useddata;

                 avail=(avail>buflen)?buflen:avail;

@@ -863,7 +863,7 @@ int

 redata_op_del(redata_t *redata, long delpos, long size, undostack_t *fromhere)

 {

         int chunkno,curchunk;

-        long pos;

+        int offset;

         undo_t *undo;

         rechunk_t *chunk;

         long ndel;

@@ -874,7 +874,7 @@ redata_op_del(redata_t *redata, long delpos, long size, undostack_t *fromhere)

           || (delpos+size)>redata_getused(redata)

           || (fromhere!=NULL && (fromhere!=&(redata->undostack) && fromhere!=&(redata->redostack))))

                 return(-1); /* sanity check failed */

-        if(redata_getposptr(redata,delpos,&chunkno,&pos)==-1)

+        if(redata_getposptr(redata,delpos,&chunkno,&offset)==-1)

                 return(-1); /* invalid pos */

         if(fromhere!=&(redata->undostack)) {

                 if((undo=redata_undo_newfromchunks(redata,&(redata->undostack),'D',delpos,size))==NULL)

@@ -884,7 +884,7 @@ redata_op_del(redata_t *redata, long delpos, long size, undostack_t *fromhere)

                 undo=NULL;

         }

         for(curchunk=chunkno,ndel=0;ndel<size;curchunk++) {

-                curpos=(curchunk==chunkno)?pos:0;

+                curpos=(curchunk==chunkno)?offset:0;

                 curdel=redata->chunks[curchunk]->useddata-curpos;

                 curdel=(curdel>(size-ndel))?(size-ndel):curdel;

                 redata_chunk_deletedata(redata,curchunk,curpos,curdel);

@@ -927,7 +927,7 @@ int

 redata_op_move(redata_t *redata, long posorig, long size, long posdest, undostack_t *fromhere)

 {

         int chunkno,dchunkno,curchunk;

-        long pos,dpos;

+        int offset,doffset;

         undo_t *undo;

         rechunk_t *chunk;

         int i;

@@ -938,9 +938,9 @@ redata_op_move(redata_t *redata, long posorig, long size, long posdest, undostac

           || (posdest>=posorig && posdest<(posorig+size))

           || (fromhere!=NULL && (fromhere!=&(redata->undostack) && fromhere!=&(redata->redostack))))

                 return(-1); /* sanity check failed */

-        if(redata_getposptr(redata,posorig,&chunkno,&pos)==-1)

+        if(redata_getposptr(redata,posorig,&chunkno,&offset)==-1)

                 return(-1); /* invalid pos */

-        if(redata_getposptr(redata,posdest,&dchunkno,&dpos)==-1)

+        if(redata_getposptr(redata,posdest,&dchunkno,&doffset)==-1)

                 return(-1); /* invalid pos */

         if(fromhere!=&(redata->undostack)) {

                 if((undo=redata_undo_newfromchunks(redata,&(redata->undostack),'M',posorig,size))==NULL)

@@ -951,48 +951,48 @@ redata_op_move(redata_t *redata, long posorig, long size, long posdest, undostac

         } else {

                 undo=NULL;

         }

-        if((pos+size)<=redata->chunks[chunkno]->useddata

+        if((offset+size)<=redata->chunks[chunkno]->useddata

           && (chunkno==dchunkno || (redata->chunkdatasize-redata->chunks[dchunkno]->useddata)>=size)) {

                 /* trivial case: (all the data is in the same chunk) AND (it is intra-chunk move or destination chunk has enough avail. space) */

-                redata_chunk_movedata(redata, chunkno, pos, dchunkno, dpos, size);

+                redata_chunk_movedata(redata, chunkno, offset, dchunkno, doffset, size);

         } else {

                 /* data spans several chunks, no space on dest, etc: do it the hard way */

                 /* separate the selected data into its own chunk(s) */

                 /* lower positions have to make the boundary first (or risk undoing it with next create boundary) */

                 if(posdest<posorig) {

                         /* make a chunk boundary in posdest */

-                        if(redata_getposptr(redata,posdest,&chunkno,&pos)==-1

-                          || redata_chunk_splithere(redata,chunkno,pos)!=0)

+                        if(redata_getposptr(redata,posdest,&chunkno,&offset)==-1

+                          || redata_chunk_splithere(redata,chunkno,offset)!=0)

                                 return(-1); /* invalid pos or insuf. mem */

                 }

                 /* make a chunk boundary in posorig and in posorig+size */

-                if(redata_getposptr(redata,posorig,&chunkno,&pos)==-1

-                  || redata_chunk_splithere(redata,chunkno,pos)!=0)

+                if(redata_getposptr(redata,posorig,&chunkno,&offset)==-1

+                  || redata_chunk_splithere(redata,chunkno,offset)!=0)

                         return(-1); /* invalid pos or insuf. mem */

-                if(redata_getposptr(redata,posorig+size,&chunkno,&pos)==-1

-                  || redata_chunk_splithere(redata,chunkno,pos)!=0)

+                if(redata_getposptr(redata,posorig+size,&chunkno,&offset)==-1

+                  || redata_chunk_splithere(redata,chunkno,offset)!=0)

                         return(-1); /* invalid pos or insuf. mem */

                 if(posdest>posorig) {

                         /* make a chunk boundary in posdest */

-                        if(redata_getposptr(redata,posdest,&chunkno,&pos)==-1

-                          || redata_chunk_splithere(redata,chunkno,pos)!=0)

+                        if(redata_getposptr(redata,posdest,&chunkno,&offset)==-1

+                          || redata_chunk_splithere(redata,chunkno,offset)!=0)

                                 return(-1); /* invalid pos or insuf. mem */

                 }

                 /* reorder the chunks */

                 {

                         int schunkno;

-                        long spos;

-                        if(redata_getposptr(redata,posorig,&chunkno,&pos)==-1)

+                        int soffset;

+                        if(redata_getposptr(redata,posorig,&chunkno,&offset)==-1)

                                 return(-1); /* invalid pos or insuf. mem */

-                        if(redata_getposptr(redata,posorig+size,&schunkno,&spos)==-1)

+                        if(redata_getposptr(redata,posorig+size,&schunkno,&soffset)==-1)

                                 return(-1); /* invalid pos or insuf. mem */

-                        if(redata_getposptr(redata,posdest,&dchunkno,&dpos)==-1)

+                        if(redata_getposptr(redata,posdest,&dchunkno,&doffset)==-1)

                                 return(-1); /* invalid pos or insuf. mem */

-                        if(pos!=0)

+                        if(offset!=0)

                                 chunkno++;

-                        if(spos!=0)

+                        if(soffset!=0)

                                 schunkno++;

-                        if(dpos!=0)

+                        if(doffset!=0)

                                 dchunkno++;

                         if(chunkno<0 || schunkno<0 || dchunkno<0

                           || chunkno>=redata->sizechunks || schunkno>=redata->sizechunks || dchunkno>=redata->sizechunks)

@@ -1011,14 +1011,14 @@ redata_op_move(redata_t *redata, long posorig, long size, long posdest, undostac

         }

         /* fix nl and delete unused chunks */

         if(posorig<posdest) {

-              if(redata_getposptr(redata,posorig,&chunkno,&pos)==-1)

+              if(redata_getposptr(redata,posorig,&chunkno,&offset)==-1)

                       return(-1); /* invalid pos */

-              if(redata_getposptr(redata,posdest,&dchunkno,&dpos)==-1)

+              if(redata_getposptr(redata,posdest,&dchunkno,&doffset)==-1)

                       return(-1); /* invalid pos */

         } else { /* posorig>posdest */

-              if(redata_getposptr(redata,posdest,&chunkno,&pos)==-1)

+              if(redata_getposptr(redata,posdest,&chunkno,&offset)==-1)

                       return(-1); /* invalid pos */

-              if(redata_getposptr(redata,posorig+size,&dchunkno,&dpos)==-1)

+              if(redata_getposptr(redata,posorig+size,&dchunkno,&doffset)==-1)

                       return(-1); /* invalid pos */

         }

         for(curchunk=dchunkno;curchunk>=chunkno;curchunk--) {

@@ -1105,7 +1105,7 @@ int

 redata_data_compare(redata_t *redata, long cmppos, char *buf, long buflen)

 {

         int chunkno;

-        long pos;

+        int offset;

         long compared;

         long n;

         int res;

@@ -1113,12 +1113,12 @@ redata_data_compare(redata_t *redata, long cmppos, char *buf, long buflen)

           || cmppos>redata_getused(redata)

           || (cmppos+buflen)>redata_getused(redata))

                 return(-1); /* sanity check failed */

-        if(redata_getposptr(redata,cmppos,&chunkno,&pos)==-1)

+        if(redata_getposptr(redata,cmppos,&chunkno,&offset)==-1)

                 return(-1); /* invalid pos */

-        for(compared=0,n=0;compared<buflen && chunkno<redata->sizechunks;chunkno++,pos=0,compared+=n) {

-                n=redata->chunks[chunkno]->useddata-pos;

+        for(compared=0,n=0;compared<buflen && chunkno<redata->sizechunks;chunkno++,offset=0,compared+=n) {

+                n=redata->chunks[chunkno]->useddata-offset;

                 n=(n<0)?0:((compared+n)>buflen)?(buflen-compared):n;

-                if((res=memcmp(redata->chunks[chunkno]->data+pos,buf+compared,n))!=0)

+                if((res=memcmp(redata->chunks[chunkno]->data+offset,buf+compared,n))!=0)

                         return(res);

         }

         if(compared<buflen)

@@ -84,7 +84,7 @@ int redata_config_chunkdatasize(redata_t *redata, int chunkdatasize);

 long redata_getsize(redata_t *redata);

 long redata_getused(redata_t *redata);

 long redata_getavailable(redata_t *redata);

-int redata_getposptr(redata_t *redata, long pos, int *numchunk, long *offset);

+int redata_getposptr(redata_t *redata, long pos, int *numchunk, int *offset);

 /* low level stuff */

 int redata_wipe(redata_t *redata);