@@ -78,6 +78,8 @@ redata_free(redata_t *redata)

         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->undo!=NULL)

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

@@ -95,6 +97,16 @@ redata_free(redata_t *redata)

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

+}

+

 int

 redata_getsize(redata_t *redata)

 {

@@ -177,10 +189,17 @@ redata_preallocate(redata_t *redata, int newsize)

         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;

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

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

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

         redata->chunks=newchunks;

@@ -198,6 +217,49 @@ redata_preallocate(redata_t *redata, int newsize)

         return(0);

 }

+int

+redata_chunk_movedata(redata_t *redata, int chunkfrom, int posfrom, int chunkto, int posto, int 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;

+        } else {

+                /* from==to */

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

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

+                if(posto>posfrom) {

+                        int inside=(posto-posfrom)-size;

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

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

+                } else {

+                        int inside=(posto-posfrom);

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

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

+                }

+        }

+        return(0);

+}

+

 int

 redata_fill_whatin(redata_t *redata, int chunkno)

 {

@@ -207,12 +269,80 @@ redata_fill_whatin(redata_t *redata, int chunkno)

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

+}

+

+void *

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

+{

+        int i;

+        void *res=NULL;

+        unsigned char b;

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

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

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

+                        res=s+i;

+        }

+        return(res);

+}

+

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

+                int i,newavail;

+                rechunk_t *newchunk;

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

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

 }

@@ -329,7 +459,6 @@ redata_unsaved_unadd(redata_t *redata, undo_t *undo)

 int

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

 {

-#warning TODO: make sure a line of len<chunksize is entirely inside one chunk (to simplify the syntax highlighting code)

         int fd,nread,totalread;

         int chunkno, avail;

         struct stat statbuf;

@@ -374,9 +503,12 @@ redata_load(redata_t *redata, char *filename, int use_unsaved)

                 }

                 chunk->useddata+=nread;

                 redata->available-=nread;

-                redata_fill_whatin(redata,chunkno);

         }

         close(fd),fd=-1;

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

+                redata_fix_nl(redata,chunkno);

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

+                redata_fill_whatin(redata,chunkno);

         /* unsaved */

         redata_hash(redata,redata->initialhash);

         if(use_unsaved) {

@@ -19,6 +19,7 @@ typedef struct whatin_t {

 typedef struct rechunk_t {

         whatin_t whatin;

+        int whatin_fresh;

         int useddata;

         unsigned char data[1];

 } rechunk_t;

@@ -35,6 +36,7 @@ typedef struct redata_t {

         int sizechunks;

         rechunk_t **chunks;

         int available;

+        rechunk_t *tmpchunk;

         /* undo */

         int sizeundo;

         int usedundo;

@@ -55,17 +57,19 @@ typedef struct redata_t {

 redata_t *redata_init(void);

 void redata_free(redata_t *redata);

+int redata_config_chunkdatasize(redata_t *redata, int chunkdatasize);

+

 int redata_getsize(redata_t *redata);

 int redata_getused(redata_t *redata);

 int redata_getavailable(redata_t *redata);

 int redata_getused(redata_t *redata);

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

-

-

 int redata_wipe(redata_t *redata);

 int redata_preallocate(redata_t *redata, int size);

+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_fix_nl(redata_t *redata, int chunkno);

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

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

@@ -84,6 +88,8 @@ int redata_op_move(redata_t *redata, int posorig, int size, int posdest);

 int redata_op_undo(redata_t *redata);

 int redata_op_redo(redata_t *redata);

+int redata_commit_unsaved(redata_t *redata);

+

 int redata_hash(redata_t *redata, char *resbuf129bytes);

 int redata_filehash(redata_t *redata, char *filename, char *resbuf129bytes);

 int redata_memhash(redata_t *redata, char *buf, int buflen, char *resbuf129bytes);