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

         /* undo */

         redata->sizeundo=0;

         redata->usedundo=0;

-        redata->curundo=0;

         redata->undo=NULL;

         redata->undobuf=NULL;

         /* unsaved */

@@ -178,6 +177,27 @@ redata_wipe(redata_t *redata)

         return(0);

 }

+int

+redata_chunk_insertnew(redata_t *redata, int afterthischunk)

+{

+        rechunk_t *newchunk;

+        int i;

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

+                return(-1);

+        if(redata->chunks[redata->sizechunks-1]->useddata!=0) {

+                if(redata_preallocate(redata,redata_getsize(redata)+redata->chunkdatasize)==-1

+                  || redata->chunks[redata->sizechunks-1]->useddata!=0)

+                        return(-1);

+        }

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

+        /* move the emtpy chunk to after chunkno */

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

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

+        redata->chunks[afterthischunk+1]=newchunk;

+        return(0);

+}

+

+

 int

 redata_preallocate(redata_t *redata, int newsize)

 {

@@ -243,6 +263,8 @@ redata_chunk_movedata(redata_t *redata, int chunkfrom, int posfrom, int chunkto,

                 memmove(from->data+posfrom,from->data+posfrom+size,from->useddata-posfrom-size);

                 from->useddata-=size;

                 to->useddata+=size;

+                from->whatin_fresh=0;

+                to->whatin_fresh=0;

         } else {

                 /* from==to */

                 rechunk_t *chunk=redata->chunks[chunkfrom];

@@ -256,12 +278,48 @@ redata_chunk_movedata(redata_t *redata, int chunkfrom, int posfrom, int chunkto,

                         memmove(chunk->data+posfrom+size-inside,chunk->data+posto,inside);

                         memcpy(chunk->data+posto,redata->tmpchunk->data,size);

                 }

+                chunk->whatin_fresh=0;

         }

         return(0);

 }

 int

-redata_fill_whatin(redata_t *redata, int chunkno)

+redata_chunk_insertdata(redata_t *redata, int chunkto, int posto, char *buf, int buflen)

+{

+        rechunk_t *chunk;

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

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

+          || posto<0 || posto>redata->chunks[chunkto]->useddata

+          || (redata->chunkdatasize-redata->chunks[chunkto]->useddata)<buflen)

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

+        chunk=redata->chunks[chunkto];

+        memmove(chunk->data+posto+buflen,chunk->data+posto,chunk->useddata-posto);

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

+        chunk->useddata+=buflen;

+        chunk->whatin_fresh=0;

+        return(0);

+}

+

+int

+redata_chunk_deletedata(redata_t *redata, int chunkno, int pos, int n)

+{

+        rechunk_t *chunk;

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

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

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

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

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

+        if(n==0)

+                return(0); /* all done */

+        chunk=redata->chunks[chunkno];

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

+        chunk->useddata-=n;

+        chunk->whatin_fresh=0;

+        return(0);

+}

+

+int

+redata_whatin_refresh(redata_t *redata, int chunkno)

 {

         rechunk_t *chunk;

         int nlcount;

@@ -290,8 +348,7 @@ mymemrchr(const void *s, int c, size_t n)

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

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

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

-                        res=s+i;

-        }

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

         return(res);

 }

@@ -321,28 +378,16 @@ redata_fix_nl(redata_t *redata, int chunkno)

                 /* move incomplete line to next chunk */

                 redata_chunk_movedata(redata, chunkno, chunk->useddata-linesize, chunkno+1, 0, linesize);

         } else if(ptr!=NULL) {

-                /* only if we have more data un chunkno before this long line */

-                int i,newavail;

-                rechunk_t *newchunk;

+                /* only if we have more data in chunkno before this long line */

+                int newavail;

                 /* create a new empty chunk in-between and put the line there */

-                if(redata->chunks[redata->sizechunks-1]->useddata!=0) {

-                        if(redata_preallocate(redata,redata->available+redata->chunkdatasize)==-1

-                          || redata->chunks[redata->sizechunks-1]->useddata!=0)

-                                return(-1);

-                }

-                newchunk=redata->chunks[redata->sizechunks-1];

-                /* move the emty chunk to after chunkno */

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

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

-                redata->chunks[chunkno+1]=newchunk;

+                if(redata_chunk_insertnew(redata,chunkno)==-1)

+                        return(-1);

                 /* move the data; if it doesn't fit, move from the beginning until it is full */

                 redata_chunk_movedata(redata, chunkno, chunk->useddata-linesize, chunkno+1, 0, linesize);

                 newavail=redata->sizechunks-linesize;

                 redata_chunk_movedata(redata, chunkno+2, 0, chunkno+1, linesize, (newavail<nextlinesize)?newavail:nextlinesize);

-                redata->chunks[chunkno+2]->whatin_fresh=0;

         }

-        redata->chunks[chunkno]->whatin_fresh=0;

-        redata->chunks[chunkno+1]->whatin_fresh=0;

         return(0);

 }

@@ -481,7 +526,7 @@ redata_load(redata_t *redata, char *filename, int use_unsaved)

         for(totalread=0,chunkno=0,nread=0;totalread<statbuf.st_size;totalread+=nread,nread=0) {

                 if(chunkno>=redata->sizechunks || redata->chunks[chunkno]==NULL) {

                         /* alloc another chunk */

-                        if(redata_preallocate(redata,(redata->sizechunks+1)*redata->chunkdatasize)==-1 ||

+                        if(redata_preallocate(redata,redata_getsize(redata)+redata->chunkdatasize)==-1 ||

                                 chunkno>=redata->sizechunks || redata->chunks[chunkno]==NULL) {

                                 close(fd),fd=-1;

                                 fprintf(stderr,"redata_load: INTERNAL ERROR\n");

@@ -508,7 +553,7 @@ redata_load(redata_t *redata, char *filename, int use_unsaved)

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

                 redata_fix_nl(redata,chunkno);

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

-                redata_fill_whatin(redata,chunkno);

+                redata_whatin_refresh(redata,chunkno);

         /* unsaved */

         redata_hash(redata,redata->initialhash);

         if(use_unsaved) {

@@ -642,7 +687,7 @@ redata_undo_newfromchunks(redata_t *redata,char *type, int pos1, int len)

 }

 undo_t *

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

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

 {

         undo_t *undo;

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

@@ -659,11 +704,73 @@ redata_undobuf_newfrombuf(redata_t *redata, char *type, char *buf, int buflen)

 }

 int

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

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

 {

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

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

+        chunk=redata->chunks[chunkno];

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

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

+        nextavail=(nextchunk==NULL)?0:redata->chunkdatasize-nextchunk->useddata;

+        if(avail>=buflen) {

+                /* fits in current chunk */

+                redata_chunk_insertdata(redata,chunkno,pos,buf,buflen);

+                redata_fix_nl(redata,chunkno);

+                nextchunk=chunk;

+        } else if((avail+nextavail)>=buflen) {

+                /* part fits in current chunk, part in next chunk */

+                int bothering;

+                bothering=chunk->useddata-pos;

+                bothering=(bothering>nextavail)?nextavail:bothering;

+                redata_chunk_movedata(redata,chunkno,chunk->useddata-bothering,chunkno+1,0,bothering);

+                redata_chunk_insertdata(redata,chunkno,pos,buf,buflen);

+        } else {

+                /* will need to add more chunks */

+                needed=(buflen+redata->chunkdatasize-1)/redata->chunkdatasize;

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

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

+                }

+                redata_chunk_insertnew(redata,chunkno);

+                redata_chunk_movedata(redata,chunkno,pos,chunkno+1,0,chunk->useddata-pos);

+                nextchunk=redata->chunks[chunkno+1];

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

+                avail=(avail>buflen)?buflen:avail;

+                redata_chunk_insertdata(redata,chunkno,chunk->useddata,buf,avail);

+                for(ptr=buf+avail,i=chunkno;(ptr-buf)<buflen;i++,ptr+=avail) {

+                        redata_chunk_insertnew(redata,i);

+                        avail=redata->chunkdatasize-redata->chunks[i+1]->useddata;

+                        avail=(avail>(buflen-(ptr-buf)))?(buflen-(ptr-buf)):avail;

+                        redata_chunk_insertdata(redata,i+1,0,ptr,avail);

-#warning TODO

-        return(-1);

+                }

+        }

+        /* fix nl until nextchunk (...fix_nl can insert chunks) */

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

+                redata_fix_nl(redata,i);

+                if(redata->chunks[i]==nextchunk)

+                        break;

+        }

+        /* activate undo */

+        redata_hash(redata,undo->posthash);

+        redata->usedundo++;

+        return(0);

 }

 int

@@ -25,9 +25,11 @@ typedef struct rechunk_t {

 } rechunk_t;

 typedef struct undo_t {

-        char type[5];

+        char type[4];

         int off;

         int len;

+        char prehash[129];

+        char posthash[129];

 } undo_t;

 typedef struct redata_t {

@@ -40,7 +42,6 @@ typedef struct redata_t {

         /* undo */

         int sizeundo;

         int usedundo;

-        int curundo;

         undo_t *undo;

         int sizeundobuf;

         int usedundobuf;

@@ -65,12 +66,20 @@ int redata_getavailable(redata_t *redata);

 int redata_getused(redata_t *redata);

 int redata_getposptr(redata_t *redata, int pos, int *numchunk, int *offset);

+/* low level stuff */

 int redata_wipe(redata_t *redata);

 int redata_preallocate(redata_t *redata, int size);

+int redata_chunk_insertnew(redata_t *redata, int afterthischunk);

 int redata_chunk_movedata(redata_t *redata, int chunkfrom, int posfrom, int chunkto, int posto, int size);

-int redata_fill_whatin(redata_t *redata, int chunkno);

+int redata_chunk_insertdata(redata_t *redata, int chunkto, int posto, char *buf, int buflen);

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

+/* high level stuff */

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

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

 int redata_unsaved_loadappend(redata_t *redata);

@@ -82,7 +91,7 @@ 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 sizebuf, int pos);

+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_undo(redata_t *redata);

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

                                 size=ptrend-ptr;

                                 if(k!=0) {

                                         /* editing */

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

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

                                         memcpy(mem+l,ptr,size);

                                         redata_op_add(redata,ptr,size,l);

                                 }