1: /* kill.c -- kill ring management. */
2:
3: /* Copyright (C) 1994 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 (num)
82: int num;
83: {
84: return 0;
85: }
86:
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. */
91: static int
92: _rl_copy_to_kill_ring (text, append)
93: char *text;
94: int append;
95: {
96: char *old, *new;
97: int slot;
98:
99: /* First, find the slot to work with. */
100: if (_rl_last_command_was_kill == 0)
101: {
102: /* Get a new slot. */
103: if (rl_kill_ring == 0)
104: {
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;
109: }
110: else
111: {
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)
116: {
117: register int i;
118: xfree (rl_kill_ring[0]);
119: for (i = 0; i < slot; i++)
120: rl_kill_ring[i] = rl_kill_ring[i + 1];
121: }
122: else
123: {
124: slot = rl_kill_ring_length += 1;
125: rl_kill_ring = (char **)xrealloc (rl_kill_ring, slot * sizeof (char *));
126: }
127: rl_kill_ring[--slot] = (char *)NULL;
128: }
129: }
130: else
131: slot = rl_kill_ring_length - 1;
132:
133: /* If the last command was a kill, prepend or append. */
134: if (_rl_last_command_was_kill && rl_editing_mode != vi_mode)
135: {
136: old = rl_kill_ring[slot];
137: new = (char *)xmalloc (1 + strlen (old) + strlen (text));
138:
139: if (append)
140: {
141: strcpy (new, old);
142: strcat (new, text);
143: }
144: else
145: {
146: strcpy (new, text);
147: strcat (new, old);
148: }
149: xfree (old);
150: xfree (text);
151: rl_kill_ring[slot] = new;
152: }
153: else
154: rl_kill_ring[slot] = text;
155:
156: rl_kill_index = slot;
157: return 0;
158: }
159:
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
164: this kill. */
165: int
166: rl_kill_text (from, to)
167: int from, to;
168: {
169: char *text;
170:
171: /* Is there anything to kill? */
172: if (from == to)
173: {
174: _rl_last_command_was_kill++;
175: return 0;
176: }
177:
178: text = rl_copy_text (from, to);
179:
180: /* Delete the copied text from the line. */
181: rl_delete_text (from, to);
182:
183: _rl_copy_to_kill_ring (text, from < to);
184:
185: _rl_last_command_was_kill++;
186: return 0;
187: }
188:
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. */
192:
193: /* **************************************************************** */
194: /* */
195: /* Killing Commands */
196: /* */
197: /* **************************************************************** */
198:
199: /* Delete the word at point, saving the text in the kill ring. */
200: int
201: rl_kill_word (count, key)
202: int count, key;
203: {
204: int orig_point;
205:
206: if (count < 0)
207: return (rl_backward_kill_word (-count, key));
208: else
209: {
210: orig_point = rl_point;
211: rl_forward_word (count, key);
212:
213: if (rl_point != orig_point)
214: rl_kill_text (orig_point, rl_point);
215:
216: rl_point = orig_point;
217: if (rl_editing_mode == emacs_mode)
218: rl_mark = rl_point;
219: }
220: return 0;
221: }
222:
223: /* Rubout the word before point, placing it on the kill ring. */
224: int
225: rl_backward_kill_word (count, ignore)
226: int count, ignore;
227: {
228: int orig_point;
229:
230: if (count < 0)
231: return (rl_kill_word (-count, ignore));
232: else
233: {
234: orig_point = rl_point;
235: rl_backward_word (count, ignore);
236:
237: if (rl_point != orig_point)
238: rl_kill_text (orig_point, rl_point);
239:
240: if (rl_editing_mode == emacs_mode)
241: rl_mark = rl_point;
242: }
243: return 0;
244: }
245:
246: /* Kill from here to the end of the line. If DIRECTION is negative, kill
247: back to the line start instead. */
248: int
249: rl_kill_line (direction, ignore)
250: int direction, ignore;
251: {
252: int orig_point;
253:
254: if (direction < 0)
255: return (rl_backward_kill_line (1, ignore));
256: else
257: {
258: orig_point = rl_point;
259: rl_end_of_line (1, ignore);
260: if (orig_point != rl_point)
261: rl_kill_text (orig_point, rl_point);
262: rl_point = orig_point;
263: if (rl_editing_mode == emacs_mode)
264: rl_mark = rl_point;
265: }
266: return 0;
267: }
268:
269: /* Kill backwards to the start of the line. If DIRECTION is negative, kill
270: forwards to the line end instead. */
271: int
272: rl_backward_kill_line (direction, ignore)
273: int direction, ignore;
274: {
275: int orig_point;
276:
277: if (direction < 0)
278: return (rl_kill_line (1, ignore));
279: else
280: {
281: if (!rl_point)
282: rl_ding ();
283: else
284: {
285: orig_point = rl_point;
286: rl_beg_of_line (1, ignore);
287: if (rl_point != orig_point)
288: rl_kill_text (orig_point, rl_point);
289: if (rl_editing_mode == emacs_mode)
290: rl_mark = rl_point;
291: }
292: }
293: return 0;
294: }
295:
296: /* Kill the whole line, no matter where point is. */
297: int
298: rl_kill_full_line (count, ignore)
299: int count, ignore;
300: {
301: rl_begin_undo_group ();
302: rl_point = 0;
303: rl_kill_text (rl_point, rl_end);
304: rl_mark = 0;
305: rl_end_undo_group ();
306: return 0;
307: }
308:
309: /* The next two functions mimic unix line editing behaviour, except they
310: save the deleted text on the kill ring. This is safer than not saving
311: it, and since we have a ring, nobody should get screwed. */
312:
313: /* This does what C-w does in Unix. We can't prevent people from
314: using behaviour that they expect. */
315: int
316: rl_unix_word_rubout (count, key)
317: int count, key;
318: {
319: int orig_point;
320:
321: if (rl_point == 0)
322: rl_ding ();
323: else
324: {
325: orig_point = rl_point;
326: if (count <= 0)
327: count = 1;
328:
329: while (count--)
330: {
331: while (rl_point && whitespace (rl_line_buffer[rl_point - 1]))
332: rl_point--;
333:
334: while (rl_point && (whitespace (rl_line_buffer[rl_point - 1]) == 0))
335: rl_point--;
336: }
337:
338: rl_kill_text (orig_point, rl_point);
339: if (rl_editing_mode == emacs_mode)
340: rl_mark = rl_point;
341: }
342:
343: return 0;
344: }
345:
346: /* This deletes one filename component in a Unix pathname. That is, it
347: deletes backward to directory separator (`/') or whitespace. */
348: int
349: rl_unix_filename_rubout (count, key)
350: int count, key;
351: {
352: int orig_point, c;
353:
354: if (rl_point == 0)
355: rl_ding ();
356: else
357: {
358: orig_point = rl_point;
359: if (count <= 0)
360: count = 1;
361:
362: while (count--)
363: {
364: c = rl_line_buffer[rl_point - 1];
365: while (rl_point && (whitespace (c) || c == '/'))
366: {
367: rl_point--;
368: c = rl_line_buffer[rl_point - 1];
369: }
370:
371: while (rl_point && (whitespace (c) == 0) && c != '/')
372: {
373: rl_point--;
374: c = rl_line_buffer[rl_point - 1];
375: }
376: }
377:
378: rl_kill_text (orig_point, rl_point);
379: if (rl_editing_mode == emacs_mode)
380: rl_mark = rl_point;
381: }
382:
383: return 0;
384: }
385:
386: /* Here is C-u doing what Unix does. You don't *have* to use these
387: key-bindings. We have a choice of killing the entire line, or
388: killing from where we are to the start of the line. We choose the
389: latter, because if you are a Unix weenie, then you haven't backspaced
390: into the line at all, and if you aren't, then you know what you are
391: doing. */
392: int
393: rl_unix_line_discard (count, key)
394: int count, key;
395: {
396: if (rl_point == 0)
397: rl_ding ();
398: else
399: {
400: rl_kill_text (rl_point, 0);
401: rl_point = 0;
402: if (rl_editing_mode == emacs_mode)
403: rl_mark = rl_point;
404: }
405: return 0;
406: }
407:
408: /* Copy the text in the `region' to the kill ring. If DELETE is non-zero,
409: delete the text from the line as well. */
410: static int
411: region_kill_internal (delete)
412: int delete;
413: {
414: char *text;
415:
416: if (rl_mark != rl_point)
417: {
418: text = rl_copy_text (rl_point, rl_mark);
419: if (delete)
420: rl_delete_text (rl_point, rl_mark);
421: _rl_copy_to_kill_ring (text, rl_point < rl_mark);
422: }
423:
424: _rl_last_command_was_kill++;
425: return 0;
426: }
427:
428: /* Copy the text in the region to the kill ring. */
429: int
430: rl_copy_region_to_kill (count, ignore)
431: int count, ignore;
432: {
433: return (region_kill_internal (0));
434: }
435:
436: /* Kill the text between the point and mark. */
437: int
438: rl_kill_region (count, ignore)
439: int count, ignore;
440: {
441: int r, npoint;
442:
443: npoint = (rl_point < rl_mark) ? rl_point : rl_mark;
444: r = region_kill_internal (1);
445: _rl_fix_point (1);
446: rl_point = npoint;
447: return r;
448: }
449:
450: /* Copy COUNT words to the kill ring. DIR says which direction we look
451: to find the words. */
452: static int
453: _rl_copy_word_as_kill (count, dir)
454: int count, dir;
455: {
456: int om, op, r;
457:
458: om = rl_mark;
459: op = rl_point;
460:
461: if (dir > 0)
462: rl_forward_word (count, 0);
463: else
464: rl_backward_word (count, 0);
465:
466: rl_mark = rl_point;
467:
468: if (dir > 0)
469: rl_backward_word (count, 0);
470: else
471: rl_forward_word (count, 0);
472:
473: r = region_kill_internal (0);
474:
475: rl_mark = om;
476: rl_point = op;
477:
478: return r;
479: }
480:
481: int
482: rl_copy_forward_word (count, key)
483: int count, key;
484: {
485: if (count < 0)
486: return (rl_copy_backward_word (-count, key));
487:
488: return (_rl_copy_word_as_kill (count, 1));
489: }
490:
491: int
492: rl_copy_backward_word (count, key)
493: int count, key;
494: {
495: if (count < 0)
496: return (rl_copy_forward_word (-count, key));
497:
498: return (_rl_copy_word_as_kill (count, -1));
499: }
500:
501: /* Yank back the last killed text. This ignores arguments. */
502: int
503: rl_yank (count, ignore)
504: int count, ignore;
505: {
506: if (rl_kill_ring == 0)
507: {
508: _rl_abort_internal ();
509: return -1;
510: }
511:
512: _rl_set_mark_at_pos (rl_point);
513: rl_insert_text (rl_kill_ring[rl_kill_index]);
514: return 0;
515: }
516:
517: /* If the last command was yank, or yank_pop, and the text just
518: before point is identical to the current kill item, then
519: delete that text from the line, rotate the index down, and
520: yank back some other text. */
521: int
522: rl_yank_pop (count, key)
523: int count, key;
524: {
525: int l, n;
526:
527: if (((rl_last_func != rl_yank_pop) && (rl_last_func != rl_yank)) ||
528: !rl_kill_ring)
529: {
530: _rl_abort_internal ();
531: return -1;
532: }
533:
534: l = strlen (rl_kill_ring[rl_kill_index]);
535: n = rl_point - l;
536: if (n >= 0 && STREQN (rl_line_buffer + n, rl_kill_ring[rl_kill_index], l))
537: {
538: rl_delete_text (n, rl_point);
539: rl_point = n;
540: rl_kill_index--;
541: if (rl_kill_index < 0)
542: rl_kill_index = rl_kill_ring_length - 1;
543: rl_yank (1, 0);
544: return 0;
545: }
546: else
547: {
548: _rl_abort_internal ();
549: return -1;
550: }
551: }
552:
553: /* Yank the COUNTh argument from the previous history line, skipping
554: HISTORY_SKIP lines before looking for the `previous line'. */
555: static int
556: rl_yank_nth_arg_internal (count, ignore, history_skip)
557: int count, ignore, history_skip;
558: {
559: register HIST_ENTRY *entry;
560: char *arg;
561: int i, pos;
562:
563: pos = where_history ();
564:
565: if (history_skip)
566: {
567: for (i = 0; i < history_skip; i++)
568: entry = previous_history ();
569: }
570:
571: entry = previous_history ();
572:
573: history_set_pos (pos);
574:
575: if (entry == 0)
576: {
577: rl_ding ();
578: return -1;
579: }
580:
581: arg = history_arg_extract (count, count, entry->line);
582: if (!arg || !*arg)
583: {
584: rl_ding ();
585: FREE (arg);
586: return -1;
587: }
588:
589: rl_begin_undo_group ();
590:
591: _rl_set_mark_at_pos (rl_point);
592:
593: #if defined (VI_MODE)
594: /* Vi mode always inserts a space before yanking the argument, and it
595: inserts it right *after* rl_point. */
596: if (rl_editing_mode == vi_mode)
597: {
598: rl_vi_append_mode (1, ignore);
599: rl_insert_text (" ");
600: }
601: #endif /* VI_MODE */
602:
603: rl_insert_text (arg);
604: xfree (arg);
605:
606: rl_end_undo_group ();
607: return 0;
608: }
609:
610: /* Yank the COUNTth argument from the previous history line. */
611: int
612: rl_yank_nth_arg (count, ignore)
613: int count, ignore;
614: {
615: return (rl_yank_nth_arg_internal (count, ignore, 0));
616: }
617:
618: /* Yank the last argument from the previous history line. This `knows'
619: how rl_yank_nth_arg treats a count of `$'. With an argument, this
620: behaves the same as rl_yank_nth_arg. */
621: int
622: rl_yank_last_arg (count, key)
623: int count, key;
624: {
625: static int history_skip = 0;
626: static int explicit_arg_p = 0;
627: static int count_passed = 1;
628: static int direction = 1;
629: static int undo_needed = 0;
630: int retval;
631:
632: if (rl_last_func != rl_yank_last_arg)
633: {
634: history_skip = 0;
635: explicit_arg_p = rl_explicit_arg;
636: count_passed = count;
637: direction = 1;
638: }
639: else
640: {
641: if (undo_needed)
642: rl_do_undo ();
643: if (count < 0) /* XXX - was < 1 */
644: direction = -direction;
645: history_skip += direction;
646: if (history_skip < 0)
647: history_skip = 0;
648: }
649:
650: if (explicit_arg_p)
651: retval = rl_yank_nth_arg_internal (count_passed, key, history_skip);
652: else
653: retval = rl_yank_nth_arg_internal ('$', key, history_skip);
654:
655: undo_needed = retval == 0;
656: return retval;
657: }
658:
659: /* A special paste command for users of Cygnus's cygwin32. */
660: #if defined (__CYGWIN__)
661: #include <windows.h>
662:
663: int
664: rl_paste_from_clipboard (count, key)
665: int count, key;
666: {
667: char *data, *ptr;
668: int len;
669:
670: if (OpenClipboard (NULL) == 0)
671: return (0);
672:
673: data = (char *)GetClipboardData (CF_TEXT);
674: if (data)
675: {
676: ptr = strchr (data, '\r');
677: if (ptr)
678: {
679: len = ptr - data;
680: ptr = (char *)xmalloc (len + 1);
681: ptr[len] = '\0';
682: strncpy (ptr, data, len);
683: }
684: else
685: ptr = data;
686: _rl_set_mark_at_pos (rl_point);
687: rl_insert_text (ptr);
688: if (ptr != data)
689: xfree (ptr);
690: CloseClipboard ();
691: }
692: return (0);
693: }
694: #endif /* __CYGWIN__ */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to kill.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / readline