@@ -561,7 +561,7 @@ redata_unsaved_loadappend(redata_t *redata)

         long nread,lim;

         char *ptr,*endptr,*aux,*bufptr;

         char actioncode;

-        long pos;

+        long pos,pos2;

         char endcode;

         int flag_multipart;

         if((fd=redata_unsaved_check_gen(redata,redata->filename))==-1)

@@ -631,7 +631,31 @@ redata_unsaved_loadappend(redata_t *redata)

                                 redata_op_del(redata,pos,aux-bufptr,NULL);

                         } while(flag_multipart);

                 } else if(actioncode=='M') {

-#warning TODO

+                        ptr=ptr_getlong(ptr,endptr,&pos);

+                        ptr+=(ptr!=NULL && ptr<endptr)?1:0;

+                        ptr=ptr_getlong(ptr,endptr,&pos2);

+                        do {

+                                flag_multipart=0;

+                                ptr=ptr_getchar(ptr,endptr,&endcode);

+                                if(ptr!=NULL && endcode=='+') {

+                                        flag_multipart=1;

+                                        ptr=ptr_getchar(ptr,endptr,&endcode);

+                                }

+                                bufptr=ptr;

+                                ptr=ptr_searchendchar(ptr,endptr,endcode,&aux);

+                                if(ptr==NULL

+                                  || pos<0 || (pos+(aux-bufptr))>redata_getused(redata)

+                                  || pos2<0 || pos2>redata_getused(redata)

+                                  || ((aux-bufptr)>0 && pos2>=pos && pos2<(pos+(aux-bufptr)))

+                                  ) {

+                                        return(-1); /* malformed register */

+                                }

+                                if(redata_data_compare(redata,pos,bufptr,aux-bufptr)!=0)

+                                        return(-1); /* corrupted data */

+                                redata_op_move(redata,pos,(aux-bufptr),pos2,NULL);

+                                pos=(pos<pos2)?pos:(pos+(aux-bufptr));

+                                pos2=pos2+(aux-bufptr);

+                        } while(flag_multipart);

                 } else {

                         return(-1); /* corrupted undobuf */

                 }

@@ -641,17 +665,77 @@ redata_unsaved_loadappend(redata_t *redata)

 int

-redata_unsaved_add(redata_t *redata, undo_t *undo)

+redata_unsaved_add(redata_t *redata, undostack_t *stack, int undono)

 {

-

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

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

+                maxsize++;

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

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

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

 }

 int

-redata_unsaved_unadd(redata_t *redata, undo_t *undo)

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

 {

 #warning TODO

         return(-1);

@@ -106,8 +106,8 @@ int redata_unsaved_check(redata_t *redata, char *filename);

 int redata_unsaved_loadappend(redata_t *redata);

 int redata_unsaved_unlink(redata_t *redata);

 int redata_unsaved_trunc(redata_t *redata);

-int redata_unsaved_add(redata_t *redata, undo_t *undo);

-int redata_unsaved_unadd(redata_t *redata, undo_t *undo);

+int redata_unsaved_add(redata_t *redata, undostack_t *stack, int undono);

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

 int redata_unsaved_commit(redata_t *redata);

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