@@ -147,8 +147,8 @@ int redata_loadquestions_wipe(redata_t *redata);

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

 int redata_save(redata_t *redata, char *filename, char **errordesc);

-int redata_needs_saving(redata_t *redata);

-

+int redata_needssaving(redata_t *redata);

+int redata_needssaving_reset(redata_t *redata);

 int redata_op_add(redata_t *redata, long pos, char *buf, long buflen, undostack_t *fromhere);

 int redata_op_addn(redata_t *redata, long pos, char character, long n, undostack_t *fromhere);

@@ -174,6 +174,8 @@ long redata_searchbackwards(redata_t *redata, long posini, char *str, int len);

 int redata_memcmp(redata_t *redata, long pos, char *str, int len);

 int redata_getutf8char(redata_t *redata, long pos, char *buf, int len, int *usedbuf);

+int redata_getprevutf8char(redata_t *redata, long pos, char *buf, int len, int *usedbuf);

+int redata_getsubstr(redata_t *redata, long posini, long posend, char *buf, int len, int *usedbuf);

 /* utf8 convenience functions */

@@ -109,6 +109,7 @@ long redata_getused(redata_t *redata);

 long redata_getavailable(redata_t *redata);

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

 int redata_getchar(redata_t *redata, long pos);

+int redata_getdata(redata_t *redata, long frompos, long size, char *dest);

 /* low level stuff */

 int redata_wipe(redata_t *redata);

@@ -209,4 +210,11 @@ int redata_pos2linecol(redata_t *redata, long pos, int *line, int *col);

 /* get the pos of that line/col (calculated using the utf8 convenience functions) */

 int redata_linecol2pos(redata_t *redata, int line, int colrequest, long *pos, int *coldone);

+int redata_line_total(redata_t *redata);

+int redata_line_getendstr(redata_t *redata, int line, char *buf, int sizebuf);

+int redata_line_getendstrtrimmed(redata_t *redata, int line, char *buf, int sizebuf, char *trimchars);

+int redata_line_getsize(redata_t *redata, int line); /* includes the \n */

+int redata_line_getstartstr(redata_t *redata, int line, char *buf, int sizebuf);

+int redata_line_getstartstrtrimmed(redata_t *redata, int line, char *buf, int sizebuf, char *trimchars);

+

 #endif

@@ -7,7 +7,7 @@

  *

  * HEADER FILE

  *

- * Author: Dario Rodriguez dario@softhome.net

+ * Author: Dario Rodriguez antartica@whereismybit.com

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

  */

@@ -108,7 +108,8 @@ long redata_getsize(redata_t *redata);

 long redata_getused(redata_t *redata);

 long redata_getavailable(redata_t *redata);

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

-

+int redata_getchar(redata_t *redata, long pos);

+ 

 /* low level stuff */

 int redata_wipe(redata_t *redata);

 int redata_preallocate(redata_t *redata, long size);

@@ -171,10 +171,17 @@ long redata_searchforward(redata_t *redata, long posini, char *str, int len);

 long redata_searchbackwards(redata_t *redata, long posini, char *str, int len);

 int redata_memcmp(redata_t *redata, long pos, char *str, int len);

+int redata_getutf8char(redata_t *redata, long pos, char *buf, int len, int *usedbuf);

+

 /* utf8 convenience functions */

 /* calculate the number of utf8-charaters in buffer */

 int redata_generic_utf8len(char *ptr, int size);

+

+/* calculate the number of utf8-charaters in buffer ignoring incomplete multibytechars at start and end */

+int redata_generic_utf8lenincomplete(char *ptr, int size, int *nstartincomplete,int *nendincomplete, int *nendrequired

+);

+

 /* return a pointer to the "n"th ("col"th) utf8-character in buffer */

 char *redata_generic_utf8col(char *ptr, int size, int col);

 /* returns the len in bytes of the character starting at ptr (zero on error)*/

@@ -74,8 +74,7 @@ typedef struct redata_plugin_t {

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

         int (*postload)(/*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 (*add_or_unadd)(/*redata_t *redata, redata_plugin_t *plugin,undo_t *undo, int is_unadd*/);

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

         void *userptr;

 } redata_plugin_t;

@@ -82,6 +82,7 @@ typedef struct redata_plugin_t {

 typedef struct redata_t {

         char filename[PATH_MAX];

+        int needs_saving;

         /* data */

         long chunkdatasize;

         int sizechunks;

@@ -145,6 +146,9 @@ int redata_loadquestions_wipe(redata_t *redata);

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

 int redata_save(redata_t *redata, char *filename, char **errordesc);

+int redata_needs_saving(redata_t *redata);

+

+

 int redata_op_add(redata_t *redata, long pos, char *buf, long buflen, undostack_t *fromhere);

 int redata_op_addn(redata_t *redata, long pos, char character, long n, undostack_t *fromhere);

 int redata_op_del(redata_t *redata, long pos, long size, undostack_t *fromhere);

@@ -163,6 +163,11 @@ undostack_t *redata_getstack(redata_t *redata, undo_t *undo);

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

+/* search */

+long redata_searchforward(redata_t *redata, long posini, char *str, int len);

+long redata_searchbackwards(redata_t *redata, long posini, char *str, int len);

+int redata_memcmp(redata_t *redata, long pos, char *str, int len);

+

 /* utf8 convenience functions */

 /* calculate the number of utf8-charaters in buffer */

@@ -100,7 +100,6 @@ typedef struct redata_t {

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

 void redata_free(redata_t *redata);

-

 void redata_idleproc(redata_t *redata, char *filename);

 int redata_config_chunkdatasize(redata_t *redata, int chunkdatasize);

@@ -47,9 +47,11 @@ typedef struct undo_t {

         long len;

         long posorig;

         long posdest;

+        int hint_groupedwithnext;

+#ifdef REDATA_HASHUNDO

         char prehash[129];

         char posthash[129];

-        int hint_groupedwithnext;

+#endif

 } undo_t;

 typedef struct undostack_t {

@@ -13,8 +13,22 @@

 #include <limits.h>

+#ifndef RE_DATA_H

+#define RE_DATA_H

 #define MAXPLUGINNAME 32

+typedef struct question_t {

+        int active;

+        int is_postload;

+        char *id;

+        char *title,*titleshort;

+        char *body,*bodyshort;

+        int nopts;

+        char **opts,**optsshort;

+        int defaultoption;

+        int selectedoption;

+} question_t;

+

 typedef struct whatin_t {

         int nlcount;

         int iscontinuation;

@@ -51,11 +65,12 @@ typedef struct undostack_t {

 typedef struct redata_plugin_t {

         int active;

         char name[MAXPLUGINNAME];

+        char *questionfilename[PATH_MAX];

+        question_t question;

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

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

-        /* loadquestion returns -1 if no question needed */

-        int (*loadquestion)(/*redata_t *redata, redata_plugin_t *plugin,char *filename, char **title, char **body, int *nopts, char **opts[] */);

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

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

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

@@ -84,6 +99,8 @@ typedef struct redata_t {

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

 void redata_free(redata_t *redata);

+void redata_idleproc(redata_t *redata, char *filename);

+

 int redata_config_chunkdatasize(redata_t *redata, int chunkdatasize);

 long redata_getsize(redata_t *redata);

@@ -119,8 +136,13 @@ int redata_undo_groupinit(redata_t *redata, undostack_t *stack);

 int redata_undo_groupcommit(redata_t *redata, undostack_t *stack);

 /* high level stuff */

-int redata_load(redata_t *redata, char *filename, int (*callback_question)(/*char *title, char *body, int nopts, char *opts[],void *userptr*/), void *userptr);

-int redata_save(redata_t *redata, char *filename);

+int redata_loadquestions_setup(redata_t *redata, char *filename);

+question_t *redata_loadquestions_getnext(redata_t *redata);

+int redata_loadquestions_reply(redata_t *redata, question_t *question, int selectedoption);

+int redata_loadquestions_wipe(redata_t *redata);

+

+int redata_load(redata_t *redata, char *filename, char **errordesc);

+int redata_save(redata_t *redata, char *filename, char **errordesc);

 int redata_op_add(redata_t *redata, long pos, char *buf, long buflen, undostack_t *fromhere);

 int redata_op_addn(redata_t *redata, long pos, char character, long n, undostack_t *fromhere);

@@ -170,3 +192,4 @@ int redata_pos2linecol(redata_t *redata, long pos, int *line, int *col);

 /* get the pos of that line/col (calculated using the utf8 convenience functions) */

 int redata_linecol2pos(redata_t *redata, int line, int colrequest, long *pos, int *coldone);

+#endif

@@ -126,8 +126,8 @@ int redata_op_add(redata_t *redata, long pos, char *buf, long buflen, undostack_

 int redata_op_addn(redata_t *redata, long pos, char character, long n, undostack_t *fromhere);

 int redata_op_del(redata_t *redata, long pos, long size, undostack_t *fromhere);

 int redata_op_move(redata_t *redata, long posorig, long size, long posdest, undostack_t *fromhere);

-int redata_op_undo(redata_t *redata);

-int redata_op_redo(redata_t *redata);

+int redata_op_undo(redata_t *redata, long *newcursorpos);

+int redata_op_redo(redata_t *redata, long *newcursorpos);

 int redata_data_compare(redata_t *redata, long pos, char *buf, long buflen);

@@ -148,7 +148,7 @@ int redata_generic_utf8len(char *ptr, int size);

 char *redata_generic_utf8col(char *ptr, int size, int col);

 /* returns the len in bytes of the character starting at ptr (zero on error)*/

 int redata_generic_utf8charlen(char *ptr, int maxsize);

-/* returns true if it's the forst byte of an UTF char */

+/* returns true if it's the first byte of an UTF char */

 int redata_generic_utf8isstartbyte(int candidate);

@@ -17,6 +17,7 @@

 typedef struct whatin_t {

         int nlcount;

+        int iscontinuation;

 } whatin_t;

 typedef struct rechunk_t {

@@ -34,12 +35,14 @@ typedef struct undo_t {

         long posdest;

         char prehash[129];

         char posthash[129];

+        int hint_groupedwithnext;

 } undo_t;

 typedef struct undostack_t {

         int sizeundo;

         int usedundo;

         undo_t *undo;

+        int groupinit;

         long sizebuf;

         long usedbuf;

         char *buf;

@@ -98,6 +101,9 @@ int redata_chunk_insertdata(redata_t *redata, int chunkto, long posto, char *buf

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

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

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

+int redata_chunk_unfreshnext(redata_t *redata, int chunkno);

+int redata_chunk_unfreshrange(redata_t *redata, int fromchunkno, int tochunkno);

+

 int redata_whatin_refresh(redata_t *redata, int chunkno);

 int redata_fix_nl(redata_t *redata, int chunkno);

 int redata_undobuf_reserve(redata_t *redata, undostack_t *stack, int minavail);

@@ -109,6 +115,8 @@ int redata_undo_removelast(redata_t *redata, undostack_t *stack);

 int redata_undo_wipe(redata_t *redata, undostack_t *stack);

 int redata_undo_inactivatelast(redata_t *redata, undostack_t *stack);

 int redata_undo_reactivatelast(redata_t *redata, undostack_t *stack);

+int redata_undo_groupinit(redata_t *redata, undostack_t *stack);

+int redata_undo_groupcommit(redata_t *redata, undostack_t *stack);

 /* high level stuff */

 int redata_load(redata_t *redata, char *filename, int (*callback_question)(/*char *title, char *body, int nopts, char *opts[],void *userptr*/), void *userptr);

@@ -140,10 +148,25 @@ int redata_generic_utf8len(char *ptr, int size);

 char *redata_generic_utf8col(char *ptr, int size, int col);

 /* returns the len in bytes of the character starting at ptr (zero on error)*/

 int redata_generic_utf8charlen(char *ptr, int maxsize);

+/* returns true if it's the forst byte of an UTF char */

+int redata_generic_utf8isstartbyte(int candidate);

 /* line convenience funtions */

-int redata_line_info(redata_t *redata, long pos, long *startpos, char **startptr, int *len);

+/* get pointer to full line (if it doesn't fit in a chunk, is_continuation is 1 and/or doesn't have an ending nl */

+int redata_line_rawinfo(redata_t *redata, long pos, long *startpos, char **startptr, int *len, int *is_continuation);

+/* get the startpos of line, even if it doesn't fit in one chunk */

+int redata_line_realstart(redata_t *redata, long pos, long *startpos);

+/* get the endpos of line, even if it doesn't fit in one chunk */

+int redata_line_realend(redata_t *redata, long pos, long *endpos);

+/* get pos of previous line real start */

+int redata_line_prevrealstart(redata_t *redata, long pos, long *startpos);

+/* get pos of next line real start */

+int redata_line_nextrealstart(redata_t *redata, long pos, long *startpos);

+/* advance "n" cols */

+int redata_line_inccol(redata_t *redata, long pos, int ncolrequest, long *newpos, int *ncoldone);

+/* get the line/col of a pos (col is calculated using the utf8 convenience functions) */

 int redata_pos2linecol(redata_t *redata, long pos, int *line, int *col);

-int redata_linecol2pos(redata_t *redata, int line, int col, long *pos);

+/* get the pos of that line/col (calculated using the utf8 convenience functions) */

+int redata_linecol2pos(redata_t *redata, int line, int colrequest, long *pos, int *coldone);

@@ -144,4 +144,6 @@ int redata_generic_utf8charlen(char *ptr, int maxsize);

 /* line convenience funtions */

 int redata_line_info(redata_t *redata, long pos, long *startpos, char **startptr, int *len);

+int redata_pos2linecol(redata_t *redata, long pos, int *line, int *col);

+int redata_linecol2pos(redata_t *redata, int line, int col, long *pos);

@@ -132,8 +132,13 @@ undostack_t *redata_getstack(redata_t *redata, undo_t *undo);

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

+/* utf8 convenience functions */

+

+/* calculate the number of utf8-charaters in buffer */

 int redata_generic_utf8len(char *ptr, int size);

+/* return a pointer to the "n"th ("col"th) utf8-character in buffer */

 char *redata_generic_utf8col(char *ptr, int size, int col);

+/* returns the len in bytes of the character starting at ptr (zero on error)*/

 int redata_generic_utf8charlen(char *ptr, int maxsize);

@@ -68,6 +68,8 @@ typedef struct redata_t {

         rechunk_t **chunks;

         long available;

         rechunk_t *tmpchunk;

+        long sizeaddnbuf;

+        char *addnbuf;

         /* undo */

         undostack_t undostack;

         undostack_t redostack;

@@ -113,6 +115,7 @@ int redata_load(redata_t *redata, char *filename, int (*callback_question)(/*cha

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

 int redata_op_add(redata_t *redata, long pos, char *buf, long buflen, undostack_t *fromhere);

+int redata_op_addn(redata_t *redata, long pos, char character, long n, undostack_t *fromhere);

 int redata_op_del(redata_t *redata, long pos, long size, undostack_t *fromhere);

 int redata_op_move(redata_t *redata, long posorig, long size, long posdest, undostack_t *fromhere);

 int redata_op_undo(redata_t *redata);

@@ -126,7 +129,14 @@ 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, long buflen, char *resbuf129bytes);

 undostack_t *redata_getstack(redata_t *redata, undo_t *undo);

+

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

+int redata_generic_utf8len(char *ptr, int size);

+char *redata_generic_utf8col(char *ptr, int size, int col);

+int redata_generic_utf8charlen(char *ptr, int maxsize);

+

+

 /* line convenience funtions */

 int redata_line_info(redata_t *redata, long pos, long *startpos, char **startptr, int *len);

+

@@ -128,3 +128,5 @@ int redata_memhash(redata_t *redata, char *buf, long buflen, char *resbuf129byte

 undostack_t *redata_getstack(redata_t *redata, undo_t *undo);

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

+/* line convenience funtions */

+int redata_line_info(redata_t *redata, long pos, long *startpos, char **startptr, int *len);

@@ -84,7 +84,7 @@ int redata_config_chunkdatasize(redata_t *redata, int chunkdatasize);

 long redata_getsize(redata_t *redata);

 long redata_getused(redata_t *redata);

 long redata_getavailable(redata_t *redata);

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

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

 /* low level stuff */

 int redata_wipe(redata_t *redata);

@@ -13,6 +13,8 @@

 #include <limits.h>

+#define MAXPLUGINNAME 32

+

 typedef struct whatin_t {

         int nlcount;

 } whatin_t;

@@ -43,22 +45,19 @@ typedef struct undostack_t {

         char *buf;

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

+        char name[MAXPLUGINNAME];

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

+        /* loadquestion returns -1 if no question needed */

+        int (*loadquestion)(/*redata_t *redata, redata_plugin_t *plugin,char *filename, char **title, char **body, int *nopts, char **opts[] */);

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

         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;

 typedef struct redata_t {

@@ -77,7 +76,6 @@ typedef struct redata_t {

         redata_plugin_t plugins[1];

 } redata_t;

-#warning TODO: Make redata_xxx call the plugins

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

 void redata_free(redata_t *redata);

@@ -111,7 +109,7 @@ int redata_undo_inactivatelast(redata_t *redata, undostack_t *stack);

 int redata_undo_reactivatelast(redata_t *redata, undostack_t *stack);

 /* high level stuff */

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

+int redata_load(redata_t *redata, char *filename, int (*callback_question)(/*char *title, char *body, int nopts, char *opts[],void *userptr*/), void *userptr);

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

 int redata_op_add(redata_t *redata, long pos, char *buf, long buflen, undostack_t *fromhere);

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

 typedef struct redata_t {

+        char filename[PATH_MAX];

         /* data */

         long chunkdatasize;

         int sizechunks;

@@ -59,14 +72,13 @@ typedef struct redata_t {

         /* undo */

         undostack_t undostack;

         undostack_t redostack;

-        /* unsaved (for recovery when the program closes unexpectedly) */

-        char filename[PATH_MAX];

-        char initialhash[129];

-        int unsavedfd;

-        unsaved_t unsaved;

+        /* plugins */

+        int sizeplugins;

+        redata_plugin_t plugins[1];

 } redata_t;

-redata_t *redata_init(void);

+#warning TODO: Make redata_xxx call the plugins

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

 void redata_free(redata_t *redata);

 int redata_config_chunkdatasize(redata_t *redata, int chunkdatasize);

@@ -98,17 +110,7 @@ int redata_undo_wipe(redata_t *redata, undostack_t *stack);

 int redata_undo_inactivatelast(redata_t *redata, undostack_t *stack);

 int redata_undo_reactivatelast(redata_t *redata, undostack_t *stack);

-

 /* high level stuff */

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

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

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

@@ -125,4 +127,6 @@ int redata_compact(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, long buflen, char *resbuf129bytes);

+undostack_t *redata_getstack(redata_t *redata, undo_t *undo);

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

new file mode 100644

@@ -0,0 +1,128 @@

+/*

+ * re_data.c

+ *

+ * A programmers editor

+ *

+ * Structures to hold the current file contents.

+ *

+ * HEADER FILE

+ *

+ * Author: Dario Rodriguez dario@softhome.net

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

+ */

+

+#include <limits.h>

+

+typedef struct whatin_t {

+        int nlcount;

+} whatin_t;

+

+typedef struct rechunk_t {

+        whatin_t whatin;

+        int whatin_fresh;

+        int useddata;

+        unsigned char data[1];

+} rechunk_t;

+

+typedef struct undo_t {

+        char type;

+        long off;

+        long len;

+        long posorig;

+        long posdest;

+        char prehash[129];

+        char posthash[129];

+} undo_t;

+

+typedef struct undostack_t {

+        int sizeundo;

+        int usedundo;

+        undo_t *undo;

+        long sizebuf;

+        long usedbuf;

+        char *buf;

+} undostack_t;

+

+typedef struct unsaved_t {

+        long sizebuf;

+        long usedbuf;

+        char *buf;

+} unsaved_t;

+

+typedef struct redata_t {

+        /* data */

+        long chunkdatasize;

+        int sizechunks;

+        rechunk_t **chunks;

+        long available;

+        rechunk_t *tmpchunk;

+        /* undo */

+        undostack_t undostack;

+        undostack_t redostack;

+        /* unsaved (for recovery when the program closes unexpectedly) */

+        char filename[PATH_MAX];

+        char initialhash[129];

+        int unsavedfd;

+        unsaved_t unsaved;

+} redata_t;

+

+redata_t *redata_init(void);

+void redata_free(redata_t *redata);

+

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

+

+long redata_getsize(redata_t *redata);

+long redata_getused(redata_t *redata);

+long redata_getavailable(redata_t *redata);

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

+

+/* low level stuff */

+int redata_wipe(redata_t *redata);

+int redata_preallocate(redata_t *redata, long size);

+int redata_chunk_insertnew(redata_t *redata, int afterthischunk);

+int redata_chunk_deletechunk(redata_t *redata, int chunkno);

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

+int redata_chunk_insertdata(redata_t *redata, int chunkto, long posto, char *buf, long buflen);

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

+int redata_chunk_splithere(redata_t *redata, int chunkno, int pos);

+int redata_chunk_fillfromnext(redata_t *redata, int chunkno, int n);

+int redata_whatin_refresh(redata_t *redata, int chunkno);

+int redata_fix_nl(redata_t *redata, int chunkno);

+int redata_undobuf_reserve(redata_t *redata, undostack_t *stack, int minavail);

+undo_t *redata_undo_new(redata_t *redata, undostack_t *stack, char type);

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

+undo_t *redata_undo_newfrombuf(redata_t *redata, undostack_t *stack, char type, char *buf, int buflen);

+int redata_undo_movelast(redata_t *redata, undostack_t *from, undostack_t *to);

+int redata_undo_removelast(redata_t *redata, undostack_t *stack);

+int redata_undo_wipe(redata_t *redata, undostack_t *stack);

+int redata_undo_inactivatelast(redata_t *redata, undostack_t *stack);

+int redata_undo_reactivatelast(redata_t *redata, undostack_t *stack);

+

+

+/* high level stuff */

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

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

+int redata_save(redata_t *redata, char *filename);

+

+int redata_op_add(redata_t *redata, long pos, char *buf, long buflen, undostack_t *fromhere);

+int redata_op_del(redata_t *redata, long pos, long size, undostack_t *fromhere);

+int redata_op_move(redata_t *redata, long posorig, long size, long posdest, undostack_t *fromhere);

+int redata_op_undo(redata_t *redata);

+int redata_op_redo(redata_t *redata);

+

+int redata_data_compare(redata_t *redata, long pos, char *buf, long buflen);

+

+int redata_compact(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, long buflen, char *resbuf129bytes);

+