@@ -40,6 +40,9 @@ static char *ptr_getlong(char *ptr,char *endptr,long *data);

 static char *ptr_getchar(char *ptr,char *endptr,char *data);

 static char *ptr_searchendchar(char *ptr, char *endptr, char endchar, char **endcharpos);

 static char sep_select(char *buf, int bufsize, char **pos);

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

+static void meminvert(void *start, void *end);

+

 redata_t *

 redata_init(void)

@@ -339,7 +342,7 @@ redata_chunk_deletedata(redata_t *redata, int chunkno, long pos, long n)

 {

         rechunk_t *chunk;

         if(redata==NULL || n<0

-          || chunk<0 || chunkno>=redata->sizechunks

+          || chunkno<0 || chunkno>=redata->sizechunks

           || pos<0 || pos>redata->chunks[chunkno]->useddata

           || (redata->chunks[chunkno]->useddata-pos)<n)

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

@@ -353,6 +356,41 @@ redata_chunk_deletedata(redata_t *redata, int chunkno, long pos, long n)

         return(0);

 }

+int

+redata_chunk_splithere(redata_t *redata, int chunkno, int pos)

+{

+        rechunk_t *chunk;

+        int size;

+        if(redata==NULL

+          || chunkno<0 || chunkno>=redata->sizechunks

+          || pos<0 || pos>redata->chunks[chunkno]->useddata)

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

+        chunk=redata->chunks[chunkno];

+        if(chunk->useddata==pos)

+                return(0); /* all done: already splitted */

+        size=redata->chunks[chunkno]->useddata-pos;

+        if((chunkno+1)<redata->sizechunks

+          && (redata->chunkdatasize-redata->chunks[chunkno+1]->useddata)>=size) {

+                redata_chunk_movedata(redata,chunkno,pos,chunkno+1,0,size);

+                return(0); /* all done: moved data cleanly to next chunk */

+        }

+        if(redata_chunk_insertnew(redata,chunkno)!=0)

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

+        redata_chunk_movedata(redata,chunkno,pos,chunkno+1,0,size);

+        return(0);

+}

+

+int

+redata_chunk_fillfromnext(redata_t *redata, int chunkno, int n)

+{

+        if(redata==NULL || chunkno<0 || (chunkno+1)>=redata->sizechunks

+          || (redata->chunkdatasize-redata->chunks[chunkno]->useddata)<n

+          || (redata->chunks[chunkno+1]->useddata)<n)

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

+        return(redata_chunk_movedata(redata,chunkno+1,0,chunkno,redata->chunks[chunkno]->useddata,n));

+}

+

+

 int

 redata_whatin_refresh(redata_t *redata, int chunkno)

 {

@@ -374,18 +412,6 @@ redata_whatin_refresh(redata_t *redata, int chunkno)

         return(0);

 }

-void *

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

-{

-        long i;

-        void *res=NULL;

-        unsigned char b;

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

-        for(i=0;i<n;i++) {

-                if(((unsigned char *)s)[i]==b)

-                        res=(((unsigned char *)s)+i);        }

-        return(res);

-}

 int

 redata_fix_nl(redata_t *redata, int chunkno)

@@ -896,6 +922,33 @@ redata_undo_wipe(redata_t *redata, undostack_t *stack)

         return(0);

 }

+int

+redata_undo_inactivatelast(redata_t *redata, undostack_t *stack)

+{

+        if(redata==NULL

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

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

+        if(stack->usedundo==0)

+                return(-1);

+        stack->usedundo--;

+        stack->usedbuf-=stack->undo[stack->usedundo].len;

+        return(0);

+}

+

+int

+redata_undo_reactivatelast(redata_t *redata, undostack_t *stack)

+{

+        if(redata==NULL

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

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

+        if(stack->usedundo==stack->sizeundo)

+                return(-1);

+        stack->usedbuf+=stack->undo[stack->usedundo].len;

+        stack->usedundo++;

+        return(0);

+}

+

+

 int

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

 {

@@ -982,6 +1035,9 @@ redata_op_add(redata_t *redata, long insertpos, char *buf, long buflen, undostac

                 /* from undo stack */

                 redata_undo_movelast(redata,&(redata->undostack),&(redata->redostack));

         }

+        /* compact if needed */

+        if(redata_getsize(redata)>(redata->chunkdatasize) && redata_getavailable(redata)>(redata_getsize(redata)/2))

+                redata_compact(redata);

         return(0);

 }

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

         long ndel;

         long curpos,curdel;

         if(redata==NULL || size<0

-          || delpos>redata_getused(redata)

+          || delpos<0

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

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

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

@@ -1037,14 +1093,139 @@ redata_op_del(redata_t *redata, long delpos, long size, undostack_t *fromhere)

                 /* from undo stack */

                 redata_undo_movelast(redata,&(redata->undostack),&(redata->redostack));

         }

+        /* compact if needed */

+        if(redata_getsize(redata)>(redata->chunkdatasize) && redata_getavailable(redata)>(redata_getsize(redata)/2))

+                redata_compact(redata);

         return(0);

 }

 int

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

 {

-#warning TODO

-        return(-1);

+        int chunkno,dchunkno,curchunk;

+        long pos,dpos;

+        undo_t *undo;

+        rechunk_t *chunk;

+        if(redata==NULL || size<0

+          || posorig<0

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

+          || posdest<0

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

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

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

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

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

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

+                        return(-1); /* couldn't create undo struct */

+                /* inactivate the undo so we are able to use return(-1) without removing it */

+                redata_undo_inactivatelast(redata,&(redata->undostack));

+                redata_hash(redata,undo->prehash);

+        } else {

+                undo=NULL;

+        }

+        if((pos+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);

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

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

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

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

+                  || redata_chunk_splithere(redata,chunkno,pos)!=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)

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

+                }

+                /* reorder the chunks */

+                {

+                        int schunkno;

+                        long spos;

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

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

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

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

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

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

+                        if(pos!=0)

+                                chunkno++;

+                        if(spos==0)

+                                schunkno--;

+                        if(dpos!=0)

+                                dchunkno++;

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

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

+                                return(-1); /* ERROR: INTERNAL ERROR */

+                        /* reorder inplace inverting the bytes (as in flipping a image) */

+                        if(chunkno<dchunkno) {

+                                meminvert(redata->chunks+chunkno,redata->chunks+dchunkno);

+                                meminvert(redata->chunks+chunkno,redata->chunks+dchunkno-(schunkno-chunkno));

+                                meminvert(redata->chunks+dchunkno-(schunkno-chunkno),redata->chunks+dchunkno);

+                        } else {

+                                meminvert(redata->chunks+dchunkno,redata->chunks+chunkno);

+                                meminvert(redata->chunks+dchunkno,redata->chunks+dchunkno+(schunkno-chunkno));

+                                meminvert(redata->chunks+dchunkno+(schunkno-chunkno),redata->chunks+chunkno);

+                        }

+                }

+        }

+        /* fix nl and delete unused chunks */

+        if(posorig<posdest) {

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

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

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

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

+        } else { /* posorig>posdest */

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

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

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

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

+        }

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

+                chunk=redata->chunks[curchunk];

+                if(chunk->useddata==0) {

+                        /* move this chunk to the end */

+                        redata_chunk_deletechunk(redata,curchunk);

+                } else

+                        redata_fix_nl(redata,curchunk);

+        }

+        /* activate undo */

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

+                /* reactivate the undo, now it is fine */

+                redata_undo_reactivatelast(redata,&(redata->undostack));

+        }

+        if(undo!=NULL) {

+                /* new or from redo stack */

+                undo->posorig=posorig;

+                undo->posdest=posdest;

+                redata_hash(redata,undo->posthash);

+                if(fromhere==&(redata->redostack))

+                        redata_undo_removelast(redata,&(redata->redostack));

+                else

+                        redata_undo_wipe(redata,&(redata->redostack));

+        } else {

+                /* from undo stack */

+                redata_undo_movelast(redata,&(redata->undostack),&(redata->redostack));

+        }

+        /* compact if needed */

+        if(redata_getsize(redata)>(redata->chunkdatasize) && redata_getavailable(redata)>(redata_getsize(redata)/2))

+                redata_compact(redata);

+        return(0);

 }

 int

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

         return(0);

 }

+int

+redata_compact(redata_t *redata)

+{

+        /* compact and free surplus chunks */

+        /* criterion: */

+        /* 1. if two neighbouring chunks could join with 10% free in result chunk, do it */

+        /* 2. if there are more than 2 unused chunks free at the end, free all unused chunks except two */

+#warning TODO

+        return(-1);

+}

+

 int

 redata_hash(redata_t *redata, char *resbuf129bytes)

 {

@@ -1315,3 +1507,29 @@ sep_select(char *buf, int bufsize, char **pos)

         return(seps[besti]);

 }

+static void *

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

+{

+        long i;

+        void *res=NULL;

+        unsigned char b;

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

+        for(i=0;i<n;i++) {

+                if(((unsigned char *)s)[i]==b)

+                        res=(((unsigned char *)s)+i);        }

+        return(res);

+}

+

+static void

+meminvert(void *start, void *end)

+{

+        unsigned char *a=(unsigned char *)start;

+        unsigned char *b=(unsigned char *)end;

+        unsigned char t;

+        for(b=b-1;a<b;a++,b--) {

+                t=*a;

+                *a=*b;

+                *b=t;

+        }

+}

+

@@ -85,6 +85,8 @@ int redata_chunk_deletechunk(redata_t *redata, int chunkno);

 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_chunk_splithere(redata_t *redata, int chunkno, int pos);

+int redata_chunk_fillfromnext(redata_t *redata, int chunkno, int 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);

@@ -94,6 +96,9 @@ undo_t *redata_undo_newfrombuf(redata_t *redata, undostack_t *stack, char type,

 int redata_undo_movelast(redata_t *redata, undostack_t *from, undostack_t *to);

 int redata_undo_removelast(redata_t *redata, undostack_t *stack);

 int redata_undo_wipe(redata_t *redata, undostack_t *stack);

+int redata_undo_inactivatelast(redata_t *redata, undostack_t *stack);

+int redata_undo_reactivatelast(redata_t *redata, undostack_t *stack);

+

 /* high level stuff */

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

@@ -116,6 +121,8 @@ int redata_op_redo(redata_t *redata);

 int redata_data_compare(redata_t *redata, long pos, char *buf, long buflen);

+int redata_compact(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, long buflen, char *resbuf129bytes);

@@ -40,36 +40,45 @@ char *test_edit(redata_t *redata, char *filename, char *edits, int filesize, int

 int

 main(int argc, char *argv[])

 {

+        static int sizes[]={-1,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,30,31,32,33,63,64,65,127,128,129,1023,1024,1025,16384};

         test_t tests[]={

                 {"newfile_16",test_newfile,PREFIX "FILE", NULL, 16, 0},

-                {"newfile_1024",test_newfile,PREFIX "FILE", NULL, 1024, 0},

+/*                {"newfile_1024",test_newfile,PREFIX "FILE", NULL, 1024, 0},

                 {"newfile_32767",test_newfile,PREFIX "FILE", NULL, 32767, 0},

                 {"newfile_32768",test_newfile,PREFIX "FILE", NULL, 32768, 0},

                 {"newfile_32769",test_newfile,PREFIX "FILE", NULL, 32769, 0},

-                {"newfile_131072",test_newfile,PREFIX "FILE", NULL, 131072, 0},

+                {"newfile_131072",test_newfile,PREFIX "FILE", NULL, 131072, 0},*/

                 {"testedit_add",test_edit,PREFIX "EDIT", "A0$Testing add$",0,0},

                 {"testedit_del",test_edit,PREFIX "EDIT", "A0$Testing add/del$D8$add/$",0,0},

         };

         redata_t *redata;

-        int i;

-        int nerrors;

+        int i,s;

+        int nerrors,total;

         char *res;

-        for(i=0,nerrors=0;i<(sizeof(tests)/sizeof(tests[0]));i++) {

-                if((redata=redata_init())==NULL) {

-                        fprintf(stderr,"ERROR: problem initializing redata module\n");

-                        return(1);

-                }

-                fprintf(stderr,"%s...",tests[i].name);

-                res=tests[i].fn(redata,tests[i].param1,tests[i].param2,tests[i].int1,tests[i].int2);

-                if(strcmp(res,TEST_OK)==0) {

-                        fprintf(stderr," ok.\n");

-                } else {

-                        fprintf(stderr," ERROR: %s\n",res);

-                        nerrors++;

+        nerrors=0;

+        total=0;

+        for(s=0;s<(sizeof(sizes)/sizeof(sizes[0]));s++) {

+                if(sizes[s]!=-1)

+                        fprintf(stderr,"SIZE: %i\n",sizes[s]);

+                for(i=0;i<(sizeof(tests)/sizeof(tests[0]));i++,total++) {

+                        if((redata=redata_init())==NULL) {

+                                fprintf(stderr,"ERROR: problem initializing redata module\n");

+                                return(1);

+                        }

+                        if(sizes[s]!=-1)

+                                redata_config_chunkdatasize(redata,sizes[s]);

+                        fprintf(stderr,"%s...",tests[i].name);

+                        res=tests[i].fn(redata,tests[i].param1,tests[i].param2,tests[i].int1,tests[i].int2);

+                                if(strcmp(res,TEST_OK)==0) {

+                                fprintf(stderr," ok.\n");

+                        } else {

+                                fprintf(stderr," ERROR: %s\n",res);

+                                nerrors++;

+                                }

+                        redata_free(redata),redata=NULL;

                 }

-                redata_free(redata),redata=NULL;

+                fprintf(stderr,"\n");

         }

-        fprintf(stderr,"\n");

         if(nerrors==0)

                 fprintf(stderr,"All tests passed OK\n");

         else