OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [readline/] [undo.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 578 markom
/* 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 2, 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
   59 Temple Place, Suite 330, Boston, MA 02111 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
#include "rlprivate.h"
51
 
52
#define SWAP(s, e)  do { int t; t = s; s = e; e = t; } while (0)
53
 
54
/* Non-zero tells rl_delete_text and rl_insert_text to not add to
55
   the undo list. */
56
int _rl_doing_an_undo = 0;
57
 
58
/* How many unclosed undo groups we currently have. */
59
int _rl_undo_group_level = 0;
60
 
61
/* The current undo list for THE_LINE. */
62
UNDO_LIST *rl_undo_list = (UNDO_LIST *)NULL;
63
 
64
/* **************************************************************** */
65
/*                                                                  */
66
/*                      Undo, and Undoing                           */
67
/*                                                                  */
68
/* **************************************************************** */
69
 
70
/* Remember how to undo something.  Concatenate some undos if that
71
   seems right. */
72
void
73
rl_add_undo (what, start, end, text)
74
     enum undo_code what;
75
     int start, end;
76
     char *text;
77
{
78
  UNDO_LIST *temp = (UNDO_LIST *)xmalloc (sizeof (UNDO_LIST));
79
  temp->what = what;
80
  temp->start = start;
81
  temp->end = end;
82
  temp->text = text;
83
  temp->next = rl_undo_list;
84
  rl_undo_list = temp;
85
}
86
 
87
/* Free the existing undo list. */
88
void
89
free_undo_list ()
90
{
91
  while (rl_undo_list)
92
    {
93
      UNDO_LIST *release = rl_undo_list;
94
      rl_undo_list = rl_undo_list->next;
95
 
96
      if (release->what == UNDO_DELETE)
97
        free (release->text);
98
 
99
      free (release);
100
    }
101
  rl_undo_list = (UNDO_LIST *)NULL;
102
}
103
 
104
/* Undo the next thing in the list.  Return 0 if there
105
   is nothing to undo, or non-zero if there was. */
106
int
107
rl_do_undo ()
108
{
109
  UNDO_LIST *release;
110
  int waiting_for_begin = 0;
111
  int start, end;
112
 
113
#define TRANS(i) ((i) == -1 ? rl_point : ((i) == -2 ? rl_end : (i)))
114
 
115
  do
116
    {
117
      if (!rl_undo_list)
118
        return (0);
119
 
120
      _rl_doing_an_undo = 1;
121
 
122
      /* To better support vi-mode, a start or end value of -1 means
123
         rl_point, and a value of -2 means rl_end. */
124
      if (rl_undo_list->what == UNDO_DELETE || rl_undo_list->what == UNDO_INSERT)
125
        {
126
          start = TRANS (rl_undo_list->start);
127
          end = TRANS (rl_undo_list->end);
128
        }
129
 
130
      switch (rl_undo_list->what)
131
        {
132
        /* Undoing deletes means inserting some text. */
133
        case UNDO_DELETE:
134
          rl_point = start;
135
          rl_insert_text (rl_undo_list->text);
136
          free (rl_undo_list->text);
137
          break;
138
 
139
        /* Undoing inserts means deleting some text. */
140
        case UNDO_INSERT:
141
          rl_delete_text (start, end);
142
          rl_point = start;
143
          break;
144
 
145
        /* Undoing an END means undoing everything 'til we get to a BEGIN. */
146
        case UNDO_END:
147
          waiting_for_begin++;
148
          break;
149
 
150
        /* Undoing a BEGIN means that we are done with this group. */
151
        case UNDO_BEGIN:
152
          if (waiting_for_begin)
153
            waiting_for_begin--;
154
          else
155
            ding ();
156
          break;
157
        }
158
 
159
      _rl_doing_an_undo = 0;
160
 
161
      release = rl_undo_list;
162
      rl_undo_list = rl_undo_list->next;
163
      free (release);
164
    }
165
  while (waiting_for_begin);
166
 
167
  return (1);
168
}
169
#undef TRANS
170
 
171
int
172
_rl_fix_last_undo_of_type (type, start, end)
173
     int type, start, end;
174
{
175
  UNDO_LIST *rl;
176
 
177
  for (rl = rl_undo_list; rl; rl = rl->next)
178
    {
179
      if (rl->what == type)
180
        {
181
          rl->start = start;
182
          rl->end = end;
183
          return 0;
184
        }
185
    }
186
  return 1;
187
}
188
 
189
/* Begin a group.  Subsequent undos are undone as an atomic operation. */
190
int
191
rl_begin_undo_group ()
192
{
193
  rl_add_undo (UNDO_BEGIN, 0, 0, 0);
194
  _rl_undo_group_level++;
195
  return 0;
196
}
197
 
198
/* End an undo group started with rl_begin_undo_group (). */
199
int
200
rl_end_undo_group ()
201
{
202
  rl_add_undo (UNDO_END, 0, 0, 0);
203
  _rl_undo_group_level--;
204
  return 0;
205
}
206
 
207
/* Save an undo entry for the text from START to END. */
208
int
209
rl_modifying (start, end)
210
     int start, end;
211
{
212
  if (start > end)
213
    {
214
      SWAP (start, end);
215
    }
216
 
217
  if (start != end)
218
    {
219
      char *temp = rl_copy_text (start, end);
220
      rl_begin_undo_group ();
221
      rl_add_undo (UNDO_DELETE, start, end, temp);
222
      rl_add_undo (UNDO_INSERT, start, end, (char *)NULL);
223
      rl_end_undo_group ();
224
    }
225
  return 0;
226
}
227
 
228
/* Revert the current line to its previous state. */
229
int
230
rl_revert_line (count, key)
231
     int count, key;
232
{
233
  if (!rl_undo_list)
234
    ding ();
235
  else
236
    {
237
      while (rl_undo_list)
238
        rl_do_undo ();
239
    }
240
  return 0;
241
}
242
 
243
/* Do some undoing of things that were done. */
244
int
245
rl_undo_command (count, key)
246
     int count, key;
247
{
248
  if (count < 0)
249
    return 0;    /* Nothing to do. */
250
 
251
  while (count)
252
    {
253
      if (rl_do_undo ())
254
        count--;
255
      else
256
        {
257
          ding ();
258
          break;
259
        }
260
    }
261
  return 0;
262
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.