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, a library for 6 reading lines of text with interactive input and history editing. 7 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. 12 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. 17 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 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. */ 62static int rl_max_kills = DEFAULT_MAX_KILLS; 63 64/* Where to store killed text. */ 65static char **rl_kill_ring = (char **)NULL; 66 67/* Where we are in the kill ring. */ 68static int rl_kill_index; 69 70/* How many slots we have in the kill ring. */ 71static int rl_kill_ring_length; 72 73static int _rl_copy_to_kill_ring PARAMS((char *, int)); 74static int region_kill_internal PARAMS((int)); 75static int _rl_copy_word_as_kill PARAMS((int, int)); 76static 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. */ 80int 81rl_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. */ 91static 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 free (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 free (old); 150 free (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. */ 165int 166rl_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. */ 200int 201rl_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. */ 224int 225rl_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. */ 248int 249rl_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. */ 271int 272rl_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. */ 297int 298rl_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. */ 315int 316rl_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 return 0; 343} 344 345/* Here is C-u doing what Unix does. You don't *have* to use these 346 key-bindings. We have a choice of killing the entire line, or 347 killing from where we are to the start of the line. We choose the 348 latter, because if you are a Unix weenie, then you haven't backspaced 349 into the line at all, and if you aren't, then you know what you are 350 doing. */ 351int 352rl_unix_line_discard (count, key) 353 int count, key; 354{ 355 if (rl_point == 0) 356 rl_ding (); 357 else 358 { 359 rl_kill_text (rl_point, 0); 360 rl_point = 0; 361 if (rl_editing_mode == emacs_mode) 362 rl_mark = rl_point; 363 } 364 return 0; 365} 366 367/* Copy the text in the `region' to the kill ring. If DELETE is non-zero, 368 delete the text from the line as well. */ 369static int 370region_kill_internal (delete) 371 int delete; 372{ 373 char *text; 374 375 if (rl_mark != rl_point) 376 { 377 text = rl_copy_text (rl_point, rl_mark); 378 if (delete) 379 rl_delete_text (rl_point, rl_mark); 380 _rl_copy_to_kill_ring (text, rl_point < rl_mark); 381 } 382 383 _rl_last_command_was_kill++; 384 return 0; 385} 386 387/* Copy the text in the region to the kill ring. */ 388int 389rl_copy_region_to_kill (count, ignore) 390 int count, ignore; 391{ 392 return (region_kill_internal (0)); 393} 394 395/* Kill the text between the point and mark. */ 396int 397rl_kill_region (count, ignore) 398 int count, ignore; 399{ 400 int r, npoint; 401 402 npoint = (rl_point < rl_mark) ? rl_point : rl_mark; 403 r = region_kill_internal (1); 404 _rl_fix_point (1); 405 rl_point = npoint; 406 return r; 407} 408 409/* Copy COUNT words to the kill ring. DIR says which direction we look 410 to find the words. */ 411static int 412_rl_copy_word_as_kill (count, dir) 413 int count, dir; 414{ 415 int om, op, r; 416 417 om = rl_mark; 418 op = rl_point; 419 420 if (dir > 0) 421 rl_forward_word (count, 0); 422 else 423 rl_backward_word (count, 0); 424 425 rl_mark = rl_point; 426 427 if (dir > 0) 428 rl_backward_word (count, 0); 429 else 430 rl_forward_word (count, 0); 431 432 r = region_kill_internal (0); 433 434 rl_mark = om; 435 rl_point = op; 436 437 return r; 438} 439 440int 441rl_copy_forward_word (count, key) 442 int count, key; 443{ 444 if (count < 0) 445 return (rl_copy_backward_word (-count, key)); 446 447 return (_rl_copy_word_as_kill (count, 1)); 448} 449 450int 451rl_copy_backward_word (count, key) 452 int count, key; 453{ 454 if (count < 0) 455 return (rl_copy_forward_word (-count, key)); 456 457 return (_rl_copy_word_as_kill (count, -1)); 458} 459 460/* Yank back the last killed text. This ignores arguments. */ 461int 462rl_yank (count, ignore) 463 int count, ignore; 464{ 465 if (rl_kill_ring == 0) 466 { 467 _rl_abort_internal (); 468 return -1; 469 } 470 471 _rl_set_mark_at_pos (rl_point); 472 rl_insert_text (rl_kill_ring[rl_kill_index]); 473 return 0; 474} 475 476/* If the last command was yank, or yank_pop, and the text just 477 before point is identical to the current kill item, then 478 delete that text from the line, rotate the index down, and 479 yank back some other text. */ 480int 481rl_yank_pop (count, key) 482 int count, key; 483{ 484 int l, n; 485 486 if (((rl_last_func != rl_yank_pop) && (rl_last_func != rl_yank)) || 487 !rl_kill_ring) 488 { 489 _rl_abort_internal (); 490 return -1; 491 } 492 493 l = strlen (rl_kill_ring[rl_kill_index]); 494 n = rl_point - l; 495 if (n >= 0 && STREQN (rl_line_buffer + n, rl_kill_ring[rl_kill_index], l)) 496 { 497 rl_delete_text (n, rl_point); 498 rl_point = n; 499 rl_kill_index--; 500 if (rl_kill_index < 0) 501 rl_kill_index = rl_kill_ring_length - 1; 502 rl_yank (1, 0); 503 return 0; 504 } 505 else 506 { 507 _rl_abort_internal (); 508 return -1; 509 } 510} 511 512/* Yank the COUNTh argument from the previous history line, skipping 513 HISTORY_SKIP lines before looking for the `previous line'. */ 514static int 515rl_yank_nth_arg_internal (count, ignore, history_skip) 516 int count, ignore, history_skip; 517{ 518 register HIST_ENTRY *entry; 519 char *arg; 520 int i, pos; 521 522 pos = where_history (); 523 524 if (history_skip) 525 { 526 for (i = 0; i < history_skip; i++) 527 entry = previous_history (); 528 } 529 530 entry = previous_history (); 531 532 history_set_pos (pos); 533 534 if (entry == 0) 535 { 536 rl_ding (); 537 return -1; 538 } 539 540 arg = history_arg_extract (count, count, entry->line); 541 if (!arg || !*arg) 542 { 543 rl_ding (); 544 return -1; 545 } 546 547 rl_begin_undo_group (); 548 549 _rl_set_mark_at_pos (rl_point); 550 551#if defined (VI_MODE) 552 /* Vi mode always inserts a space before yanking the argument, and it 553 inserts it right *after* rl_point. */ 554 if (rl_editing_mode == vi_mode) 555 { 556 rl_vi_append_mode (1, ignore); 557 rl_insert_text (" "); 558 } 559#endif /* VI_MODE */ 560 561 rl_insert_text (arg); 562 free (arg); 563 564 rl_end_undo_group (); 565 return 0; 566} 567 568/* Yank the COUNTth argument from the previous history line. */ 569int 570rl_yank_nth_arg (count, ignore) 571 int count, ignore; 572{ 573 return (rl_yank_nth_arg_internal (count, ignore, 0)); 574} 575 576/* Yank the last argument from the previous history line. This `knows' 577 how rl_yank_nth_arg treats a count of `$'. With an argument, this 578 behaves the same as rl_yank_nth_arg. */ 579int 580rl_yank_last_arg (count, key) 581 int count, key; 582{ 583 static int history_skip = 0; 584 static int explicit_arg_p = 0; 585 static int count_passed = 1; 586 static int direction = 1; 587 static int undo_needed = 0; 588 int retval; 589 590 if (rl_last_func != rl_yank_last_arg) 591 { 592 history_skip = 0; 593 explicit_arg_p = rl_explicit_arg; 594 count_passed = count; 595 direction = 1; 596 } 597 else 598 { 599 if (undo_needed) 600 rl_do_undo (); 601 if (count < 1) 602 direction = -direction; 603 history_skip += direction; 604 if (history_skip < 0) 605 history_skip = 0; 606 } 607 608 if (explicit_arg_p) 609 retval = rl_yank_nth_arg_internal (count_passed, key, history_skip); 610 else 611 retval = rl_yank_nth_arg_internal ('$', key, history_skip); 612 613 undo_needed = retval == 0; 614 return retval; 615} 616 617/* A special paste command for users of Cygnus's cygwin32. */ 618#if defined (__CYGWIN__) 619#include <windows.h> 620 621int 622rl_paste_from_clipboard (count, key) 623 int count, key; 624{ 625 char *data, *ptr; 626 int len; 627 628 if (OpenClipboard (NULL) == 0) 629 return (0); 630 631 data = (char *)GetClipboardData (CF_TEXT); 632 if (data) 633 { 634 ptr = strchr (data, '\r'); 635 if (ptr) 636 { 637 len = ptr - data; 638 ptr = (char *)xmalloc (len + 1); 639 ptr[len] = '\0'; 640 strncpy (ptr, data, len); 641 } 642 else 643 ptr = data; 644 _rl_set_mark_at_pos (rl_point); 645 rl_insert_text (ptr); 646 if (ptr != data) 647 free (ptr); 648 CloseClipboard (); 649 } 650 return (0); 651} 652#endif /* __CYGWIN__ */ 653