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

/* History.c -- standalone history library */

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

   This file contains the GNU History Library (the Library), a set of
   routines for managing the text of previously typed lines.

   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 2, 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,
   59 Temple Place, Suite 330, Boston, MA 02111 USA. */

/* The goal is to make the implementation transparent, so that you
   don't have to know what data types are used, just what functions
   you can call.  I think I have done that. */
#define READLINE_LIBRARY

#if defined (HAVE_CONFIG_H)
#  include <config.h>
#endif

#include <stdio.h>

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

#if defined (HAVE_UNISTD_H)
#  ifdef _MINIX
#    include <sys/types.h>
#  endif
#  include <unistd.h>
#endif

#if defined (HAVE_STRING_H)
#  include <string.h>
#else
#  include <strings.h>
#endif /* !HAVE_STRING_H */

#include "history.h"
#include "histlib.h"

#include "xmalloc.h"

/* The number of slots to increase the_history by. */
#define DEFAULT_HISTORY_GROW_SIZE 50

/* **************************************************************** */
/*								    */
/*			History Functions			    */
/*								    */
/* **************************************************************** */

/* An array of HIST_ENTRY.  This is where we store the history. */
static HIST_ENTRY **the_history = (HIST_ENTRY **)NULL;

/* Non-zero means that we have enforced a limit on the amount of
   history that we save. */
static int history_stifled;

/* If HISTORY_STIFLED is non-zero, then this is the maximum number of
   entries to remember. */
int max_input_history;

/* The current location of the interactive history pointer.  Just makes
   life easier for outside callers. */
int history_offset;

/* The number of strings currently stored in the history list. */
int history_length;

/* The current number of slots allocated to the input_history. */
static int history_size;

/* The logical `base' of the history array.  It defaults to 1. */
int history_base = 1;

/* Return the current HISTORY_STATE of the history. */
HISTORY_STATE *
history_get_history_state ()
{
  HISTORY_STATE *state;

  state = (HISTORY_STATE *)xmalloc (sizeof (HISTORY_STATE));
  state->entries = the_history;
  state->offset = history_offset;
  state->length = history_length;
  state->size = history_size;
  state->flags = 0;
  if (history_stifled)
    state->flags |= HS_STIFLED;

  return (state);
}

/* Set the state of the current history array to STATE. */
void
history_set_history_state (state)
     HISTORY_STATE *state;
{
  the_history = state->entries;
  history_offset = state->offset;
  history_length = state->length;
  history_size = state->size;
  if (state->flags & HS_STIFLED)
    history_stifled = 1;
}

/* Begin a session in which the history functions might be used.  This
   initializes interactive variables. */
void
using_history ()
{
  history_offset = history_length;
}

/* Return the number of bytes that the primary history entries are using.
   This just adds up the lengths of the_history->lines. */
int
history_total_bytes ()
{
  register int i, result;

  result = 0;

  for (i = 0; the_history && the_history[i]; i++)
    result += strlen (the_history[i]->line);

  return (result);
}

/* Returns the magic number which says what history element we are
   looking at now.  In this implementation, it returns history_offset. */
int
where_history ()
{
  return (history_offset);
}

/* Make the current history item be the one at POS, an absolute index.
   Returns zero if POS is out of range, else non-zero. */
int
history_set_pos (pos)
     int pos;
{
  if (pos > history_length || pos < 0 || !the_history)
    return (0);
  history_offset = pos;
  return (1);
}
 
/* Return the current history array.  The caller has to be carefull, since this
   is the actual array of data, and could be bashed or made corrupt easily.
   The array is terminated with a NULL pointer. */
HIST_ENTRY **
history_list ()
{
  return (the_history);
}

/* Return the history entry at the current position, as determined by
   history_offset.  If there is no entry there, return a NULL pointer. */
HIST_ENTRY *
current_history ()
{
  return ((history_offset == history_length) || the_history == 0)
		? (HIST_ENTRY *)NULL
		: the_history[history_offset];
}

/* Back up history_offset to the previous history entry, and return
   a pointer to that entry.  If there is no previous entry then return
   a NULL pointer. */
HIST_ENTRY *
previous_history ()
{
  return history_offset ? the_history[--history_offset] : (HIST_ENTRY *)NULL;
}

/* Move history_offset forward to the next history entry, and return
   a pointer to that entry.  If there is no next entry then return a
   NULL pointer. */
HIST_ENTRY *
next_history ()
{
  return (history_offset == history_length) ? (HIST_ENTRY *)NULL : the_history[++history_offset];
}

/* Return the history entry which is logically at OFFSET in the history array.
   OFFSET is relative to history_base. */
HIST_ENTRY *
history_get (offset)
     int offset;
{
  int local_index;

  local_index = offset - history_base;
  return (local_index >= history_length || local_index < 0 || !the_history)
		? (HIST_ENTRY *)NULL
		: the_history[local_index];
}

/* Place STRING at the end of the history list.  The data field
   is  set to NULL. */
void
add_history (string)
     char *string;
{
  HIST_ENTRY *temp;

  if (history_stifled && (history_length == max_input_history))
    {
      register int i;

      /* If the history is stifled, and history_length is zero,
	 and it equals max_input_history, we don't save items. */
      if (history_length == 0)
	return;

      /* If there is something in the slot, then remove it. */
      if (the_history[0])
	{
	  free (the_history[0]->line);
	  free (the_history[0]);
	}

      /* Copy the rest of the entries, moving down one slot. */
      for (i = 0; i < history_length; i++)
	the_history[i] = the_history[i + 1];

      history_base++;
    }
  else
    {
      if (history_size == 0)
	{
	  history_size = DEFAULT_HISTORY_GROW_SIZE;
	  the_history = (HIST_ENTRY **)xmalloc (history_size * sizeof (HIST_ENTRY *));
	  history_length = 1;
	}
      else
	{
	  if (history_length == (history_size - 1))
	    {
	      history_size += DEFAULT_HISTORY_GROW_SIZE;
	      the_history = (HIST_ENTRY **)
		xrealloc (the_history, history_size * sizeof (HIST_ENTRY *));
	    }
	  history_length++;
	}
    }

  temp = (HIST_ENTRY *)xmalloc (sizeof (HIST_ENTRY));
  temp->line = savestring (string);
  temp->data = (char *)NULL;

  the_history[history_length] = (HIST_ENTRY *)NULL;
  the_history[history_length - 1] = temp;
}

/* Make the history entry at WHICH have LINE and DATA.  This returns
   the old entry so you can dispose of the data.  In the case of an
   invalid WHICH, a NULL pointer is returned. */
HIST_ENTRY *
replace_history_entry (which, line, data)
     int which;
     char *line;
     histdata_t data;
{
  HIST_ENTRY *temp = (HIST_ENTRY *)xmalloc (sizeof (HIST_ENTRY));
  HIST_ENTRY *old_value;

  if (which >= history_length)
    return ((HIST_ENTRY *)NULL);

  old_value = the_history[which];

  temp->line = savestring (line);
  temp->data = data;
  the_history[which] = temp;

  return (old_value);
}

/* Remove history element WHICH from the history.  The removed
   element is returned to you so you can free the line, data,
   and containing structure. */
HIST_ENTRY *
remove_history (which)
     int which;
{
  HIST_ENTRY *return_value;

  if (which >= history_length || !history_length)
    return_value = (HIST_ENTRY *)NULL;
  else
    {
      register int i;
      return_value = the_history[which];

      for (i = which; i < history_length; i++)
	the_history[i] = the_history[i + 1];

      history_length--;
    }

  return (return_value);
}

/* Stifle the history list, remembering only MAX number of lines. */
void
stifle_history (max)
     int max;
{
  if (max < 0)
    max = 0;

  if (history_length > max)
    {
      register int i, j;

      /* This loses because we cannot free the data. */
      for (i = 0, j = history_length - max; i < j; i++)
	{
	  free (the_history[i]->line);
	  free (the_history[i]);
	}

      history_base = i;
      for (j = 0, i = history_length - max; j < max; i++, j++)
	the_history[j] = the_history[i];
      the_history[j] = (HIST_ENTRY *)NULL;
      history_length = j;
    }

  history_stifled = 1;
  max_input_history = max;
}

/* Stop stifling the history.  This returns the previous amount the 
   history was stifled by.  The value is positive if the history was
   stifled,  negative if it wasn't. */
int
unstifle_history ()
{
  if (history_stifled)
    {
      history_stifled = 0;
      return (-max_input_history);
    }

  return (max_input_history);
}

int
history_is_stifled ()
{
  return (history_stifled);
}

void
clear_history ()
{
  register int i;

  /* This loses because we cannot free the data. */
  for (i = 0; i < history_length; i++)
    {
      free (the_history[i]->line);
      free (the_history[i]);
      the_history[i] = (HIST_ENTRY *)NULL;
    }

  history_offset = history_length = 0;
}
Commit	Line	Data
d60d9f65 SS	1	/* History.c -- standalone history library */
	2
	3	/* Copyright (C) 1989, 1992 Free Software Foundation, Inc.
	4
	5	This file contains the GNU History Library (the Library), a set of
	6	routines for managing the text of previously typed lines.
	7
	8	The Library is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
1b17e766	10	the Free Software Foundation; either version 2, or (at your option)
d60d9f65 SS	11	any later version.
	12
	13	The Library is distributed in the hope that it will be useful, but
	14	WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	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,
1b17e766	21	59 Temple Place, Suite 330, Boston, MA 02111 USA. */
d60d9f65 SS	22
	23	/* The goal is to make the implementation transparent, so that you
	24	don't have to know what data types are used, just what functions
	25	you can call. I think I have done that. */
	26	#define READLINE_LIBRARY
	27
	28	#if defined (HAVE_CONFIG_H)
	29	# include <config.h>
	30	#endif
	31
	32	#include <stdio.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	#if defined (HAVE_UNISTD_H)
	41	# ifdef _MINIX
	42	# include <sys/types.h>
	43	# endif
	44	# include <unistd.h>
	45	#endif
	46
	47	#if defined (HAVE_STRING_H)
	48	# include <string.h>
	49	#else
	50	# include <strings.h>
	51	#endif /* !HAVE_STRING_H */
	52
	53	#include "history.h"
	54	#include "histlib.h"
	55
1b17e766	56	#include "xmalloc.h"
d60d9f65 SS	57
	58	/* The number of slots to increase the_history by. */
	59	#define DEFAULT_HISTORY_GROW_SIZE 50
	60
	61	/* **************************************************************** */
	62	/* */
	63	/* History Functions */
	64	/* */
	65	/* **************************************************************** */
	66
	67	/* An array of HIST_ENTRY. This is where we store the history. */
	68	static HIST_ENTRY the_history = (HIST_ENTRY )NULL;
	69
	70	/* Non-zero means that we have enforced a limit on the amount of
	71	history that we save. */
	72	static int history_stifled;
	73
	74	/* If HISTORY_STIFLED is non-zero, then this is the maximum number of
	75	entries to remember. */
	76	int max_input_history;
	77
	78	/* The current location of the interactive history pointer. Just makes
	79	life easier for outside callers. */
	80	int history_offset;
	81
	82	/* The number of strings currently stored in the history list. */
	83	int history_length;
	84
	85	/* The current number of slots allocated to the input_history. */
	86	static int history_size;
	87
	88	/* The logical `base' of the history array. It defaults to 1. */
	89	int history_base = 1;
	90
	91	/* Return the current HISTORY_STATE of the history. */
	92	HISTORY_STATE *
	93	history_get_history_state ()
	94	{
	95	HISTORY_STATE *state;
	96
	97	state = (HISTORY_STATE *)xmalloc (sizeof (HISTORY_STATE));
	98	state->entries = the_history;
	99	state->offset = history_offset;
	100	state->length = history_length;
	101	state->size = history_size;
	102	state->flags = 0;
	103	if (history_stifled)
	104	state->flags \|= HS_STIFLED;
	105
	106	return (state);
	107	}
	108
	109	/* Set the state of the current history array to STATE. */
	110	void
	111	history_set_history_state (state)
	112	HISTORY_STATE *state;
	113	{
	114	the_history = state->entries;
	115	history_offset = state->offset;
	116	history_length = state->length;
	117	history_size = state->size;
	118	if (state->flags & HS_STIFLED)
	119	history_stifled = 1;
	120	}
121
122	/* Begin a session in which the history functions might be used. This
123	initializes interactive variables. */
124	void
125	using_history ()
126	{
127	history_offset = history_length;
128	}
129
130	/* Return the number of bytes that the primary history entries are using.
131	This just adds up the lengths of the_history->lines. */
132	int
133	history_total_bytes ()
134	{
135	register int i, result;
136
137	result = 0;
138
139	for (i = 0; the_history && the_history[i]; i++)
140	result += strlen (the_history[i]->line);
141
142	return (result);
143	}
144
145	/* Returns the magic number which says what history element we are
146	looking at now. In this implementation, it returns history_offset. */
147	int
148	where_history ()
149	{
150	return (history_offset);
151	}
152
153	/* Make the current history item be the one at POS, an absolute index.
154	Returns zero if POS is out of range, else non-zero. */
155	int
156	history_set_pos (pos)
157	int pos;
158	{
159	if (pos > history_length \|\| pos < 0 \|\| !the_history)
160	return (0);
161	history_offset = pos;
162	return (1);
163	}
164
165	/* Return the current history array. The caller has to be carefull, since this
166	is the actual array of data, and could be bashed or made corrupt easily.
167	The array is terminated with a NULL pointer. */
168	HIST_ENTRY **
169	history_list ()
170	{
171	return (the_history);
172	}
173
174	/* Return the history entry at the current position, as determined by
175	history_offset. If there is no entry there, return a NULL pointer. */
176	HIST_ENTRY *
177	current_history ()
178	{
179	return ((history_offset == history_length) \|\| the_history == 0)
180	? (HIST_ENTRY *)NULL
181	: the_history[history_offset];
182	}
183
184	/* Back up history_offset to the previous history entry, and return
185	a pointer to that entry. If there is no previous entry then return
186	a NULL pointer. */
187	HIST_ENTRY *
188	previous_history ()
189	{
190	return history_offset ? the_history[--history_offset] : (HIST_ENTRY *)NULL;
191	}
192
193	/* Move history_offset forward to the next history entry, and return
194	a pointer to that entry. If there is no next entry then return a
195	NULL pointer. */
196	HIST_ENTRY *
197	next_history ()
198	{
199	return (history_offset == history_length) ? (HIST_ENTRY *)NULL : the_history[++history_offset];
200	}
201
202	/* Return the history entry which is logically at OFFSET in the history array.
203	OFFSET is relative to history_base. */
204	HIST_ENTRY *
205	history_get (offset)
206	int offset;
207	{
208	int local_index;
209
210	local_index = offset - history_base;
211	return (local_index >= history_length \|\| local_index < 0 \|\| !the_history)
212	? (HIST_ENTRY *)NULL
213	: the_history[local_index];
214	}
215
216	/* Place STRING at the end of the history list. The data field
217	is set to NULL. */
218	void
219	add_history (string)
220	char *string;
221	{
222	HIST_ENTRY *temp;
223
224	if (history_stifled && (history_length == max_input_history))
225	{
226	register int i;
227
228	/* If the history is stifled, and history_length is zero,
229	and it equals max_input_history, we don't save items. */
230	if (history_length == 0)
231	return;
232
233	/* If there is something in the slot, then remove it. */
234	if (the_history[0])
235	{
236	free (the_history[0]->line);
237	free (the_history[0]);
238	}
239
240	/* Copy the rest of the entries, moving down one slot. */
241	for (i = 0; i < history_length; i++)
242	the_history[i] = the_history[i + 1];
243
244	history_base++;
245	}
246	else
247	{
248	if (history_size == 0)
249	{
250	history_size = DEFAULT_HISTORY_GROW_SIZE;
251	the_history = (HIST_ENTRY *)xmalloc (history_size sizeof (HIST_ENTRY *));
252	history_length = 1;
253	}
254	else
255	{
256	if (history_length == (history_size - 1))
257	{
258	history_size += DEFAULT_HISTORY_GROW_SIZE;
259	the_history = (HIST_ENTRY **)
260	xrealloc (the_history, history_size * sizeof (HIST_ENTRY *));
261	}
262	history_length++;
263	}
264	}
265
266	temp = (HIST_ENTRY *)xmalloc (sizeof (HIST_ENTRY));
267	temp->line = savestring (string);
268	temp->data = (char *)NULL;
269
270	the_history[history_length] = (HIST_ENTRY *)NULL;
271	the_history[history_length - 1] = temp;
272	}
273
274	/* Make the history entry at WHICH have LINE and DATA. This returns
275	the old entry so you can dispose of the data. In the case of an
276	invalid WHICH, a NULL pointer is returned. */
277	HIST_ENTRY *
278	replace_history_entry (which, line, data)
279	int which;
280	char *line;
c862e87b	281	histdata_t data;
d60d9f65 SS	282	{
	283	HIST_ENTRY temp = (HIST_ENTRY )xmalloc (sizeof (HIST_ENTRY));
	284	HIST_ENTRY *old_value;
	285
	286	if (which >= history_length)
	287	return ((HIST_ENTRY *)NULL);
	288
	289	old_value = the_history[which];
	290
	291	temp->line = savestring (line);
	292	temp->data = data;
	293	the_history[which] = temp;
	294
	295	return (old_value);
	296	}
	297
	298	/* Remove history element WHICH from the history. The removed
	299	element is returned to you so you can free the line, data,
	300	and containing structure. */
	301	HIST_ENTRY *
	302	remove_history (which)
	303	int which;
	304	{
	305	HIST_ENTRY *return_value;
	306
	307	if (which >= history_length \|\| !history_length)
	308	return_value = (HIST_ENTRY *)NULL;
	309	else
	310	{
	311	register int i;
	312	return_value = the_history[which];
	313
	314	for (i = which; i < history_length; i++)
	315	the_history[i] = the_history[i + 1];
	316
	317	history_length--;
	318	}
	319
	320	return (return_value);
	321	}
	322
	323	/* Stifle the history list, remembering only MAX number of lines. */
	324	void
	325	stifle_history (max)
	326	int max;
	327	{
	328	if (max < 0)
	329	max = 0;
	330
	331	if (history_length > max)
	332	{
	333	register int i, j;
	334
	335	/* This loses because we cannot free the data. */
	336	for (i = 0, j = history_length - max; i < j; i++)
	337	{
	338	free (the_history[i]->line);
	339	free (the_history[i]);
	340	}
	341
	342	history_base = i;
	343	for (j = 0, i = history_length - max; j < max; i++, j++)
	344	the_history[j] = the_history[i];
	345	the_history[j] = (HIST_ENTRY *)NULL;
346	history_length = j;
347	}
348
349	history_stifled = 1;
350	max_input_history = max;
351	}
352
353	/* Stop stifling the history. This returns the previous amount the
354	history was stifled by. The value is positive if the history was
355	stifled, negative if it wasn't. */
356	int
357	unstifle_history ()
358	{
359	if (history_stifled)
360	{
361	history_stifled = 0;
362	return (-max_input_history);
363	}
364
365	return (max_input_history);
366	}
367
368	int
369	history_is_stifled ()
370	{
371	return (history_stifled);
372	}
373
374	void
375	clear_history ()
376	{
377	register int i;
378
379	/* This loses because we cannot free the data. */
380	for (i = 0; i < history_length; i++)
381	{
382	free (the_history[i]->line);
383	free (the_history[i]);
384	the_history[i] = (HIST_ENTRY *)NULL;
385	}
386
387	history_offset = history_length = 0;
388	}