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__ */ 695