1 /* undo.c - manage list of changes to lines, offering opportunity to undo them */
2
3 /* Copyright (C) 1987-2017 Free Software Foundation, Inc.
4
5 This file is part of the GNU Readline Library (Readline), a library
6 for reading lines of text with interactive input and history editing.
7
8 Readline is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
12
13 Readline is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with Readline. If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #define READLINE_LIBRARY
23
24 #if defined (HAVE_CONFIG_H)
25 # include <config.h>
26 #endif
27
28 #include <sys/types.h>
29
30 #if defined (HAVE_UNISTD_H)
31 # include <unistd.h> /* for _POSIX_VERSION */
32 #endif /* HAVE_UNISTD_H */
33
34 #if defined (HAVE_STDLIB_H)
35 # include <stdlib.h>
36 #else
37 # include "ansi_stdlib.h"
38 #endif /* HAVE_STDLIB_H */
39
40 #include <stdio.h>
41
42 /* System-specific feature definitions and include files. */
43 #include "rldefs.h"
44
45 /* Some standard library routines. */
46 #include "readline.h"
47 #include "history.h"
48
49 #include "rlprivate.h"
50 #include "xmalloc.h"
51
52 extern void _hs_replace_history_data PARAMS((int, histdata_t *, histdata_t *));
53
54 extern HIST_ENTRY *_rl_saved_line_for_history;
55
56 /* Non-zero tells rl_delete_text and rl_insert_text to not add to
57 the undo list. */
58 int _rl_doing_an_undo = 0;
59
60 /* How many unclosed undo groups we currently have. */
61 int _rl_undo_group_level = 0;
62
63 /* The current undo list for THE_LINE. */
64 UNDO_LIST *rl_undo_list = (UNDO_LIST *)NULL;
65
66 /* **************************************************************** */
67 /* */
68 /* Undo, and Undoing */
69 /* */
70 /* **************************************************************** */
71
72 static UNDO_LIST *
alloc_undo_entry(enum undo_code what,int start,int end,char * text)73 alloc_undo_entry (enum undo_code what, int start, int end, char *text)
74 {
75 UNDO_LIST *temp;
76
77 temp = (UNDO_LIST *)xmalloc (sizeof (UNDO_LIST));
78 temp->what = what;
79 temp->start = start;
80 temp->end = end;
81 temp->text = text;
82
83 temp->next = (UNDO_LIST *)NULL;
84 return temp;
85 }
86
87 /* Remember how to undo something. Concatenate some undos if that
88 seems right. */
89 void
rl_add_undo(enum undo_code what,int start,int end,char * text)90 rl_add_undo (enum undo_code what, int start, int end, char *text)
91 {
92 UNDO_LIST *temp;
93
94 temp = alloc_undo_entry (what, start, end, text);
95 temp->next = rl_undo_list;
96 rl_undo_list = temp;
97 }
98
99 /* Free an UNDO_LIST */
100 void
_rl_free_undo_list(UNDO_LIST * ul)101 _rl_free_undo_list (UNDO_LIST *ul)
102 {
103 UNDO_LIST *release;
104
105 while (ul)
106 {
107 release = ul;
108 ul = ul->next;
109
110 if (release->what == UNDO_DELETE)
111 xfree (release->text);
112
113 xfree (release);
114 }
115 }
116
117 /* Free the existing undo list. */
118 void
rl_free_undo_list(void)119 rl_free_undo_list (void)
120 {
121 UNDO_LIST *release, *orig_list;
122
123 orig_list = rl_undo_list;
124 _rl_free_undo_list (rl_undo_list);
125 rl_undo_list = (UNDO_LIST *)NULL;
126 _hs_replace_history_data (-1, (histdata_t *)orig_list, (histdata_t *)NULL);
127 }
128
129 UNDO_LIST *
_rl_copy_undo_entry(UNDO_LIST * entry)130 _rl_copy_undo_entry (UNDO_LIST *entry)
131 {
132 UNDO_LIST *new;
133
134 new = alloc_undo_entry (entry->what, entry->start, entry->end, (char *)NULL);
135 new->text = entry->text ? savestring (entry->text) : 0;
136 return new;
137 }
138
139 UNDO_LIST *
_rl_copy_undo_list(UNDO_LIST * head)140 _rl_copy_undo_list (UNDO_LIST *head)
141 {
142 UNDO_LIST *list, *new, *roving, *c;
143
144 if (head == 0)
145 return head;
146
147 list = head;
148 new = 0;
149 while (list)
150 {
151 c = _rl_copy_undo_entry (list);
152 if (new == 0)
153 roving = new = c;
154 else
155 {
156 roving->next = c;
157 roving = roving->next;
158 }
159 list = list->next;
160 }
161
162 roving->next = 0;
163 return new;
164 }
165
166 /* Undo the next thing in the list. Return 0 if there
167 is nothing to undo, or non-zero if there was. */
168 int
rl_do_undo(void)169 rl_do_undo (void)
170 {
171 UNDO_LIST *release, *search;
172 int waiting_for_begin, start, end;
173 HIST_ENTRY *cur, *temp;
174
175 #define TRANS(i) ((i) == -1 ? rl_point : ((i) == -2 ? rl_end : (i)))
176
177 start = end = waiting_for_begin = 0;
178 do
179 {
180 if (rl_undo_list == 0)
181 return (0);
182
183 _rl_doing_an_undo = 1;
184 RL_SETSTATE(RL_STATE_UNDOING);
185
186 /* To better support vi-mode, a start or end value of -1 means
187 rl_point, and a value of -2 means rl_end. */
188 if (rl_undo_list->what == UNDO_DELETE || rl_undo_list->what == UNDO_INSERT)
189 {
190 start = TRANS (rl_undo_list->start);
191 end = TRANS (rl_undo_list->end);
192 }
193
194 switch (rl_undo_list->what)
195 {
196 /* Undoing deletes means inserting some text. */
197 case UNDO_DELETE:
198 rl_point = start;
199 _rl_fix_point (1);
200 rl_insert_text (rl_undo_list->text);
201 xfree (rl_undo_list->text);
202 break;
203
204 /* Undoing inserts means deleting some text. */
205 case UNDO_INSERT:
206 rl_delete_text (start, end);
207 rl_point = start;
208 _rl_fix_point (1);
209 break;
210
211 /* Undoing an END means undoing everything 'til we get to a BEGIN. */
212 case UNDO_END:
213 waiting_for_begin++;
214 break;
215
216 /* Undoing a BEGIN means that we are done with this group. */
217 case UNDO_BEGIN:
218 if (waiting_for_begin)
219 waiting_for_begin--;
220 else
221 rl_ding ();
222 break;
223 }
224
225 _rl_doing_an_undo = 0;
226 RL_UNSETSTATE(RL_STATE_UNDOING);
227
228 release = rl_undo_list;
229 rl_undo_list = rl_undo_list->next;
230 release->next = 0; /* XXX */
231
232 /* If we are editing a history entry, make sure the change is replicated
233 in the history entry's line */
234 cur = current_history ();
235 if (cur && cur->data && (UNDO_LIST *)cur->data == release)
236 {
237 temp = replace_history_entry (where_history (), rl_line_buffer, (histdata_t)rl_undo_list);
238 xfree (temp->line);
239 FREE (temp->timestamp);
240 xfree (temp);
241 }
242
243 /* Make sure there aren't any history entries with that undo list */
244 _hs_replace_history_data (-1, (histdata_t *)release, (histdata_t *)rl_undo_list);
245
246 /* And make sure this list isn't anywhere in the saved line for history */
247 if (_rl_saved_line_for_history && _rl_saved_line_for_history->data)
248 {
249 /* Brute force; no finesse here */
250 search = (UNDO_LIST *)_rl_saved_line_for_history->data;
251 if (search == release)
252 _rl_saved_line_for_history->data = rl_undo_list;
253 else
254 {
255 while (search->next)
256 {
257 if (search->next == release)
258 {
259 search->next = rl_undo_list;
260 break;
261 }
262 search = search->next;
263 }
264 }
265 }
266
267 xfree (release);
268 }
269 while (waiting_for_begin);
270
271 return (1);
272 }
273 #undef TRANS
274
275 int
_rl_fix_last_undo_of_type(int type,int start,int end)276 _rl_fix_last_undo_of_type (int type, int start, int end)
277 {
278 UNDO_LIST *rl;
279
280 for (rl = rl_undo_list; rl; rl = rl->next)
281 {
282 if (rl->what == type)
283 {
284 rl->start = start;
285 rl->end = end;
286 return 0;
287 }
288 }
289 return 1;
290 }
291
292 /* Begin a group. Subsequent undos are undone as an atomic operation. */
293 int
rl_begin_undo_group(void)294 rl_begin_undo_group (void)
295 {
296 rl_add_undo (UNDO_BEGIN, 0, 0, 0);
297 _rl_undo_group_level++;
298 return 0;
299 }
300
301 /* End an undo group started with rl_begin_undo_group (). */
302 int
rl_end_undo_group(void)303 rl_end_undo_group (void)
304 {
305 rl_add_undo (UNDO_END, 0, 0, 0);
306 _rl_undo_group_level--;
307 return 0;
308 }
309
310 /* Save an undo entry for the text from START to END. */
311 int
rl_modifying(int start,int end)312 rl_modifying (int start, int end)
313 {
314 if (start > end)
315 {
316 SWAP (start, end);
317 }
318
319 if (start != end)
320 {
321 char *temp = rl_copy_text (start, end);
322 rl_begin_undo_group ();
323 rl_add_undo (UNDO_DELETE, start, end, temp);
324 rl_add_undo (UNDO_INSERT, start, end, (char *)NULL);
325 rl_end_undo_group ();
326 }
327 return 0;
328 }
329
330 /* Revert the current line to its previous state. */
331 int
rl_revert_line(int count,int key)332 rl_revert_line (int count, int key)
333 {
334 if (rl_undo_list == 0)
335 rl_ding ();
336 else
337 {
338 while (rl_undo_list)
339 rl_do_undo ();
340 #if defined (VI_MODE)
341 if (rl_editing_mode == vi_mode)
342 rl_point = rl_mark = 0; /* rl_end should be set correctly */
343 #endif
344 }
345
346 return 0;
347 }
348
349 /* Do some undoing of things that were done. */
350 int
rl_undo_command(int count,int key)351 rl_undo_command (int count, int key)
352 {
353 if (count < 0)
354 return 0; /* Nothing to do. */
355
356 while (count)
357 {
358 if (rl_do_undo ())
359 count--;
360 else
361 {
362 rl_ding ();
363 break;
364 }
365 }
366 return 0;
367 }
368