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

Subversion Repositories or1k

[/] [or1k/] [branches/] [oc/] [gdb-5.0/] [readline/] [undo.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 106 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 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
}

powered by: WebSVN 2.1.0

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