@@ -65,7 +65,6 @@ redata_init(void)

         redata->filename[0]='\0';

         redata->unsavedfd=-1;

         redata->unsaved.sizebuf=redata->unsaved.usedbuf=0;

-        redata->unsaved.lastsize=0;

         /* all done */

         return(redata);

 }

@@ -106,7 +105,6 @@ redata_free(redata_t *redata)

         if(redata->unsaved.buf!=NULL) {

                 free(redata->unsaved.buf),redata->unsaved.buf=NULL;

                 redata->unsaved.sizebuf=redata->unsaved.usedbuf=0;

-                redata->unsaved.lastsize=0;

         }

         /* free main struct */

         free(redata),redata=NULL;

@@ -580,7 +578,6 @@ redata_unsaved_loadappend(redata_t *redata)

                 redata->unsaved.buf=newptr;

                 redata->unsaved.sizebuf=(statbuf.st_size-headerhashsize);

         }

-        redata->unsaved.lastsize=0;

         redata->unsaved.usedbuf=0;

         lim=(statbuf.st_size-headerhashsize);

         for(nread=0;redata->unsaved.usedbuf<lim;redata->unsaved.usedbuf+=nread,nread=0) {

@@ -731,21 +728,100 @@ redata_unsaved_add(redata_t *redata, undostack_t *stack, int undono)

                         buf=redata->unsaved.buf+redata->unsaved.usedbuf;

                 }

         }

-        return(-1);

+        return(0);

 }

 int

 redata_unsaved_unadd(redata_t *redata, undostack_t *stack, int undono)

 {

-#warning TODO

-        return(-1);

+        /* adds to unsaved the inverse operation to the one specified in the undo */

+        char sep;

+        undo_t *undo;

+        char *sepend,*ptr,*endptr;

+        char *buf;

+        int k;

+        int maxsize,newsize;

+        char posbuf[128];

+        if(redata==NULL

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

+          || undono<0 || undono>=stack->usedundo)

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

+        /* syntax (see loadappend): A<pos><+?><sep><text><sep>[<+?><sep><text><sep>[...]] */

+        undo=stack->undo+undono;

+        if(undo->type!='A' && undo->type!='D' && undo->type!='M')

+                return(-1); /* unrecognized undo type */

+        for(k=0,maxsize=0,buf=NULL;k<2;k++,maxsize=0) {

+                ptr=stack->buf+undo->off;

+                endptr=ptr+undo->len;

+                if(k!=0)

+                        buf[maxsize]=(undo->type=='A')?'D':(undo->type=='D')?'A':undo->type;

+                maxsize++;

+                if(undo->type=='A' || undo->type=='D')

+                        snprintf(posbuf,sizeof(posbuf),"%li",undo->posorig);

+                else

+                        snprintf(posbuf,sizeof(posbuf),"%li",(undo->posorig<undo->posdest)?undo->posdest-undo->len:undo->posdest);

+                posbuf[sizeof(posbuf)-1]='\0';

+                if(k!=0)

+                        strcpy(buf+maxsize,posbuf);

+                maxsize+=strlen(posbuf);

+                if(undo->type=='M') {

+                        snprintf(posbuf,sizeof(posbuf),",%li",(undo->posorig<undo->posdest)?undo->posorig:undo->posorig+undo->len);

+                        posbuf[sizeof(posbuf)-1]='\0';

+                        if(k!=0)

+                                strcpy(buf+maxsize,posbuf);

+                        maxsize+=strlen(posbuf);

+                }

+                while(ptr<endptr) {

+                        sep=sep_select(ptr,endptr-ptr,&sepend);

+                        if(sepend!=endptr) {

+                                if(k!=0)

+                                        buf[maxsize]='+';

+                                maxsize++;

+                        }

+                        if(k!=0)

+                                buf[maxsize]=sep;

+                        maxsize++;

+                        if(k!=0)

+                                memcpy(buf+maxsize,ptr,sepend-ptr);

+                        maxsize+=sepend-ptr;

+                        if(k!=0)

+                                buf[maxsize]=sep;

+                        maxsize++;

+                        ptr=sepend;

+                }

+                if(k==0) {

+                        /* get mem */

+                        if((redata->unsaved.sizebuf-redata->unsaved.sizebuf)<maxsize) {

+                                newsize=(redata->unsaved.sizebuf+maxsize+UNDOGROWSIZE-1)/UNDOGROWSIZE;

+                                newsize*=UNDOGROWSIZE;

+                                if((buf=realloc(redata->unsaved.buf,newsize))==NULL)

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

+                                redata->unsaved.buf=buf;

+                                redata->unsaved.sizebuf=newsize;

+                        }

+                        buf=redata->unsaved.buf+redata->unsaved.usedbuf;

+                }

+        }

+        return(0);

 }

 int

 redata_unsaved_commit(redata_t *redata)

 {

-#warning TODO

-        return(-1);

+        int n,nwritten;

+        char unsname[PATH_MAX+1];

+        if(redata==NULL || redata->unsavedfd==-1)

+                return(-1);

+        for(nwritten=0;nwritten<redata->unsaved.usedbuf;nwritten+=n) {

+                if((n=write(redata->unsavedfd,redata->unsaved.buf+nwritten,redata->unsaved.usedbuf-nwritten))<0) {

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

+                        if((unsaved_genname(redata->filename,unsname,sizeof(unsname)))!=NULL)

+                                unlink(unsname); /* a corrupted unsaved is of no use, delete it */

+                        return(-1); /* error writing */

+                }

+        }

+        redata->unsaved.usedbuf=0;

+        return(0);

 }

@@ -1120,6 +1196,8 @@ redata_op_add(redata_t *redata, long insertpos, char *buf, long buflen, undostac

                 /* from undo stack */

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

         }

+        /* add to unsaved */

+        redata_unsaved_add(redata,&(redata->undostack),redata->undostack.usedundo-1);

         /* compact if needed */

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

                 redata_compact(redata);

@@ -1178,6 +1256,8 @@ redata_op_del(redata_t *redata, long delpos, long size, undostack_t *fromhere)

                 /* from undo stack */

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

         }

+        /* add to unsaved */

+        redata_unsaved_add(redata,&(redata->undostack),redata->undostack.usedundo-1);

         /* compact if needed */

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

                 redata_compact(redata);

@@ -1307,6 +1387,8 @@ redata_op_move(redata_t *redata, long posorig, long size, long posdest, undostac

                 /* from undo stack */

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

         }

+        /* add to unsaved */

+        redata_unsaved_add(redata,&(redata->undostack),redata->undostack.usedundo-1);

         /* compact if needed */

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

                 redata_compact(redata);

@@ -47,7 +47,6 @@ typedef struct unsaved_t {

         long sizebuf;

         long usedbuf;

         char *buf;

-        long lastsize;

 } unsaved_t;

 typedef struct redata_t {