@@ -197,6 +197,25 @@ redata_chunk_insertnew(redata_t *redata, int afterthischunk)

         return(0);

 }

+int

+redata_chunk_deletechunk(redata_t *redata, int chunkno)

+{

+        rechunk_t *chunk;

+        int i;

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

+                return(-1);

+        chunk=redata->chunks[chunkno];

+        if(chunk->useddata>0) {

+                redata->available+=chunk->useddata;

+                chunk->useddata=0;

+                chunk->whatin_fresh=0;

+        }

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

+                redata->chunks[i]=redata->chunks[i+1];

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

+        return(0);

+}

+

 int

 redata_preallocate(redata_t *redata, long newsize)

@@ -297,6 +316,7 @@ redata_chunk_insertdata(redata_t *redata, int chunkto, long posto, char *buf, lo

         memcpy(chunk->data+posto,buf,buflen);

         chunk->useddata+=buflen;

         chunk->whatin_fresh=0;

+        redata->available-=buflen;

         return(0);

 }

@@ -315,6 +335,7 @@ redata_chunk_deletedata(redata_t *redata, int chunkno, long pos, long n)

         memmove(chunk->data+pos,chunk->data+pos+n,chunk->useddata-pos-n);

         chunk->useddata-=n;

         chunk->whatin_fresh=0;

+        redata->available+=n;

         return(0);

 }

@@ -713,7 +734,7 @@ redata_undo_movelast(redata_t *redata, undostack_t *from, undostack_t *to)

 {

         undo_t *undofrom;

         undo_t *undoto;

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

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

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

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

           || from->usedundo<1)

@@ -758,7 +779,7 @@ 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)

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

 {

         int chunkno;

         long pos;

@@ -804,6 +825,7 @@ redata_op_add(redata_t *redata, int insertpos, char *buf, int buflen, undostack_

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

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

                         if(undo!=NULL) {

+                                redata->undostack.usedundo--;

                                 redata->undostack.usedbuf-=buflen;

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

                         }

@@ -834,7 +856,6 @@ redata_op_add(redata_t *redata, int insertpos, char *buf, int buflen, undostack_

                 /* 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

@@ -847,14 +868,62 @@ redata_op_add(redata_t *redata, int insertpos, char *buf, int buflen, undostack_

 }

 int

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

+redata_op_del(redata_t *redata, long delpos, long size, undostack_t *fromhere)

 {

-#warning TODO

-        return(-1);

+        int chunkno,curchunk;

+        long pos;

+        undo_t *undo;

+        rechunk_t *chunk;

+        long ndel;

+        long curpos,curdel;

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

+          || delpos>redata_getused(redata)

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

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

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

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

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

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

+                if((undo=redata_undo_newfromchunks(redata,&(redata->undostack),"DEL",delpos,size))==NULL)

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

+                redata_hash(redata,undo->prehash);

+        } else {

+                undo=NULL;

+        }

+        for(curchunk=chunkno,ndel=0;ndel<size;curchunk++) {

+                curpos=(curchunk==chunkno)?pos:0;

+                curdel=redata->chunks[curchunk]->useddata-curpos;

+                curdel=(curdel>(size-ndel))?(size-ndel):curdel;

+                redata_chunk_deletedata(redata,chunkno,curpos,curdel);

+                ndel+=curdel;

+        }

+        /* fix nl and delete unused chunks */

+        for(curchunk--;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(undo!=NULL) {

+                /* new or from redo stack */

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

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

+        }

+        return(0);

 }

 int

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

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

 {

 #warning TODO

         return(-1);

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

 #include <limits.h>

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

 typedef struct whatin_t {

         int nlcount;

 } whatin_t;

@@ -62,8 +61,6 @@ typedef struct redata_t {

         int flag_unsaveddata;

 } redata_t;

-#warning TODO: undo operations log/buffer, add/remove/move text funtions

-

 redata_t *redata_init(void);

 void redata_free(redata_t *redata);

@@ -78,6 +75,7 @@ int redata_getposptr(redata_t *redata, long pos, int *numchunk, long *offset);

 int redata_wipe(redata_t *redata);

 int redata_preallocate(redata_t *redata, long size);

 int redata_chunk_insertnew(redata_t *redata, int afterthischunk);

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

@@ -104,9 +102,9 @@ 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);

-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_add(redata_t *redata, long pos, char *buf, long buflen, undostack_t *fromhere);

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

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

 int redata_op_undo(redata_t *redata);

 int redata_op_redo(redata_t *redata);

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

                                 progress[l]=(l<(sizeof(progress)-2))?*ptr:'+';

                                 progress[l+1]='\0';

                         }

+if(k!=0) redata_save(redata,"test.pre");

                         if(*ptr=='A') {

                                 /* A,<insertpos>,<endchar>,<text><endchar> */

                                 ptr++;

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

                                 ptr+=(*ptr==',')?1:0;

                                 endcode=*ptr;

                                 ptr+=(*ptr!='\0')?1:0;

+                                ptr+=(*ptr==',')?1:0;

                                 ptrend=strchr(ptr,endcode);

                                 ptrend=(ptrend==NULL)?ptr+strlen(ptr):ptrend;

                                 size=ptrend-ptr;

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

                                 return(errorbuf);

                         }

                         if(k!=0) {

+if(k!=0) redata_save(redata,"test.post");

                                 redata_hash(redata,hash129_redata);

                                 redata_memhash(redata,mem,cursize,hash129_mem);

                                 if(strcmp(hash129_redata,hash129_mem)!=0) {

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

                                         return(errorbuf);

                                 }

                                 redata_op_undo(redata);

+redata_save(redata,"test.undo");

                                 redata_hash(redata,hash129_redata);

                                 if(strcmp(hash129_redata,hash129_memold)!=0) {

                                         if(mem!=NULL)

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

                                         return(errorbuf);

                                 }

                                 redata_op_redo(redata);

+redata_save(redata,"test.redo");

                                 redata_hash(redata,hash129_redata);

                                 if(strcmp(hash129_redata,hash129_mem)!=0) {

                                         if(mem!=NULL)