[thirdparty/bash.git] / lib / readline / util.c

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

/* Copyright (C) 1987-2009 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"

/* **************************************************************** */
/*								    */
/*			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. */
int
_rl_strnicmp (string1, string2, count)
     char *string1, *string2;
     int count;
{
  register char ch1, ch2;

  while (count)
    {
      ch1 = *string1++;
      ch2 = *string2++;
      if (_rl_to_upper(ch1) == _rl_to_upper(ch2))
	count--;
      else
        break;
    }
  return (count);
}

/* strcmp (), but caseless. */
int
_rl_stricmp (string1, string2)
     char *string1, *string2;
{
  register char ch1, ch2;

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