deleted file mode 100644

@@ -1,1766 +0,0 @@

-/*

- * recenteditor_data.c

- *

- * A programmers editor

- *

- * Structures to hold the current file contents.

- *

- * Author: Dario Rodriguez dario@softhome.net

- * This program is licensed under the terms of GNU GPL v2.1+

- */

-

-#include <stdio.h>

-#include <stdlib.h>

-#include <unistd.h>

-#include <string.h>

-#include <sys/types.h>

-#include <sys/stat.h>

-#include <fcntl.h>

-#include <limits.h>

-#include <inttypes.h>

-

-#include "recenteditor_data.h"

-#include "sha3/sha3.h"

-

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

-

-#if 0

-static void

-redata_debug_chunkdump(redata_t *redata, char *title)

-{

-        int m,k;

-        char c;

-        title=(title==NULL)?"":title;

-        fprintf(stderr,"%s:CHUNKDUMP (sizechunks:%i)\n",title,redata->sizechunks);

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

-                fprintf(stderr,"%s:chunk[%i]:\"",title,m);

-                for(k=0;k<redata->chunks[m]->useddata;k++) {

-                        c=redata->chunks[m]->data[k];

-                        c=(c>=' ' && c<='~')?c:'.';

-                        fprintf(stderr,"%c",c);

-                }

-                fprintf(stderr,"\"\n");

-        }

-}

-#endif

-

-redata_t *

-redata_init(void)

-{

-        redata_t *redata;

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

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

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

-        /* data */

-        redata->sizechunks=0;

-        redata->chunks=NULL;

-        redata->chunkdatasize=CHUNKSIZE;

-        redata->available=0;

-        /* undo */

-        redata->undostack.sizeundo=0;

-        redata->undostack.usedundo=0;

-        redata->undostack.undo=NULL;

-        redata->undostack.buf=NULL;

-        /* unsaved */

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

-        redata->unsavedfd=-1;

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

-        /* all done */

-        return(redata);

-}

-

-void

-redata_free(redata_t *redata)

-{

-        int i;

-        char unsname[PATH_MAX];

-        if(redata==NULL)

-                return; /* nothing to do */

-        /* data */

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

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

-                        free(redata->chunks[i]),redata->chunks[i]=NULL;

-        }

-        redata->sizechunks=0;

-        if(redata->chunks!=NULL)

-                free(redata->chunks),redata->chunks=NULL;

-        if(redata->tmpchunk!=NULL)

-                free(redata->tmpchunk),redata->tmpchunk=NULL;

-        /* undo */

-        if(redata->undostack.undo!=NULL)

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

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

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

-        /* redo */

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

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

-}

-

-int

-redata_config_chunkdatasize(redata_t *redata, int chunkdatasize)

-{

-        /* NOTE: this can only be configured immediately after doing redata_init() */

-        if(redata==NULL || chunkdatasize<=0 || redata->sizechunks!=0)

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

-        redata->chunkdatasize=chunkdatasize;

-        return(0);

-}

-

-long

-redata_getsize(redata_t *redata)

-{

-        if(redata==NULL)

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

-        return(redata->chunkdatasize*redata->sizechunks);

-}

-

-long

-redata_getavailable(redata_t *redata)

-{

-        if(redata==NULL)

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

-        return(redata->available);

-}

-

-long

-redata_getused(redata_t *redata)

-{

-        long used;

-        if(redata==NULL)

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

-        used=redata->chunkdatasize*redata->sizechunks-redata->available;

-        return(used);

-}

-

-int

-redata_getposptr(redata_t *redata, long pos, int *numchunk, long *offset)

-{

-        long used;

-        int i;

-        long ipos;

-        used=redata_getused(redata);

-        if(redata==NULL || pos<0 || pos>used || numchunk==NULL || offset==NULL)

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

-        for(ipos=0,i=0;i<redata->sizechunks;ipos+=redata->chunks[i]->useddata,i++) {

-                if(pos>(ipos+redata->chunks[i]->useddata))

-                        continue;

-                /* found */

-                *numchunk=i;

-                *offset=pos-ipos;

-                return(0);

-        }

-        return(-1);

-}

-

-int

-redata_wipe(redata_t *redata)

-{

-        int i;

-        char unsname[PATH_MAX];

-        if(redata==NULL)

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

-        /* data */

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

-                redata->chunks[i]->useddata=0;

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

-        }

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

-        redata->unsaved.usedbuf=0;

-        /* all done */

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

-{

-        long cursize;

-        int nchunks;

-        int i;

-        long rechunksize;

-        rechunk_t **newchunks,*chunk;

-        int oldsizechunks;

-        if(redata==NULL || redata->chunkdatasize==0 || newsize<0)

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

-        rechunksize=sizeof(rechunk_t)-1+redata->chunkdatasize;

-        /* before doing any chunk alloc, we setup tmpchunk (used for moves) */

-        if(redata->tmpchunk==NULL) {

-                if((redata->tmpchunk=malloc(rechunksize))==NULL)

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

-                memset(redata->tmpchunk,0,rechunksize);

-        }

-        /* new chunk processing */

-        if((cursize=redata_getsize(redata))>=newsize)

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

-        nchunks=(newsize-cursize+redata->chunkdatasize-1)/redata->chunkdatasize;

-        if((newchunks=realloc(redata->chunks,sizeof(rechunk_t *)*(redata->sizechunks+nchunks)))==NULL)

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

-        redata->chunks=newchunks;

-        memset(redata->chunks+redata->sizechunks,0,sizeof(rechunk_t *)*nchunks);

-        oldsizechunks=redata->sizechunks;

-        for(i=0;i<nchunks;i++) {

-                if((chunk=malloc(rechunksize))==NULL)

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

-                memset(chunk,0,rechunksize);

-                chunk->useddata=0;

-                redata->chunks[oldsizechunks+i]=chunk;

-                redata->sizechunks++;

-                redata->available+=redata->chunkdatasize;

-        }

-        return(0);

-}

-

-int

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

-{

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

-          || chunkfrom<0 || chunkfrom>=redata->sizechunks

-          || posfrom<0 || (posfrom+size)>redata->chunks[chunkfrom]->useddata

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

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

-          || (chunkfrom!=chunkto && (redata->chunkdatasize-redata->chunks[chunkto]->useddata)<size)

-          || (chunkfrom==chunkto && posfrom<posto && posfrom+size>posto)

-          )

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

-        if(size==0

-          || (chunkfrom==chunkto && posfrom==posto)

-          || (chunkfrom==chunkto && (posfrom+size)==posto)

-          )

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

-        if(chunkfrom!=chunkto) {

-                rechunk_t *from,*to;

-                from=redata->chunks[chunkfrom];

-                to=redata->chunks[chunkto];

-                memmove(to->data+posto+size,to->data+posto,to->useddata-posto);

-                memcpy(to->data+posto,from->data+posfrom,size);

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

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

-                if(posfrom>posto) {

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

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

-                } else {

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

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

-                }

-                chunk->whatin_fresh=0;

-        }

-        return(0);

-}

-

-int

-redata_chunk_insertdata(redata_t *redata, int chunkto, long posto, char *buf, long 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;

-        redata->available-=buflen;

-        return(0);

-}

-

-int

-redata_chunk_deletedata(redata_t *redata, int chunkno, long pos, long n)

-{

-        rechunk_t *chunk;

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

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

-        redata->available+=n;

-        return(0);

-}

-

-int

-redata_chunk_splithere(redata_t *redata, int chunkno, int pos)

-{

-        rechunk_t *chunk;

-        int size;

-        if(redata==NULL

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

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

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

-        chunk=redata->chunks[chunkno];

-        if(chunk->useddata==pos)

-                return(0); /* all done: already splitted */

-        size=redata->chunks[chunkno]->useddata-pos;

-        if((chunkno+1)<redata->sizechunks

-          && (redata->chunkdatasize-redata->chunks[chunkno+1]->useddata)>=size) {

-                redata_chunk_movedata(redata,chunkno,pos,chunkno+1,0,size);

-                return(0); /* all done: moved data cleanly to next chunk */

-        }

-        if(redata_chunk_insertnew(redata,chunkno)!=0)

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

-        redata_chunk_movedata(redata,chunkno,pos,chunkno+1,0,size);

-        return(0);

-}

-

-int

-redata_chunk_fillfromnext(redata_t *redata, int chunkno, int n)

-{

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

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

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

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

-        return(redata_chunk_movedata(redata,chunkno+1,0,chunkno,redata->chunks[chunkno]->useddata,n));

-}

-

-

-int

-redata_whatin_refresh(redata_t *redata, int chunkno)

-{

-        rechunk_t *chunk;

-        int nlcount;

-        int i,lim;

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

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

-        chunk=redata->chunks[chunkno];

-        if(chunk->whatin_fresh)

-                return(0);

-        memset(&(chunk->whatin),0,sizeof(whatin_t));

-        nlcount=0;

-        for(i=0,lim=chunk->useddata;i<lim;i++) {

-                nlcount+=(chunk->data[i]=='\n')?1:0;

-        }

-        chunk->whatin.nlcount=nlcount;

-        chunk->whatin_fresh=1;

-        return(0);

-}

-

-

-int

-redata_fix_nl(redata_t *redata, int chunkno)

-{

-        /* make sure a line of len<chunksize is entirely inside one chunk (to simplify the syntax highlighting code) */

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

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

-        if(chunkno==(redata->sizechunks-1) || redata->chunks[chunkno]->useddata==0 || redata->chunks[chunkno]->data[redata->chunks[chunkno]->useddata-1]=='\n')

-                return(0); /* Nothing to do (last chunk, chunk empty or already fixed) */

-        rechunk_t *chunk,*nextchunk;

-        int linesize, nextlinesize, avail, nextavail;

-        unsigned char *ptr,*nextptr;

-        chunk=redata->chunks[chunkno];

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

-        ptr=mymemrchr(chunk->data,'\n',chunk->useddata);

-        nextptr=memchr(nextchunk->data,'\n',nextchunk->useddata);

-        linesize=(ptr==NULL)?chunk->useddata:(chunk->useddata-(ptr-chunk->data)-1);

-        nextlinesize=(nextptr==NULL)?nextchunk->useddata:((nextptr-nextchunk->data)+1);

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

-        nextavail=redata->chunkdatasize-nextchunk->useddata;

-        if(avail>=nextlinesize) {

-                /* move remaining bytes of line to current chunk */

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

-        } else if(nextavail>=linesize) {

-                /* 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 in chunkno before this long line */

-                int newavail;

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

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

-        }

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

-{

-        int fd,nread,totalread;

-        int chunkno, avail;

-        struct stat statbuf;

-        rechunk_t *chunk;

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

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

-        redata_wipe(redata);

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

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

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

-                if(fd!=-1)

-                        close(fd),fd=-1;

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

-        }

-        /* preallocate 10% more than needed */

-        if(redata_preallocate(redata,statbuf.st_size+(statbuf.st_size/10)+1 )) {

-                close(fd),fd=-1;

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

-        }

-        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_getsize(redata)+redata->chunkdatasize)==-1 ||

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

-                                close(fd),fd=-1;

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

-                                return(-2); /* internal error */

-                        }

-                }