@@ -43,6 +43,25 @@ 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);

+#if 0

+static void

+redata_debug_chunkdump(redata_t *redata, char *title)

+{

+        int m,k;

+        char c;

+        title=(title==NULL)?"":title;

+        fprintf(stderr,"%s:CHUNKDUMP (sizechunks:%i)\n",title,redata->sizechunks);

+        for(m=0;m<redata->sizechunks;m++) {

+                fprintf(stderr,"%s:chunk[%i]:\"",title,m);

+                for(k=0;k<redata->chunks[m]->useddata;k++) {

+                        c=redata->chunks[m]->data[k];

+                        c=(c>=' ' && c<='~')?c:'.';

+                        fprintf(stderr,"%c",c);

+                }

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

+        }

+}

+#endif

 redata_t *

 redata_init(void)

@@ -534,6 +553,8 @@ redata_unsaved_trunc(redata_t *redata)

                 return(-1); /* malformed filename */

         if(redata->unsavedfd!=-1)

                 close(redata->unsavedfd),redata->unsavedfd=-1;

+        redata_hash(redata,redata->initialhash);

+        redata->unsaved.usedbuf=0;

         if((redata->unsavedfd=open(unsname,O_WRONLY|O_TRUNC|O_CREAT,0644))==-1)

                 return(-1); /* couldn't open file for writing */

         if((n=write(redata->unsavedfd,header,sizeof(header)-1))==-1

@@ -879,12 +900,13 @@ redata_load(redata_t *redata, char *filename, int use_unsaved)

         for(chunkno=0;chunkno<redata->sizechunks;chunkno++)

                 redata_whatin_refresh(redata,chunkno);

         /* unsaved */

-        redata_hash(redata,redata->initialhash);

         if(use_unsaved) {

                 /* apply missing changes and append new changes to unsaved */

+                redata_hash(redata,redata->initialhash);

                 redata_unsaved_loadappend(redata);

         } else {

                 /* nuke existing unsaved (if exists) and prepare new unsaved */

+                /* _trunc() fills itself redata->initialhash */

                 redata_unsaved_trunc(redata);

         }

         /* all done */

@@ -918,8 +940,9 @@ redata_save(redata_t *redata, char *filename)

                 return(-1); /* couldn't overwrite old file */

         }

         redata_unsaved_unlink(redata);

-        redata_hash(redata,redata->initialhash);

-        redata->unsaved.usedbuf=0;

+        strncpy(redata->filename,filename,sizeof(redata->filename));

+        redata->filename[sizeof(redata->filename)-1]='\0';

+        redata_unsaved_trunc(redata);

         return(0);

 }

@@ -1461,6 +1484,8 @@ redata_data_compare(redata_t *redata, long cmppos, char *buf, long buflen)

         return(0);

 }

+

+

 int

 redata_compact(redata_t *redata)

 {

@@ -1468,8 +1493,44 @@ redata_compact(redata_t *redata)

         /* 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 i,l;

+        rechunk_t *chunk,**newchunks;

+        if(redata==NULL)

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

+        /* skip free chunks at end */

+        for(i=redata->sizechunks-1;i>=0;i--) {

+                if(redata->chunks[i]->useddata!=0)

+                        break;

+        }

+        /* join neighbouring chunks where appropiate */

+        l=redata->chunkdatasize-(redata->chunkdatasize)/10;

+        for(;i>0;i--) {

+                if((redata->chunks[i]->useddata+redata->chunks[i-1]->useddata)>=l)

+                        continue;

+                /* move data to prev. chunk, move chunk to end */

+                redata_chunk_fillfromnext(redata,i-1,redata->chunks[i]->useddata);

+                if(redata->chunks[i]->useddata>0)

+                        continue; /* couldn't move data */

+                chunk=redata->chunks[i];

+                memmove(redata->chunks+i,redata->chunks+i+1,sizeof(rechunk_t *)*(redata->sizechunks-i-1));

+                redata->chunks[redata->sizechunks-1]=chunk;

+        }

+        /* free unused chunks at end (leave two empty chunks, free the rest) */

+        for(i=redata->sizechunks-1;i>=0;i--) {

+                if(redata->chunks[i]->useddata!=0)

+                        break;

+        }

+        l=i+3;

+        if(l<redata->sizechunks) {

+                for(i=l;i<redata->sizechunks;i++) {

+                        free(redata->chunks[i]),redata->chunks[i]=NULL;

+                        redata->available-=redata->chunkdatasize;

+                }

+                if((newchunks=realloc(redata->chunks,l*sizeof(rechunk_t *)))!=NULL)

+                        redata->chunks=newchunks;

+                redata->sizechunks=l;

+        }

+        return(0);

 }

 int