Move readline to the readline/readline subdirectory
[deliverable/binutils-gdb.git] / readline / readline / kill.c
1 /* kill.c -- kill ring management. */
2
3 /* Copyright (C) 1994-2017 Free Software Foundation, Inc.
4
5 This file is part of the GNU Readline Library (Readline), a library
6 for reading lines of text with interactive input and history editing.
7
8 Readline is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
12
13 Readline is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with Readline. If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #define READLINE_LIBRARY
23
24 #if defined (HAVE_CONFIG_H)
25 # include <config.h>
26 #endif
27
28 #include <sys/types.h>
29
30 #if defined (HAVE_UNISTD_H)
31 # include <unistd.h> /* for _POSIX_VERSION */
32 #endif /* HAVE_UNISTD_H */
33
34 #if defined (HAVE_STDLIB_H)
35 # include <stdlib.h>
36 #else
37 # include "ansi_stdlib.h"
38 #endif /* HAVE_STDLIB_H */
39
40 #include <stdio.h>
41
42 /* System-specific feature definitions and include files. */
43 #include "rldefs.h"
44
45 /* Some standard library routines. */
46 #include "readline.h"
47 #include "history.h"
48
49 #include "rlprivate.h"
50 #include "xmalloc.h"
51
52 /* **************************************************************** */
53 /* */
54 /* Killing Mechanism */
55 /* */
56 /* **************************************************************** */
57
58 /* What we assume for a max number of kills. */
59 #define DEFAULT_MAX_KILLS 10
60
61 /* The real variable to look at to find out when to flush kills. */
62 static int rl_max_kills = DEFAULT_MAX_KILLS;
63
64 /* Where to store killed text. */
65 static char **rl_kill_ring = (char **)NULL;
66
67 /* Where we are in the kill ring. */
68 static int rl_kill_index;
69
70 /* How many slots we have in the kill ring. */
71 static int rl_kill_ring_length;
72
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));
77
78 /* How to say that you only want to save a certain amount
79 of kill material. */
80 int
81 rl_set_retained_kills (int num)
82 {
83 return 0;
84 }
85
86 /* Add TEXT to the kill ring, allocating a new kill ring slot as necessary.
87 This uses TEXT directly, so the caller must not free it. If APPEND is
88 non-zero, and the last command was a kill, the text is appended to the
89 current kill ring slot, otherwise prepended. */
90 static int
91 _rl_copy_to_kill_ring (char *text, int append)
92 {
93 char *old, *new;
94 int slot;
95
96 /* First, find the slot to work with. */
97 if (_rl_last_command_was_kill == 0 || rl_kill_ring == 0)
98 {
99 /* Get a new slot. */
100 if (rl_kill_ring == 0)
101 {
102 /* If we don't have any defined, then make one. */
103 rl_kill_ring = (char **)
104 xmalloc (((rl_kill_ring_length = 1) + 1) * sizeof (char *));
105 rl_kill_ring[slot = 0] = (char *)NULL;
106 }
107 else
108 {
109 /* We have to add a new slot on the end, unless we have
110 exceeded the max limit for remembering kills. */
111 slot = rl_kill_ring_length;
112 if (slot == rl_max_kills)
113 {
114 register int i;
115 xfree (rl_kill_ring[0]);
116 for (i = 0; i < slot; i++)
117 rl_kill_ring[i] = rl_kill_ring[i + 1];
118 }
119 else
120 {
121 slot = rl_kill_ring_length += 1;
122 rl_kill_ring = (char **)xrealloc (rl_kill_ring, (slot + 1) * sizeof (char *));
123 }
124 rl_kill_ring[--slot] = (char *)NULL;
125 }
126 }
127 else
128 slot = rl_kill_ring_length - 1;
129
130 /* If the last command was a kill, prepend or append. */
131 if (_rl_last_command_was_kill && rl_kill_ring[slot] && rl_editing_mode != vi_mode)
132 {
133 old = rl_kill_ring[slot];
134 new = (char *)xmalloc (1 + strlen (old) + strlen (text));
135
136 if (append)
137 {
138 strcpy (new, old);
139 strcat (new, text);
140 }
141 else
142 {
143 strcpy (new, text);
144 strcat (new, old);
145 }
146 xfree (old);
147 xfree (text);
148 rl_kill_ring[slot] = new;
149 }
150 else
151 rl_kill_ring[slot] = text;
152
153 rl_kill_index = slot;
154 return 0;
155 }
156
157 /* The way to kill something. This appends or prepends to the last
158 kill, if the last command was a kill command. if FROM is less
159 than TO, then the text is appended, otherwise prepended. If the
160 last command was not a kill command, then a new slot is made for
161 this kill. */
162 int
163 rl_kill_text (int from, int to)
164 {
165 char *text;
166
167 /* Is there anything to kill? */
168 if (from == to)
169 {
170 _rl_last_command_was_kill++;
171 return 0;
172 }
173
174 text = rl_copy_text (from, to);
175
176 /* Delete the copied text from the line. */
177 rl_delete_text (from, to);
178
179 _rl_copy_to_kill_ring (text, from < to);
180
181 _rl_last_command_was_kill++;
182 return 0;
183 }
184
185 /* Now REMEMBER! In order to do prepending or appending correctly, kill
186 commands always make rl_point's original position be the FROM argument,
187 and rl_point's extent be the TO argument. */
188
189 /* **************************************************************** */
190 /* */
191 /* Killing Commands */
192 /* */
193 /* **************************************************************** */
194
195 /* Delete the word at point, saving the text in the kill ring. */
196 int
197 rl_kill_word (int count, int key)
198 {
199 int orig_point;
200
201 if (count < 0)
202 return (rl_backward_kill_word (-count, key));
203 else
204 {
205 orig_point = rl_point;
206 rl_forward_word (count, key);
207
208 if (rl_point != orig_point)
209 rl_kill_text (orig_point, rl_point);
210
211 rl_point = orig_point;
212 if (rl_editing_mode == emacs_mode)
213 rl_mark = rl_point;
214 }
215 return 0;
216 }
217
218 /* Rubout the word before point, placing it on the kill ring. */
219 int
220 rl_backward_kill_word (int count, int key)
221 {
222 int orig_point;
223
224 if (count < 0)
225 return (rl_kill_word (-count, key));
226 else
227 {
228 orig_point = rl_point;
229 rl_backward_word (count, key);
230
231 if (rl_point != orig_point)
232 rl_kill_text (orig_point, rl_point);
233
234 if (rl_editing_mode == emacs_mode)
235 rl_mark = rl_point;
236 }
237 return 0;
238 }
239
240 /* Kill from here to the end of the line. If DIRECTION is negative, kill
241 back to the line start instead. */
242 int
243 rl_kill_line (int direction, int key)
244 {
245 int orig_point;
246
247 if (direction < 0)
248 return (rl_backward_kill_line (1, key));
249 else
250 {
251 orig_point = rl_point;
252 rl_end_of_line (1, key);
253 if (orig_point != rl_point)
254 rl_kill_text (orig_point, rl_point);
255 rl_point = orig_point;
256 if (rl_editing_mode == emacs_mode)
257 rl_mark = rl_point;
258 }
259 return 0;
260 }
261
262 /* Kill backwards to the start of the line. If DIRECTION is negative, kill
263 forwards to the line end instead. */
264 int
265 rl_backward_kill_line (int direction, int key)
266 {
267 int orig_point;
268
269 if (direction < 0)
270 return (rl_kill_line (1, key));
271 else
272 {
273 if (rl_point == 0)
274 rl_ding ();
275 else
276 {
277 orig_point = rl_point;
278 rl_beg_of_line (1, key);
279 if (rl_point != orig_point)
280 rl_kill_text (orig_point, rl_point);
281 if (rl_editing_mode == emacs_mode)
282 rl_mark = rl_point;
283 }
284 }
285 return 0;
286 }
287
288 /* Kill the whole line, no matter where point is. */
289 int
290 rl_kill_full_line (int count, int key)
291 {
292 rl_begin_undo_group ();
293 rl_point = 0;
294 rl_kill_text (rl_point, rl_end);
295 rl_mark = 0;
296 rl_end_undo_group ();
297 return 0;
298 }
299
300 /* The next two functions mimic unix line editing behaviour, except they
301 save the deleted text on the kill ring. This is safer than not saving
302 it, and since we have a ring, nobody should get screwed. */
303
304 /* This does what C-w does in Unix. We can't prevent people from
305 using behaviour that they expect. */
306 int
307 rl_unix_word_rubout (int count, int key)
308 {
309 int orig_point;
310
311 if (rl_point == 0)
312 rl_ding ();
313 else
314 {
315 orig_point = rl_point;
316 if (count <= 0)
317 count = 1;
318
319 while (count--)
320 {
321 while (rl_point && whitespace (rl_line_buffer[rl_point - 1]))
322 rl_point--;
323
324 while (rl_point && (whitespace (rl_line_buffer[rl_point - 1]) == 0))
325 rl_point--; /* XXX - multibyte? */
326 }
327
328 rl_kill_text (orig_point, rl_point);
329 if (rl_editing_mode == emacs_mode)
330 rl_mark = rl_point;
331 }
332
333 return 0;
334 }
335
336 /* This deletes one filename component in a Unix pathname. That is, it
337 deletes backward to directory separator (`/') or whitespace. */
338 int
339 rl_unix_filename_rubout (int count, int key)
340 {
341 int orig_point, c;
342
343 if (rl_point == 0)
344 rl_ding ();
345 else
346 {
347 orig_point = rl_point;
348 if (count <= 0)
349 count = 1;
350
351 while (count--)
352 {
353 c = rl_line_buffer[rl_point - 1];
354 while (rl_point && (whitespace (c) || c == '/'))
355 {
356 rl_point--;
357 c = rl_line_buffer[rl_point - 1];
358 }
359
360 while (rl_point && (whitespace (c) == 0) && c != '/')
361 {
362 rl_point--; /* XXX - multibyte? */
363 c = rl_line_buffer[rl_point - 1];
364 }
365 }
366
367 rl_kill_text (orig_point, rl_point);
368 if (rl_editing_mode == emacs_mode)
369 rl_mark = rl_point;
370 }
371
372 return 0;
373 }
374
375 /* Here is C-u doing what Unix does. You don't *have* to use these
376 key-bindings. We have a choice of killing the entire line, or
377 killing from where we are to the start of the line. We choose the
378 latter, because if you are a Unix weenie, then you haven't backspaced
379 into the line at all, and if you aren't, then you know what you are
380 doing. */
381 int
382 rl_unix_line_discard (int count, int key)
383 {
384 if (rl_point == 0)
385 rl_ding ();
386 else
387 {
388 rl_kill_text (rl_point, 0);
389 rl_point = 0;
390 if (rl_editing_mode == emacs_mode)
391 rl_mark = rl_point;
392 }
393 return 0;
394 }
395
396 /* Copy the text in the `region' to the kill ring. If DELETE is non-zero,
397 delete the text from the line as well. */
398 static int
399 region_kill_internal (int delete)
400 {
401 char *text;
402
403 if (rl_mark != rl_point)
404 {
405 text = rl_copy_text (rl_point, rl_mark);
406 if (delete)
407 rl_delete_text (rl_point, rl_mark);
408 _rl_copy_to_kill_ring (text, rl_point < rl_mark);
409 }
410
411 _rl_last_command_was_kill++;
412 return 0;
413 }
414
415 /* Copy the text in the region to the kill ring. */
416 int
417 rl_copy_region_to_kill (int count, int key)
418 {
419 return (region_kill_internal (0));
420 }
421
422 /* Kill the text between the point and mark. */
423 int
424 rl_kill_region (int count, int key)
425 {
426 int r, npoint;
427
428 npoint = (rl_point < rl_mark) ? rl_point : rl_mark;
429 r = region_kill_internal (1);
430 _rl_fix_point (1);
431 rl_point = npoint;
432 return r;
433 }
434
435 /* Copy COUNT words to the kill ring. DIR says which direction we look
436 to find the words. */
437 static int
438 _rl_copy_word_as_kill (int count, int dir)
439 {
440 int om, op, r;
441
442 om = rl_mark;
443 op = rl_point;
444
445 if (dir > 0)
446 rl_forward_word (count, 0);
447 else
448 rl_backward_word (count, 0);
449
450 rl_mark = rl_point;
451
452 if (dir > 0)
453 rl_backward_word (count, 0);
454 else
455 rl_forward_word (count, 0);
456
457 r = region_kill_internal (0);
458
459 rl_mark = om;
460 rl_point = op;
461
462 return r;
463 }
464
465 int
466 rl_copy_forward_word (int count, int key)
467 {
468 if (count < 0)
469 return (rl_copy_backward_word (-count, key));
470
471 return (_rl_copy_word_as_kill (count, 1));
472 }
473
474 int
475 rl_copy_backward_word (int count, int key)
476 {
477 if (count < 0)
478 return (rl_copy_forward_word (-count, key));
479
480 return (_rl_copy_word_as_kill (count, -1));
481 }
482
483 /* Yank back the last killed text. This ignores arguments. */
484 int
485 rl_yank (int count, int key)
486 {
487 if (rl_kill_ring == 0)
488 {
489 _rl_abort_internal ();
490 return 1;
491 }
492
493 _rl_set_mark_at_pos (rl_point);
494 rl_insert_text (rl_kill_ring[rl_kill_index]);
495 return 0;
496 }
497
498 /* If the last command was yank, or yank_pop, and the text just
499 before point is identical to the current kill item, then
500 delete that text from the line, rotate the index down, and
501 yank back some other text. */
502 int
503 rl_yank_pop (int count, int key)
504 {
505 int l, n;
506
507 if (((rl_last_func != rl_yank_pop) && (rl_last_func != rl_yank)) ||
508 !rl_kill_ring)
509 {
510 _rl_abort_internal ();
511 return 1;
512 }
513
514 l = strlen (rl_kill_ring[rl_kill_index]);
515 n = rl_point - l;
516 if (n >= 0 && STREQN (rl_line_buffer + n, rl_kill_ring[rl_kill_index], l))
517 {
518 rl_delete_text (n, rl_point);
519 rl_point = n;
520 rl_kill_index--;
521 if (rl_kill_index < 0)
522 rl_kill_index = rl_kill_ring_length - 1;
523 rl_yank (1, 0);
524 return 0;
525 }
526 else
527 {
528 _rl_abort_internal ();
529 return 1;
530 }
531 }
532
533 #if defined (VI_MODE)
534 int
535 rl_vi_yank_pop (int count, int key)
536 {
537 int l, n;
538
539 if (((rl_last_func != rl_vi_yank_pop) && (rl_last_func != rl_vi_put)) ||
540 !rl_kill_ring)
541 {
542 _rl_abort_internal ();
543 return 1;
544 }
545
546 l = strlen (rl_kill_ring[rl_kill_index]);
547 n = rl_point - l;
548 if (n >= 0 && STREQN (rl_line_buffer + n, rl_kill_ring[rl_kill_index], l))
549 {
550 rl_delete_text (n, rl_point);
551 rl_point = n;
552 rl_kill_index--;
553 if (rl_kill_index < 0)
554 rl_kill_index = rl_kill_ring_length - 1;
555 rl_vi_put (1, 'p');
556 return 0;
557 }
558 else
559 {
560 _rl_abort_internal ();
561 return 1;
562 }
563 }
564 #endif /* VI_MODE */
565
566 /* Yank the COUNTh argument from the previous history line, skipping
567 HISTORY_SKIP lines before looking for the `previous line'. */
568 static int
569 rl_yank_nth_arg_internal (int count, int key, int history_skip)
570 {
571 register HIST_ENTRY *entry;
572 char *arg;
573 int i, pos;
574
575 pos = where_history ();
576
577 if (history_skip)
578 {
579 for (i = 0; i < history_skip; i++)
580 entry = previous_history ();
581 }
582
583 entry = previous_history ();
584
585 history_set_pos (pos);
586
587 if (entry == 0)
588 {
589 rl_ding ();
590 return 1;
591 }
592
593 arg = history_arg_extract (count, count, entry->line);
594 if (!arg || !*arg)
595 {
596 rl_ding ();
597 FREE (arg);
598 return 1;
599 }
600
601 rl_begin_undo_group ();
602
603 _rl_set_mark_at_pos (rl_point);
604
605 #if defined (VI_MODE)
606 /* Vi mode always inserts a space before yanking the argument, and it
607 inserts it right *after* rl_point. */
608 if (rl_editing_mode == vi_mode)
609 {
610 rl_vi_append_mode (1, key);
611 rl_insert_text (" ");
612 }
613 #endif /* VI_MODE */
614
615 rl_insert_text (arg);
616 xfree (arg);
617
618 rl_end_undo_group ();
619 return 0;
620 }
621
622 /* Yank the COUNTth argument from the previous history line. */
623 int
624 rl_yank_nth_arg (int count, int key)
625 {
626 return (rl_yank_nth_arg_internal (count, key, 0));
627 }
628
629 /* Yank the last argument from the previous history line. This `knows'
630 how rl_yank_nth_arg treats a count of `$'. With an argument, this
631 behaves the same as rl_yank_nth_arg. */
632 int
633 rl_yank_last_arg (int count, int key)
634 {
635 static int history_skip = 0;
636 static int explicit_arg_p = 0;
637 static int count_passed = 1;
638 static int direction = 1;
639 static int undo_needed = 0;
640 int retval;
641
642 if (rl_last_func != rl_yank_last_arg)
643 {
644 history_skip = 0;
645 explicit_arg_p = rl_explicit_arg;
646 count_passed = count;
647 direction = 1;
648 }
649 else
650 {
651 if (undo_needed)
652 rl_do_undo ();
653 if (count < 0) /* XXX - was < 1 */
654 direction = -direction;
655 history_skip += direction;
656 if (history_skip < 0)
657 history_skip = 0;
658 }
659
660 if (explicit_arg_p)
661 retval = rl_yank_nth_arg_internal (count_passed, key, history_skip);
662 else
663 retval = rl_yank_nth_arg_internal ('$', key, history_skip);
664
665 undo_needed = retval == 0;
666 return retval;
667 }
668
669 /* Having read the special escape sequence denoting the beginning of a
670 `bracketed paste' sequence, read the rest of the pasted input until the
671 closing sequence and insert the pasted text as a single unit without
672 interpretation. */
673 char *
674 _rl_bracketed_text (size_t *lenp)
675 {
676 int c;
677 size_t len, cap;
678 char *buf;
679
680 len = 0;
681 buf = xmalloc (cap = 64);
682 buf[0] = '\0';
683
684 RL_SETSTATE (RL_STATE_MOREINPUT);
685 while ((c = rl_read_key ()) >= 0)
686 {
687 if (RL_ISSTATE (RL_STATE_MACRODEF))
688 _rl_add_macro_char (c);
689
690 if (c == '\r') /* XXX */
691 c = '\n';
692
693 if (len == cap)
694 buf = xrealloc (buf, cap *= 2);
695
696 buf[len++] = c;
697 if (len >= BRACK_PASTE_SLEN && c == BRACK_PASTE_LAST &&
698 STREQN (buf + len - BRACK_PASTE_SLEN, BRACK_PASTE_SUFF, BRACK_PASTE_SLEN))
699 {
700 len -= BRACK_PASTE_SLEN;
701 break;
702 }
703 }
704 RL_UNSETSTATE (RL_STATE_MOREINPUT);
705
706 if (c >= 0)
707 {
708 if (len == cap)
709 buf = xrealloc (buf, cap + 1);
710 buf[len] = '\0';
711 }
712
713 if (lenp)
714 *lenp = len;
715 return (buf);
716 }
717
718 int
719 rl_bracketed_paste_begin (int count, int key)
720 {
721 int retval, c;
722 size_t len, cap;
723 char *buf;
724
725 buf = _rl_bracketed_text (&len);
726 retval = rl_insert_text (buf) == len ? 0 : 1;
727
728 xfree (buf);
729 return (retval);
730 }
731
732 /* A special paste command for Windows users. */
733 #if defined (_WIN32)
734 #include <windows.h>
735
736 int
737 rl_paste_from_clipboard (int count, int key)
738 {
739 char *data, *ptr;
740 int len;
741
742 if (OpenClipboard (NULL) == 0)
743 return (0);
744
745 data = (char *)GetClipboardData (CF_TEXT);
746 if (data)
747 {
748 ptr = strchr (data, '\r');
749 if (ptr)
750 {
751 len = ptr - data;
752 ptr = (char *)xmalloc (len + 1);
753 ptr[len] = '\0';
754 strncpy (ptr, data, len);
755 }
756 else
757 ptr = data;
758 _rl_set_mark_at_pos (rl_point);
759 rl_insert_text (ptr);
760 if (ptr != data)
761 xfree (ptr);
762 CloseClipboard ();
763 }
764 return (0);
765 }
766 #endif /* _WIN32 */
This page took 0.056431 seconds and 4 git commands to generate.