lib/readline/kill.c

   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. */
  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               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. */
 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   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. */
 351 int
 352 rl_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. */
 369 static int
 370 region_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. */
 388 int
 389 rl_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. */
 396 int
 397 rl_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. */
 411 static 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
 440 int
 441 rl_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
 450 int
 451 rl_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. */
 461 int
 462 rl_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. */
 480 int
 481 rl_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'. */
 514 static int
 515 rl_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. */
 569 int
 570 rl_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. */
 579 int
 580 rl_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
 621 int
 622 rl_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__ */