1 /* kill.c -- kill ring management. */
3 /* Copyright (C) 1994 Free Software Foundation, Inc.
5 This file is part of the GNU Readline Library, a library for
6 reading lines of text with interactive input and history editing.
8 The GNU Readline Library is free software; you can redistribute it
9 and/or modify it under the terms of the GNU General Public License
10 as published by the Free Software Foundation; either version 2, or
11 (at your option) any later version.
13 The GNU Readline Library is distributed in the hope that it will be
14 useful, but WITHOUT ANY WARRANTY; without even the implied warranty
15 of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 The GNU General Public License is often shipped with GNU software, and
19 is generally kept in a file called COPYING or LICENSE. If you do not
20 have a copy of the license, write to the Free Software Foundation,
21 59 Temple Place, Suite 330, Boston, MA 02111 USA. */
22 #define READLINE_LIBRARY
24 #if defined (HAVE_CONFIG_H)
28 #include <sys/types.h>
30 #if defined (HAVE_UNISTD_H)
31 # include <unistd.h> /* for _POSIX_VERSION */
32 #endif /* HAVE_UNISTD_H */
34 #if defined (HAVE_STDLIB_H)
37 # include "ansi_stdlib.h"
38 #endif /* HAVE_STDLIB_H */
42 /* System-specific feature definitions and include files. */
45 /* Some standard library routines. */
49 #include "rlprivate.h"
52 /* **************************************************************** */
54 /* Killing Mechanism */
56 /* **************************************************************** */
58 /* What we assume for a max number of kills. */
59 #define DEFAULT_MAX_KILLS 10
61 /* The real variable to look at to find out when to flush kills. */
62 static int rl_max_kills = DEFAULT_MAX_KILLS;
64 /* Where to store killed text. */
65 static char **rl_kill_ring = (char **)NULL;
67 /* Where we are in the kill ring. */
68 static int rl_kill_index;
70 /* How many slots we have in the kill ring. */
71 static int rl_kill_ring_length;
73 static int _rl_copy_to_kill_ring PARAMS((char *, int));
74 static int region_kill_internal PARAMS((int));
75 static int _rl_copy_word_as_kill PARAMS((int, int));
76 static int rl_yank_nth_arg_internal PARAMS((int, int, int));
78 /* How to say that you only want to save a certain amount
81 rl_set_retained_kills (num)
87 /* Add TEXT to the kill ring, allocating a new kill ring slot as necessary.
88 This uses TEXT directly, so the caller must not free it. If APPEND is
89 non-zero, and the last command was a kill, the text is appended to the
90 current kill ring slot, otherwise prepended. */
92 _rl_copy_to_kill_ring (text, append)
99 /* First, find the slot to work with. */
100 if (_rl_last_command_was_kill == 0)
102 /* Get a new slot. */
103 if (rl_kill_ring == 0)
105 /* If we don't have any defined, then make one. */
106 rl_kill_ring = (char **)
107 xmalloc (((rl_kill_ring_length = 1) + 1) * sizeof (char *));
108 rl_kill_ring[slot = 0] = (char *)NULL;
112 /* We have to add a new slot on the end, unless we have
113 exceeded the max limit for remembering kills. */
114 slot = rl_kill_ring_length;
115 if (slot == rl_max_kills)
118 free (rl_kill_ring[0]);
119 for (i = 0; i < slot; i++)
120 rl_kill_ring[i] = rl_kill_ring[i + 1];
124 slot = rl_kill_ring_length += 1;
125 rl_kill_ring = (char **)xrealloc (rl_kill_ring, slot * sizeof (char *));
127 rl_kill_ring[--slot] = (char *)NULL;
131 slot = rl_kill_ring_length - 1;
133 /* If the last command was a kill, prepend or append. */
134 if (_rl_last_command_was_kill && rl_editing_mode != vi_mode)
136 old = rl_kill_ring[slot];
137 new = (char *)xmalloc (1 + strlen (old) + strlen (text));
151 rl_kill_ring[slot] = new;
154 rl_kill_ring[slot] = text;
156 rl_kill_index = slot;
160 /* The way to kill something. This appends or prepends to the last
161 kill, if the last command was a kill command. if FROM is less
162 than TO, then the text is appended, otherwise prepended. If the
163 last command was not a kill command, then a new slot is made for
166 rl_kill_text (from, to)
171 /* Is there anything to kill? */
174 _rl_last_command_was_kill++;
178 text = rl_copy_text (from, to);
180 /* Delete the copied text from the line. */
181 rl_delete_text (from, to);
183 _rl_copy_to_kill_ring (text, from < to);
185 _rl_last_command_was_kill++;
189 /* Now REMEMBER! In order to do prepending or appending correctly, kill
190 commands always make rl_point's original position be the FROM argument,
191 and rl_point's extent be the TO argument. */
193 /* **************************************************************** */
195 /* Killing Commands */
197 /* **************************************************************** */
199 /* Delete the word at point, saving the text in the kill ring. */
201 rl_kill_word (count, key)
204 int orig_point = rl_point;
207 return (rl_backward_kill_word (-count, key));
210 rl_forward_word (count, key);
212 if (rl_point != orig_point)
213 rl_kill_text (orig_point, rl_point);
215 rl_point = orig_point;
220 /* Rubout the word before point, placing it on the kill ring. */
222 rl_backward_kill_word (count, ignore)
225 int orig_point = rl_point;
228 return (rl_kill_word (-count, ignore));
231 rl_backward_word (count, ignore);
233 if (rl_point != orig_point)
234 rl_kill_text (orig_point, rl_point);
239 /* Kill from here to the end of the line. If DIRECTION is negative, kill
240 back to the line start instead. */
242 rl_kill_line (direction, ignore)
243 int direction, ignore;
245 int orig_point = rl_point;
248 return (rl_backward_kill_line (1, ignore));
251 rl_end_of_line (1, ignore);
252 if (orig_point != rl_point)
253 rl_kill_text (orig_point, rl_point);
254 rl_point = orig_point;
259 /* Kill backwards to the start of the line. If DIRECTION is negative, kill
260 forwards to the line end instead. */
262 rl_backward_kill_line (direction, ignore)
263 int direction, ignore;
265 int orig_point = rl_point;
268 return (rl_kill_line (1, ignore));
275 rl_beg_of_line (1, ignore);
276 rl_kill_text (orig_point, rl_point);
282 /* Kill the whole line, no matter where point is. */
284 rl_kill_full_line (count, ignore)
287 rl_begin_undo_group ();
289 rl_kill_text (rl_point, rl_end);
290 rl_end_undo_group ();
294 /* The next two functions mimic unix line editing behaviour, except they
295 save the deleted text on the kill ring. This is safer than not saving
296 it, and since we have a ring, nobody should get screwed. */
298 /* This does what C-w does in Unix. We can't prevent people from
299 using behaviour that they expect. */
301 rl_unix_word_rubout (count, key)
310 orig_point = rl_point;
316 while (rl_point && whitespace (rl_line_buffer[rl_point - 1]))
319 while (rl_point && (whitespace (rl_line_buffer[rl_point - 1]) == 0))
323 rl_kill_text (orig_point, rl_point);
328 /* Here is C-u doing what Unix does. You don't *have* to use these
329 key-bindings. We have a choice of killing the entire line, or
330 killing from where we are to the start of the line. We choose the
331 latter, because if you are a Unix weenie, then you haven't backspaced
332 into the line at all, and if you aren't, then you know what you are
335 rl_unix_line_discard (count, key)
342 rl_kill_text (rl_point, 0);
348 /* Copy the text in the `region' to the kill ring. If DELETE is non-zero,
349 delete the text from the line as well. */
351 region_kill_internal (delete)
356 if (rl_mark == rl_point)
358 _rl_last_command_was_kill++;
362 text = rl_copy_text (rl_point, rl_mark);
364 rl_delete_text (rl_point, rl_mark);
365 _rl_copy_to_kill_ring (text, rl_point < rl_mark);
367 _rl_last_command_was_kill++;
371 /* Copy the text in the region to the kill ring. */
373 rl_copy_region_to_kill (count, ignore)
376 return (region_kill_internal (0));
379 /* Kill the text between the point and mark. */
381 rl_kill_region (count, ignore)
386 npoint = (rl_point < rl_mark) ? rl_point : rl_mark;
387 r = region_kill_internal (1);
393 /* Copy COUNT words to the kill ring. DIR says which direction we look
394 to find the words. */
396 _rl_copy_word_as_kill (count, dir)
405 rl_forward_word (count, 0);
407 rl_backward_word (count, 0);
412 rl_backward_word (count, 0);
414 rl_forward_word (count, 0);
416 r = region_kill_internal (0);
425 rl_copy_forward_word (count, key)
429 return (rl_copy_backward_word (-count, key));
431 return (_rl_copy_word_as_kill (count, 1));
435 rl_copy_backward_word (count, key)
439 return (rl_copy_forward_word (-count, key));
441 return (_rl_copy_word_as_kill (count, -1));
444 /* Yank back the last killed text. This ignores arguments. */
446 rl_yank (count, ignore)
449 if (rl_kill_ring == 0)
451 _rl_abort_internal ();
455 _rl_set_mark_at_pos (rl_point);
456 rl_insert_text (rl_kill_ring[rl_kill_index]);
460 /* If the last command was yank, or yank_pop, and the text just
461 before point is identical to the current kill item, then
462 delete that text from the line, rotate the index down, and
463 yank back some other text. */
465 rl_yank_pop (count, key)
470 if (((rl_last_func != rl_yank_pop) && (rl_last_func != rl_yank)) ||
473 _rl_abort_internal ();
477 l = strlen (rl_kill_ring[rl_kill_index]);
479 if (n >= 0 && STREQN (rl_line_buffer + n, rl_kill_ring[rl_kill_index], l))
481 rl_delete_text (n, rl_point);
484 if (rl_kill_index < 0)
485 rl_kill_index = rl_kill_ring_length - 1;
491 _rl_abort_internal ();
496 /* Yank the COUNTh argument from the previous history line, skipping
497 HISTORY_SKIP lines before looking for the `previous line'. */
499 rl_yank_nth_arg_internal (count, ignore, history_skip)
500 int count, ignore, history_skip;
502 register HIST_ENTRY *entry;
506 pos = where_history ();
510 for (i = 0; i < history_skip; i++)
511 entry = previous_history ();
514 entry = previous_history ();
516 history_set_pos (pos);
524 arg = history_arg_extract (count, count, entry->line);
531 rl_begin_undo_group ();
533 #if defined (VI_MODE)
534 /* Vi mode always inserts a space before yanking the argument, and it
535 inserts it right *after* rl_point. */
536 if (rl_editing_mode == vi_mode)
538 rl_vi_append_mode (1, ignore);
539 rl_insert_text (" ");
543 rl_insert_text (arg);
546 rl_end_undo_group ();
550 /* Yank the COUNTth argument from the previous history line. */
552 rl_yank_nth_arg (count, ignore)
555 return (rl_yank_nth_arg_internal (count, ignore, 0));
558 /* Yank the last argument from the previous history line. This `knows'
559 how rl_yank_nth_arg treats a count of `$'. With an argument, this
560 behaves the same as rl_yank_nth_arg. */
562 rl_yank_last_arg (count, key)
565 static int history_skip = 0;
566 static int explicit_arg_p = 0;
567 static int count_passed = 1;
568 static int direction = 1;
569 static int undo_needed = 0;
572 if (rl_last_func != rl_yank_last_arg)
575 explicit_arg_p = rl_explicit_arg;
576 count_passed = count;
584 direction = -direction;
585 history_skip += direction;
586 if (history_skip < 0)
591 retval = rl_yank_nth_arg_internal (count_passed, key, history_skip);
593 retval = rl_yank_nth_arg_internal ('$', key, history_skip);
595 undo_needed = retval == 0;
599 /* A special paste command for users of Cygnus's cygwin32. */
600 #if defined (__CYGWIN__)
604 rl_paste_from_clipboard (count, key)
610 if (OpenClipboard (NULL) == 0)
613 data = (char *)GetClipboardData (CF_TEXT);
616 ptr = strchr (data, '\r');
620 ptr = (char *)xmalloc (len + 1);
622 strncpy (ptr, data, len);
626 rl_insert_text (ptr);
633 #endif /* __CYGWIN__ */