@@ -32,7 +32,7 @@

 #define UNSAVEDHEADER "REUNSAV\n"

 #define UNSAVEDVERSION "\n000001\0"

-static int redata_hash_gen(redata_t *redata, char *filename, char *buf, int buflen, char *resbuf129bytes);

+static int redata_hash_gen(redata_t *redata, char *filename, char *buf, long buflen, char *resbuf129bytes);

 static char *unsaved_genname(char *filename, char *buf, int bufsize);

 static char *securesave_genname(char *filename, char *buf, int bufsize);

 static char *genname(char *filename,char *prefix, char *postfix, char *buf, int bufsize);

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

         return(0);

 }

-int

+long

 redata_getsize(redata_t *redata)

 {

         if(redata==NULL)

@@ -114,7 +114,7 @@ redata_getsize(redata_t *redata)

         return(redata->chunkdatasize*redata->sizechunks);

 }

-int

+long

 redata_getavailable(redata_t *redata)

 {

         if(redata==NULL)

@@ -122,10 +122,10 @@ redata_getavailable(redata_t *redata)

         return(redata->available);

 }

-int

+long

 redata_getused(redata_t *redata)

 {

-        int used;

+        long used;

         if(redata==NULL)

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

         used=redata->chunkdatasize*redata->sizechunks-redata->available;

@@ -133,11 +133,11 @@ redata_getused(redata_t *redata)

 }

 int

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

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

 {

-        int used;

+        long used;

         int i;

-        int ipos;

+        long ipos;

         used=redata_getused(redata);

         if(redata==NULL || pos<0 || pos>used || numchunk==NULL || offset==NULL)

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

@@ -199,12 +199,12 @@ redata_chunk_insertnew(redata_t *redata, int afterthischunk)

 int

-redata_preallocate(redata_t *redata, int newsize)

+redata_preallocate(redata_t *redata, long newsize)

 {

-        int cursize;

+        long cursize;

         int nchunks;

         int i;

-        int rechunksize;

+        long rechunksize;

         rechunk_t **newchunks,*chunk;

         int oldsizechunks;

         if(redata==NULL || redata->chunkdatasize==0 || newsize<0)

@@ -238,7 +238,7 @@ redata_preallocate(redata_t *redata, int newsize)

 }

 int

-redata_chunk_movedata(redata_t *redata, int chunkfrom, int posfrom, int chunkto, int posto, int size)

+redata_chunk_movedata(redata_t *redata, int chunkfrom, long posfrom, int chunkto, long posto, long size)

 {

         if(redata==NULL || size<0

           || chunkfrom<0 || chunkfrom>=redata->sizechunks

@@ -284,7 +284,7 @@ redata_chunk_movedata(redata_t *redata, int chunkfrom, int posfrom, int chunkto,

 }

 int

-redata_chunk_insertdata(redata_t *redata, int chunkto, int posto, char *buf, int buflen)

+redata_chunk_insertdata(redata_t *redata, int chunkto, long posto, char *buf, long buflen)

 {

         rechunk_t *chunk;

         if(redata==NULL || buflen<0 || buf==NULL

@@ -301,7 +301,7 @@ redata_chunk_insertdata(redata_t *redata, int chunkto, int posto, char *buf, int

 }

 int

-redata_chunk_deletedata(redata_t *redata, int chunkno, int pos, int n)

+redata_chunk_deletedata(redata_t *redata, int chunkno, long pos, long n)

 {

         rechunk_t *chunk;

         if(redata==NULL || n<0

@@ -342,7 +342,7 @@ redata_whatin_refresh(redata_t *redata, int chunkno)

 void *

 mymemrchr(const void *s, int c, size_t n)

 {

-        int i;

+        long i;

         void *res=NULL;

         unsigned char b;

         b=(*((unsigned int *)(&c)))&0xff;

@@ -649,11 +649,12 @@ 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,startoff,endpos,endoff;

+        int startpos,endpos;

+        long startoff,endoff;

         undo_t *undo;

         int k;

-        int used;

-        int copyfrom,copysize;

+        long used;

+        long copyfrom,copysize;

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

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

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

@@ -759,10 +760,11 @@ redata_undo_wipe(redata_t *redata, undostack_t *stack)

 int

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

 {

-        int chunkno,pos;

+        int chunkno;

+        long pos;

         undo_t *undo;

         rechunk_t *chunk,*nextchunk;

-        int avail,nextavail;

+        long avail,nextavail;

         int i;

         int needed;

         char *ptr;

@@ -905,7 +907,7 @@ redata_filehash(redata_t *redata, char *filename, char *resbuf129bytes)

 }

 int

-redata_memhash(redata_t *redata, char *buf, int buflen, char *resbuf129bytes)

+redata_memhash(redata_t *redata, char *buf, long buflen, char *resbuf129bytes)

 {

         if(resbuf129bytes!=NULL)

                 *resbuf129bytes='\0';

@@ -915,7 +917,7 @@ redata_memhash(redata_t *redata, char *buf, int buflen, char *resbuf129bytes)

 }

 static int

-redata_hash_gen(redata_t *redata, char *filename, char *buf, int buflen, char *resbuf129bytes)

+redata_hash_gen(redata_t *redata, char *filename, char *buf, long buflen, char *resbuf129bytes)

 {

         static char conv[]={"0123456789ABCDEF"};

         sha3_context sha3;

@@ -946,7 +948,7 @@ redata_hash_gen(redata_t *redata, char *filename, char *buf, int buflen, char *r

                         sha3_Update(&sha3,(void *) redata->chunks[i]->data,redata->chunks[i]->useddata);

         } else if(filename!=NULL) {

                 char buf[16384];

-                int totalread,nread;

+                long totalread,nread;

                 for(totalread=0,nread=0;totalread<statbuf.st_size;totalread+=nread,nread=0) {

                         if((nread=read(fd,buf,sizeof(buf)))<=0) {

                                 close(fd),fd=-1;

@@ -13,6 +13,7 @@

 #include <limits.h>

+#warning TODO: change "pos" (offset in data) to long

 typedef struct whatin_t {

         int nlcount;

 } whatin_t;

@@ -26,10 +27,10 @@ typedef struct rechunk_t {

 typedef struct undo_t {

         char type[4];

-        int off;

-        int len;

-        int posorig;

-        int posdest;

+        long off;

+        long len;

+        long posorig;

+        long posdest;

         char prehash[129];

         char posthash[129];

 } undo_t;

@@ -45,15 +46,16 @@ typedef struct undostack_t {

 typedef struct redata_t {

         /* data */

-        int chunkdatasize;

+        long chunkdatasize;

         int sizechunks;

         rechunk_t **chunks;

-        int available;

+        long available;

         rechunk_t *tmpchunk;

         /* undo */

         undostack_t undostack;

         undostack_t redostack;

         /* unsaved (for recovery when the program closes unexpectedly) */

+        undostack_t unsavedstack;

         char filename[PATH_MAX];

         char initialhash[129];

         int unsavedfd;

@@ -67,19 +69,18 @@ void redata_free(redata_t *redata);

 int redata_config_chunkdatasize(redata_t *redata, int chunkdatasize);

-int redata_getsize(redata_t *redata);

-int redata_getused(redata_t *redata);

-int redata_getavailable(redata_t *redata);

-int redata_getused(redata_t *redata);

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

+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);

 /* low level stuff */

 int redata_wipe(redata_t *redata);

-int redata_preallocate(redata_t *redata, int size);

+int redata_preallocate(redata_t *redata, long size);

 int redata_chunk_insertnew(redata_t *redata, int afterthischunk);

-int redata_chunk_movedata(redata_t *redata, int chunkfrom, int posfrom, int chunkto, int posto, int size);

-int redata_chunk_insertdata(redata_t *redata, int chunkto, int posto, char *buf, int buflen);

-int redata_chunk_deletedata(redata_t *redata, int chunk, int pos, int n);

+int redata_chunk_movedata(redata_t *redata, int chunkfrom, long posfrom, int chunkto, long posto, long size);

+int redata_chunk_insertdata(redata_t *redata, int chunkto, long posto, char *buf, long buflen);

+int redata_chunk_deletedata(redata_t *redata, int chunkno, long pos, long n);

 int redata_whatin_refresh(redata_t *redata, int chunkno);

 int redata_fix_nl(redata_t *redata, int chunkno);

 int redata_undobuf_reserve(redata_t *redata, undostack_t *stack, int minavail);

@@ -98,6 +99,7 @@ int redata_unsaved_unlink(redata_t *redata);

 int redata_unsaved_trunc(redata_t *redata);

 int redata_unsaved_add(redata_t *redata, undo_t *undo);

 int redata_unsaved_unadd(redata_t *redata, undo_t *undo);

+int redata_unsaved_commit(redata_t *redata);

 int redata_load(redata_t *redata, char *filename, int use_unsaved);

 int redata_save(redata_t *redata, char *filename);

@@ -108,9 +110,8 @@ int redata_op_move(redata_t *redata, int posorig, int size, int posdest, undosta

 int redata_op_undo(redata_t *redata);

 int redata_op_redo(redata_t *redata);

-int redata_commit_unsaved(redata_t *redata);

 int redata_hash(redata_t *redata, char *resbuf129bytes);

 int redata_filehash(redata_t *redata, char *filename, char *resbuf129bytes);

-int redata_memhash(redata_t *redata, char *buf, int buflen, char *resbuf129bytes);

+int redata_memhash(redata_t *redata, char *buf, long buflen, char *resbuf129bytes);