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

/* util.c -- readline utility functions */

/* Copyright (C) 1987-2010 Free Software Foundation, Inc.

   This file is part of the GNU Readline Library (Readline), a library
   for reading lines of text with interactive input and history editing.      

   Readline 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 3 of the License, or
   (at your option) any later version.

   Readline 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.

   You should have received a copy of the GNU General Public License
   along with Readline.  If not, see <http://www.gnu.org/licenses/>.
*/

#define READLINE_LIBRARY

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

#include <sys/types.h>
#include <fcntl.h>
#include "posixjmp.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>
#include <ctype.h>

/* System-specific feature definitions and include files. */
#include "rldefs.h"
#include "rlmbutil.h"

#if defined (TIOCSTAT_IN_SYS_IOCTL)
#  include <sys/ioctl.h>
#endif /* TIOCSTAT_IN_SYS_IOCTL */

/* Some standard library routines. */
#include "readline.h"

#include "rlprivate.h"
#include "xmalloc.h"
#include "rlshell.h"

/* **************************************************************** */
/*								    */
/*			Utility Functions			    */
/*								    */
/* **************************************************************** */

/* Return 0 if C is not a member of the class of characters that belong
   in words, or 1 if it is. */

int _rl_allow_pathname_alphabetic_chars = 0;
static const char * const pathname_alphabetic_chars = "/-_=~.#$";

int
rl_alphabetic (c)
     int c;
{
  if (ALPHABETIC (c))
    return (1);

  return (_rl_allow_pathname_alphabetic_chars &&
	    strchr (pathname_alphabetic_chars, c) != NULL);
}

#if defined (HANDLE_MULTIBYTE)
int
_rl_walphabetic (wchar_t wc)
{
  int c;

  if (iswalnum (wc))
    return (1);     

  c = wc & 0177;
  return (_rl_allow_pathname_alphabetic_chars &&
	    strchr (pathname_alphabetic_chars, c) != NULL);
}
#endif

/* How to abort things. */
int
_rl_abort_internal ()
{
  rl_ding ();
  rl_clear_message ();
  _rl_reset_argument ();
  rl_clear_pending_input ();

  RL_UNSETSTATE (RL_STATE_MACRODEF);
  while (rl_executing_macro)
    _rl_pop_executing_macro ();

  rl_last_func = (rl_command_func_t *)NULL;
  longjmp (_rl_top_level, 1);
  return (0);
}

int
rl_abort (count, key)
     int count, key;
{
  return (_rl_abort_internal ());
}

int
_rl_null_function (count, key)
     int count, key;
{
  return 0;
}

int
rl_tty_status (count, key)
     int count, key;
{
#if defined (TIOCSTAT)
  ioctl (1, TIOCSTAT, (char *)0);
  rl_refresh_line (count, key);
#else
  rl_ding ();
#endif
  return 0;
}

/* Return a copy of the string between FROM and TO.
   FROM is inclusive, TO is not. */
char *
rl_copy_text (from, to)
     int from, to;
{
  register int length;
  char *copy;

  /* Fix it if the caller is confused. */
  if (from > to)
    SWAP (from, to);

  length = to - from;
  copy = (char *)xmalloc (1 + length);
  strncpy (copy, rl_line_buffer + from, length);
  copy[length] = '\0';
  return (copy);
}

/* Increase the size of RL_LINE_BUFFER until it has enough space to hold
   LEN characters. */
void
rl_extend_line_buffer (len)
     int len;
{
  while (len >= rl_line_buffer_len)
    {
      rl_line_buffer_len += DEFAULT_BUFFER_SIZE;
      rl_line_buffer = (char *)xrealloc (rl_line_buffer, rl_line_buffer_len);
    }

  _rl_set_the_line ();
}


/* A function for simple tilde expansion. */
int
rl_tilde_expand (ignore, key)
     int ignore, key;
{
  register int start, end;
  char *homedir, *temp;
  int len;

  end = rl_point;
  start = end - 1;

  if (rl_point == rl_end && rl_line_buffer[rl_point] == '~')
    {
      homedir = tilde_expand ("~");
      _rl_replace_text (homedir, start, end);
      xfree (homedir);
      return (0);
    }
  else if (rl_line_buffer[start] != '~')
    {
      for (; !whitespace (rl_line_buffer[start]) && start >= 0; start--)
        ;
      start++;
    }

  end = start;
  do
    end++;
  while (whitespace (rl_line_buffer[end]) == 0 && end < rl_end);

  if (whitespace (rl_line_buffer[end]) || end >= rl_end)
    end--;

  /* If the first character of the current word is a tilde, perform
     tilde expansion and insert the result.  If not a tilde, do
     nothing. */
  if (rl_line_buffer[start] == '~')
    {
      len = end - start + 1;
      temp = (char *)xmalloc (len + 1);
      strncpy (temp, rl_line_buffer + start, len);
      temp[len] = '\0';
      homedir = tilde_expand (temp);
      xfree (temp);

      _rl_replace_text (homedir, start, end);
      xfree (homedir);
    }

  return (0);
}

#if defined (USE_VARARGS)
void
#if defined (PREFER_STDARG)
_rl_ttymsg (const char *format, ...)
#else
_rl_ttymsg (va_alist)
     va_dcl
#endif
{
  va_list args;
#if defined (PREFER_VARARGS)
  char *format;
#endif

#if defined (PREFER_STDARG)
  va_start (args, format);
#else
  va_start (args);
  format = va_arg (args, char *);
#endif

  fprintf (stderr, "readline: ");
  vfprintf (stderr, format, args);
  fprintf (stderr, "\n");
  fflush (stderr);

  va_end (args);

  rl_forced_update_display ();
}

void
#if defined (PREFER_STDARG)
_rl_errmsg (const char *format, ...)
#else
_rl_errmsg (va_alist)
     va_dcl
#endif
{
  va_list args;
#if defined (PREFER_VARARGS)
  char *format;
#endif

#if defined (PREFER_STDARG)
  va_start (args, format);
#else
  va_start (args);
  format = va_arg (args, char *);
#endif

  fprintf (stderr, "readline: ");
  vfprintf (stderr, format, args);
  fprintf (stderr, "\n");
  fflush (stderr);

  va_end (args);
}

#else /* !USE_VARARGS */
void
_rl_ttymsg (format, arg1, arg2)
     char *format;
{
  fprintf (stderr, "readline: ");
  fprintf (stderr, format, arg1, arg2);
  fprintf (stderr, "\n");

  rl_forced_update_display ();
}

void
_rl_errmsg (format, arg1, arg2)
     char *format;
{
  fprintf (stderr, "readline: ");
  fprintf (stderr, format, arg1, arg2);
  fprintf (stderr, "\n");
}
#endif /* !USE_VARARGS */

/* **************************************************************** */
/*								    */
/*			String Utility Functions		    */
/*								    */
/* **************************************************************** */

/* Determine if s2 occurs in s1.  If so, return a pointer to the
   match in s1.  The compare is case insensitive. */
char *
_rl_strindex (s1, s2)
     register const char *s1, *s2;
{
  register int i, l, len;

  for (i = 0, l = strlen (s2), len = strlen (s1); (len - i) >= l; i++)
    if (_rl_strnicmp (s1 + i, s2, l) == 0)
      return ((char *) (s1 + i));
  return ((char *)NULL);
}

#ifndef HAVE_STRPBRK
/* Find the first occurrence in STRING1 of any character from STRING2.
   Return a pointer to the character in STRING1. */
char *
_rl_strpbrk (string1, string2)
     const char *string1, *string2;
{
  register const char *scan;
#if defined (HANDLE_MULTIBYTE)
  mbstate_t ps;
  register int i, v;

  memset (&ps, 0, sizeof (mbstate_t));
#endif

  for (; *string1; string1++)
    {
      for (scan = string2; *scan; scan++)
	{
	  if (*string1 == *scan)
	    return ((char *)string1);
	}
#if defined (HANDLE_MULTIBYTE)
      if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
	{
	  v = _rl_get_char_len (string1, &ps);
	  if (v > 1)
	    string1 += v - 1;	/* -1 to account for auto-increment in loop */
	}
#endif
    }
  return ((char *)NULL);
}
#endif

#if !defined (HAVE_STRCASECMP)
/* Compare at most COUNT characters from string1 to string2.  Case
   doesn't matter (strncasecmp). */
int
_rl_strnicmp (string1, string2, count)
     char *string1, *string2;
     int count;
{
  register char *s1, *s2;
  int d;

  if (count <= 0 || (string1 == string2))
    return 0;

  s1 = string1;
  s2 = string2;
  do
    {
      d = _rl_to_lower (*s1) - _rl_to_lower (*s2);	/* XXX - cast to unsigned char? */
      if (d != 0)
	return d;
      if (*s1++ == '\0')
        break;
      s2++;
    }
  while (--count != 0);

  return (0);
}

/* strcmp (), but caseless (strcasecmp). */
int
_rl_stricmp (string1, string2)
     char *string1, *string2;
{
  register char *s1, *s2;
  int d;

  s1 = string1;
  s2 = string2;

  if (s1 == s2)
    return 0;

  while ((d = _rl_to_lower (*s1) - _rl_to_lower (*s2)) == 0)
    {
      if (*s1++ == '\0')
        return 0;
      s2++;
    }

  return (d);
}
#endif /* !HAVE_STRCASECMP */

/* Stupid comparison routine for qsort () ing strings. */
int
_rl_qsort_string_compare (s1, s2)
  char **s1, **s2;
{
#if defined (HAVE_STRCOLL)
  return (strcoll (*s1, *s2));
#else
  int result;

  result = **s1 - **s2;
  if (result == 0)
    result = strcmp (*s1, *s2);

  return result;
#endif
}

/* Function equivalents for the macros defined in chardefs.h. */
#define FUNCTION_FOR_MACRO(f)	int (f) (c) int c; { return f (c); }

FUNCTION_FOR_MACRO (_rl_digit_p)
FUNCTION_FOR_MACRO (_rl_digit_value)
FUNCTION_FOR_MACRO (_rl_lowercase_p)
FUNCTION_FOR_MACRO (_rl_pure_alphabetic)
FUNCTION_FOR_MACRO (_rl_to_lower)
FUNCTION_FOR_MACRO (_rl_to_upper)
FUNCTION_FOR_MACRO (_rl_uppercase_p)

/* A convenience function, to force memory deallocation to be performed
   by readline.  DLLs on Windows apparently require this. */
void
rl_free (mem)
     void *mem;
{
  if (mem)
    free (mem);
}

/* Backwards compatibility, now that savestring has been removed from
   all `public' readline header files. */
#undef _rl_savestring
char *
_rl_savestring (s)
     const char *s;
{
  return (strcpy ((char *)xmalloc (1 + (int)strlen (s)), (s)));
}

#if defined (USE_VARARGS)
static FILE *_rl_tracefp;

void
#if defined (PREFER_STDARG)
_rl_trace (const char *format, ...)
#else
_rl_trace (va_alist)
     va_dcl
#endif
{
  va_list args;
#if defined (PREFER_VARARGS)
  char *format;
#endif

#if defined (PREFER_STDARG)
  va_start (args, format);
#else
  va_start (args);
  format = va_arg (args, char *);
#endif

  if (_rl_tracefp == 0)
    _rl_tropen ();
  vfprintf (_rl_tracefp, format, args);
  fprintf (_rl_tracefp, "\n");
  fflush (_rl_tracefp);

  va_end (args);
}

int
_rl_tropen ()
{
  char fnbuf[128];

  if (_rl_tracefp)
    fclose (_rl_tracefp);
#if defined (_WIN32) && !defined (__CYGWIN__)
  /* Windows doesn't have /var/tmp, so open the trace file in the
     user's temporary directory instead.  */
  sprintf (fnbuf, "%s/rltrace.%ld",
	   (sh_get_env_value ("TEMP")
	    ? sh_get_env_value ("TEMP")
	    : "."),
	   getpid ());
#else
  sprintf (fnbuf, "/var/tmp/rltrace.%ld", (long) getpid ());
#endif
  unlink (fnbuf);
  _rl_tracefp = fopen (fnbuf, "w+");
  return _rl_tracefp != 0;
}

int
_rl_trclose ()
{
  int r;

  r = fclose (_rl_tracefp);
  _rl_tracefp = 0;
  return r;
}

#endif
Commit	Line	Data
	1	/* util.c -- readline utility functions */
	2
	3	/* Copyright (C) 1987-2010 Free Software Foundation, Inc.
	4
	5	This file is part of the GNU Readline Library (Readline), a library
	6	for reading lines of text with interactive input and history editing.
	7
	8	Readline is free software: you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation, either version 3 of the License, or
	11	(at your option) any later version.
	12
	13	Readline is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
	19	along with Readline. If not, see <http://www.gnu.org/licenses/>.
	20	*/
	21
	22	#define READLINE_LIBRARY
	23
	24	#if defined (HAVE_CONFIG_H)
	25	# include <config.h>
	26	#endif
	27
	28	#include <sys/types.h>
	29	#include <fcntl.h>
	30	#include "posixjmp.h"
	31
	32	#if defined (HAVE_UNISTD_H)
	33	# include <unistd.h> /* for _POSIX_VERSION */
	34	#endif /* HAVE_UNISTD_H */
	35
	36	#if defined (HAVE_STDLIB_H)
	37	# include <stdlib.h>
	38	#else
	39	# include "ansi_stdlib.h"
	40	#endif /* HAVE_STDLIB_H */
	41
	42	#include <stdio.h>
	43	#include <ctype.h>
	44
	45	/* System-specific feature definitions and include files. */
	46	#include "rldefs.h"
	47	#include "rlmbutil.h"
	48
	49	#if defined (TIOCSTAT_IN_SYS_IOCTL)
	50	# include <sys/ioctl.h>
	51	#endif /* TIOCSTAT_IN_SYS_IOCTL */
	52
	53	/* Some standard library routines. */
	54	#include "readline.h"
	55
	56	#include "rlprivate.h"
	57	#include "xmalloc.h"
	58	#include "rlshell.h"
	59
	60	/* **************************************************************** */
	61	/* */
	62	/* Utility Functions */
	63	/* */
	64	/* **************************************************************** */
	65
	66	/* Return 0 if C is not a member of the class of characters that belong
	67	in words, or 1 if it is. */
	68
	69	int _rl_allow_pathname_alphabetic_chars = 0;
	70	static const char * const pathname_alphabetic_chars = "/-_=~.#$";
	71
	72	int
	73	rl_alphabetic (c)
	74	int c;
	75	{
	76	if (ALPHABETIC (c))
	77	return (1);
	78
	79	return (_rl_allow_pathname_alphabetic_chars &&
	80	strchr (pathname_alphabetic_chars, c) != NULL);
	81	}
	82
	83	#if defined (HANDLE_MULTIBYTE)
	84	int
	85	_rl_walphabetic (wchar_t wc)
	86	{
	87	int c;
	88
	89	if (iswalnum (wc))
	90	return (1);
	91
	92	c = wc & 0177;
	93	return (_rl_allow_pathname_alphabetic_chars &&
	94	strchr (pathname_alphabetic_chars, c) != NULL);
	95	}
	96	#endif
	97
	98	/* How to abort things. */
	99	int
	100	_rl_abort_internal ()
	101	{
	102	rl_ding ();
	103	rl_clear_message ();
	104	_rl_reset_argument ();
	105	rl_clear_pending_input ();
	106
	107	RL_UNSETSTATE (RL_STATE_MACRODEF);
	108	while (rl_executing_macro)
	109	_rl_pop_executing_macro ();
	110
	111	rl_last_func = (rl_command_func_t *)NULL;
	112	longjmp (_rl_top_level, 1);
	113	return (0);
	114	}
	115
	116	int
	117	rl_abort (count, key)
	118	int count, key;
	119	{
	120	return (_rl_abort_internal ());
	121	}
	122
	123	int
	124	_rl_null_function (count, key)
	125	int count, key;
	126	{
	127	return 0;
	128	}
	129
	130	int
	131	rl_tty_status (count, key)
	132	int count, key;
	133	{
	134	#if defined (TIOCSTAT)
	135	ioctl (1, TIOCSTAT, (char *)0);
	136	rl_refresh_line (count, key);
	137	#else
	138	rl_ding ();
	139	#endif
	140	return 0;
	141	}
	142
	143	/* Return a copy of the string between FROM and TO.
	144	FROM is inclusive, TO is not. */
	145	char *
	146	rl_copy_text (from, to)
	147	int from, to;
	148	{
	149	register int length;
	150	char *copy;
	151
	152	/* Fix it if the caller is confused. */
	153	if (from > to)
	154	SWAP (from, to);
	155
	156	length = to - from;
	157	copy = (char *)xmalloc (1 + length);
	158	strncpy (copy, rl_line_buffer + from, length);
	159	copy[length] = '\0';
	160	return (copy);
	161	}
	162
	163	/* Increase the size of RL_LINE_BUFFER until it has enough space to hold
	164	LEN characters. */
	165	void
	166	rl_extend_line_buffer (len)
	167	int len;
	168	{
	169	while (len >= rl_line_buffer_len)
	170	{
	171	rl_line_buffer_len += DEFAULT_BUFFER_SIZE;
	172	rl_line_buffer = (char *)xrealloc (rl_line_buffer, rl_line_buffer_len);
	173	}
	174
	175	_rl_set_the_line ();
	176	}
	177
	178
	179	/* A function for simple tilde expansion. */
	180	int
	181	rl_tilde_expand (ignore, key)
	182	int ignore, key;
	183	{
	184	register int start, end;
	185	char homedir, temp;
	186	int len;
	187
	188	end = rl_point;
	189	start = end - 1;
	190
	191	if (rl_point == rl_end && rl_line_buffer[rl_point] == '~')
	192	{
	193	homedir = tilde_expand ("~");
	194	_rl_replace_text (homedir, start, end);
	195	xfree (homedir);
	196	return (0);
	197	}
	198	else if (rl_line_buffer[start] != '~')
	199	{
	200	for (; !whitespace (rl_line_buffer[start]) && start >= 0; start--)
	201	;
	202	start++;
	203	}
	204
	205	end = start;
	206	do
	207	end++;
	208	while (whitespace (rl_line_buffer[end]) == 0 && end < rl_end);
	209
	210	if (whitespace (rl_line_buffer[end]) \|\| end >= rl_end)
	211	end--;
	212
	213	/* If the first character of the current word is a tilde, perform
	214	tilde expansion and insert the result. If not a tilde, do
	215	nothing. */
	216	if (rl_line_buffer[start] == '~')
	217	{
	218	len = end - start + 1;
	219	temp = (char *)xmalloc (len + 1);
	220	strncpy (temp, rl_line_buffer + start, len);
	221	temp[len] = '\0';
	222	homedir = tilde_expand (temp);
	223	xfree (temp);
	224
	225	_rl_replace_text (homedir, start, end);
	226	xfree (homedir);
	227	}
	228
	229	return (0);
	230	}
	231
	232	#if defined (USE_VARARGS)
	233	void
	234	#if defined (PREFER_STDARG)
	235	_rl_ttymsg (const char *format, ...)
	236	#else
	237	_rl_ttymsg (va_alist)
	238	va_dcl
	239	#endif
	240	{
	241	va_list args;
	242	#if defined (PREFER_VARARGS)
	243	char *format;
	244	#endif
	245
	246	#if defined (PREFER_STDARG)
	247	va_start (args, format);
	248	#else
	249	va_start (args);
	250	format = va_arg (args, char *);
	251	#endif
	252
	253	fprintf (stderr, "readline: ");
	254	vfprintf (stderr, format, args);
	255	fprintf (stderr, "\n");
	256	fflush (stderr);
	257
	258	va_end (args);
	259
	260	rl_forced_update_display ();
	261	}
	262
	263	void
	264	#if defined (PREFER_STDARG)
	265	_rl_errmsg (const char *format, ...)
	266	#else
	267	_rl_errmsg (va_alist)
	268	va_dcl
	269	#endif
	270	{
	271	va_list args;
	272	#if defined (PREFER_VARARGS)
	273	char *format;
	274	#endif
	275
	276	#if defined (PREFER_STDARG)
	277	va_start (args, format);
	278	#else
	279	va_start (args);
	280	format = va_arg (args, char *);
	281	#endif
	282
	283	fprintf (stderr, "readline: ");
	284	vfprintf (stderr, format, args);
	285	fprintf (stderr, "\n");
	286	fflush (stderr);
	287
	288	va_end (args);
	289	}
	290
	291	#else /* !USE_VARARGS */
	292	void
	293	_rl_ttymsg (format, arg1, arg2)
	294	char *format;
	295	{
	296	fprintf (stderr, "readline: ");
	297	fprintf (stderr, format, arg1, arg2);
	298	fprintf (stderr, "\n");
	299
	300	rl_forced_update_display ();
	301	}
	302
	303	void
	304	_rl_errmsg (format, arg1, arg2)
	305	char *format;
	306	{
	307	fprintf (stderr, "readline: ");
	308	fprintf (stderr, format, arg1, arg2);
	309	fprintf (stderr, "\n");
	310	}
	311	#endif /* !USE_VARARGS */
	312
	313	/* **************************************************************** */
	314	/* */
	315	/* String Utility Functions */
	316	/* */
	317	/* **************************************************************** */
	318
	319	/* Determine if s2 occurs in s1. If so, return a pointer to the
	320	match in s1. The compare is case insensitive. */
	321	char *
	322	_rl_strindex (s1, s2)
	323	register const char s1, s2;
	324	{
	325	register int i, l, len;
	326
	327	for (i = 0, l = strlen (s2), len = strlen (s1); (len - i) >= l; i++)
	328	if (_rl_strnicmp (s1 + i, s2, l) == 0)
	329	return ((char *) (s1 + i));
	330	return ((char *)NULL);
	331	}
	332
	333	#ifndef HAVE_STRPBRK
	334	/* Find the first occurrence in STRING1 of any character from STRING2.
	335	Return a pointer to the character in STRING1. */
	336	char *
	337	_rl_strpbrk (string1, string2)
	338	const char string1, string2;
	339	{
	340	register const char *scan;
	341	#if defined (HANDLE_MULTIBYTE)
	342	mbstate_t ps;
	343	register int i, v;
	344
	345	memset (&ps, 0, sizeof (mbstate_t));
	346	#endif
	347
	348	for (; *string1; string1++)
	349	{
	350	for (scan = string2; *scan; scan++)
	351	{
	352	if (string1 == scan)
	353	return ((char *)string1);
	354	}
	355	#if defined (HANDLE_MULTIBYTE)
	356	if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
	357	{
	358	v = _rl_get_char_len (string1, &ps);
	359	if (v > 1)
	360	string1 += v - 1; /* -1 to account for auto-increment in loop */
	361	}
	362	#endif
	363	}
	364	return ((char *)NULL);
	365	}
	366	#endif
	367
	368	#if !defined (HAVE_STRCASECMP)
	369	/* Compare at most COUNT characters from string1 to string2. Case
	370	doesn't matter (strncasecmp). */
	371	int
	372	_rl_strnicmp (string1, string2, count)
	373	char string1, string2;
	374	int count;
	375	{
	376	register char s1, s2;
	377	int d;
	378
	379	if (count <= 0 \|\| (string1 == string2))
	380	return 0;
	381
	382	s1 = string1;
	383	s2 = string2;
	384	do
	385	{
	386	d = _rl_to_lower (s1) - _rl_to_lower (s2); /* XXX - cast to unsigned char? */
	387	if (d != 0)
	388	return d;
	389	if (*s1++ == '\0')
	390	break;
	391	s2++;
	392	}
	393	while (--count != 0);
	394
	395	return (0);
	396	}
	397
	398	/* strcmp (), but caseless (strcasecmp). */
	399	int
	400	_rl_stricmp (string1, string2)
	401	char string1, string2;
	402	{
	403	register char s1, s2;
	404	int d;
	405
	406	s1 = string1;
	407	s2 = string2;
	408
	409	if (s1 == s2)
	410	return 0;
	411
	412	while ((d = _rl_to_lower (s1) - _rl_to_lower (s2)) == 0)
	413	{
	414	if (*s1++ == '\0')
	415	return 0;
	416	s2++;
	417	}
	418
	419	return (d);
	420	}
	421	#endif /* !HAVE_STRCASECMP */
	422
	423	/* Stupid comparison routine for qsort () ing strings. */
	424	int
	425	_rl_qsort_string_compare (s1, s2)
	426	char s1, s2;
	427	{
	428	#if defined (HAVE_STRCOLL)
	429	return (strcoll (s1, s2));
	430	#else
	431	int result;
	432
	433	result = s1 - s2;
	434	if (result == 0)
	435	result = strcmp (s1, s2);
	436
	437	return result;
	438	#endif
	439	}
	440
	441	/* Function equivalents for the macros defined in chardefs.h. */
	442	#define FUNCTION_FOR_MACRO(f) int (f) (c) int c; { return f (c); }
	443
	444	FUNCTION_FOR_MACRO (_rl_digit_p)
	445	FUNCTION_FOR_MACRO (_rl_digit_value)
	446	FUNCTION_FOR_MACRO (_rl_lowercase_p)
	447	FUNCTION_FOR_MACRO (_rl_pure_alphabetic)
	448	FUNCTION_FOR_MACRO (_rl_to_lower)
	449	FUNCTION_FOR_MACRO (_rl_to_upper)
	450	FUNCTION_FOR_MACRO (_rl_uppercase_p)
	451
	452	/* A convenience function, to force memory deallocation to be performed
	453	by readline. DLLs on Windows apparently require this. */
	454	void
	455	rl_free (mem)
	456	void *mem;
	457	{
	458	if (mem)
	459	free (mem);
	460	}
	461
	462	/* Backwards compatibility, now that savestring has been removed from
	463	all `public' readline header files. */
	464	#undef _rl_savestring
	465	char *
	466	_rl_savestring (s)
	467	const char *s;
	468	{
	469	return (strcpy ((char *)xmalloc (1 + (int)strlen (s)), (s)));
	470	}
	471
	472	#if defined (USE_VARARGS)
	473	static FILE *_rl_tracefp;
	474
	475	void
	476	#if defined (PREFER_STDARG)
	477	_rl_trace (const char *format, ...)
	478	#else
	479	_rl_trace (va_alist)
	480	va_dcl
	481	#endif
	482	{
	483	va_list args;
	484	#if defined (PREFER_VARARGS)
	485	char *format;
	486	#endif
	487
	488	#if defined (PREFER_STDARG)
	489	va_start (args, format);
	490	#else
	491	va_start (args);
	492	format = va_arg (args, char *);
	493	#endif
	494
	495	if (_rl_tracefp == 0)
	496	_rl_tropen ();
	497	vfprintf (_rl_tracefp, format, args);
	498	fprintf (_rl_tracefp, "\n");
	499	fflush (_rl_tracefp);
	500
	501	va_end (args);
	502	}
	503
	504	int
	505	_rl_tropen ()
	506	{
	507	char fnbuf[128];
	508
	509	if (_rl_tracefp)
	510	fclose (_rl_tracefp);
	511	#if defined (_WIN32) && !defined (__CYGWIN__)
	512	/* Windows doesn't have /var/tmp, so open the trace file in the
	513	user's temporary directory instead. */
	514	sprintf (fnbuf, "%s/rltrace.%ld",
	515	(sh_get_env_value ("TEMP")
	516	? sh_get_env_value ("TEMP")
	517	: "."),
	518	getpid ());
	519	#else
	520	sprintf (fnbuf, "/var/tmp/rltrace.%ld", (long) getpid ());
	521	#endif
	522	unlink (fnbuf);
	523	_rl_tracefp = fopen (fnbuf, "w+");
	524	return _rl_tracefp != 0;
	525	}
	526
	527	int
	528	_rl_trclose ()
	529	{
	530	int r;
	531
	532	r = fclose (_rl_tracefp);
	533	_rl_tracefp = 0;
	534	return r;
	535	}
	536
	537	#endif