@@ -39,6 +39,7 @@ static char *genname(char *filename,char *prefix, char *postfix, char *buf, int

 static char *ptr_getlong(char *ptr,char *endptr,long *data);

 static char *ptr_getchar(char *ptr,char *endptr,char *data);

 static char *ptr_searchendchar(char *ptr, char *endptr, char endchar, char **endcharpos);

+static char sep_select(char *buf, int bufsize, char **pos);

 redata_t *

 redata_init(void)

@@ -618,6 +619,7 @@ redata_unsaved_loadappend(redata_t *redata)

 int

 redata_unsaved_add(redata_t *redata, undo_t *undo)

 {

+

         /* separator is '$' , '@'  or '%' (whatever makes the longest string) */

         /* if len is omitted, then it goes inmediatly after the last op (probably there separator character was used in the string) */

 #warning TODO

@@ -631,6 +633,14 @@ redata_unsaved_unadd(redata_t *redata, undo_t *undo)

         return(-1);

 }

+int

+redata_unsaved_commit(redata_t *redata)

+{

+#warning TODO

+        return(-1);

+}

+

+

 int

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

 {

@@ -751,11 +761,11 @@ redata_undobuf_reserve(redata_t *redata, undostack_t *stack, int minavail)

 }

 undo_t *

-redata_undo_new(redata_t *redata, undostack_t *stack, 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

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

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

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

@@ -769,15 +779,14 @@ redata_undo_new(redata_t *redata, undostack_t *stack, char *type)

         }

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

         stack->usedundo++;

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

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

+        undo->type=type;

         undo->off=stack->usedbuf;

         undo->len=0;

         return(undo);

 }

 undo_t *

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

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

 {

         int startpos,endpos;

         long startoff,endoff;

@@ -785,7 +794,7 @@ redata_undo_newfromchunks(redata_t *redata, undostack_t *stack, char *type, int

         int k;

         long used;

         long copyfrom,copysize;

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

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

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

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

         if(redata_getposptr(redata,pos1,&startpos,&startoff)==-1 ||

@@ -821,10 +830,10 @@ redata_undo_newfromchunks(redata_t *redata, undostack_t *stack, char *type, int

 }

 undo_t *

-redata_undo_newfrombuf(redata_t *redata, undostack_t *stack, 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 || buflen<=0

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

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

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

@@ -905,7 +914,7 @@ redata_op_add(redata_t *redata, long insertpos, char *buf, long buflen, undostac

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

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

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

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

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

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

                 redata_hash(redata,undo->prehash);

         } else {

@@ -993,7 +1002,7 @@ redata_op_del(redata_t *redata, long delpos, long size, undostack_t *fromhere)

         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)

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

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

                 redata_hash(redata,undo->prehash);

         } else {

@@ -1046,11 +1055,11 @@ redata_op_undo(redata_t *redata)

           || redata->undostack.usedundo<1)

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

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

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

+        if(undo->type=='A') { /* ADD */

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

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

+        } else if(undo->type=='D') { /* DEL */

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

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

+        } else if(undo->type=='M') { /* MOVE */

                 if(undo->posorig<undo->posdest)

                         redata_op_move(redata,undo->posdest-undo->len, undo->len, undo->posorig,&(redata->undostack));

                 else

@@ -1068,11 +1077,11 @@ redata_op_redo(redata_t *redata)

           || redata->redostack.usedundo<1)

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

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

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

+        if(undo->type=='A') { /* ADD */

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

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

+        } else if(undo->type=='D') { /* DEL */

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

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

+        } else if(undo->type=='M') { /* MOVE */

                 redata_op_move(redata,undo->posorig, undo->len, undo->posdest,&(redata->redostack));

         } else

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

@@ -1284,3 +1293,25 @@ ptr_searchendchar(char *ptr, char *endptr, char endchar, char **endcharpos)

         return(aux+1);

 }

+static char

+sep_select(char *buf, int bufsize, char **pos)

+{

+        static char seps[]={"$%@!|&/='\"^*;:,-_"};

+        char *ptr,*bestptr;

+        int i,besti;

+        bestptr=buf;

+        if(pos!=NULL)

+                *pos=NULL;

+        for(i=0,besti=0;i<sizeof(seps);i++) {

+                if((ptr=memchr(buf,seps[i],bufsize))==NULL)

+                        return(seps[i]);

+                if(ptr>bestptr) {

+                        besti=0;

+                        bestptr=ptr;

+                }

+        }

+        if(pos!=NULL)

+                *pos=bestptr;

+        return(seps[besti]);

+}

+

@@ -25,7 +25,7 @@ typedef struct rechunk_t {

 } rechunk_t;

 typedef struct undo_t {

-        char type[4];

+        char type;

         long off;

         long len;

         long posorig;

@@ -88,9 +88,9 @@ int redata_chunk_deletedata(redata_t *redata, int chunkno, long pos, long n);

 int redata_whatin_refresh(redata_t *redata, int chunkno);

 int redata_fix_nl(redata_t *redata, int chunkno);

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

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

@@ -171,7 +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(k!=0) redata_save(redata,"test.pre");*/

                         if(*ptr=='A') {

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

                                 ptr++;

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

                                 return(errorbuf);

                         }

                         if(k!=0) {

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

+/*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,7 +217,7 @@ if(k!=0) redata_save(redata,"test.post");

                                         return(errorbuf);

                                 }

                                 redata_op_undo(redata);

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

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

                                 redata_hash(redata,hash129_redata);

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

                                         if(mem!=NULL)

@@ -228,7 +228,7 @@ redata_save(redata,"test.undo");

                                         return(errorbuf);

                                 }

                                 redata_op_redo(redata);

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

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

                                 redata_hash(redata,hash129_redata);

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

                                         if(mem!=NULL)