/* 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", 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