[deliverable/binutils-gdb.git] / readline / search.c

/* search.c - code for non-incremental searching in emacs and vi modes. */

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

   This file is part of the Readline Library (the Library), a set of
   routines for providing Emacs style line input to programs that ask
   for it.

   The 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 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>
#include <stdio.h>

#if defined (HAVE_UNISTD_H)
#  include <unistd.h>
#endif

#if defined (HAVE_STDLIB_H)
#  include <stdlib.h>
#else
#  include "ansi_stdlib.h"
#endif

#include "rldefs.h"
#include "readline.h"
#include "history.h"

#ifdef abs
#  undef abs
#endif
#define abs(x)		(((x) >= 0) ? (x) : -(x))

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

/* Variables imported from readline.c */
extern int rl_point, rl_end, rl_line_buffer_len;
extern int rl_editing_mode;
extern char *rl_prompt;
extern char *rl_line_buffer;
extern HIST_ENTRY *saved_line_for_history;
extern Function *rl_last_func;

/* Functions imported from the rest of the library. */
extern int _rl_free_history_entry ();
extern char *_rl_make_prompt_for_search ();
extern void rl_extend_line_buffer ();

static char *noninc_search_string = (char *) NULL;
static int noninc_history_pos;
static char *prev_line_found = (char *) NULL;

/* Search the history list for STRING starting at absolute history position
   POS.  If STRING begins with `^', the search must match STRING at the
   beginning of a history line, otherwise a full substring match is performed
   for STRING.  DIR < 0 means to search backwards through the history list,
   DIR >= 0 means to search forward. */
static int
noninc_search_from_pos (string, pos, dir)
     char *string;
     int pos, dir;
{
  int ret, old;

  old = where_history ();
  history_set_pos (pos);

  if (*string == '^')
    ret = history_search_prefix (string + 1, dir);
  else
    ret = history_search (string, dir);

  if (ret != -1)
    ret = where_history ();

  history_set_pos (old);
  return (ret);
}

/* Search for a line in the history containing STRING.  If DIR is < 0, the
   search is backwards through previous entries, else through subsequent
   entries. */
static void
noninc_dosearch (string, dir)
     char *string;
     int dir;
{
  int oldpos, pos, line_len;
  HIST_ENTRY *entry;

  if (string == 0 || *string == '\0' || noninc_history_pos < 0)
    {
      ding ();
      return;
    }

  pos = noninc_search_from_pos (string, noninc_history_pos + dir, dir);
  if (pos == -1)
    {
      /* Search failed, current history position unchanged. */
      maybe_unsave_line ();
      rl_clear_message ();
      rl_point = 0;
      ding ();
      return;
    }

  noninc_history_pos = pos;

  oldpos = where_history ();
  history_set_pos (noninc_history_pos);
  entry = current_history ();
#if defined (VI_MODE)
  if (rl_editing_mode != vi_mode)
#endif
  history_set_pos (oldpos);

  line_len = strlen (entry->line);
  if (line_len >= rl_line_buffer_len)
    rl_extend_line_buffer (line_len);
  strcpy (rl_line_buffer, entry->line);

  rl_undo_list = (UNDO_LIST *)entry->data;
  rl_end = strlen (rl_line_buffer);
  rl_point = 0;
  rl_clear_message ();

  if (saved_line_for_history)
    _rl_free_history_entry (saved_line_for_history);
  saved_line_for_history = (HIST_ENTRY *)NULL;
}

/* Search non-interactively through the history list.  DIR < 0 means to
   search backwards through the history of previous commands; otherwise
   the search is for commands subsequent to the current position in the
   history list.  PCHAR is the character to use for prompting when reading
   the search string; if not specified (0), it defaults to `:'. */
static void
noninc_search (dir, pchar)
     int dir;
     int pchar;
{
  int saved_point, c;
  char *p;

  maybe_save_line ();
  saved_point = rl_point;

  /* Use the line buffer to read the search string. */
  rl_line_buffer[0] = 0;
  rl_end = rl_point = 0;

  p = _rl_make_prompt_for_search (pchar ? pchar : ':');
  rl_message (p, 0, 0);
  free (p);

#define SEARCH_RETURN rl_restore_prompt (); return

  /* Read the search string. */
  while (c = rl_read_key ())
    {
      switch (c)
	{
	case CTRL('H'):
	case RUBOUT:
	  if (rl_point == 0)
	    {
	      maybe_unsave_line ();
	      rl_clear_message ();
	      rl_point = saved_point;
	      SEARCH_RETURN;
	    }
	  rl_rubout (1, c);
	  break;

	case CTRL('W'):
	  rl_unix_word_rubout (1, c);
	  break;

	case CTRL('U'):
	  rl_unix_line_discard (1, c);
	  break;

	case RETURN:
	case NEWLINE:
	  goto dosearch;
	  /* NOTREACHED */
	  break;

	case CTRL('C'):
	case CTRL('G'):
	  maybe_unsave_line ();
	  rl_clear_message ();
	  rl_point = saved_point;
	  ding ();
	  SEARCH_RETURN;

	default:
	  rl_insert (1, c);
	  break;
	}
      (*rl_redisplay_function) ();
    }

 dosearch:
  /* If rl_point == 0, we want to re-use the previous search string and
     start from the saved history position.  If there's no previous search
     string, punt. */
  if (rl_point == 0)
    {
      if (!noninc_search_string)
	{
	  ding ();
	  SEARCH_RETURN;
	}
    }
  else
    {
      /* We want to start the search from the current history position. */
      noninc_history_pos = where_history ();
      if (noninc_search_string)
	free (noninc_search_string);
      noninc_search_string = savestring (rl_line_buffer);
    }

  rl_restore_prompt ();
  noninc_dosearch (noninc_search_string, dir);
}

/* Search forward through the history list for a string.  If the vi-mode
   code calls this, KEY will be `?'. */
int
rl_noninc_forward_search (count, key)
     int count, key;
{
  noninc_search (1, (key == '?') ? '?' : 0);
  return 0;
}

/* Reverse search the history list for a string.  If the vi-mode code
   calls this, KEY will be `/'. */
int
rl_noninc_reverse_search (count, key)
     int count, key;
{
  noninc_search (-1, (key == '/') ? '/' : 0);
  return 0;
}

/* Search forward through the history list for the last string searched
   for.  If there is no saved search string, abort. */
int
rl_noninc_forward_search_again (count, key)
     int count, key;
{
  if (!noninc_search_string)
    {
      ding ();
      return (-1);
    }
  noninc_dosearch (noninc_search_string, 1);
  return 0;
}

/* Reverse search in the history list for the last string searched
   for.  If there is no saved search string, abort. */
int
rl_noninc_reverse_search_again (count, key)
     int count, key;
{
  if (!noninc_search_string)
    {
      ding ();
      return (-1);
    }
  noninc_dosearch (noninc_search_string, -1);
  return 0;
}

static int
rl_history_search_internal (count, direction)
     int count, direction;
{
  HIST_ENTRY *temp, *old_temp;
  int line_len;

  maybe_save_line ();

  temp = old_temp = (HIST_ENTRY *)NULL;
  while (count)
    {
      temp = (direction < 0) ? previous_history () : next_history ();
      if (temp == 0)
        break;
      /* On an empty prefix, make this the same as previous-history. */
      if (rl_point == 0)
	{
	  count--;
	  continue;
	}
      if (STREQN (rl_line_buffer, temp->line, rl_point))
	{
	  /* Don't find multiple instances of the same line. */
	  if (prev_line_found && STREQ (prev_line_found, temp->line))
	    continue;
          if (direction < 0)
            old_temp = temp;
          prev_line_found = temp->line;
          count--;
	}
    }

  if (temp == 0)
    {
      if (direction < 0 && old_temp)
	temp = old_temp;
      else
	{
	  maybe_unsave_line ();
	  ding ();
	  return 1;
	}
    }

  line_len = strlen (temp->line);
  if (line_len >= rl_line_buffer_len)
    rl_extend_line_buffer (line_len);
  strcpy (rl_line_buffer, temp->line);
  rl_undo_list = (UNDO_LIST *)temp->data;
  rl_end = line_len;
  return 0;
}

/* Search forward in the history for the string of characters
   from the start of the line to rl_point.  This is a non-incremental
   search. */
int
rl_history_search_forward (count, ignore)
     int count, ignore;
{
  if (count == 0)
    return (0);
  if (rl_last_func != rl_history_search_forward)
    prev_line_found = (char *)NULL;
  return (rl_history_search_internal (abs (count), (count > 0) ? 1 : -1));
}

/* Search backward through the history for the string of characters
   from the start of the line to rl_point.  This is a non-incremental
   search. */
int
rl_history_search_backward (count, ignore)
     int count, ignore;
{
  if (count == 0)
    return (0);
  if (rl_last_func != rl_history_search_backward)
    prev_line_found = (char *)NULL;
  return (rl_history_search_internal (abs (count), (count > 0) ? -1 : 1));
}
Commit	Line	Data
d60d9f65 SS	1	/* search.c - code for non-incremental searching in emacs and vi modes. */
	2
	3	/* Copyright (C) 1992 Free Software Foundation, Inc.
	4
	5	This file is part of the Readline Library (the Library), a set of
	6	routines for providing Emacs style line input to programs that ask
	7	for it.
	8
	9	The Library is free software; you can redistribute it and/or modify
	10	it under the terms of the GNU General Public License as published by
	11	the Free Software Foundation; either version 1, or (at your option)
	12	any later version.
	13
	14	The Library is distributed in the hope that it will be useful, but
	15	WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	17	General Public License for more details.
	18
	19	The GNU General Public License is often shipped with GNU software, and
	20	is generally kept in a file called COPYING or LICENSE. If you do not
	21	have a copy of the license, write to the Free Software Foundation,
	22	675 Mass Ave, Cambridge, MA 02139, USA. */
	23	#define READLINE_LIBRARY
	24
	25	#if defined (HAVE_CONFIG_H)
	26	# include <config.h>
	27	#endif
	28
	29	#include <sys/types.h>
	30	#include <stdio.h>
	31
	32	#if defined (HAVE_UNISTD_H)
	33	# include <unistd.h>
	34	#endif
	35
	36	#if defined (HAVE_STDLIB_H)
	37	# include <stdlib.h>
	38	#else
	39	# include "ansi_stdlib.h"
	40	#endif
	41
	42	#include "rldefs.h"
	43	#include "readline.h"
	44	#include "history.h"
	45
	46	#ifdef abs
	47	# undef abs
	48	#endif
	49	#define abs(x) (((x) >= 0) ? (x) : -(x))
	50
	51	extern char xmalloc (), xrealloc ();
	52
	53	/* Variables imported from readline.c */
	54	extern int rl_point, rl_end, rl_line_buffer_len;
	55	extern int rl_editing_mode;
	56	extern char *rl_prompt;
	57	extern char *rl_line_buffer;
	58	extern HIST_ENTRY *saved_line_for_history;
	59	extern Function *rl_last_func;
	60
	61	/* Functions imported from the rest of the library. */
	62	extern int _rl_free_history_entry ();
	63	extern char *_rl_make_prompt_for_search ();
d60d9f65 SS	64	extern void rl_extend_line_buffer ();
	65
	66	static char noninc_search_string = (char ) NULL;
	67	static int noninc_history_pos;
	68	static char prev_line_found = (char ) NULL;
	69
	70	/* Search the history list for STRING starting at absolute history position
	71	POS. If STRING begins with `^', the search must match STRING at the
	72	beginning of a history line, otherwise a full substring match is performed
	73	for STRING. DIR < 0 means to search backwards through the history list,
	74	DIR >= 0 means to search forward. */
	75	static int
	76	noninc_search_from_pos (string, pos, dir)
	77	char *string;
	78	int pos, dir;
	79	{
	80	int ret, old;
	81
	82	old = where_history ();
	83	history_set_pos (pos);
	84
	85	if (*string == '^')
	86	ret = history_search_prefix (string + 1, dir);
	87	else
	88	ret = history_search (string, dir);
	89
	90	if (ret != -1)
	91	ret = where_history ();
	92
	93	history_set_pos (old);
	94	return (ret);
	95	}
	96
	97	/* Search for a line in the history containing STRING. If DIR is < 0, the
	98	search is backwards through previous entries, else through subsequent
	99	entries. */
	100	static void
	101	noninc_dosearch (string, dir)
	102	char *string;
	103	int dir;
	104	{
	105	int oldpos, pos, line_len;
	106	HIST_ENTRY *entry;
	107
	108	if (string == 0 \|\| *string == '\0' \|\| noninc_history_pos < 0)
	109	{
	110	ding ();
	111	return;
	112	}
	113
	114	pos = noninc_search_from_pos (string, noninc_history_pos + dir, dir);
	115	if (pos == -1)
	116	{
	117	/* Search failed, current history position unchanged. */
	118	maybe_unsave_line ();
	119	rl_clear_message ();
	120	rl_point = 0;
	121	ding ();
	122	return;
	123	}
	124
	125	noninc_history_pos = pos;
	126
	127	oldpos = where_history ();
128	history_set_pos (noninc_history_pos);
129	entry = current_history ();
130	#if defined (VI_MODE)
131	if (rl_editing_mode != vi_mode)
132	#endif
133	history_set_pos (oldpos);
134
135	line_len = strlen (entry->line);
136	if (line_len >= rl_line_buffer_len)
137	rl_extend_line_buffer (line_len);
138	strcpy (rl_line_buffer, entry->line);
139
140	rl_undo_list = (UNDO_LIST *)entry->data;
141	rl_end = strlen (rl_line_buffer);
142	rl_point = 0;
143	rl_clear_message ();
144
145	if (saved_line_for_history)
146	_rl_free_history_entry (saved_line_for_history);
147	saved_line_for_history = (HIST_ENTRY *)NULL;
148	}
149
150	/* Search non-interactively through the history list. DIR < 0 means to
151	search backwards through the history of previous commands; otherwise
152	the search is for commands subsequent to the current position in the
153	history list. PCHAR is the character to use for prompting when reading
154	the search string; if not specified (0), it defaults to `:'. */
155	static void
156	noninc_search (dir, pchar)
157	int dir;
158	int pchar;
159	{
160	int saved_point, c;
161	char *p;
162
163	maybe_save_line ();
164	saved_point = rl_point;
165
166	/* Use the line buffer to read the search string. */
167	rl_line_buffer[0] = 0;
168	rl_end = rl_point = 0;
169
170	p = _rl_make_prompt_for_search (pchar ? pchar : ':');
171	rl_message (p, 0, 0);
172	free (p);
173
c862e87b	174	#define SEARCH_RETURN rl_restore_prompt (); return
d60d9f65 SS	175
	176	/* Read the search string. */
	177	while (c = rl_read_key ())
	178	{
	179	switch (c)
	180	{
	181	case CTRL('H'):
	182	case RUBOUT:
	183	if (rl_point == 0)
	184	{
	185	maybe_unsave_line ();
	186	rl_clear_message ();
	187	rl_point = saved_point;
	188	SEARCH_RETURN;
	189	}
	190	rl_rubout (1, c);
	191	break;
	192
	193	case CTRL('W'):
	194	rl_unix_word_rubout (1, c);
	195	break;
	196
	197	case CTRL('U'):
	198	rl_unix_line_discard (1, c);
	199	break;
	200
	201	case RETURN:
	202	case NEWLINE:
	203	goto dosearch;
	204	/* NOTREACHED */
	205	break;
	206
	207	case CTRL('C'):
	208	case CTRL('G'):
	209	maybe_unsave_line ();
	210	rl_clear_message ();
	211	rl_point = saved_point;
	212	ding ();
	213	SEARCH_RETURN;
	214
	215	default:
	216	rl_insert (1, c);
	217	break;
	218	}
	219	(*rl_redisplay_function) ();
	220	}
	221
	222	dosearch:
	223	/* If rl_point == 0, we want to re-use the previous search string and
	224	start from the saved history position. If there's no previous search
	225	string, punt. */
	226	if (rl_point == 0)
	227	{
	228	if (!noninc_search_string)
	229	{
	230	ding ();
	231	SEARCH_RETURN;
	232	}
	233	}
	234	else
	235	{
	236	/* We want to start the search from the current history position. */
	237	noninc_history_pos = where_history ();
	238	if (noninc_search_string)
239	free (noninc_search_string);
240	noninc_search_string = savestring (rl_line_buffer);
241	}
242
c862e87b	243	rl_restore_prompt ();
d60d9f65 SS	244	noninc_dosearch (noninc_search_string, dir);
	245	}
	246
	247	/* Search forward through the history list for a string. If the vi-mode
	248	code calls this, KEY will be `?'. */
	249	int
	250	rl_noninc_forward_search (count, key)
	251	int count, key;
	252	{
	253	noninc_search (1, (key == '?') ? '?' : 0);
	254	return 0;
	255	}
	256
	257	/* Reverse search the history list for a string. If the vi-mode code
	258	calls this, KEY will be `/'. */
	259	int
	260	rl_noninc_reverse_search (count, key)
	261	int count, key;
	262	{
	263	noninc_search (-1, (key == '/') ? '/' : 0);
	264	return 0;
	265	}
	266
	267	/* Search forward through the history list for the last string searched
	268	for. If there is no saved search string, abort. */
	269	int
	270	rl_noninc_forward_search_again (count, key)
	271	int count, key;
	272	{
	273	if (!noninc_search_string)
	274	{
	275	ding ();
	276	return (-1);
	277	}
	278	noninc_dosearch (noninc_search_string, 1);
	279	return 0;
	280	}
	281
	282	/* Reverse search in the history list for the last string searched
	283	for. If there is no saved search string, abort. */
	284	int
	285	rl_noninc_reverse_search_again (count, key)
	286	int count, key;
	287	{
	288	if (!noninc_search_string)
	289	{
	290	ding ();
	291	return (-1);
	292	}
	293	noninc_dosearch (noninc_search_string, -1);
	294	return 0;
	295	}
	296
	297	static int
	298	rl_history_search_internal (count, direction)
	299	int count, direction;
	300	{
	301	HIST_ENTRY temp, old_temp;
	302	int line_len;
	303
	304	maybe_save_line ();
	305
	306	temp = old_temp = (HIST_ENTRY *)NULL;
	307	while (count)
308	{
309	temp = (direction < 0) ? previous_history () : next_history ();
310	if (temp == 0)
311	break;
312	/* On an empty prefix, make this the same as previous-history. */
313	if (rl_point == 0)
314	{
315	count--;
316	continue;
317	}
318	if (STREQN (rl_line_buffer, temp->line, rl_point))
319	{
320	/* Don't find multiple instances of the same line. */
321	if (prev_line_found && STREQ (prev_line_found, temp->line))
322	continue;
323	if (direction < 0)
324	old_temp = temp;
325	prev_line_found = temp->line;
326	count--;
327	}
328	}
329
330	if (temp == 0)
331	{
332	if (direction < 0 && old_temp)
333	temp = old_temp;
334	else
335	{
336	maybe_unsave_line ();
337	ding ();
338	return 1;
339	}
340	}
341
342	line_len = strlen (temp->line);
343	if (line_len >= rl_line_buffer_len)
344	rl_extend_line_buffer (line_len);
345	strcpy (rl_line_buffer, temp->line);
346	rl_undo_list = (UNDO_LIST *)temp->data;
347	rl_end = line_len;
348	return 0;
349	}
350
351	/* Search forward in the history for the string of characters
352	from the start of the line to rl_point. This is a non-incremental
353	search. */
354	int
355	rl_history_search_forward (count, ignore)
356	int count, ignore;
357	{
358	if (count == 0)
359	return (0);
360	if (rl_last_func != rl_history_search_forward)
361	prev_line_found = (char *)NULL;
362	return (rl_history_search_internal (abs (count), (count > 0) ? 1 : -1));
363	}
364
365	/* Search backward through the history for the string of characters
366	from the start of the line to rl_point. This is a non-incremental
367	search. */
368	int
369	rl_history_search_backward (count, ignore)
370	int count, ignore;
371	{
372	if (count == 0)
373	return (0);
374	if (rl_last_func != rl_history_search_backward)
375	prev_line_found = (char *)NULL;
376	return (rl_history_search_internal (abs (count), (count > 0) ? -1 : 1));
377	}