/* util.c -- readline utility functions */ /* Copyright (C) 1987, 1989, 1992 Free Software Foundation, Inc. This file is part of the GNU Readline Library, a library for reading lines of text with interactive input and history editing. The GNU Readline 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 GNU Readline 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. */ #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" #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" #define SWAP(s, e) do { int t; t = s; s = e; e = t; } while (0) /* **************************************************************** */ /* */ /* 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 char *pathname_alphabetic_chars = "/-_=~.#$"; int alphabetic (c) int c; { if (ALPHABETIC (c)) return (1); return (_rl_allow_pathname_alphabetic_chars && strchr (pathname_alphabetic_chars, c) != NULL); } /* How to abort things. */ int _rl_abort_internal () { ding (); rl_clear_message (); _rl_init_argument (); rl_pending_input = 0; _rl_defining_kbd_macro = 0; while (_rl_executing_macro) _rl_pop_executing_macro (); rl_last_func = (Function *)NULL; longjmp (readline_top_level, 1); return (0); } int rl_abort (count, key) int count, key; { return (_rl_abort_internal ()); } int rl_tty_status (count, key) int count, key; { #if defined (TIOCSTAT) ioctl (1, TIOCSTAT, (char *)0); rl_refresh_line (count, key); #else 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 = 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 = 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); 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 = xmalloc (len + 1); strncpy (temp, rl_line_buffer + start, len); temp[len] = '\0'; homedir = tilde_expand (temp); free (temp); _rl_replace_text (homedir, start, end); } return (0); } /* **************************************************************** */ /* */ /* 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 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 (s1 + i); return ((char *)NULL); } #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 chartypes.h. */ #undef _rl_uppercase_p int _rl_uppercase_p (c) int c; { return (isupper (c)); } #undef _rl_lowercase_p int _rl_lowercase_p (c) int c; { return (islower (c)); } #undef _rl_pure_alphabetic int _rl_pure_alphabetic (c) int c; { return (isupper (c) || islower (c)); } #undef _rl_digit_p int _rl_digit_p (c) int c; { return (isdigit (c)); } #undef _rl_to_lower int _rl_to_lower (c) int c; { return (isupper (c) ? tolower (c) : c); } #undef _rl_to_upper int _rl_to_upper (c) int c; { return (islower (c) ? toupper (c) : c); } #undef _rl_digit_value int _rl_digit_value (c) int c; { return (isdigit (c) ? c - '0' : c); } /* Backwards compatibility, now that savestring has been removed from all `public' readline header files. */ #undef _rl_savestring char * _rl_savestring (s) char *s; { return ((char *)strcpy (xmalloc (1 + (int)strlen (s)), (s))); }