path: root/tap/readline/text.c

/* text.c
 * Part of the Readline module for Tap. These are functions which
 * manipulate the text in some way.
 */

/* Copyright (C) 1999 Jonathan duSaint
 *
 * This file is part of Tap, an interactive program for reading and
 * writing data to the serial port to facilitate the reverse
 * engineering of communication protocols.
 *
 * Tap 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 2, or (at your option)
 * any later version.
 *
 * Tap 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 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.
 */

#include "readline.h"

/* Move the cursor one space to the left,
 * don't perform range check and don't update
 * position in line
 */
void
cursor_left (void)
{
  if (input_window->_curx == 0)
    {
      input_window->_cury--;
      input_window->_curx = window_width - 1;
    }
  else
    input_window->_curx--;
}

/* Move the cursor one space to the right,
 * don't perform range check and don't update
 * position in line
 */
void
cursor_right (void)
{
  if (input_window->_curx + 1 == window_width)
    {
      input_window->_cury++;
      input_window->_curx = 0;
    }
  else
    input_window->_curx++;
}

/* Kill the region from the mark to the point;
 * bound to C-w
 */
void
kill_region (void)
{
  long kstart, kend;

  /* find the region to be killed */
  if (mark_start == -1)
    {
      warning_beep ();
      return;
    }
  else if (mark_start == current_position)
    {
      mark_start = -1;
      return;
    }
  else if (mark_start < current_position)
    {
      int k;

      kstart = mark_start;
      kend = current_position;

      for (k = 0; k < kend - kstart; k++) cursor_left ();
    }
  else
    {
      kstart = current_position;
      kend = mark_start;
    }

  kill_to_ring (kstart, kend);

  memmove (current_line + kstart, current_line + kend,
	   chars_in_line - kend + 1);

  chars_in_line -= kend - kstart;
  mark_start = -1;

  current_position = kstart;
}

/* Kill from the point to the end of the line;
 * bound to C-k
 */
void
kill_to_eol (void)
{
  kill_to_ring (current_position, chars_in_line);

  current_line[current_position] = 0;
  chars_in_line = current_position;
}

/* Move the cursor left, doing range check and
 * updating position in line;
 * bound to C-b and the left arrow key
 */
void
move_cursor_left (void)
{
  if (current_position == 0)
    {
      warning_beep ();
      return;
    }

  current_position--;

  cursor_left ();
}

/* Move the cursor right, doing range check and
 * updating position in line;
 * bound to C-f and the right arrow key
 */
void
move_cursor_right (void)
{
  if (current_position == chars_in_line)
    {
      warning_beep ();
      return;
    }

  current_position++;

  cursor_right ();
}

/* Move the cursor to the start of the line;
 * bound to C-a
 */
void
move_cursor_to_start (void)
{
  int k;

  for (k = 0; k < current_position; k++) cursor_left ();

  current_position = 0;
}

/* Move the cursor to the end of the line;
 * bound to C-e
 */
void
move_cursor_to_end (void)
{
  int k;

  for (k = 0; k < chars_in_line - current_position; k++) cursor_right ();

  current_position = chars_in_line;
}

/* Transpose the character under the point with the one
 * to the left performing range checking;
 * bound to C-t
 */
void
transpose_chars (void)
{
  char ch;

  if (current_position == 0 || current_position == chars_in_line)
    {
      warning_beep ();
      return;
    }

  ch = current_line[current_position];
  current_line[current_position] = current_line[current_position - 1];
  current_line[current_position - 1] = ch;

  move_cursor_right ();
}

/* Insert CH into the line at CURRENT_POSITION
 */
void
insert_char (char ch)
{
  if (chars_in_line + 1 == line_size)
    {
      current_line = xrealloc (current_line, line_size + GROW_SIZE);
      line_size += GROW_SIZE;
    }

  memmove (current_line + current_position + 1,
	   current_line + current_position,
	   chars_in_line - current_position + 1);

  current_line[current_position] = ch;

  cursor_right ();

  current_position++;
  chars_in_line++;
}

/* Delete the character either under the point
 * or to the left depending on the direction;
 * bound to C-d and DEL as RIGHT and C-h and
 * BACKSPACE as LEFT
 */
void
delete_char (enum direction which)
{
  /* check if there is a char to delete */
  if ((which == LEFT && current_position == 0)
      || (which == RIGHT && current_position == chars_in_line))
    {
      warning_beep ();
      return;
    }

  if (which == LEFT)
    {
      current_position--;
      cursor_left ();
    }

  memmove (current_line + current_position,
	   current_line + current_position + 1,
	   chars_in_line - current_position);

  chars_in_line--;
}

/* Yank text out of the kill ring and insert into the line;
 * bound to C-y
 */
void
yank_text (void)
{
  int k;
  char *insert_text;

  insert_text = get_ring_entry (repeat_value);

  for (k = 0; k < strlen (insert_text); k++)
    {
      insert_char (insert_text[k]);
    }
}

/* Read in a number and repeat the following command that
 * many times, or if the next command is yank, uses the
 * count as an index into the kill ring;
 * bound to C-u
 */
void
do_count (void)
{
  int k, y_save, ok, ch = 0, x0, y0, line_pos;

  /* save the sojourn */
  x0 = input_window->_curx;
  y0 = input_window->_cury;
  line_pos = current_position;

  move_cursor_to_end ();

  waddstr (input_window, "\nC-u> "); wrefresh (input_window);

  y_save = input_window->_cury;

  repeat_value = 0;

  /* read in a number */
  while (1)
    {
      ch = wgetch (input_window);
      if (ch >= '0' && ch <= '9')
	{
	  repeat_value *= 10;
	  repeat_value += ch - '0';

	  waddch (input_window, ch); wrefresh (input_window);
	}
      else
	{
	  /* if ok == 1 , the number has been read */
	  ok = (ch == '\n') ? 1 : 0;
	  break;
	}
    }

  if (ok) /* got a \n */
    {
      waddch (input_window, ' '); wrefresh (input_window);
      ch = readchar ();
    }

  /* restore the old positions */
  input_window->_cury = y_save;
  input_window->_curx = 0;

  waddnstr (input_window, " ", window_width); wrefresh (input_window);

  input_window->_curx = x0;
  input_window->_cury = y0;
  current_position = line_pos;

  if (!ok) /* if a valid number wasn't read, just return */
    {
      repeat_value = 1;
      warning_beep ();
      return;
    }

  if (ch == ECYANK)
      yank_text ();
  else if (ch == ECQUIT)
      ungetch ('\n');
  else if (ch == ECCOUNT)
      warning_beep ();
  else
    {
      for (k = 0; k < repeat_value; k++)
	{
	  if (ch > 0xFF)
	      dispatch_special (ch);
	  else
	      insert_char (ch);
	}
    }

  repeat_value = 1;
}