home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 22 gnu / 22-gnu.zip / readline.zip / readline-2.1 / kill.c < prev    next >
C/C++ Source or Header  |  1997-04-02  |  13KB  |  553 lines
  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 1, 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.    675 Mass Ave, Cambridge, MA 02139, 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. extern int _rl_last_command_was_kill;
  50. extern int rl_editing_mode;
  51. extern int rl_explicit_arg;
  52. extern Function *rl_last_func;
  53.  
  54. extern void _rl_init_argument ();
  55. extern int _rl_set_mark_at_pos ();
  56. extern void _rl_fix_point ();
  57. extern void _rl_abort_internal ();
  58.  
  59. extern char *xmalloc (), *xrealloc ();
  60.  
  61. /* **************************************************************** */
  62. /*                                    */
  63. /*            Killing Mechanism                */
  64. /*                                    */
  65. /* **************************************************************** */
  66.  
  67. /* What we assume for a max number of kills. */
  68. #define DEFAULT_MAX_KILLS 10
  69.  
  70. /* The real variable to look at to find out when to flush kills. */
  71. static int rl_max_kills =  DEFAULT_MAX_KILLS;
  72.  
  73. /* Where to store killed text. */
  74. static char **rl_kill_ring = (char **)NULL;
  75.  
  76. /* Where we are in the kill ring. */
  77. static int rl_kill_index;
  78.  
  79. /* How many slots we have in the kill ring. */
  80. static int rl_kill_ring_length;
  81.  
  82. /* How to say that you only want to save a certain amount
  83.    of kill material. */
  84. int
  85. rl_set_retained_kills (num)
  86.      int num;
  87. {
  88.   return 0;
  89. }
  90.  
  91. /* Add TEXT to the kill ring, allocating a new kill ring slot as necessary.
  92.    This uses TEXT directly, so the caller must not free it.  If APPEND is
  93.    non-zero, and the last command was a kill, the text is appended to the
  94.    current kill ring slot, otherwise prepended. */
  95. static int
  96. _rl_copy_to_kill_ring (text, append)
  97.      char *text;
  98.      int append;
  99. {
  100.   char *old, *new;
  101.   int slot;
  102.  
  103.   /* First, find the slot to work with. */
  104.   if (_rl_last_command_was_kill == 0)
  105.     {
  106.       /* Get a new slot.  */
  107.       if (rl_kill_ring == 0)
  108.     {
  109.       /* If we don't have any defined, then make one. */
  110.       rl_kill_ring = (char **)
  111.         xmalloc (((rl_kill_ring_length = 1) + 1) * sizeof (char *));
  112.       rl_kill_ring[slot = 0] = (char *)NULL;
  113.     }
  114.       else
  115.     {
  116.       /* We have to add a new slot on the end, unless we have
  117.          exceeded the max limit for remembering kills. */
  118.       slot = rl_kill_ring_length;
  119.       if (slot == rl_max_kills)
  120.         {
  121.           register int i;
  122.           free (rl_kill_ring[0]);
  123.           for (i = 0; i < slot; i++)
  124.         rl_kill_ring[i] = rl_kill_ring[i + 1];
  125.         }
  126.       else
  127.         {
  128.           slot = rl_kill_ring_length += 1;
  129.           rl_kill_ring = (char **)xrealloc (rl_kill_ring, slot * sizeof (char *));
  130.         }
  131.       rl_kill_ring[--slot] = (char *)NULL;
  132.     }
  133.     }
  134.   else
  135.     slot = rl_kill_ring_length - 1;
  136.  
  137.   /* If the last command was a kill, prepend or append. */
  138.   if (_rl_last_command_was_kill && rl_editing_mode != vi_mode)
  139.     {
  140.       old = rl_kill_ring[slot];
  141.       new = xmalloc (1 + strlen (old) + strlen (text));
  142.  
  143.       if (append)
  144.     {
  145.       strcpy (new, old);
  146.       strcat (new, text);
  147.     }
  148.       else
  149.     {
  150.       strcpy (new, text);
  151.       strcat (new, old);
  152.     }
  153.       free (old);
  154.       free (text);
  155.       rl_kill_ring[slot] = new;
  156.     }
  157.   else
  158.     rl_kill_ring[slot] = text;
  159.  
  160.   rl_kill_index = slot;
  161.   return 0;
  162. }
  163.  
  164. /* The way to kill something.  This appends or prepends to the last
  165.    kill, if the last command was a kill command.  if FROM is less
  166.    than TO, then the text is appended, otherwise prepended.  If the
  167.    last command was not a kill command, then a new slot is made for
  168.    this kill. */
  169. int
  170. rl_kill_text (from, to)
  171.      int from, to;
  172. {
  173.   char *text;
  174.  
  175.   /* Is there anything to kill? */
  176.   if (from == to)
  177.     {
  178.       _rl_last_command_was_kill++;
  179.       return 0;
  180.     }
  181.  
  182.   text = rl_copy_text (from, to);
  183.  
  184.   /* Delete the copied text from the line. */
  185.   rl_delete_text (from, to);
  186.  
  187.   _rl_copy_to_kill_ring (text, from < to);
  188.  
  189.   _rl_last_command_was_kill++;
  190.   return 0;
  191. }
  192.  
  193. /* Now REMEMBER!  In order to do prepending or appending correctly, kill
  194.    commands always make rl_point's original position be the FROM argument,
  195.    and rl_point's extent be the TO argument. */
  196.  
  197. /* **************************************************************** */
  198. /*                                    */
  199. /*            Killing Commands                */
  200. /*                                    */
  201. /* **************************************************************** */
  202.  
  203. /* Delete the word at point, saving the text in the kill ring. */
  204. int
  205. rl_kill_word (count, key)
  206.      int count, key;
  207. {
  208.   int orig_point = rl_point;
  209.  
  210.   if (count < 0)
  211.     return (rl_backward_kill_word (-count, key));
  212.   else
  213.     {
  214.       rl_forward_word (count, key);
  215.  
  216.       if (rl_point != orig_point)
  217.     rl_kill_text (orig_point, rl_point);
  218.  
  219.       rl_point = orig_point;
  220.     }
  221.   return 0;
  222. }
  223.  
  224. /* Rubout the word before point, placing it on the kill ring. */
  225. int
  226. rl_backward_kill_word (count, ignore)
  227.      int count, ignore;
  228. {
  229.   int orig_point = rl_point;
  230.  
  231.   if (count < 0)
  232.     return (rl_kill_word (-count, ignore));
  233.   else
  234.     {
  235.       rl_backward_word (count, ignore);
  236.  
  237.       if (rl_point != orig_point)
  238.     rl_kill_text (orig_point, rl_point);
  239.     }
  240.   return 0;
  241. }
  242.  
  243. /* Kill from here to the end of the line.  If DIRECTION is negative, kill
  244.    back to the line start instead. */
  245. int
  246. rl_kill_line (direction, ignore)
  247.      int direction, ignore;
  248. {
  249.   int orig_point = rl_point;
  250.  
  251.   if (direction < 0)
  252.     return (rl_backward_kill_line (1, ignore));
  253.   else
  254.     {
  255.       rl_end_of_line (1, ignore);
  256.       if (orig_point != rl_point)
  257.     rl_kill_text (orig_point, rl_point);
  258.       rl_point = orig_point;
  259.     }
  260.   return 0;
  261. }
  262.  
  263. /* Kill backwards to the start of the line.  If DIRECTION is negative, kill
  264.    forwards to the line end instead. */
  265. int
  266. rl_backward_kill_line (direction, ignore)
  267.      int direction, ignore;
  268. {
  269.   int orig_point = rl_point;
  270.  
  271.   if (direction < 0)
  272.     return (rl_kill_line (1, ignore));
  273.   else
  274.     {
  275.       if (!rl_point)
  276.     ding ();
  277.       else
  278.     {
  279.       rl_beg_of_line (1, ignore);
  280.       rl_kill_text (orig_point, rl_point);
  281.     }
  282.     }
  283.   return 0;
  284. }
  285.  
  286. /* Kill the whole line, no matter where point is. */
  287. int
  288. rl_kill_full_line (count, ignore)
  289.      int count, ignore;
  290. {
  291.   rl_begin_undo_group ();
  292.   rl_point = 0;
  293.   rl_kill_text (rl_point, rl_end);
  294.   rl_end_undo_group ();
  295.   return 0;
  296. }
  297.  
  298. /* The next two functions mimic unix line editing behaviour, except they
  299.    save the deleted text on the kill ring.  This is safer than not saving
  300.    it, and since we have a ring, nobody should get screwed. */
  301.  
  302. /* This does what C-w does in Unix.  We can't prevent people from
  303.    using behaviour that they expect. */
  304. int
  305. rl_unix_word_rubout (count, key)
  306.      int count, key;
  307. {
  308.   int orig_point;
  309.  
  310.   if (rl_point == 0)
  311.     ding ();
  312.   else
  313.     {
  314.       orig_point = rl_point;
  315.       if (count <= 0)
  316.     count = 1;
  317.  
  318.       while (count--)
  319.     {
  320.       while (rl_point && whitespace (rl_line_buffer[rl_point - 1]))
  321.         rl_point--;
  322.  
  323.       while (rl_point && (whitespace (rl_line_buffer[rl_point - 1]) == 0))
  324.         rl_point--;
  325.     }
  326.  
  327.       rl_kill_text (orig_point, rl_point);
  328.     }
  329.   return 0;
  330. }
  331.  
  332. /* Here is C-u doing what Unix does.  You don't *have* to use these
  333.    key-bindings.  We have a choice of killing the entire line, or
  334.    killing from where we are to the start of the line.  We choose the
  335.    latter, because if you are a Unix weenie, then you haven't backspaced
  336.    into the line at all, and if you aren't, then you know what you are
  337.    doing. */
  338. int
  339. rl_unix_line_discard (count, key)
  340.      int count, key;
  341. {
  342.   if (rl_point == 0)
  343.     ding ();
  344.   else
  345.     {
  346.       rl_kill_text (rl_point, 0);
  347.       rl_point = 0;
  348.     }
  349.   return 0;
  350. }
  351.  
  352. /* Copy the text in the `region' to the kill ring.  If DELETE is non-zero,
  353.    delete the text from the line as well. */
  354. static int
  355. region_kill_internal (delete)
  356.      int delete;
  357. {
  358.   char *text;
  359.  
  360.   if (rl_mark == rl_point)
  361.     {
  362.       _rl_last_command_was_kill++;
  363.       return 0;
  364.     }
  365.  
  366.   text = rl_copy_text (rl_point, rl_mark);
  367.   if (delete)
  368.     rl_delete_text (rl_point, rl_mark);
  369.   _rl_copy_to_kill_ring (text, rl_point < rl_mark);
  370.  
  371.   _rl_last_command_was_kill++;
  372.   return 0;
  373. }
  374.  
  375. /* Copy the text in the region to the kill ring. */
  376. int
  377. rl_copy_region_to_kill (count, ignore)
  378.      int count, ignore;
  379. {
  380.   return (region_kill_internal (0));
  381. }
  382.  
  383. /* Kill the text between the point and mark. */
  384. int
  385. rl_kill_region (count, ignore)
  386.      int count, ignore;
  387. {
  388.   int r;
  389.  
  390.   r = region_kill_internal (1);
  391.   _rl_fix_point (1);
  392.   return r;
  393. }
  394.  
  395. /* Copy COUNT words to the kill ring.  DIR says which direction we look
  396.    to find the words. */
  397. static int
  398. _rl_copy_word_as_kill (count, dir)
  399.      int count, dir;
  400. {
  401.   int om, op, r;
  402.  
  403.   om = rl_mark;
  404.   op = rl_point;
  405.  
  406.   if (dir > 0)
  407.     rl_forward_word (count, 0);
  408.   else
  409.     rl_backward_word (count, 0);
  410.  
  411.   rl_mark = rl_point;
  412.  
  413.   if (dir > 0)
  414.     rl_backward_word (count, 0);
  415.   else
  416.     rl_forward_word (count, 0);
  417.  
  418.   r = region_kill_internal (0);
  419.  
  420.   rl_mark = om;
  421.   rl_point = op;
  422.  
  423.   return r;
  424. }
  425.  
  426. int
  427. rl_copy_forward_word (count, key)
  428.      int count, key;
  429. {
  430.   if (count < 0)
  431.     return (rl_copy_backward_word (-count, key));
  432.  
  433.   return (_rl_copy_word_as_kill (count, 1));
  434. }
  435.  
  436. int
  437. rl_copy_backward_word (count, key)
  438.      int count, key;
  439. {
  440.   if (count < 0)
  441.     return (rl_copy_forward_word (-count, key));
  442.  
  443.   return (_rl_copy_word_as_kill (count, -1));
  444. }
  445.   
  446. /* Yank back the last killed text.  This ignores arguments. */
  447. int
  448. rl_yank (count, ignore)
  449.      int count, ignore;
  450. {
  451.   if (rl_kill_ring == 0)
  452.     {
  453.       _rl_abort_internal ();
  454.       return -1;
  455.     }
  456.  
  457.   _rl_set_mark_at_pos (rl_point);
  458.   rl_insert_text (rl_kill_ring[rl_kill_index]);
  459.   return 0;
  460. }
  461.  
  462. /* If the last command was yank, or yank_pop, and the text just
  463.    before point is identical to the current kill item, then
  464.    delete that text from the line, rotate the index down, and
  465.    yank back some other text. */
  466. int
  467. rl_yank_pop (count, key)
  468.      int count, key;
  469. {
  470.   int l, n;
  471.  
  472.   if (((rl_last_func != rl_yank_pop) && (rl_last_func != rl_yank)) ||
  473.       !rl_kill_ring)
  474.     {
  475.       _rl_abort_internal ();
  476.       return -1;
  477.     }
  478.  
  479.   l = strlen (rl_kill_ring[rl_kill_index]);
  480.   n = rl_point - l;
  481.   if (n >= 0 && STREQN (rl_line_buffer + n, rl_kill_ring[rl_kill_index], l))
  482.     {
  483.       rl_delete_text (n, rl_point);
  484.       rl_point = n;
  485.       rl_kill_index--;
  486.       if (rl_kill_index < 0)
  487.     rl_kill_index = rl_kill_ring_length - 1;
  488.       rl_yank (1, 0);
  489.       return 0;
  490.     }
  491.   else
  492.     {
  493.       _rl_abort_internal ();
  494.       return -1;
  495.     }
  496. }
  497.  
  498. /* Yank the COUNTth argument from the previous history line. */
  499. int
  500. rl_yank_nth_arg (count, ignore)
  501.      int count, ignore;
  502. {
  503.   register HIST_ENTRY *entry;
  504.   char *arg;
  505.  
  506.   entry = previous_history ();
  507.   if (entry)
  508.     next_history ();
  509.   else
  510.     {
  511.       ding ();
  512.       return -1;
  513.     }
  514.  
  515.   arg = history_arg_extract (count, count, entry->line);
  516.   if (!arg || !*arg)
  517.     {
  518.       ding ();
  519.       return -1;
  520.     }
  521.  
  522.   rl_begin_undo_group ();
  523.  
  524. #if defined (VI_MODE)
  525.   /* Vi mode always inserts a space before yanking the argument, and it
  526.      inserts it right *after* rl_point. */
  527.   if (rl_editing_mode == vi_mode)
  528.     {
  529.       rl_vi_append_mode (1, ignore);
  530.       rl_insert_text (" ");
  531.     }
  532. #endif /* VI_MODE */
  533.  
  534.   rl_insert_text (arg);
  535.   free (arg);
  536.  
  537.   rl_end_undo_group ();
  538.   return 0;
  539. }
  540.  
  541. /* Yank the last argument from the previous history line.  This `knows'
  542.    how rl_yank_nth_arg treats a count of `$'.  With an argument, this
  543.    behaves the same as rl_yank_nth_arg. */
  544. int
  545. rl_yank_last_arg (count, key)
  546.      int count, key;
  547. {
  548.   if (rl_explicit_arg)
  549.     return (rl_yank_nth_arg (count, key));
  550.   else
  551.     return (rl_yank_nth_arg ('$', key));
  552. }
  553.