Dariaceli's Git
Browse code

renamed recenteditor_data to re_data, recenteditor_tests to re_tests

Dario Rodriguez authored on 01/04/2019 21:26:29
Showing 1 changed files
recenteditor_data.h
History View file @ aa72865
1 1 
deleted file mode 100644
... ... 
@@ -1,128 +0,0 @@
1 
-/*
2 
- * recenteditor_data.c
3 
- *
4 
- * A programmers editor
5 
- *
6 
- * Structures to hold the current file contents.
7 
- *
8 
- * HEADER FILE
9 
- *
10 
- * Author: Dario Rodriguez dario@softhome.net
11 
- * This program is licensed under the terms of GNU GPL v2.1+
12 
- */
13 
-
14 
-#include <limits.h>
15 
-
16 
-typedef struct whatin_t {
17 
-        int nlcount;
18 
-} whatin_t;
19 
-
20 
-typedef struct rechunk_t {
21 
-        whatin_t whatin;
22 
-        int whatin_fresh;
23 
-        int useddata;
24 
-        unsigned char data[1];
25 
-} rechunk_t;
26 
-
27 
-typedef struct undo_t {
28 
-        char type;
29 
-        long off;
30 
-        long len;
31 
-        long posorig;
32 
-        long posdest;
33 
-        char prehash[129];
34 
-        char posthash[129];
35 
-} undo_t;
36 
-
37 
-typedef struct undostack_t {
38 
-        int sizeundo;
39 
-        int usedundo;
40 
-        undo_t *undo;
41 
-        long sizebuf;
42 
-        long usedbuf;
43 
-        char *buf;
44 
-} undostack_t;
45 
-
46 
-typedef struct unsaved_t {
47 
-        long sizebuf;
48 
-        long usedbuf;
49 
-        char *buf;
50 
-} unsaved_t;
51 
-
52 
-typedef struct redata_t {
53 
-        /* data */
54 
-        long chunkdatasize;
55 
-        int sizechunks;
56 
-        rechunk_t **chunks;
57 
-        long available;
58 
-        rechunk_t *tmpchunk;
59 
-        /* undo */
60 
-        undostack_t undostack;
61 
-        undostack_t redostack;
62 
-        /* unsaved (for recovery when the program closes unexpectedly) */
63 
-        char filename[PATH_MAX];
64 
-        char initialhash[129];
65 
-        int unsavedfd;
66 
-        unsaved_t unsaved;
67 
-} redata_t;
68 
-
69 
-redata_t *redata_init(void);
70 
-void redata_free(redata_t *redata);
71 
-
72 
-int redata_config_chunkdatasize(redata_t *redata, int chunkdatasize);
73 
-
74 
-long redata_getsize(redata_t *redata);
75 
-long redata_getused(redata_t *redata);
76 
-long redata_getavailable(redata_t *redata);
77 
-int redata_getposptr(redata_t *redata, long pos, int *numchunk, long *offset);
78 
-
79 
-/* low level stuff */
80 
-int redata_wipe(redata_t *redata);
81 
-int redata_preallocate(redata_t *redata, long size);
82 
-int redata_chunk_insertnew(redata_t *redata, int afterthischunk);
83 
-int redata_chunk_deletechunk(redata_t *redata, int chunkno);
84 
-int redata_chunk_movedata(redata_t *redata, int chunkfrom, long posfrom, int chunkto, long posto, long size);
85 
-int redata_chunk_insertdata(redata_t *redata, int chunkto, long posto, char *buf, long buflen);
86 
-int redata_chunk_deletedata(redata_t *redata, int chunkno, long pos, long n);
87 
-int redata_chunk_splithere(redata_t *redata, int chunkno, int pos);
88 
-int redata_chunk_fillfromnext(redata_t *redata, int chunkno, int n);
89 
-int redata_whatin_refresh(redata_t *redata, int chunkno);
90 
-int redata_fix_nl(redata_t *redata, int chunkno);
91 
-int redata_undobuf_reserve(redata_t *redata, undostack_t *stack, int minavail);
92 
-undo_t *redata_undo_new(redata_t *redata, undostack_t *stack, char type);
93 
-undo_t *redata_undo_newfromchunks(redata_t *redata, undostack_t *stack, char type, int pos1, int len);
94 
-undo_t *redata_undo_newfrombuf(redata_t *redata, undostack_t *stack, char type, char *buf, int buflen);
95 
-int redata_undo_movelast(redata_t *redata, undostack_t *from, undostack_t *to);
96 
-int redata_undo_removelast(redata_t *redata, undostack_t *stack);
97 
-int redata_undo_wipe(redata_t *redata, undostack_t *stack);
98 
-int redata_undo_inactivatelast(redata_t *redata, undostack_t *stack);
99 
-int redata_undo_reactivatelast(redata_t *redata, undostack_t *stack);
100 
-
101 
-
102 
-/* high level stuff */
103 
-int redata_unsaved_exists(redata_t *redata, char *filename);
104 
-int redata_unsaved_check(redata_t *redata, char *filename);
105 
-int redata_unsaved_loadappend(redata_t *redata);
106 
-int redata_unsaved_unlink(redata_t *redata);
107 
-int redata_unsaved_trunc(redata_t *redata);
108 
-int redata_unsaved_add(redata_t *redata, undostack_t *stack, int undono);
109 
-int redata_unsaved_unadd(redata_t *redata, undostack_t *stack, int undono);
110 
-int redata_unsaved_commit(redata_t *redata);
111 
-
112 
-int redata_load(redata_t *redata, char *filename, int use_unsaved);
113 
-int redata_save(redata_t *redata, char *filename);
114 
-
115 
-int redata_op_add(redata_t *redata, long pos, char *buf, long buflen, undostack_t *fromhere);
116 
-int redata_op_del(redata_t *redata, long pos, long size, undostack_t *fromhere);
117 
-int redata_op_move(redata_t *redata, long posorig, long size, long posdest, undostack_t *fromhere);
118 
-int redata_op_undo(redata_t *redata);
119 
-int redata_op_redo(redata_t *redata);
120 
-
121 
-int redata_data_compare(redata_t *redata, long pos, char *buf, long buflen);
122 
-
123 
-int redata_compact(redata_t *redata);
124 
-
125 
-int redata_hash(redata_t *redata, char *resbuf129bytes);
126 
-int redata_filehash(redata_t *redata, char *filename, char *resbuf129bytes);
127 
-int redata_memhash(redata_t *redata, char *buf, long buflen, char *resbuf129bytes);
128 
-
Browse code

unsaved_unadd and unsaved_commit

Dario Rodriguez authored on 20/03/2019 22:56:11
Showing 1 changed files
recenteditor_data.h
History View file @ 507cc66
... ... 
@@ -47,7 +47,6 @@ typedef struct unsaved_t {
47 47 
         long sizebuf;
48 48 
         long usedbuf;
49 49 
         char *buf;
50 
-        long lastsize;
51 50 
 } unsaved_t;
52 51
53 52 
 typedef struct redata_t {
Browse code

implement unsaved_loadappend 'M' and unsaved_add

Dario Rodriguez authored on 19/03/2019 22:07:56
Showing 1 changed files
recenteditor_data.h
History View file @ 5e69a02
... ... 
@@ -106,8 +106,8 @@ int redata_unsaved_check(redata_t *redata, char *filename);
106 106 
 int redata_unsaved_loadappend(redata_t *redata);
107 107 
 int redata_unsaved_unlink(redata_t *redata);
108 108 
 int redata_unsaved_trunc(redata_t *redata);
109 
-int redata_unsaved_add(redata_t *redata, undo_t *undo);
110 
-int redata_unsaved_unadd(redata_t *redata, undo_t *undo);
109 
+int redata_unsaved_add(redata_t *redata, undostack_t *stack, int undono);
110 
+int redata_unsaved_unadd(redata_t *redata, undostack_t *stack, int undono);
111 111 
 int redata_unsaved_commit(redata_t *redata);
112 112
113 113 
 int redata_load(redata_t *redata, char *filename, int use_unsaved);
Browse code

Implement op_move. Make the tests more thorough by having them check several different chunkdatasizes.

Dario Rodriguez authored on 15/03/2019 21:43:40
Showing 1 changed files
recenteditor_data.h
History View file @ 71ff911
... ... 
@@ -85,6 +85,8 @@ int redata_chunk_deletechunk(redata_t *redata, int chunkno);
85 85 
 int redata_chunk_movedata(redata_t *redata, int chunkfrom, long posfrom, int chunkto, long posto, long size);
86 86 
 int redata_chunk_insertdata(redata_t *redata, int chunkto, long posto, char *buf, long buflen);
87 87 
 int redata_chunk_deletedata(redata_t *redata, int chunkno, long pos, long n);
88 
+int redata_chunk_splithere(redata_t *redata, int chunkno, int pos);
89 
+int redata_chunk_fillfromnext(redata_t *redata, int chunkno, int n);
88 90 
 int redata_whatin_refresh(redata_t *redata, int chunkno);
89 91 
 int redata_fix_nl(redata_t *redata, int chunkno);
90 92 
 int redata_undobuf_reserve(redata_t *redata, undostack_t *stack, int minavail);
... ... 
@@ -94,6 +96,9 @@ undo_t *redata_undo_newfrombuf(redata_t *redata, undostack_t *stack, char type,
94 96 
 int redata_undo_movelast(redata_t *redata, undostack_t *from, undostack_t *to);
95 97 
 int redata_undo_removelast(redata_t *redata, undostack_t *stack);
96 98 
 int redata_undo_wipe(redata_t *redata, undostack_t *stack);
99 
+int redata_undo_inactivatelast(redata_t *redata, undostack_t *stack);
100 
+int redata_undo_reactivatelast(redata_t *redata, undostack_t *stack);
101 
+
97 102
98 103 
 /* high level stuff */
99 104 
 int redata_unsaved_exists(redata_t *redata, char *filename);
... ... 
@@ -116,6 +121,8 @@ int redata_op_redo(redata_t *redata);
116 121
117 122 
 int redata_data_compare(redata_t *redata, long pos, char *buf, long buflen);
118 123
124 
+int redata_compact(redata_t *redata);
125 
+
119 126 
 int redata_hash(redata_t *redata, char *resbuf129bytes);
120 127 
 int redata_filehash(redata_t *redata, char *filename, char *resbuf129bytes);
121 128 
 int redata_memhash(redata_t *redata, char *buf, long buflen, char *resbuf129bytes);
Browse code

recenteditor_data: change undo type from string to char (as it is in the unsaved buf)

Dario Rodriguez authored on 15/03/2019 13:21:58
Showing 1 changed files
recenteditor_data.h
History View file @ b9e0fb8
... ... 
@@ -25,7 +25,7 @@ typedef struct rechunk_t {
25 25 
 } rechunk_t;
26 26
27 27 
 typedef struct undo_t {
28 
-        char type[4];
28 
+        char type;
29 29 
         long off;
30 30 
         long len;
31 31 
         long posorig;
... ... 
@@ -88,9 +88,9 @@ int redata_chunk_deletedata(redata_t *redata, int chunkno, long pos, long n);
88 88 
 int redata_whatin_refresh(redata_t *redata, int chunkno);
89 89 
 int redata_fix_nl(redata_t *redata, int chunkno);
90 90 
 int redata_undobuf_reserve(redata_t *redata, undostack_t *stack, int minavail);
91 
-undo_t *redata_undo_new(redata_t *redata, undostack_t *stack, char *type);
92 
-undo_t *redata_undo_newfromchunks(redata_t *redata, undostack_t *stack, char *type, int pos1, int len);
93 
-undo_t *redata_undo_newfrombuf(redata_t *redata, undostack_t *stack, char *type, char *buf, int buflen);
91 
+undo_t *redata_undo_new(redata_t *redata, undostack_t *stack, char type);
92 
+undo_t *redata_undo_newfromchunks(redata_t *redata, undostack_t *stack, char type, int pos1, int len);
93 
+undo_t *redata_undo_newfrombuf(redata_t *redata, undostack_t *stack, char type, char *buf, int buflen);
94 94 
 int redata_undo_movelast(redata_t *redata, undostack_t *from, undostack_t *to);
95 95 
 int redata_undo_removelast(redata_t *redata, undostack_t *stack);
96 96 
 int redata_undo_wipe(redata_t *redata, undostack_t *stack);
Browse code

unsaved_loadappend: implement loading of A(dd) and D(el) registers

Dario Rodriguez authored on 14/03/2019 22:37:34
Showing 1 changed files
recenteditor_data.h
History View file @ 3a8fd14
... ... 
@@ -114,6 +114,7 @@ int redata_op_move(redata_t *redata, long posorig, long size, long posdest, undo
114 114 
 int redata_op_undo(redata_t *redata);
115 115 
 int redata_op_redo(redata_t *redata);
116 116
117 
+int redata_data_compare(redata_t *redata, long pos, char *buf, long buflen);
117 118
118 119 
 int redata_hash(redata_t *redata, char *resbuf129bytes);
119 120 
 int redata_filehash(redata_t *redata, char *filename, char *resbuf129bytes);
Browse code

partial unsaved implementation

Dario Rodriguez authored on 13/03/2019 23:31:53
Showing 1 changed files
recenteditor_data.h
History View file @ 0700c31
... ... 
@@ -38,11 +38,18 @@ typedef struct undostack_t {
38 38 
         int sizeundo;
39 39 
         int usedundo;
40 40 
         undo_t *undo;
41 
-        int sizebuf;
42 
-        int usedbuf;
41 
+        long sizebuf;
42 
+        long usedbuf;
43 43 
         char *buf;
44 44 
 } undostack_t;
45 45
46 
+typedef struct unsaved_t {
47 
+        long sizebuf;
48 
+        long usedbuf;
49 
+        char *buf;
50 
+        long lastsize;
51 
+} unsaved_t;
52 
+
46 53 
 typedef struct redata_t {
47 54 
         /* data */
48 55 
         long chunkdatasize;
... ... 
@@ -54,11 +61,10 @@ typedef struct redata_t {
54 61 
         undostack_t undostack;
55 62 
         undostack_t redostack;
56 63 
         /* unsaved (for recovery when the program closes unexpectedly) */
57 
-        undostack_t unsavedstack;
58 64 
         char filename[PATH_MAX];
59 65 
         char initialhash[129];
60 66 
         int unsavedfd;
61 
-        int flag_unsaveddata;
67 
+        unsaved_t unsaved;
62 68 
 } redata_t;
63 69
64 70 
 redata_t *redata_init(void);
Browse code

implementation of op_del, op_undo, op_redo

Dario Rodriguez authored on 13/03/2019 17:07:30
Showing 1 changed files
recenteditor_data.h
History View file @ 423cb02
... ... 
@@ -13,7 +13,6 @@
13 13
14 14 
 #include <limits.h>
15 15
16 
-#warning TODO: change "pos" (offset in data) to long
17 16 
 typedef struct whatin_t {
18 17 
         int nlcount;
19 18 
 } whatin_t;
... ... 
@@ -62,8 +61,6 @@ typedef struct redata_t {
62 61 
         int flag_unsaveddata;
63 62 
 } redata_t;
64 63
65 
-#warning TODO: undo operations log/buffer, add/remove/move text funtions
66 
-
67 64 
 redata_t *redata_init(void);
68 65 
 void redata_free(redata_t *redata);
69 66
... ... 
@@ -78,6 +75,7 @@ int redata_getposptr(redata_t *redata, long pos, int *numchunk, long *offset);
78 75 
 int redata_wipe(redata_t *redata);
79 76 
 int redata_preallocate(redata_t *redata, long size);
80 77 
 int redata_chunk_insertnew(redata_t *redata, int afterthischunk);
78 
+int redata_chunk_deletechunk(redata_t *redata, int chunkno);
81 79 
 int redata_chunk_movedata(redata_t *redata, int chunkfrom, long posfrom, int chunkto, long posto, long size);
82 80 
 int redata_chunk_insertdata(redata_t *redata, int chunkto, long posto, char *buf, long buflen);
83 81 
 int redata_chunk_deletedata(redata_t *redata, int chunkno, long pos, long n);
... ... 
@@ -104,9 +102,9 @@ int redata_unsaved_commit(redata_t *redata);
104 102 
 int redata_load(redata_t *redata, char *filename, int use_unsaved);
105 103 
 int redata_save(redata_t *redata, char *filename);
106 104
107 
-int redata_op_add(redata_t *redata, int pos, char *buf, int buflen, undostack_t *fromhere);
108 
-int redata_op_del(redata_t *redata, int pos, int size, undostack_t *fromhere);
109 
-int redata_op_move(redata_t *redata, int posorig, int size, int posdest, undostack_t *fromhere);
105 
+int redata_op_add(redata_t *redata, long pos, char *buf, long buflen, undostack_t *fromhere);
106 
+int redata_op_del(redata_t *redata, long pos, long size, undostack_t *fromhere);
107 
+int redata_op_move(redata_t *redata, long posorig, long size, long posdest, undostack_t *fromhere);
110 108 
 int redata_op_undo(redata_t *redata);
111 109 
 int redata_op_redo(redata_t *redata);
112 110
Browse code

Changes to support files larger than 2GB

Dario Rodriguez authored on 12/03/2019 15:17:21
Showing 1 changed files
recenteditor_data.h
History View file @ d3db189
... ... 
@@ -13,6 +13,7 @@
13 13
14 14 
 #include <limits.h>
15 15
16 
+#warning TODO: change "pos" (offset in data) to long
16 17 
 typedef struct whatin_t {
17 18 
         int nlcount;
18 19 
 } whatin_t;
... ... 
@@ -26,10 +27,10 @@ typedef struct rechunk_t {
26 27
27 28 
 typedef struct undo_t {
28 29 
         char type[4];
29 
-        int off;
30 
-        int len;
31 
-        int posorig;
32 
-        int posdest;
30 
+        long off;
31 
+        long len;
32 
+        long posorig;
33 
+        long posdest;
33 34 
         char prehash[129];
34 35 
         char posthash[129];
35 36 
 } undo_t;
... ... 
@@ -45,15 +46,16 @@ typedef struct undostack_t {
45 46
46 47 
 typedef struct redata_t {
47 48 
         /* data */
48 
-        int chunkdatasize;
49 
+        long chunkdatasize;
49 50 
         int sizechunks;
50 51 
         rechunk_t **chunks;
51 
-        int available;
52 
+        long available;
52 53 
         rechunk_t *tmpchunk;
53 54 
         /* undo */
54 55 
         undostack_t undostack;
55 56 
         undostack_t redostack;
56 57 
         /* unsaved (for recovery when the program closes unexpectedly) */
58 
+        undostack_t unsavedstack;
57 59 
         char filename[PATH_MAX];
58 60 
         char initialhash[129];
59 61 
         int unsavedfd;
... ... 
@@ -67,19 +69,18 @@ void redata_free(redata_t *redata);
67 69
68 70 
 int redata_config_chunkdatasize(redata_t *redata, int chunkdatasize);
69 71
70 
-int redata_getsize(redata_t *redata);
71 
-int redata_getused(redata_t *redata);
72 
-int redata_getavailable(redata_t *redata);
73 
-int redata_getused(redata_t *redata);
74 
-int redata_getposptr(redata_t *redata, int pos, int *numchunk, int *offset);
72 
+long redata_getsize(redata_t *redata);
73 
+long redata_getused(redata_t *redata);
74 
+long redata_getavailable(redata_t *redata);
75 
+int redata_getposptr(redata_t *redata, long pos, int *numchunk, long *offset);
75 76
76 77 
 /* low level stuff */
77 78 
 int redata_wipe(redata_t *redata);
78 
-int redata_preallocate(redata_t *redata, int size);
79 
+int redata_preallocate(redata_t *redata, long size);
79 80 
 int redata_chunk_insertnew(redata_t *redata, int afterthischunk);
80 
-int redata_chunk_movedata(redata_t *redata, int chunkfrom, int posfrom, int chunkto, int posto, int size);
81 
-int redata_chunk_insertdata(redata_t *redata, int chunkto, int posto, char *buf, int buflen);
82 
-int redata_chunk_deletedata(redata_t *redata, int chunk, int pos, int n);
81 
+int redata_chunk_movedata(redata_t *redata, int chunkfrom, long posfrom, int chunkto, long posto, long size);
82 
+int redata_chunk_insertdata(redata_t *redata, int chunkto, long posto, char *buf, long buflen);
83 
+int redata_chunk_deletedata(redata_t *redata, int chunkno, long pos, long n);
83 84 
 int redata_whatin_refresh(redata_t *redata, int chunkno);
84 85 
 int redata_fix_nl(redata_t *redata, int chunkno);
85 86 
 int redata_undobuf_reserve(redata_t *redata, undostack_t *stack, int minavail);
... ... 
@@ -98,6 +99,7 @@ int redata_unsaved_unlink(redata_t *redata);
98 99 
 int redata_unsaved_trunc(redata_t *redata);
99 100 
 int redata_unsaved_add(redata_t *redata, undo_t *undo);
100 101 
 int redata_unsaved_unadd(redata_t *redata, undo_t *undo);
102 
+int redata_unsaved_commit(redata_t *redata);
101 103
102 104 
 int redata_load(redata_t *redata, char *filename, int use_unsaved);
103 105 
 int redata_save(redata_t *redata, char *filename);
... ... 
@@ -108,9 +110,8 @@ int redata_op_move(redata_t *redata, int posorig, int size, int posdest, undosta
108 110 
 int redata_op_undo(redata_t *redata);
109 111 
 int redata_op_redo(redata_t *redata);
110 112
111 
-int redata_commit_unsaved(redata_t *redata);
112 113
113 114 
 int redata_hash(redata_t *redata, char *resbuf129bytes);
114 115 
 int redata_filehash(redata_t *redata, char *filename, char *resbuf129bytes);
115 
-int redata_memhash(redata_t *redata, char *buf, int buflen, char *resbuf129bytes);
116 
+int redata_memhash(redata_t *redata, char *buf, long buflen, char *resbuf129bytes);
116 117
Browse code

Undo/redo enablement

Dario Rodriguez authored on 11/03/2019 23:24:17
Showing 1 changed files
recenteditor_data.h
History View file @ 7403005
... ... 
@@ -28,10 +28,21 @@ typedef struct undo_t {
28 28 
         char type[4];
29 29 
         int off;
30 30 
         int len;
31 
+        int posorig;
32 
+        int posdest;
31 33 
         char prehash[129];
32 34 
         char posthash[129];
33 35 
 } undo_t;
34 36
37 
+typedef struct undostack_t {
38 
+        int sizeundo;
39 
+        int usedundo;
40 
+        undo_t *undo;
41 
+        int sizebuf;
42 
+        int usedbuf;
43 
+        char *buf;
44 
+} undostack_t;
45 
+
35 46 
 typedef struct redata_t {
36 47 
         /* data */
37 48 
         int chunkdatasize;
... ... 
@@ -40,12 +51,8 @@ typedef struct redata_t {
40 51 
         int available;
41 52 
         rechunk_t *tmpchunk;
42 53 
         /* undo */
43 
-        int sizeundo;
44 
-        int usedundo;
45 
-        undo_t *undo;
46 
-        int sizeundobuf;
47 
-        int usedundobuf;
48 
-        char *undobuf;
54 
+        undostack_t undostack;
55 
+        undostack_t redostack;
49 56 
         /* unsaved (for recovery when the program closes unexpectedly) */
50 57 
         char filename[PATH_MAX];
51 58 
         char initialhash[129];
... ... 
@@ -75,9 +82,13 @@ int redata_chunk_insertdata(redata_t *redata, int chunkto, int posto, char *buf,
75 82 
 int redata_chunk_deletedata(redata_t *redata, int chunk, int pos, int n);
76 83 
 int redata_whatin_refresh(redata_t *redata, int chunkno);
77 84 
 int redata_fix_nl(redata_t *redata, int chunkno);
78 
-undo_t *redata_undo_new(redata_t *redata, char *type);
79 
-undo_t *redata_undo_newfromchunks(redata_t *redata,char *type, int pos1, int len);
80 
-undo_t *redata_undo_newfrombuf(redata_t *redata, char *type, char *buf, int buflen);
85 
+int redata_undobuf_reserve(redata_t *redata, undostack_t *stack, int minavail);
86 
+undo_t *redata_undo_new(redata_t *redata, undostack_t *stack, char *type);
87 
+undo_t *redata_undo_newfromchunks(redata_t *redata, undostack_t *stack, char *type, int pos1, int len);
88 
+undo_t *redata_undo_newfrombuf(redata_t *redata, undostack_t *stack, char *type, char *buf, int buflen);
89 
+int redata_undo_movelast(redata_t *redata, undostack_t *from, undostack_t *to);
90 
+int redata_undo_removelast(redata_t *redata, undostack_t *stack);
91 
+int redata_undo_wipe(redata_t *redata, undostack_t *stack);
81 92
82 93 
 /* high level stuff */
83 94 
 int redata_unsaved_exists(redata_t *redata, char *filename);
... ... 
@@ -91,9 +102,9 @@ int redata_unsaved_unadd(redata_t *redata, undo_t *undo);
91 102 
 int redata_load(redata_t *redata, char *filename, int use_unsaved);
92 103 
 int redata_save(redata_t *redata, char *filename);
93 104
94 
-int redata_op_add(redata_t *redata, char *buf, int buflen, int pos);
95 
-int redata_op_del(redata_t *redata, int pos, int size);
96 
-int redata_op_move(redata_t *redata, int posorig, int size, int posdest);
105 
+int redata_op_add(redata_t *redata, int pos, char *buf, int buflen, undostack_t *fromhere);
106 
+int redata_op_del(redata_t *redata, int pos, int size, undostack_t *fromhere);
107 
+int redata_op_move(redata_t *redata, int posorig, int size, int posdest, undostack_t *fromhere);
97 108 
 int redata_op_undo(redata_t *redata);
98 109 
 int redata_op_redo(redata_t *redata);
99 110
Browse code

Implement add operation

Dario Rodriguez authored on 10/03/2019 23:50:38
Showing 1 changed files
recenteditor_data.h
History View file @ 947dc5d
... ... 
@@ -25,9 +25,11 @@ typedef struct rechunk_t {
25 25 
 } rechunk_t;
26 26
27 27 
 typedef struct undo_t {
28 
-        char type[5];
28 
+        char type[4];
29 29 
         int off;
30 30 
         int len;
31 
+        char prehash[129];
32 
+        char posthash[129];
31 33 
 } undo_t;
32 34
33 35 
 typedef struct redata_t {
... ... 
@@ -40,7 +42,6 @@ typedef struct redata_t {
40 42 
         /* undo */
41 43 
         int sizeundo;
42 44 
         int usedundo;
43 
-        int curundo;
44 45 
         undo_t *undo;
45 46 
         int sizeundobuf;
46 47 
         int usedundobuf;
... ... 
@@ -65,12 +66,20 @@ int redata_getavailable(redata_t *redata);
65 66 
 int redata_getused(redata_t *redata);
66 67 
 int redata_getposptr(redata_t *redata, int pos, int *numchunk, int *offset);
67 68
69 
+/* low level stuff */
68 70 
 int redata_wipe(redata_t *redata);
69 71 
 int redata_preallocate(redata_t *redata, int size);
72 
+int redata_chunk_insertnew(redata_t *redata, int afterthischunk);
70 73 
 int redata_chunk_movedata(redata_t *redata, int chunkfrom, int posfrom, int chunkto, int posto, int size);
71 
-int redata_fill_whatin(redata_t *redata, int chunkno);
74 
+int redata_chunk_insertdata(redata_t *redata, int chunkto, int posto, char *buf, int buflen);
75 
+int redata_chunk_deletedata(redata_t *redata, int chunk, int pos, int n);
76 
+int redata_whatin_refresh(redata_t *redata, int chunkno);
72 77 
 int redata_fix_nl(redata_t *redata, int chunkno);
78 
+undo_t *redata_undo_new(redata_t *redata, char *type);
79 
+undo_t *redata_undo_newfromchunks(redata_t *redata,char *type, int pos1, int len);
80 
+undo_t *redata_undo_newfrombuf(redata_t *redata, char *type, char *buf, int buflen);
73 81
82 
+/* high level stuff */
74 83 
 int redata_unsaved_exists(redata_t *redata, char *filename);
75 84 
 int redata_unsaved_check(redata_t *redata, char *filename);
76 85 
 int redata_unsaved_loadappend(redata_t *redata);
... ... 
@@ -82,7 +91,7 @@ int redata_unsaved_unadd(redata_t *redata, undo_t *undo);
82 91 
 int redata_load(redata_t *redata, char *filename, int use_unsaved);
83 92 
 int redata_save(redata_t *redata, char *filename);
84 93
85 
-int redata_op_add(redata_t *redata, char *buf, int sizebuf, int pos);
94 
+int redata_op_add(redata_t *redata, char *buf, int buflen, int pos);
86 95 
 int redata_op_del(redata_t *redata, int pos, int size);
87 96 
 int redata_op_move(redata_t *redata, int posorig, int size, int posdest);
88 97 
 int redata_op_undo(redata_t *redata);
Browse code

Change chunk data management so that lines are entirely inside one chunk (this is to simplify the implementation of syntax highlighting)

Dario Rodriguez authored on 10/03/2019 00:03:02
Showing 1 changed files
recenteditor_data.h
History View file @ c25ce73
... ... 
@@ -19,6 +19,7 @@ typedef struct whatin_t {
19 19
20 20 
 typedef struct rechunk_t {
21 21 
         whatin_t whatin;
22 
+        int whatin_fresh;
22 23 
         int useddata;
23 24 
         unsigned char data[1];
24 25 
 } rechunk_t;
... ... 
@@ -35,6 +36,7 @@ typedef struct redata_t {
35 36 
         int sizechunks;
36 37 
         rechunk_t **chunks;
37 38 
         int available;
39 
+        rechunk_t *tmpchunk;
38 40 
         /* undo */
39 41 
         int sizeundo;
40 42 
         int usedundo;
... ... 
@@ -55,17 +57,19 @@ typedef struct redata_t {
55 57 
 redata_t *redata_init(void);
56 58 
 void redata_free(redata_t *redata);
57 59
60 
+int redata_config_chunkdatasize(redata_t *redata, int chunkdatasize);
61 
+
58 62 
 int redata_getsize(redata_t *redata);
59 63 
 int redata_getused(redata_t *redata);
60 64 
 int redata_getavailable(redata_t *redata);
61 65 
 int redata_getused(redata_t *redata);
62 66 
 int redata_getposptr(redata_t *redata, int pos, int *numchunk, int *offset);
63 67
64 
-
65 
-
66 68 
 int redata_wipe(redata_t *redata);
67 69 
 int redata_preallocate(redata_t *redata, int size);
70 
+int redata_chunk_movedata(redata_t *redata, int chunkfrom, int posfrom, int chunkto, int posto, int size);
68 71 
 int redata_fill_whatin(redata_t *redata, int chunkno);
72 
+int redata_fix_nl(redata_t *redata, int chunkno);
69 73
70 74 
 int redata_unsaved_exists(redata_t *redata, char *filename);
71 75 
 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);
84 88 
 int redata_op_undo(redata_t *redata);
85 89 
 int redata_op_redo(redata_t *redata);
86 90
91 
+int redata_commit_unsaved(redata_t *redata);
92 
+
87 93 
 int redata_hash(redata_t *redata, char *resbuf129bytes);
88 94 
 int redata_filehash(redata_t *redata, char *filename, char *resbuf129bytes);
89 95 
 int redata_memhash(redata_t *redata, char *buf, int buflen, char *resbuf129bytes);
Browse code

Add insertion test as preparation for implementing insertion

Dario Rodriguez authored on 08/03/2019 18:49:22
Showing 1 changed files
recenteditor_data.h
History View file @ 397aced
... ... 
@@ -86,4 +86,5 @@ int redata_op_redo(redata_t *redata);
86 86
87 87 
 int redata_hash(redata_t *redata, char *resbuf129bytes);
88 88 
 int redata_filehash(redata_t *redata, char *filename, char *resbuf129bytes);
89 
+int redata_memhash(redata_t *redata, char *buf, int buflen, char *resbuf129bytes);
89 90
Browse code

Add undobuf structire and corresponding functions

Dario Rodriguez authored on 05/03/2019 21:40:51
Showing 1 changed files
recenteditor_data.h
History View file @ 67f9982
... ... 
@@ -11,6 +11,8 @@
11 11 
  * This program is licensed under the terms of GNU GPL v2.1+
12 12 
  */
13 13
14 
+#include <limits.h>
15 
+
14 16 
 typedef struct whatin_t {
15 17 
         int nlcount;
16 18 
 } whatin_t;
... ... 
@@ -22,7 +24,9 @@ typedef struct rechunk_t {
22 24 
 } rechunk_t;
23 25
24 26 
 typedef struct undo_t {
25 
-
27 
+        char type[5];
28 
+        int off;
29 
+        int len;
26 30 
 } undo_t;
27 31
28 32 
 typedef struct redata_t {
... ... 
@@ -36,9 +40,12 @@ typedef struct redata_t {
36 40 
         int usedundo;
37 41 
         int curundo;
38 42 
         undo_t *undo;
43 
+        int sizeundobuf;
44 
+        int usedundobuf;
39 45 
         char *undobuf;
40 46 
         /* unsaved (for recovery when the program closes unexpectedly) */
41 
-        char *unsavedfilename;
47 
+        char filename[PATH_MAX];
48 
+        char initialhash[129];
42 49 
         int unsavedfd;
43 50 
         int flag_unsaveddata;
44 51 
 } redata_t;
... ... 
@@ -51,6 +58,10 @@ void redata_free(redata_t *redata);
51 58 
 int redata_getsize(redata_t *redata);
52 59 
 int redata_getused(redata_t *redata);
53 60 
 int redata_getavailable(redata_t *redata);
61 
+int redata_getused(redata_t *redata);
62 
+int redata_getposptr(redata_t *redata, int pos, int *numchunk, int *offset);
63 
+
64 
+
54 65
55 66 
 int redata_wipe(redata_t *redata);
56 67 
 int redata_preallocate(redata_t *redata, int size);
... ... 
@@ -58,8 +69,9 @@ int redata_fill_whatin(redata_t *redata, int chunkno);
58 69
59 70 
 int redata_unsaved_exists(redata_t *redata, char *filename);
60 71 
 int redata_unsaved_check(redata_t *redata, char *filename);
61 
-int redata_unsaved_loadappend(redata_t *redata, char *filename);
62 
-int redata_unsaved_trunc(redata_t *redata, char *filename);
72 
+int redata_unsaved_loadappend(redata_t *redata);
73 
+int redata_unsaved_unlink(redata_t *redata);
74 
+int redata_unsaved_trunc(redata_t *redata);
63 75 
 int redata_unsaved_add(redata_t *redata, undo_t *undo);
64 76 
 int redata_unsaved_unadd(redata_t *redata, undo_t *undo);
65 77
... ... 
@@ -70,7 +82,7 @@ int redata_op_add(redata_t *redata, char *buf, int sizebuf, int pos);
70 82 
 int redata_op_del(redata_t *redata, int pos, int size);
71 83 
 int redata_op_move(redata_t *redata, int posorig, int size, int posdest);
72 84 
 int redata_op_undo(redata_t *redata);
73 
-int redata_op_redor(redata_t *redata);
85 
+int redata_op_redo(redata_t *redata);
74 86
75 87 
 int redata_hash(redata_t *redata, char *resbuf129bytes);
76 88 
 int redata_filehash(redata_t *redata, char *filename, char *resbuf129bytes);
Browse code

Change sha3 implementation used. Initial unsaved data API.

Dario Rodriguez authored on 02/03/2019 16:12:12
Showing 1 changed files
recenteditor_data.h
History View file @ e6ebc6a
... ... 
@@ -56,7 +56,13 @@ int redata_wipe(redata_t *redata);
56 56 
 int redata_preallocate(redata_t *redata, int size);
57 57 
 int redata_fill_whatin(redata_t *redata, int chunkno);
58 58
59 
-int redata_unsavedcheck(redata_t *redata, char *filename);
59 
+int redata_unsaved_exists(redata_t *redata, char *filename);
60 
+int redata_unsaved_check(redata_t *redata, char *filename);
61 
+int redata_unsaved_loadappend(redata_t *redata, char *filename);
62 
+int redata_unsaved_trunc(redata_t *redata, char *filename);
63 
+int redata_unsaved_add(redata_t *redata, undo_t *undo);
64 
+int redata_unsaved_unadd(redata_t *redata, undo_t *undo);
65 
+
60 66 
 int redata_load(redata_t *redata, char *filename, int use_unsaved);
61 67 
 int redata_save(redata_t *redata, char *filename);
62 68
... ... 
@@ -67,4 +73,5 @@ int redata_op_undo(redata_t *redata);
67 73 
 int redata_op_redor(redata_t *redata);
68 74
69 75 
 int redata_hash(redata_t *redata, char *resbuf129bytes);
76 
+int redata_filehash(redata_t *redata, char *filename, char *resbuf129bytes);
70 77
Browse code

start implementation of undo and unsaved in redata. tentative sha3-512 support for unsaved integrity check

Dario Rodriguez authored on 26/02/2019 21:26:05
Showing 1 changed files
recenteditor_data.h
History View file @ 16296c5
... ... 
@@ -11,7 +11,6 @@
11 11 
  * This program is licensed under the terms of GNU GPL v2.1+
12 12 
  */
13 13
14 
-
15 14 
 typedef struct whatin_t {
16 15 
         int nlcount;
17 16 
 } whatin_t;
... ... 
@@ -22,13 +21,30 @@ typedef struct rechunk_t {
22 21 
         unsigned char data[1];
23 22 
 } rechunk_t;
24 23
24 
+typedef struct undo_t {
25 
+
26 
+} undo_t;
27 
+
25 28 
 typedef struct redata_t {
29 
+        /* data */
26 30 
         int chunkdatasize;
27 31 
         int sizechunks;
28 32 
         rechunk_t **chunks;
29 33 
         int available;
34 
+        /* undo */
35 
+        int sizeundo;
36 
+        int usedundo;
37 
+        int curundo;
38 
+        undo_t *undo;
39 
+        char *undobuf;
40 
+        /* unsaved (for recovery when the program closes unexpectedly) */
41 
+        char *unsavedfilename;
42 
+        int unsavedfd;
43 
+        int flag_unsaveddata;
30 44 
 } redata_t;
31 45
46 
+#warning TODO: undo operations log/buffer, add/remove/move text funtions
47 
+
32 48 
 redata_t *redata_init(void);
33 49 
 void redata_free(redata_t *redata);
34 50
... ... 
@@ -40,5 +56,15 @@ int redata_wipe(redata_t *redata);
40 56 
 int redata_preallocate(redata_t *redata, int size);
41 57 
 int redata_fill_whatin(redata_t *redata, int chunkno);
42 58
43 
-int redata_load(redata_t *redata, char *filename);
59 
+int redata_unsavedcheck(redata_t *redata, char *filename);
60 
+int redata_load(redata_t *redata, char *filename, int use_unsaved);
44 61 
 int redata_save(redata_t *redata, char *filename);
62 
+
63 
+int redata_op_add(redata_t *redata, char *buf, int sizebuf, int pos);
64 
+int redata_op_del(redata_t *redata, int pos, int size);
65 
+int redata_op_move(redata_t *redata, int posorig, int size, int posdest);
66 
+int redata_op_undo(redata_t *redata);
67 
+int redata_op_redor(redata_t *redata);
68 
+
69 
+int redata_hash(redata_t *redata, char *resbuf129bytes);
70 
+
Browse code

data structures skeleton

Dario Rodriguez authored on 25/02/2019 22:04:09
Showing 1 changed files
recenteditor_data.h
History View file @ 4b22f0f
1 1 
new file mode 100644
... ... 
@@ -0,0 +1,44 @@
1 
+/*
2 
+ * recenteditor_data.c
3 
+ *
4 
+ * A programmers editor
5 
+ *
6 
+ * Structures to hold the current file contents.
7 
+ *
8 
+ * HEADER FILE
9 
+ *
10 
+ * Author: Dario Rodriguez dario@softhome.net
11 
+ * This program is licensed under the terms of GNU GPL v2.1+
12 
+ */
13 
+
14 
+
15 
+typedef struct whatin_t {
16 
+        int nlcount;
17 
+} whatin_t;
18 
+
19 
+typedef struct rechunk_t {
20 
+        whatin_t whatin;
21 
+        int useddata;
22 
+        unsigned char data[1];
23 
+} rechunk_t;
24 
+
25 
+typedef struct redata_t {
26 
+        int chunkdatasize;
27 
+        int sizechunks;
28 
+        rechunk_t **chunks;
29 
+        int available;
30 
+} redata_t;
31 
+
32 
+redata_t *redata_init(void);
33 
+void redata_free(redata_t *redata);
34 
+
35 
+int redata_getsize(redata_t *redata);
36 
+int redata_getused(redata_t *redata);
37 
+int redata_getavailable(redata_t *redata);
38 
+
39 
+int redata_wipe(redata_t *redata);
40 
+int redata_preallocate(redata_t *redata, int size);
41 
+int redata_fill_whatin(redata_t *redata, int chunkno);
42 
+
43 
+int redata_load(redata_t *redata, char *filename);
44 
+int redata_save(redata_t *redata, char *filename);