@@ -8,16 +8,18 @@ recenteditor.o: recenteditor.c re_data.h

 re_data.o: re_data.c re_data.h

+re_plugin_unsaved.o: re_plugin_unsaved.c re_plugin_unsaved.h re_data.h

+

 re_tests.o: re_tests.c re_data.h

 sha3.o: sha3/sha3.c sha3/sha3.h

 	$(CC) $(CFLAGS) -Isha3 -c -o sha3.o sha3/sha3.c

-re: recenteditor.o re_data.o sha3.o

-	$(CC) $(LDFLAGS) -o re recenteditor.o re_data.o sha3.o

+re: recenteditor.o re_data.o re_plugin_unsaved.o sha3.o

+	$(CC) $(LDFLAGS) -o re recenteditor.o re_data.o re_plugin_unsaved.o sha3.o

 tests: re_tests.o re_data.o sha3.o

 	$(CC) $(LDFLAGS) -o tests re_tests.o re_data.o sha3.o

 clean:

-	rm -f recenteditor.o re_data.o re_tests.o sha3.o re tests

+	rm -f recenteditor.o re_data.o re_tests.o re_plugin_unsaved.o sha3.o re tests

@@ -18,6 +18,7 @@

 #include <fcntl.h>

 #include <limits.h>

 #include <inttypes.h>

+#include <stdarg.h>

 #include "re_data.h"

 #include "sha3/sha3.h"

@@ -25,21 +26,11 @@

 #define CHUNKSIZE 32768

 #define UNDOBLOCK 1024

 #define UNDOGROWSIZE (256*1024)

-#define UNSAVEDPREFIX "."

-#define UNSAVEDPOSTFIX ".reu"

 #define SECURESAVEPREFIX "."

 #define SECURESAVEPOSTFIX ".saving"

-#define UNSAVEDHEADER "reunsaved00,"

 static int redata_hash_gen(redata_t *redata, char *filename, char *buf, long buflen, char *resbuf129bytes);

-static int redata_unsaved_check_gen(redata_t *redata, char *filename);

-static char *unsaved_genname(char *filename, char *buf, int bufsize);

 static char *securesave_genname(char *filename, char *buf, int bufsize);

-static char *genname(char *filename,char *prefix, char *postfix, char *buf, int bufsize);

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

 static void *mymemrchr(const void *s, int c, size_t n);

 static void meminvert(void *start, void *end);

@@ -64,12 +55,23 @@ redata_debug_chunkdump(redata_t *redata, char *title)

 #endif

 redata_t *

-redata_init(void)

+redata_init(int (*pluginregisterfn)(redata_t *redata, redata_plugin_t *slot), ...)

 {

         redata_t *redata;

-        if((redata=malloc(sizeof(redata_t)))==NULL)

+        va_list args;

+        int nargs;

+        int res;

+        int (*fn)(redata_t *redata, redata_plugin_t *slot);

+        /* count number of plugins */

+        va_start(args,pluginregisterfn);

+        for(nargs=0,fn=pluginregisterfn;fn!=NULL;fn=va_arg(args,int (*)(redata_t *redata, redata_plugin_t *slot)))

+                nargs++;

+        va_end(args);

+        /* get memory */

+        if((redata=malloc(sizeof(redata_t)+sizeof(redata_plugin_t)*(nargs-1)))==NULL)

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

-        memset(redata,0,sizeof(redata_t));

+        memset(redata,0,sizeof(redata_t)+sizeof(redata_plugin_t)*(nargs-1));

+        redata->sizeplugins=nargs;

         /* data */

         redata->sizechunks=0;

         redata->chunks=NULL;

@@ -80,10 +82,15 @@ redata_init(void)

         redata->undostack.usedundo=0;

         redata->undostack.undo=NULL;

         redata->undostack.buf=NULL;

-        /* unsaved */

+        /* plugins */

+        for(nargs=0,fn=pluginregisterfn;fn!=NULL;fn=va_arg(args,int (*)(redata_t *redata,redata_plugin_t *slot))) {

+                res=fn(redata,redata->plugins+nargs);

+                redata->plugins[nargs].active=(res==0)?1:0;

+                nargs++;

+        }

+        va_end(args);

+        /* filename */

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

-        redata->unsavedfd=-1;

-        redata->unsaved.sizebuf=redata->unsaved.usedbuf=0;

         /* all done */

         return(redata);

 }

@@ -92,9 +99,14 @@ void

 redata_free(redata_t *redata)

 {

         int i;

-        char unsname[PATH_MAX];

         if(redata==NULL)

                 return; /* nothing to do */

+        /* plugins */

+        for(i=0;i<redata->sizeplugins;i++) {

+                if(redata->plugins[i].unregister!=NULL)

+                        redata->plugins[i].unregister(redata,redata->plugins+i,redata->filename);

+                memset(redata->plugins+i,0,sizeof(redata_plugin_t));

+        }

         /* data */

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

                 if(redata->chunks[i]!=NULL)

@@ -115,16 +127,6 @@ redata_free(redata_t *redata)

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

         if(redata->redostack.buf!=NULL)

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

-        /* unsaved */

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

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

-                if(unsaved_genname(redata->filename,unsname,sizeof(unsname))!=NULL)

-                        unlink(unsname);

-        }

-        if(redata->unsaved.buf!=NULL) {

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

-                redata->unsaved.sizebuf=redata->unsaved.usedbuf=0;

-        }

         /* free main struct */

         free(redata),redata=NULL;

         return;

@@ -190,7 +192,6 @@ int

 redata_wipe(redata_t *redata)

 {

         int i;

-        char unsname[PATH_MAX];

         if(redata==NULL)

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

         /* data */

@@ -199,14 +200,12 @@ redata_wipe(redata_t *redata)

                 memset(&(redata->chunks[i]->whatin),0,sizeof(whatin_t));

         }

         redata->available=redata_getsize(redata);

-        /* unsaved */

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

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

-                if(unsaved_genname(redata->filename,unsname,sizeof(unsname))!=NULL)

-                        unlink(unsname);

+        /* plugins */

+        for(i=0;i<redata->sizeplugins;i++) {

+                if(redata->plugins[i].wipe!=NULL)

+                        redata->plugins[i].wipe(redata,redata->plugins+i,redata->filename);

         }

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

-        redata->unsaved.usedbuf=0;

         /* all done */

         return(0);

 }

@@ -467,385 +466,6 @@ redata_fix_nl(redata_t *redata, int chunkno)

         return(0);

 }

-int

-redata_unsaved_exists(redata_t *redata, char *filename)

-{

-        char unsname[PATH_MAX+1];

-        int fd;

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

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

-        if((unsaved_genname(filename,unsname,sizeof(unsname)))==NULL)

-                return(-1); /* malformed filename */

-        if((fd=open(unsname,O_RDONLY))==-1)

-                return(-1);

-        close(fd),fd=-1;

-        return(0);

-}

-

-static int

-redata_unsaved_check_gen(redata_t *redata, char *filename)

-{

-        char unsname[PATH_MAX+1];

-        int fd,nread;

-        static char header[]={UNSAVEDHEADER};

-        char filehash[129],undohash[129],buf[16];

-        char fileheader[]={UNSAVEDHEADER};

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

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

-        if((unsaved_genname(filename,unsname,sizeof(unsname)))==NULL)

-                return(-1); /* malformed filename */

-        if(redata_filehash(redata,filename,filehash)!=0)

-                return(-1);

-        if((fd=open(unsname,O_RDONLY))==-1)

-                return(-1);

-        memset(fileheader,0,sizeof(fileheader));

-        if((nread=read(fd,fileheader,sizeof(fileheader)-1))==-1

-          || nread!=(sizeof(fileheader)-1) || memcmp(fileheader,header,sizeof(fileheader))!=0) {

-                close(fd),fd=-1;

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

-        }

-        if((nread=read(fd,undohash,128))==-1 || nread!=128 || memcmp(undohash,filehash,128)!=0) {

-                close(fd),fd=-1;

-                return(-1); /* wrong hash */

-        }

-        if((nread=read(fd,buf,1))==-1 || nread!=1 || *buf!=',') {

-                close(fd),fd=-1;

-                return(-1); /* wrong hash separator */

-        }

-        return(fd);

-}

-

-int

-redata_unsaved_check(redata_t *redata, char *filename)

-{

-        int fd;

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

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

-        close(fd),fd=-1;

-        return(0);

-}

-

-

-int

-redata_unsaved_unlink(redata_t *redata)

-{

-        char unsname[PATH_MAX+1];

-        if(redata==NULL || redata->filename[0]=='\0')

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

-        if(redata_unsaved_exists(redata,redata->filename)==-1)

-                return(0); /* file not found, nothing to unlink */

-        if((unsaved_genname(redata->filename,unsname,sizeof(unsname)))==NULL)

-                return(-1); /* malformed filename */

-        unlink(unsname);

-        return(0);

-}

-

-int

-redata_unsaved_trunc(redata_t *redata)

-{

-        char unsname[PATH_MAX+1];

-        static char header[]={UNSAVEDHEADER};

-        int n;

-        if(redata==NULL || redata->filename[0]=='\0')

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

-        redata_unsaved_unlink(redata);

-        if((unsaved_genname(redata->filename,unsname,sizeof(unsname)))==NULL)

-                return(-1); /* malformed filename */

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

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

-        redata_hash(redata,redata->initialhash);

-        redata->unsaved.usedbuf=0;

-        if((redata->unsavedfd=open(unsname,O_WRONLY|O_TRUNC|O_CREAT,0644))==-1)

-                return(-1); /* couldn't open file for writing */

-        if((n=write(redata->unsavedfd,header,sizeof(header)-1))==-1

-          || n!=(sizeof(header)-1)

-          || (n=write(redata->unsavedfd,redata->initialhash,128))==-1 || n!=128

-          || (n=write(redata->unsavedfd,",",1))==-1 || n!=1) {

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

-                unlink(unsname);

-                return(-1); /* couldn't write header/hash */

-        }

-        return(0);

-}

-

-

-int

-redata_unsaved_loadappend(redata_t *redata)

-{

-        int fd;

-        struct stat statbuf;

-        static char header[]={UNSAVEDHEADER};

-        long headerhashsize;

-        char *newptr;

-        long nread,lim;

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

-        char actioncode;

-        long pos,pos2;

-        char endcode;

-        int flag_multipart;

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

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

-        if(fstat(fd,&statbuf)!=0 || !S_ISREG(statbuf.st_mode)) {

-                close(fd),fd=-1;

-                return(-1); /* couldn't query size or not regular file */

-        }

-        headerhashsize=(sizeof(header)-1)+1+128+1;

-        /* load unsaved to memory */

-        if(redata->unsaved.sizebuf<(statbuf.st_size-headerhashsize)) {

-                if((newptr=realloc(redata->unsaved.buf,(statbuf.st_size-headerhashsize)))==NULL) {

-                        close(fd),fd=-1;

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

-                }

-                redata->unsaved.buf=newptr;

-                redata->unsaved.sizebuf=(statbuf.st_size-headerhashsize);

-        }

-        redata->unsaved.usedbuf=0;

-        lim=(statbuf.st_size-headerhashsize);

-        for(nread=0;redata->unsaved.usedbuf<lim;redata->unsaved.usedbuf+=nread,nread=0) {

-                if((nread=read(fd,redata->unsaved.buf+redata->unsaved.usedbuf,lim-redata->unsaved.usedbuf))<=0) {

-                        redata->unsaved.usedbuf=0;

-                        close(fd),fd=-1;

-                        return(-1); /* short read */

-                }

-        }

-        close(fd),fd=-1;

-        /* process unsaved data */

-        endptr=redata->unsaved.buf+redata->unsaved.usedbuf;

-        for(ptr=redata->unsaved.buf;ptr<endptr;) {

-                if((ptr=ptr_getchar(ptr,endptr,&actioncode))==NULL)

-                        return(-1); /* no space for action char */

-                /* multipart example: A10+$aj$%$% >> insert "aj$" into pos 10 */

-                if(actioncode=='A') {

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

-                        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>redata_getused(redata))

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

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

-                                pos+=aux-bufptr;

-                        } while(flag_multipart);

-                } else if(actioncode=='D') {

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

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

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

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

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

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

-                        } while(flag_multipart);

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

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

-                }

-        }

-        return(-1);

-}

-

-

-int

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

-{

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

-}

-

-int

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

-{

-        /* adds to unsaved the inverse operation to the one specified in the undo */

-        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=='A')?'D':(undo->type=='D')?'A':undo->type;

-                maxsize++;

-                if(undo->type=='A' || undo->type=='D')

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

-                else

-                        snprintf(posbuf,sizeof(posbuf),"%li",(undo->posorig<undo->posdest)?undo->posdest-undo->len:undo->posdest);

-                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->posorig<undo->posdest)?undo->posorig:undo->posorig+undo->len);

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

-}

-

-int

-redata_unsaved_commit(redata_t *redata)

-{

-        int n,nwritten;

-        char unsname[PATH_MAX+1];

-        if(redata==NULL || redata->unsavedfd==-1)

-                return(-1);

-        for(nwritten=0;nwritten<redata->unsaved.usedbuf;nwritten+=n) {

-                if((n=write(redata->unsavedfd,redata->unsaved.buf+nwritten,redata->unsaved.usedbuf-nwritten))<0) {

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

-                        if((unsaved_genname(redata->filename,unsname,sizeof(unsname)))!=NULL)

-                                unlink(unsname); /* a corrupted unsaved is of no use, delete it */

-                        return(-1); /* error writing */

-                }

-        }

-        redata->unsaved.usedbuf=0;

-        return(0);

-}

-

-

 int

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

 {

@@ -853,6 +473,7 @@ redata_load(redata_t *redata, char *filename, int use_unsaved)

         int chunkno, avail;

         struct stat statbuf;

         rechunk_t *chunk;

+        int i;

         if(redata==NULL || filename==NULL)

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

         redata_wipe(redata);

@@ -900,14 +521,17 @@ redata_load(redata_t *redata, char *filename, int use_unsaved)

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

                 redata_whatin_refresh(redata,chunkno);

         /* unsaved */

-        if(use_unsaved) {

-                /* apply missing changes and append new changes to unsaved */

-                redata_hash(redata,redata->initialhash);

-                redata_unsaved_loadappend(redata);

-        } else {

-                /* nuke existing unsaved (if exists) and prepare new unsaved */

-                /* _trunc() fills itself redata->initialhash */

-                redata_unsaved_trunc(redata);

+        for(i=0;i<redata->sizeplugins;i++) {

+                if(use_unsaved) {

+                        /* apply missing changes and append new changes to unsaved */

+                        if(redata->plugins[i].postload!=NULL)

+                                redata->plugins[i].postload(redata,redata->plugins+i,filename);

+                } else {

+                        /* nuke existing unsaved (if exists) and prepare new unsaved */

+                        /* _trunc() fills itself redata->initialhash */

+                        if(redata->plugins[i].truncload!=NULL)

+                                redata->plugins[i].truncload(redata,redata->plugins+i,filename);

+                }

         }

         /* all done */

         return(0);

@@ -939,10 +563,12 @@ redata_save(redata_t *redata, char *filename)

                 unlink(tmpfile);

                 return(-1); /* couldn't overwrite old file */

         }

-        redata_unsaved_unlink(redata);

+        for(i=0;i<redata->sizeplugins;i++) {

+                if(redata->plugins[i].postsave!=NULL)

+                        redata->plugins[i].postsave(redata,redata->plugins+i,redata->filename,filename);

+        }

         strncpy(redata->filename,filename,sizeof(redata->filename));

         redata->filename[sizeof(redata->filename)-1]='\0';

-        redata_unsaved_trunc(redata);

         return(0);

 }

@@ -1219,8 +845,11 @@ redata_op_add(redata_t *redata, long insertpos, char *buf, long buflen, undostac

                 /* from undo stack */

                 redata_undo_movelast(redata,&(redata->undostack),&(redata->redostack));

         }

-        /* add to unsaved */

-        redata_unsaved_add(redata,&(redata->undostack),redata->undostack.usedundo-1);

+        /* add to plugins (unsaved,...) */

+        for(i=0;i<redata->sizeplugins;i++) {

+                if(redata->plugins[i].add!=NULL)

+                        redata->plugins[i].add(redata,redata->plugins+i,redata->undostack.undo+redata->undostack.usedundo-1);

+        }

         /* compact if needed */

         if(redata_getsize(redata)>(redata->chunkdatasize) && redata_getavailable(redata)>(redata_getsize(redata)/2))

                 redata_compact(redata);

@@ -1236,6 +865,7 @@ redata_op_del(redata_t *redata, long delpos, long size, undostack_t *fromhere)

         rechunk_t *chunk;

         long ndel;

         long curpos,curdel;

+        int i;

         if(redata==NULL || size<0

           || delpos<0

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

@@ -1279,8 +909,11 @@ redata_op_del(redata_t *redata, long delpos, long size, undostack_t *fromhere)

                 /* from undo stack */

                 redata_undo_movelast(redata,&(redata->undostack),&(redata->redostack));

         }

-        /* add to unsaved */

-        redata_unsaved_add(redata,&(redata->undostack),redata->undostack.usedundo-1);

+        /* add to plugins (unsaved,...) */

+        for(i=0;i<redata->sizeplugins;i++) {

+                if(redata->plugins[i].add!=NULL)

+                        redata->plugins[i].add(redata,redata->plugins+i,redata->undostack.undo+redata->undostack.usedundo-1);

+        }

         /* compact if needed */

         if(redata_getsize(redata)>(redata->chunkdatasize) && redata_getavailable(redata)>(redata_getsize(redata)/2))

                 redata_compact(redata);

@@ -1294,6 +927,7 @@ redata_op_move(redata_t *redata, long posorig, long size, long posdest, undostac

         long pos,dpos;

         undo_t *undo;

         rechunk_t *chunk;

+        int i;

         if(redata==NULL || size<0

           || posorig<0

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

@@ -1410,8 +1044,11 @@ redata_op_move(redata_t *redata, long posorig, long size, long posdest, undostac

                 /* from undo stack */

                 redata_undo_movelast(redata,&(redata->undostack),&(redata->redostack));

         }

-        /* add to unsaved */

-        redata_unsaved_add(redata,&(redata->undostack),redata->undostack.usedundo-1);

+        /* add to plugins (unsaved,...) */

+        for(i=0;i<redata->sizeplugins;i++) {

+                if(redata->plugins[i].add!=NULL)

+                        redata->plugins[i].add(redata,redata->plugins+i,redata->undostack.undo+redata->undostack.usedundo-1);

+        }

         /* compact if needed */

         if(redata_getsize(redata)>(redata->chunkdatasize) && redata_getavailable(redata)>(redata_getsize(redata)/2))

                 redata_compact(redata);

@@ -1437,6 +1074,7 @@ redata_op_undo(redata_t *redata)

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

         } else

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

+#warning TODO: Is it neccessary to do an unadd to the plugins?

         return(-1);

 }

@@ -1456,6 +1094,7 @@ redata_op_redo(redata_t *redata)

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

         } else

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

+#warning TODO: Is it neccessary to do an unadd to the plugins?

         return(-1);

 }

@@ -1559,6 +1198,54 @@ redata_memhash(redata_t *redata, char *buf, long buflen, char *resbuf129bytes)

         return(redata_hash_gen(NULL,NULL,buf,buflen,resbuf129bytes));

 }

+undostack_t *

+redata_getstack(redata_t *redata, undo_t *undo)

+{

+        if(redata==NULL || undo==NULL)

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

+        if(undo>=redata->undostack.undo && undo<(redata->undostack.undo+redata->undostack.sizeundo))

+                return(&(redata->undostack));

+        if(undo>=redata->redostack.undo && undo<(redata->redostack.undo+redata->redostack.sizeundo))

+                return(&(redata->redostack));

+        return(NULL); /* unknown stack */

+}

+

+char *

+redata_generic_genname(char *filename,char *prefix, char *postfix, char *buf, int bufsize)

+{

+        char *name,*ptr;

+        int filenamelen;

+        int prelen,postlen,finallen,off;

+        if(filename==NULL || prefix==NULL || postfix==NULL)

+                return(NULL);

+        filenamelen=strlen(filename);

+        prelen=strlen(prefix);

+        postlen=strlen(postfix);

+        finallen=filenamelen+prelen+postlen+1;

+        if(buf==NULL) {

+                if((name=malloc(finallen))==NULL)

+                        return(NULL);

+        } else {

+                if(bufsize<filenamelen)

+                        return(NULL);

+                name=buf;

+        }

+        for(ptr=filename+strlen(filename);ptr>filename && ptr[-1]!='/';ptr--)

+                ;

+        off=0;

+        memcpy(name+off,filename,ptr-filename);

+        off+=ptr-filename;

+        memcpy(name+off,prefix,prelen);

+        off+=prelen;

+        memcpy(name+off,ptr,filenamelen-(ptr-filename));

+        off+=filenamelen-(ptr-filename);

+        memcpy(name+off,postfix,postlen);

+        off+=postlen;

+        name[off]='\0';

+        return(name);

+}

+

+

 static int

 redata_hash_gen(redata_t *redata, char *filename, char *buf, long buflen, char *resbuf129bytes)

 {

@@ -1614,128 +1301,12 @@ redata_hash_gen(redata_t *redata, char *filename, char *buf, long buflen, char *

         return(0);

 }

-

-static char *

-unsaved_genname(char *filename, char *buf, int bufsize)

-{

-        static char pre[]={UNSAVEDPREFIX};

-        static char post[]={UNSAVEDPOSTFIX};

-        return(genname(filename,pre,post,buf,bufsize));

-}

-

 static char *

 securesave_genname(char *filename, char *buf, int bufsize)

 {

         static char pre[]={SECURESAVEPREFIX};

         static char post[]={SECURESAVEPOSTFIX};

-        return(genname(filename,pre,post,buf,bufsize));

-}

-

-

-static char *

-genname(char *filename,char *prefix, char *postfix, char *buf, int bufsize)

-{

-        char *name,*ptr;

-        int filenamelen;

-        int prelen,postlen,finallen,off;

-        if(filename==NULL || prefix==NULL || postfix==NULL)

-                return(NULL);

-        filenamelen=strlen(filename);

-        prelen=strlen(prefix);

-        postlen=strlen(postfix);

-        finallen=filenamelen+prelen+postlen+1;

-        if(buf==NULL) {

-                if((name=malloc(finallen))==NULL)

-                        return(NULL);

-        } else {

-                if(bufsize<filenamelen)

-                        return(NULL);

-                name=buf;

-        }

-        for(ptr=filename+strlen(filename);ptr>filename && ptr[-1]!='/';ptr--)

-                ;

-        off=0;

-        memcpy(name+off,filename,ptr-filename);

-        off+=ptr-filename;

-        memcpy(name+off,prefix,prelen);

-        off+=prelen;

-        memcpy(name+off,ptr,filenamelen-(ptr-filename));

-        off+=filenamelen-(ptr-filename);

-        memcpy(name+off,postfix,postlen);

-        off+=postlen;

-        name[off]='\0';

-        return(name);

-}

-

-static char *

-ptr_getlong(char *ptr,char *endptr,long *data)

-{

-        long l,s;

-        if(ptr==NULL || endptr==NULL || ptr>endptr)

-                return(NULL);

-        s=1;

-        if(ptr<endptr && *ptr=='-') {

-                s=-1;

-                ptr++;

-        }

-        for(l=0;ptr<endptr && *ptr>='0' && *ptr<='9';ptr++) {

-                l*=10;

-                l+=(*ptr-'0');

-        }

-        l*=s;

-        if(data!=NULL)

-                *data=l;

-        return(ptr);

-}

-

-

-static char *

-ptr_getchar(char *ptr,char *endptr,char *data)

-{

-        if(ptr==NULL || endptr==NULL || ptr>endptr)

-                return(NULL);

-        if(data!=NULL)

-                *data=*ptr;

-        ptr++;

-        return(ptr);

-}

-

-static char *

-ptr_searchendchar(char *ptr, char *endptr, char endchar, char **endcharpos)

-{

-        char *aux;

-        if(ptr==NULL || endptr==NULL || ptr>endptr)

-                return(NULL);

-        if((aux=memchr(ptr,endchar,endptr-ptr))==NULL)

-                return(NULL);

-        if(endcharpos!=NULL)

-                *endcharpos=aux;

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

-                        if(pos!=NULL)

-                                *pos=buf+bufsize;

-                        return(seps[i]);

-                }

-                if(ptr>bestptr) {

-                        besti=0;

-                        bestptr=ptr;

-                }

-        }

-        if(pos!=NULL)

-                *pos=bestptr;

-        return(seps[besti]);

+        return(redata_generic_genname(filename,pre,post,buf,bufsize));

 }

 static void *

@@ -1,5 +1,5 @@

 /*

- * re_data.c

+ * re_data.h

  *

  * A programmers editor

  *

@@ -43,13 +43,26 @@ typedef struct undostack_t {

         char *buf;

 } undostack_t;

-typedef struct unsaved_t {

-        long sizebuf;

-        long usedbuf;

-        char *buf;

-} unsaved_t;

+#define PLUGIN_CHECKUSERCONFIRM 1 /* if check is Ok, confirm with user whether to postload or go inactive */

+

+typedef struct redata_plugin_t {

+        int active;

+        int (*unregister)(/*redata_t *redata, redata_plugin_t *plugin,char *filename*/);

+        /* checkload returns 0:Ok, 1:Not needed, -1: error, go inactive */

+        int (*wipe)(/*redata_t *redata, redata_plugin_t *plugin,char *filename*/);

+        int (*checkload)(/*redata_t *redata, redata_plugin_t *plugin,char *filename*/);

+        int (*postload)(/*redata_t *redata, redata_plugin_t *plugin,char *filename*/);

+        int (*truncload)(/*redata_t *redata, redata_plugin_t *plugin,char *filename*/);

+        int (*postsave)(/*redata_t *redata, redata_plugin_t *plugin,char *oldfilename,char *newfilename*/);

+        int (*add)(/*redata_t *redata, redata_plugin_t *plugin,undo_t *undo*/);

+        int (*unadd)(/*redata_t *redata, redata_plugin_t *plugin,undo_t *undo*/);

+        int (*commit)(/*redata_t *redata, redata_plugin_t *plugin,char *filename*/);

+        void *userptr;

+        int flags;

+} redata_plugin_t;