This commit was generated by cvs2svn to track changes on a CVS vendor
[external/binutils.git] / readline / undo.c
1 /* readline.c -- a general facility for reading lines of input
2    with emacs style editing and completion. */
3
4 /* Copyright (C) 1987, 1989, 1992 Free Software Foundation, Inc.
5
6    This file is part of the GNU Readline Library, a library for
7    reading lines of text with interactive input and history editing.
8
9    The GNU Readline Library is free software; you can redistribute it
10    and/or modify it under the terms of the GNU General Public License
11    as published by the Free Software Foundation; either version 1, or
12    (at your option) any later version.
13
14    The GNU Readline Library is distributed in the hope that it will be
15    useful, but WITHOUT ANY WARRANTY; without even the implied warranty
16    of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18
19    The GNU General Public License is often shipped with GNU software, and
20    is generally kept in a file called COPYING or LICENSE.  If you do not
21    have a copy of the license, write to the Free Software Foundation,
22    675 Mass Ave, Cambridge, MA 02139, USA. */
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 #define SWAP(s, e)  do { int t; t = s; s = e; e = t; } while (0)
51
52 /* Non-zero tells rl_delete_text and rl_insert_text to not add to
53    the undo list. */
54 int _rl_doing_an_undo = 0;
55
56 /* How many unclosed undo groups we currently have. */
57 int _rl_undo_group_level = 0;
58
59 /* The current undo list for THE_LINE. */
60 UNDO_LIST *rl_undo_list = (UNDO_LIST *)NULL;
61
62 /* **************************************************************** */
63 /*                                                                  */
64 /*                      Undo, and Undoing                           */
65 /*                                                                  */
66 /* **************************************************************** */
67
68 /* Remember how to undo something.  Concatenate some undos if that
69    seems right. */
70 void
71 rl_add_undo (what, start, end, text)
72      enum undo_code what;
73      int start, end;
74      char *text;
75 {
76   UNDO_LIST *temp = (UNDO_LIST *)xmalloc (sizeof (UNDO_LIST));
77   temp->what = what;
78   temp->start = start;
79   temp->end = end;
80   temp->text = text;
81   temp->next = rl_undo_list;
82   rl_undo_list = temp;
83 }
84
85 /* Free the existing undo list. */
86 void
87 free_undo_list ()
88 {
89   while (rl_undo_list)
90     {
91       UNDO_LIST *release = rl_undo_list;
92       rl_undo_list = rl_undo_list->next;
93
94       if (release->what == UNDO_DELETE)
95         free (release->text);
96
97       free (release);
98     }
99   rl_undo_list = (UNDO_LIST *)NULL;
100 }
101
102 /* Undo the next thing in the list.  Return 0 if there
103    is nothing to undo, or non-zero if there was. */
104 int
105 rl_do_undo ()
106 {
107   UNDO_LIST *release;
108   int waiting_for_begin = 0;
109   int start, end;
110
111 #define TRANS(i) ((i) == -1 ? rl_point : ((i) == -2 ? rl_end : (i)))
112
113   do
114     {
115       if (!rl_undo_list)
116         return (0);
117
118       _rl_doing_an_undo = 1;
119
120       /* To better support vi-mode, a start or end value of -1 means
121          rl_point, and a value of -2 means rl_end. */
122       if (rl_undo_list->what == UNDO_DELETE || rl_undo_list->what == UNDO_INSERT)
123         {
124           start = TRANS (rl_undo_list->start);
125           end = TRANS (rl_undo_list->end);
126         }
127
128       switch (rl_undo_list->what)
129         {
130         /* Undoing deletes means inserting some text. */
131         case UNDO_DELETE:
132           rl_point = start;
133           rl_insert_text (rl_undo_list->text);
134           free (rl_undo_list->text);
135           break;
136
137         /* Undoing inserts means deleting some text. */
138         case UNDO_INSERT:
139           rl_delete_text (start, end);
140           rl_point = start;
141           break;
142
143         /* Undoing an END means undoing everything 'til we get to a BEGIN. */
144         case UNDO_END:
145           waiting_for_begin++;
146           break;
147
148         /* Undoing a BEGIN means that we are done with this group. */
149         case UNDO_BEGIN:
150           if (waiting_for_begin)
151             waiting_for_begin--;
152           else
153             ding ();
154           break;
155         }
156
157       _rl_doing_an_undo = 0;
158
159       release = rl_undo_list;
160       rl_undo_list = rl_undo_list->next;
161       free (release);
162     }
163   while (waiting_for_begin);
164
165   return (1);
166 }
167 #undef TRANS
168
169 int
170 _rl_fix_last_undo_of_type (type, start, end)
171      int type, start, end;
172 {
173   UNDO_LIST *rl;
174
175   for (rl = rl_undo_list; rl; rl = rl->next)
176     {
177       if (rl->what == type)
178         {
179           rl->start = start;
180           rl->end = end;
181           return 0;
182         }
183     }
184   return 1;
185 }
186
187 /* Begin a group.  Subsequent undos are undone as an atomic operation. */
188 int
189 rl_begin_undo_group ()
190 {
191   rl_add_undo (UNDO_BEGIN, 0, 0, 0);
192   _rl_undo_group_level++;
193   return 0;
194 }
195
196 /* End an undo group started with rl_begin_undo_group (). */
197 int
198 rl_end_undo_group ()
199 {
200   rl_add_undo (UNDO_END, 0, 0, 0);
201   _rl_undo_group_level--;
202   return 0;
203 }
204
205 /* Save an undo entry for the text from START to END. */
206 int
207 rl_modifying (start, end)
208      int start, end;
209 {
210   if (start > end)
211     {
212       SWAP (start, end);
213     }
214
215   if (start != end)
216     {
217       char *temp = rl_copy_text (start, end);
218       rl_begin_undo_group ();
219       rl_add_undo (UNDO_DELETE, start, end, temp);
220       rl_add_undo (UNDO_INSERT, start, end, (char *)NULL);
221       rl_end_undo_group ();
222     }
223   return 0;
224 }
225
226 /* Revert the current line to its previous state. */
227 int
228 rl_revert_line (count, key)
229      int count, key;
230 {
231   if (!rl_undo_list)
232     ding ();
233   else
234     {
235       while (rl_undo_list)
236         rl_do_undo ();
237     }
238   return 0;
239 }
240
241 /* Do some undoing of things that were done. */
242 int
243 rl_undo_command (count, key)
244      int count, key;
245 {
246   if (count < 0)
247     return 0;   /* Nothing to do. */
248
249   while (count)
250     {
251       if (rl_do_undo ())
252         count--;
253       else
254         {
255           ding ();
256           break;
257         }
258     }
259   return 0;
260 }