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