Subversion Repositories or1k

/* kill.c -- kill ring management. */

/* Copyright (C) 1994 Free Software Foundation, Inc.

   This file is part of the GNU Readline Library, a library for

   reading lines of text with interactive input and history editing.

   The GNU Readline Library is free software; you can redistribute it

   and/or modify it under the terms of the GNU General Public License

   as published by the Free Software Foundation; either version 1, or

   (at your option) any later version.

   The GNU Readline Library is distributed in the hope that it will be

   useful, but WITHOUT ANY WARRANTY; without even the implied warranty

   of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   The GNU General Public License is often shipped with GNU software, and

   is generally kept in a file called COPYING or LICENSE.  If you do not

   have a copy of the license, write to the Free Software Foundation,

   675 Mass Ave, Cambridge, MA 02139, USA. */

#define READLINE_LIBRARY

#if defined (HAVE_CONFIG_H)

#  include <config.h>

#endif

#include <sys/types.h>

#if defined (HAVE_UNISTD_H)

#  include <unistd.h>           /* for _POSIX_VERSION */

#endif /* HAVE_UNISTD_H */

#if defined (HAVE_STDLIB_H)

#  include <stdlib.h>

#else

#  include "ansi_stdlib.h"

#endif /* HAVE_STDLIB_H */

#include <stdio.h>

/* System-specific feature definitions and include files. */

#include "rldefs.h"

/* Some standard library routines. */

#include "readline.h"

#include "history.h"

extern int _rl_last_command_was_kill;

extern int rl_editing_mode;

extern int rl_explicit_arg;

extern Function *rl_last_func;

extern void _rl_init_argument ();

extern int _rl_set_mark_at_pos ();

extern void _rl_fix_point ();

extern void _rl_abort_internal ();

extern char *xmalloc (), *xrealloc ();

/* **************************************************************** */

/*                                                                  */

/*                      Killing Mechanism                           */

/*                                                                  */

/* **************************************************************** */

/* What we assume for a max number of kills. */

#define DEFAULT_MAX_KILLS 10

/* The real variable to look at to find out when to flush kills. */

static int rl_max_kills =  DEFAULT_MAX_KILLS;

/* Where to store killed text. */

static char **rl_kill_ring = (char **)NULL;

/* Where we are in the kill ring. */

static int rl_kill_index;

/* How many slots we have in the kill ring. */

static int rl_kill_ring_length;

/* How to say that you only want to save a certain amount

   of kill material. */

int

rl_set_retained_kills (num)

     int num;

{

  return 0;

}

/* Add TEXT to the kill ring, allocating a new kill ring slot as necessary.

   This uses TEXT directly, so the caller must not free it.  If APPEND is

   non-zero, and the last command was a kill, the text is appended to the

   current kill ring slot, otherwise prepended. */

static int

_rl_copy_to_kill_ring (text, append)

     char *text;

     int append;

{

  char *old, *new;

  int slot;

  /* First, find the slot to work with. */

  if (_rl_last_command_was_kill == 0)

    {

      /* Get a new slot.  */

      if (rl_kill_ring == 0)

        {

          /* If we don't have any defined, then make one. */

          rl_kill_ring = (char **)

            xmalloc (((rl_kill_ring_length = 1) + 1) * sizeof (char *));

          rl_kill_ring[slot = 0] = (char *)NULL;

        }

      else

        {

          /* We have to add a new slot on the end, unless we have

             exceeded the max limit for remembering kills. */

          slot = rl_kill_ring_length;

          if (slot == rl_max_kills)

            {

              register int i;

              free (rl_kill_ring[0]);

              for (i = 0; i < slot; i++)

                rl_kill_ring[i] = rl_kill_ring[i + 1];

            }

          else

            {

              slot = rl_kill_ring_length += 1;

              rl_kill_ring = (char **)xrealloc (rl_kill_ring, slot * sizeof (char *));

            }

          rl_kill_ring[--slot] = (char *)NULL;

        }

    }

  else

    slot = rl_kill_ring_length - 1;

  /* If the last command was a kill, prepend or append. */

  if (_rl_last_command_was_kill && rl_editing_mode != vi_mode)

    {

      old = rl_kill_ring[slot];

      new = xmalloc (1 + strlen (old) + strlen (text));

      if (append)

        {

          strcpy (new, old);

          strcat (new, text);

        }

      else

        {

          strcpy (new, text);

          strcat (new, old);

        }

      free (old);

      free (text);

      rl_kill_ring[slot] = new;

    }

  else

    rl_kill_ring[slot] = text;

  rl_kill_index = slot;

  return 0;

}

/* The way to kill something.  This appends or prepends to the last

   kill, if the last command was a kill command.  if FROM is less

   than TO, then the text is appended, otherwise prepended.  If the

   last command was not a kill command, then a new slot is made for

   this kill. */

int

rl_kill_text (from, to)

     int from, to;

{

  char *text;

  /* Is there anything to kill? */

  if (from == to)

    {

      _rl_last_command_was_kill++;

      return 0;

    }

  text = rl_copy_text (from, to);

  /* Delete the copied text from the line. */

  rl_delete_text (from, to);

  _rl_copy_to_kill_ring (text, from < to);

  _rl_last_command_was_kill++;

  return 0;

}

/* Now REMEMBER!  In order to do prepending or appending correctly, kill

   commands always make rl_point's original position be the FROM argument,

   and rl_point's extent be the TO argument. */

/* **************************************************************** */

/*                                                                  */

/*                      Killing Commands                            */

/*                                                                  */

/* **************************************************************** */

/* Delete the word at point, saving the text in the kill ring. */

int

rl_kill_word (count, key)

     int count, key;

{

  int orig_point = rl_point;

  if (count < 0)

    return (rl_backward_kill_word (-count, key));

  else

    {

      rl_forward_word (count, key);

      if (rl_point != orig_point)

        rl_kill_text (orig_point, rl_point);

      rl_point = orig_point;

    }

  return 0;

}

/* Rubout the word before point, placing it on the kill ring. */

int

rl_backward_kill_word (count, ignore)

     int count, ignore;

{

  int orig_point = rl_point;

  if (count < 0)

    return (rl_kill_word (-count, ignore));

  else

    {

      rl_backward_word (count, ignore);

      if (rl_point != orig_point)

        rl_kill_text (orig_point, rl_point);

    }

  return 0;

}

/* Kill from here to the end of the line.  If DIRECTION is negative, kill

   back to the line start instead. */

int

rl_kill_line (direction, ignore)

     int direction, ignore;

{

  int orig_point = rl_point;

  if (direction < 0)

    return (rl_backward_kill_line (1, ignore));

  else

    {

      rl_end_of_line (1, ignore);

      if (orig_point != rl_point)

        rl_kill_text (orig_point, rl_point);

      rl_point = orig_point;

    }

  return 0;

}

/* Kill backwards to the start of the line.  If DIRECTION is negative, kill

   forwards to the line end instead. */

int

rl_backward_kill_line (direction, ignore)

     int direction, ignore;

{

  int orig_point = rl_point;

  if (direction < 0)

    return (rl_kill_line (1, ignore));

  else

    {

      if (!rl_point)

        ding ();

      else

        {

          rl_beg_of_line (1, ignore);

          rl_kill_text (orig_point, rl_point);

        }

    }

  return 0;

}

/* Kill the whole line, no matter where point is. */

int

rl_kill_full_line (count, ignore)

     int count, ignore;

{

  rl_begin_undo_group ();

  rl_point = 0;

  rl_kill_text (rl_point, rl_end);

  rl_end_undo_group ();

  return 0;

}

/* The next two functions mimic unix line editing behaviour, except they

   save the deleted text on the kill ring.  This is safer than not saving

   it, and since we have a ring, nobody should get screwed. */

/* This does what C-w does in Unix.  We can't prevent people from

   using behaviour that they expect. */

int

rl_unix_word_rubout (count, key)

     int count, key;

{

  int orig_point;

  if (rl_point == 0)

    ding ();

  else

    {

      orig_point = rl_point;

      if (count <= 0)

        count = 1;

      while (count--)

        {

          while (rl_point && whitespace (rl_line_buffer[rl_point - 1]))

            rl_point--;

          while (rl_point && (whitespace (rl_line_buffer[rl_point - 1]) == 0))

            rl_point--;

        }

      rl_kill_text (orig_point, rl_point);

    }

  return 0;

}

/* Here is C-u doing what Unix does.  You don't *have* to use these

   key-bindings.  We have a choice of killing the entire line, or

   killing from where we are to the start of the line.  We choose the

   latter, because if you are a Unix weenie, then you haven't backspaced

   into the line at all, and if you aren't, then you know what you are

   doing. */

int

rl_unix_line_discard (count, key)

     int count, key;

{

  if (rl_point == 0)

    ding ();

  else

    {

      rl_kill_text (rl_point, 0);

      rl_point = 0;

    }

  return 0;

}

/* Copy the text in the `region' to the kill ring.  If DELETE is non-zero,

   delete the text from the line as well. */

static int

region_kill_internal (delete)

     int delete;

{

  char *text;

  if (rl_mark == rl_point)

    {

      _rl_last_command_was_kill++;

      return 0;

    }

  text = rl_copy_text (rl_point, rl_mark);

  if (delete)

    rl_delete_text (rl_point, rl_mark);

  _rl_copy_to_kill_ring (text, rl_point < rl_mark);

  _rl_last_command_was_kill++;

  return 0;

}

/* Copy the text in the region to the kill ring. */

int

rl_copy_region_to_kill (count, ignore)

     int count, ignore;

{

  return (region_kill_internal (0));

}

/* Kill the text between the point and mark. */

int

rl_kill_region (count, ignore)

     int count, ignore;

{

  int r;

  r = region_kill_internal (1);

  _rl_fix_point (1);

  return r;

}

/* Copy COUNT words to the kill ring.  DIR says which direction we look

   to find the words. */

static int

_rl_copy_word_as_kill (count, dir)

     int count, dir;

{

  int om, op, r;

  om = rl_mark;

  op = rl_point;

  if (dir > 0)

    rl_forward_word (count, 0);

  else

    rl_backward_word (count, 0);

  rl_mark = rl_point;

  if (dir > 0)

    rl_backward_word (count, 0);

  else

    rl_forward_word (count, 0);

  r = region_kill_internal (0);

  rl_mark = om;

  rl_point = op;

  return r;

}

int

rl_copy_forward_word (count, key)

     int count, key;

{

  if (count < 0)

    return (rl_copy_backward_word (-count, key));

  return (_rl_copy_word_as_kill (count, 1));

}

int

rl_copy_backward_word (count, key)

     int count, key;

{

  if (count < 0)

    return (rl_copy_forward_word (-count, key));

  return (_rl_copy_word_as_kill (count, -1));

}

/* Yank back the last killed text.  This ignores arguments. */

int

rl_yank (count, ignore)

     int count, ignore;

{

  if (rl_kill_ring == 0)

    {

      _rl_abort_internal ();

      return -1;

    }

  _rl_set_mark_at_pos (rl_point);

  rl_insert_text (rl_kill_ring[rl_kill_index]);

  return 0;

}

/* If the last command was yank, or yank_pop, and the text just

   before point is identical to the current kill item, then

   delete that text from the line, rotate the index down, and

   yank back some other text. */

int

rl_yank_pop (count, key)

     int count, key;

{

  int l, n;

  if (((rl_last_func != rl_yank_pop) && (rl_last_func != rl_yank)) ||

      !rl_kill_ring)

    {

      _rl_abort_internal ();

      return -1;

    }

  l = strlen (rl_kill_ring[rl_kill_index]);

  n = rl_point - l;

  if (n >= 0 && STREQN (rl_line_buffer + n, rl_kill_ring[rl_kill_index], l))

    {

      rl_delete_text (n, rl_point);

      rl_point = n;

      rl_kill_index--;

      if (rl_kill_index < 0)

        rl_kill_index = rl_kill_ring_length - 1;

      rl_yank (1, 0);

      return 0;

    }

  else

    {

      _rl_abort_internal ();

      return -1;

    }

}

/* Yank the COUNTh argument from the previous history line, skipping

   HISTORY_SKIP lines before looking for the `previous line'. */

static int

rl_yank_nth_arg_internal (count, ignore, history_skip)

     int count, ignore, history_skip;

{

  register HIST_ENTRY *entry;

  char *arg;

  int i;

  if (history_skip)

    {

      for (i = 0; i < history_skip; i++)

        entry = previous_history ();

    }

  entry = previous_history ();

  if (entry)

    {

      if (history_skip)

        {

          for (i = 0; i < history_skip; i++)

            next_history ();

        }

      next_history ();

    }

  else

    {

      ding ();

      return -1;

    }

  arg = history_arg_extract (count, count, entry->line);

  if (!arg || !*arg)

    {

      ding ();

      return -1;

    }

  rl_begin_undo_group ();

#if defined (VI_MODE)

  /* Vi mode always inserts a space before yanking the argument, and it

     inserts it right *after* rl_point. */

  if (rl_editing_mode == vi_mode)

    {

      rl_vi_append_mode (1, ignore);

      rl_insert_text (" ");

    }

#endif /* VI_MODE */

  rl_insert_text (arg);

  free (arg);

  rl_end_undo_group ();

  return 0;

}

/* Yank the COUNTth argument from the previous history line. */

int

rl_yank_nth_arg (count, ignore)

     int count, ignore;

{

  return (rl_yank_nth_arg_internal (count, ignore, 0));

}

/* Yank the last argument from the previous history line.  This `knows'

   how rl_yank_nth_arg treats a count of `$'.  With an argument, this

   behaves the same as rl_yank_nth_arg. */

int

rl_yank_last_arg (count, key)

     int count, key;

{

  static int history_skip = 0;

  static int explicit_arg_p = 0;

  static int count_passed = 1;

  static int direction = 1;

  static int undo_needed = 0;

  int retval;

  if (rl_last_func != rl_yank_last_arg)

    {

      history_skip = 0;

      explicit_arg_p = rl_explicit_arg;

      count_passed = count;

      direction = 1;

    }

  else

    {

      if (undo_needed)

        rl_do_undo ();

      if (count < 1)

        direction = -direction;

      history_skip += direction;

      if (history_skip < 0)

        history_skip = 0;

    }

  if (explicit_arg_p)

    retval = rl_yank_nth_arg_internal (count_passed, key, history_skip);

  else

    retval = rl_yank_nth_arg_internal ('$', key, history_skip);

  undo_needed = retval == 0;

  return retval;

}

/* A special paste command for users of Cygnus's cygwin32. */

#if defined (__CYGWIN32__)

#include <windows.h>

int

rl_paste_from_clipboard (count, key)

     int count, key;

{

  char *data, *ptr;

  int len;

  if (OpenClipboard (NULL) == 0)

    return (0);

  data = (char *)GetClipboardData (CF_TEXT);

  if (data)

    {

      ptr = strchr (data, '\r');

      if (ptr)

        {

          len = ptr - data;

          ptr = xmalloc (len + 1);

          ptr[len] = '\0';

          strncpy (ptr, data, len);

        }

      else

        ptr = data;

      rl_insert_text (ptr);

      if (ptr != data)

        free (ptr);

      CloseClipboard ();

    }

  return (0);

}

#endif /* __CYGWIN32__ */