@@ -50,10 +50,10 @@ redata_init(void)

         redata->chunkdatasize=CHUNKSIZE;

         redata->available=0;

         /* undo */

-        redata->sizeundo=0;

-        redata->usedundo=0;

-        redata->undo=NULL;

-        redata->undobuf=NULL;

+        redata->undostack.sizeundo=0;

+        redata->undostack.usedundo=0;

+        redata->undostack.undo=NULL;

+        redata->undostack.buf=NULL;

         /* unsaved */

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

         redata->unsavedfd=-1;

@@ -80,10 +80,10 @@ redata_free(redata_t *redata)

         if(redata->tmpchunk!=NULL)

                 free(redata->tmpchunk),redata->tmpchunk=NULL;

         /* undo */

-        if(redata->undo!=NULL)

-                free(redata->undo),redata->undo=NULL;

-        if(redata->undobuf!=NULL)

-                free(redata->undobuf),redata->undobuf=NULL;

+        if(redata->undostack.undo!=NULL)

+                free(redata->undostack.undo),redata->undostack.undo=NULL;

+        if(redata->undostack.buf!=NULL)

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

         /* unsaved */

         if(redata->unsavedfd!=-1) {

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

@@ -600,69 +600,72 @@ redata_save(redata_t *redata, char *filename)

 }

 int

-redata_undobuf_reserve(redata_t *redata, int minavail)

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

 {

         int unused;

         int newsize;

         char *newptr;

-        if(redata==NULL || minavail<0)

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

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

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

-        unused=redata->sizeundobuf-redata->usedundobuf;

+        unused=stack->sizebuf-stack->usedbuf;

         if(unused<minavail) {

-                newsize=(redata->sizeundobuf+minavail+UNDOGROWSIZE-1)/UNDOGROWSIZE;

+                newsize=(stack->sizebuf+minavail+UNDOGROWSIZE-1)/UNDOGROWSIZE;

                 newsize*=UNDOGROWSIZE;

-                if((newptr=realloc(redata->undobuf,newsize))==NULL)

+                if((newptr=realloc(stack->buf,newsize))==NULL)

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

-                redata->undobuf=newptr;

-                redata->sizeundobuf=newsize;

+                stack->buf=newptr;

+                stack->sizebuf=newsize;

         }

         return(0);

 }

 undo_t *

-redata_undo_new(redata_t *redata, char *type)

+redata_undo_new(redata_t *redata, undostack_t *stack, char *type)

 {

         int newsize;

         undo_t *newptr,*undo;

-        if(redata==NULL || type==NULL)

+        if(redata==NULL || type==NULL

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

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

-        if(redata->sizeundo==redata->usedundo) {

-                newsize=(redata->sizeundo+1+UNDOBLOCK-1)/UNDOBLOCK;

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

+                newsize=(stack->sizeundo+1+UNDOBLOCK-1)/UNDOBLOCK;

                 newsize*=UNDOBLOCK;

-                if((newptr=realloc(redata->undo,sizeof(undo_t)*newsize))==NULL)

+                if((newptr=realloc(stack->undo,sizeof(undo_t)*newsize))==NULL)

                         return(NULL);

-                redata->undo=newptr;

-                memset(redata->undo+redata->sizeundo,0,sizeof(undo_t)*(newsize-redata->sizeundo));

-                redata->sizeundo=newsize;

+                stack->undo=newptr;

+                memset(stack->undo+stack->sizeundo,0,sizeof(undo_t)*(newsize-stack->sizeundo));

+                stack->sizeundo=newsize;

         }

-        undo=redata->undo+redata->usedundo;

-        redata->usedundo++;

+        undo=stack->undo+stack->usedundo;

+        stack->usedundo++;

         strncpy(undo->type,type,sizeof(undo->type));

         undo->type[sizeof(undo->type)-1]='\0';

-        undo->off=redata->usedundobuf;

+        undo->off=stack->usedbuf;

         undo->len=0;

         return(undo);

 }

 undo_t *

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

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

 {

         int startpos,startoff,endpos,endoff;

         undo_t *undo;

         int k;

         int used;

         int copyfrom,copysize;

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

+        if(redata==NULL || type==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) {

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

         }

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

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

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

-        if((undo=redata_undo_new(redata,type))==NULL)

+        if((undo=redata_undo_new(redata,stack,type))==NULL)

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

-        undo->off=redata->usedundobuf;

+        undo->off=stack->usedbuf;

         /* copy contents */

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

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

@@ -678,8 +681,8 @@ redata_undo_newfromchunks(redata_t *redata,char *type, int pos1, int len)

                         copyfrom=0;

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

                 }

-                memcpy(redata->undobuf+redata->usedundobuf,redata->chunks[k]->data+copyfrom,copysize);

-                redata->usedundobuf+=copysize;

+                memcpy(stack->buf+stack->usedbuf,redata->chunks[k]->data+copyfrom,copysize);

+                stack->usedbuf+=copysize;

                 used+=copysize;

         }

         undo->len=used;

@@ -687,40 +690,95 @@ redata_undo_newfromchunks(redata_t *redata,char *type, int pos1, int len)

 }

 undo_t *

-redata_undo_newfrombuf(redata_t *redata, char *type, char *buf, int buflen)

+redata_undo_newfrombuf(redata_t *redata, undostack_t *stack, char *type, char *buf, int buflen)

 {

         undo_t *undo;

-        if(redata==NULL || type==NULL || buflen<=0)

+        if(redata==NULL || type==NULL || buflen<=0

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

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

-        if(redata_undobuf_reserve(redata,buflen)!=0)

+        if(redata_undobuf_reserve(redata,stack, buflen)!=0)

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

-        if((undo=redata_undo_new(redata,type))==NULL)

+        if((undo=redata_undo_new(redata,stack,  type))==NULL)

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

-        undo->off=redata->usedundobuf;

-        memcpy(redata->undobuf+redata->usedundobuf,buf,buflen);

-        redata->usedundobuf+=buflen;

+        undo->off=stack->usedbuf;

+        memcpy(stack->buf+stack->usedbuf,buf,buflen);

+        stack->usedbuf+=buflen;

         undo->len=buflen;

         return(undo);

 }

 int

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

+redata_undo_movelast(redata_t *redata, undostack_t *from, undostack_t *to)

+{

+        undo_t *undofrom;

+        undo_t *undoto;

+        if(redata==NULL || from!=to

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

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

+          || from->usedundo<1)

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

+        undofrom=from->undo+from->usedundo-1;

+        if((undoto=redata_undo_newfrombuf(redata,to,undofrom->type,from->buf+undofrom->off,undofrom->len))==NULL)

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

+        undoto->posorig=undofrom->posorig;

+        undoto->posdest=undofrom->posdest;

+        memcpy(undoto->prehash,undofrom->prehash,sizeof(undoto->prehash));

+        memcpy(undoto->posthash,undofrom->posthash,sizeof(undoto->posthash));

+        redata_undo_removelast(redata, from);

+        return(0);

+}

+

+int

+redata_undo_removelast(redata_t *redata, undostack_t *stack)

+{

+        undo_t *undo;

+        if(redata==NULL

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

+          || stack->usedundo<1)

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

+        undo=stack->undo+stack->usedundo-1;

+        stack->usedbuf-=undo->len;

+        memset(undo,0,sizeof(undo_t));

+        stack->usedundo--;

+        return(0);

+}

+

+int

+redata_undo_wipe(redata_t *redata, undostack_t *stack)

+{

+        if(redata==NULL

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

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

+        memset(stack->undo,0,sizeof(undo_t)*stack->usedundo);

+        stack->usedundo=0;

+        memset(stack->buf,0,stack->usedbuf);

+        stack->usedbuf=0;

+        return(0);

+}

+

+int

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

 {

         int chunkno,pos;

-        char hashpost[129];

         undo_t *undo;

         rechunk_t *chunk,*nextchunk;

         int avail,nextavail;

         int i;

         int needed;

         char *ptr;

-        if(redata==NULL || buf==NULL || buflen<0 || insertpos<0  || insertpos>redata_getused(redata))

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

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

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

-        if((undo=redata_undo_newfrombuf(redata,"ADD",buf,buflen))==NULL)

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

-        redata_hash(redata,undo->prehash);

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

+                if((undo=redata_undo_newfrombuf(redata,&(redata->undostack),"ADD",buf,buflen))==NULL)

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

+                redata_hash(redata,undo->prehash);

+        } else {

+                undo=NULL;

+        }

         chunk=redata->chunks[chunkno];

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

         nextchunk=((chunkno+1)<redata->sizechunks)?redata->chunks[chunkno+1]:NULL;

@@ -743,8 +801,10 @@ redata_op_add(redata_t *redata, char *buf, int buflen, int insertpos)

                 needed*=redata->chunkdatasize;

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

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

-                        redata->usedundobuf-=buflen;

-                        memset(undo,0,sizeof(undo_t));

+                        if(undo!=NULL) {

+                                redata->undostack.usedbuf-=buflen;

+                                memset(undo,0,sizeof(undo_t));

+                        }

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

                 }

                 redata_chunk_insertnew(redata,chunkno);

@@ -768,20 +828,31 @@ redata_op_add(redata_t *redata, char *buf, int buflen, int insertpos)

                         break;

         }

         /* activate undo */

-        redata_hash(redata,undo->posthash);

-        redata->usedundo++;

+        if(undo!=NULL) {

+                /* new or from redo stack */

+                undo->posorig=undo->posdest=insertpos;

+                redata_hash(redata,undo->posthash);

+                redata->undostack.usedundo++;

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

+        }

         return(0);

 }

 int

-redata_op_del(redata_t *redata, int pos, int size)

+redata_op_del(redata_t *redata, int pos, int size, undostack_t *fromhere)

 {

 #warning TODO

         return(-1);

 }

 int

-redata_op_move(redata_t *redata, int posorig, int size, int posdest)

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

 {

 #warning TODO

         return(-1);

@@ -790,13 +861,29 @@ redata_op_move(redata_t *redata, int posorig, int size, int posdest)

 int

 redata_op_undo(redata_t *redata)

 {

+        undo_t *undo;

+        if(redata==NULL

+          || redata->undostack.usedundo<1)

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

+        undo=redata->undostack.undo+redata->undostack.usedundo-1;

+        if(strcmp(undo->type,"ADD")==0) {

+                redata_op_del(redata,undo->posorig,undo->len,&(redata->undostack));

+        } else if(strcmp(undo->type,"DEL")==0) {

+                redata_op_add(redata,undo->posorig,redata->undostack.buf+undo->off,undo->len,&(redata->undostack));

+        } else if(strcmp(undo->type,"MOV")==0) {

 #warning TODO

+        } else

+                return(-1); /* unknown operation */

+ #warning TODO

         return(-1);

 }

 int

 redata_op_redo(redata_t *redata)

 {

+        if(redata==NULL

+          || redata->redostack.usedundo<1)

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

 #warning TODO

         return(-1);

 }

@@ -28,10 +28,21 @@ typedef struct undo_t {

         char type[4];

         int off;

         int len;

+        int posorig;

+        int posdest;

         char prehash[129];

         char posthash[129];

 } undo_t;

+typedef struct undostack_t {

+        int sizeundo;

+        int usedundo;

+        undo_t *undo;

+        int sizebuf;

+        int usedbuf;

+        char *buf;

+} undostack_t;

+

 typedef struct redata_t {

         /* data */

         int chunkdatasize;

@@ -40,12 +51,8 @@ typedef struct redata_t {

         int available;

         rechunk_t *tmpchunk;

         /* undo */

-        int sizeundo;

-        int usedundo;

-        undo_t *undo;

-        int sizeundobuf;

-        int usedundobuf;

-        char *undobuf;

+        undostack_t undostack;

+        undostack_t redostack;

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

         char filename[PATH_MAX];

         char initialhash[129];

@@ -75,9 +82,13 @@ int redata_chunk_insertdata(redata_t *redata, int chunkto, int posto, char *buf,

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

 int redata_whatin_refresh(redata_t *redata, int chunkno);

 int redata_fix_nl(redata_t *redata, int chunkno);

-undo_t *redata_undo_new(redata_t *redata, char *type);

-undo_t *redata_undo_newfromchunks(redata_t *redata,char *type, int pos1, int len);

-undo_t *redata_undo_newfrombuf(redata_t *redata, char *type, char *buf, int buflen);

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

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

+undo_t *redata_undo_newfrombuf(redata_t *redata, undostack_t *stack, char *type, char *buf, int buflen);

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

 /* high level stuff */

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

@@ -91,9 +102,9 @@ int redata_unsaved_unadd(redata_t *redata, undo_t *undo);

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

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

-int redata_op_add(redata_t *redata, char *buf, int buflen, int pos);

-int redata_op_del(redata_t *redata, int pos, int size);

-int redata_op_move(redata_t *redata, int posorig, int size, int posdest);

+int redata_op_add(redata_t *redata, int pos, char *buf, int buflen, undostack_t *fromhere);

+int redata_op_del(redata_t *redata, int pos, int size, undostack_t *fromhere);

+int redata_op_move(redata_t *redata, int posorig, int size, int posdest, undostack_t *fromhere);

 int redata_op_undo(redata_t *redata);

 int redata_op_redo(redata_t *redata);

@@ -192,7 +192,7 @@ fprintf(stderr,"\ntest_edit(%s%s%s,%s%s%s,%i,%i);\nResult: ",(filename!=NULL)?"\

                                         /* editing */

                                         memmove(mem+l+size,mem+l,cursize-l);

                                         memcpy(mem+l,ptr,size);

-                                        redata_op_add(redata,ptr,size,l);

+                                        redata_op_add(redata,l,ptr,size,NULL);

                                 }

                                 cursize+=size;

                                 ptr+=size;