/* 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_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_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)

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_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", 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