]>
Commit | Line | Data |
---|---|---|
ccc6cda3 JA |
1 | /* util.c -- readline utility functions */ |
2 | ||
3 | /* Copyright (C) 1987, 1989, 1992 Free Software Foundation, Inc. | |
4 | ||
5 | This file is part of the GNU Readline Library, a library for | |
6 | reading lines of text with interactive input and history editing. | |
7 | ||
8 | The GNU Readline Library is free software; you can redistribute it | |
9 | and/or modify it under the terms of the GNU General Public License | |
bb70624e | 10 | as published by the Free Software Foundation; either version 2, or |
ccc6cda3 JA |
11 | (at your option) any later version. |
12 | ||
13 | The GNU Readline Library is distributed in the hope that it will be | |
14 | useful, but WITHOUT ANY WARRANTY; without even the implied warranty | |
15 | of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | GNU General Public License for more details. | |
17 | ||
18 | The GNU General Public License is often shipped with GNU software, and | |
19 | is generally kept in a file called COPYING or LICENSE. If you do not | |
20 | have a copy of the license, write to the Free Software Foundation, | |
bb70624e | 21 | 59 Temple Place, Suite 330, Boston, MA 02111 USA. */ |
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> |
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. */ |
46 | #include "rldefs.h" | |
47 | ||
48 | #if defined (TIOCSTAT_IN_SYS_IOCTL) | |
49 | # include <sys/ioctl.h> | |
50 | #endif /* TIOCSTAT_IN_SYS_IOCTL */ | |
51 | ||
52 | /* Some standard library routines. */ | |
53 | #include "readline.h" | |
54 | ||
bb70624e JA |
55 | #include "rlprivate.h" |
56 | #include "xmalloc.h" | |
ccc6cda3 | 57 | |
bb70624e | 58 | #define SWAP(s, e) do { int t; t = s; s = e; e = t; } while (0) |
ccc6cda3 JA |
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; | |
28ef6c31 | 70 | static const char *pathname_alphabetic_chars = "/-_=~.#$"; |
ccc6cda3 JA |
71 | |
72 | int | |
28ef6c31 | 73 | rl_alphabetic (c) |
ccc6cda3 JA |
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 | /* How to abort things. */ | |
84 | int | |
85 | _rl_abort_internal () | |
86 | { | |
28ef6c31 | 87 | rl_ding (); |
ccc6cda3 JA |
88 | rl_clear_message (); |
89 | _rl_init_argument (); | |
28ef6c31 | 90 | rl_clear_pending_input (); |
ccc6cda3 JA |
91 | |
92 | _rl_defining_kbd_macro = 0; | |
28ef6c31 | 93 | while (rl_executing_macro) |
ccc6cda3 JA |
94 | _rl_pop_executing_macro (); |
95 | ||
28ef6c31 | 96 | rl_last_func = (rl_command_func_t *)NULL; |
ccc6cda3 JA |
97 | longjmp (readline_top_level, 1); |
98 | return (0); | |
99 | } | |
100 | ||
101 | int | |
102 | rl_abort (count, key) | |
103 | int count, key; | |
104 | { | |
105 | return (_rl_abort_internal ()); | |
106 | } | |
107 | ||
108 | int | |
109 | rl_tty_status (count, key) | |
110 | int count, key; | |
111 | { | |
112 | #if defined (TIOCSTAT) | |
113 | ioctl (1, TIOCSTAT, (char *)0); | |
b72432fd | 114 | rl_refresh_line (count, key); |
ccc6cda3 | 115 | #else |
28ef6c31 | 116 | rl_ding (); |
ccc6cda3 JA |
117 | #endif |
118 | return 0; | |
119 | } | |
120 | ||
121 | /* Return a copy of the string between FROM and TO. | |
122 | FROM is inclusive, TO is not. */ | |
123 | char * | |
124 | rl_copy_text (from, to) | |
125 | int from, to; | |
126 | { | |
127 | register int length; | |
128 | char *copy; | |
129 | ||
130 | /* Fix it if the caller is confused. */ | |
131 | if (from > to) | |
132 | SWAP (from, to); | |
133 | ||
134 | length = to - from; | |
135 | copy = xmalloc (1 + length); | |
136 | strncpy (copy, rl_line_buffer + from, length); | |
137 | copy[length] = '\0'; | |
138 | return (copy); | |
139 | } | |
140 | ||
141 | /* Increase the size of RL_LINE_BUFFER until it has enough space to hold | |
142 | LEN characters. */ | |
143 | void | |
144 | rl_extend_line_buffer (len) | |
145 | int len; | |
146 | { | |
147 | while (len >= rl_line_buffer_len) | |
148 | { | |
149 | rl_line_buffer_len += DEFAULT_BUFFER_SIZE; | |
150 | rl_line_buffer = xrealloc (rl_line_buffer, rl_line_buffer_len); | |
151 | } | |
152 | ||
153 | _rl_set_the_line (); | |
154 | } | |
155 | ||
cce855bc JA |
156 | |
157 | /* A function for simple tilde expansion. */ | |
158 | int | |
159 | rl_tilde_expand (ignore, key) | |
160 | int ignore, key; | |
161 | { | |
162 | register int start, end; | |
163 | char *homedir, *temp; | |
164 | int len; | |
165 | ||
166 | end = rl_point; | |
167 | start = end - 1; | |
168 | ||
169 | if (rl_point == rl_end && rl_line_buffer[rl_point] == '~') | |
170 | { | |
171 | homedir = tilde_expand ("~"); | |
172 | _rl_replace_text (homedir, start, end); | |
173 | return (0); | |
174 | } | |
175 | else if (rl_line_buffer[start] != '~') | |
176 | { | |
177 | for (; !whitespace (rl_line_buffer[start]) && start >= 0; start--) | |
178 | ; | |
179 | start++; | |
180 | } | |
181 | ||
182 | end = start; | |
183 | do | |
184 | end++; | |
185 | while (whitespace (rl_line_buffer[end]) == 0 && end < rl_end); | |
186 | ||
187 | if (whitespace (rl_line_buffer[end]) || end >= rl_end) | |
188 | end--; | |
189 | ||
190 | /* If the first character of the current word is a tilde, perform | |
191 | tilde expansion and insert the result. If not a tilde, do | |
192 | nothing. */ | |
193 | if (rl_line_buffer[start] == '~') | |
194 | { | |
195 | len = end - start + 1; | |
196 | temp = xmalloc (len + 1); | |
197 | strncpy (temp, rl_line_buffer + start, len); | |
198 | temp[len] = '\0'; | |
199 | homedir = tilde_expand (temp); | |
200 | free (temp); | |
201 | ||
202 | _rl_replace_text (homedir, start, end); | |
203 | } | |
204 | ||
205 | return (0); | |
206 | } | |
207 | ||
ccc6cda3 JA |
208 | /* **************************************************************** */ |
209 | /* */ | |
210 | /* String Utility Functions */ | |
211 | /* */ | |
212 | /* **************************************************************** */ | |
213 | ||
214 | /* Determine if s2 occurs in s1. If so, return a pointer to the | |
215 | match in s1. The compare is case insensitive. */ | |
216 | char * | |
217 | _rl_strindex (s1, s2) | |
28ef6c31 | 218 | register const char *s1, *s2; |
ccc6cda3 JA |
219 | { |
220 | register int i, l, len; | |
221 | ||
222 | for (i = 0, l = strlen (s2), len = strlen (s1); (len - i) >= l; i++) | |
223 | if (_rl_strnicmp (s1 + i, s2, l) == 0) | |
28ef6c31 JA |
224 | return ((char *) (s1 + i)); |
225 | return ((char *)NULL); | |
226 | } | |
227 | ||
228 | /* Find the first occurrence in STRING1 of any character from STRING2. | |
229 | Return a pointer to the character in STRING1. */ | |
230 | char * | |
231 | _rl_strpbrk (string1, string2) | |
232 | const char *string1, *string2; | |
233 | { | |
234 | register const char *scan; | |
235 | ||
236 | for (; *string1; string1++) | |
237 | { | |
238 | for (scan = string2; *scan; scan++) | |
239 | { | |
240 | if (*string1 == *scan) | |
241 | return ((char *)string1); | |
242 | } | |
243 | } | |
ccc6cda3 JA |
244 | return ((char *)NULL); |
245 | } | |
246 | ||
247 | #if !defined (HAVE_STRCASECMP) | |
248 | /* Compare at most COUNT characters from string1 to string2. Case | |
249 | doesn't matter. */ | |
250 | int | |
251 | _rl_strnicmp (string1, string2, count) | |
252 | char *string1, *string2; | |
253 | int count; | |
254 | { | |
255 | register char ch1, ch2; | |
256 | ||
257 | while (count) | |
258 | { | |
259 | ch1 = *string1++; | |
260 | ch2 = *string2++; | |
261 | if (_rl_to_upper(ch1) == _rl_to_upper(ch2)) | |
262 | count--; | |
263 | else | |
264 | break; | |
265 | } | |
266 | return (count); | |
267 | } | |
268 | ||
269 | /* strcmp (), but caseless. */ | |
270 | int | |
271 | _rl_stricmp (string1, string2) | |
272 | char *string1, *string2; | |
273 | { | |
274 | register char ch1, ch2; | |
275 | ||
276 | while (*string1 && *string2) | |
277 | { | |
278 | ch1 = *string1++; | |
279 | ch2 = *string2++; | |
280 | if (_rl_to_upper(ch1) != _rl_to_upper(ch2)) | |
281 | return (1); | |
282 | } | |
283 | return (*string1 - *string2); | |
284 | } | |
285 | #endif /* !HAVE_STRCASECMP */ | |
286 | ||
287 | /* Stupid comparison routine for qsort () ing strings. */ | |
288 | int | |
289 | _rl_qsort_string_compare (s1, s2) | |
290 | char **s1, **s2; | |
291 | { | |
292 | #if defined (HAVE_STRCOLL) | |
293 | return (strcoll (*s1, *s2)); | |
294 | #else | |
295 | int result; | |
296 | ||
297 | result = **s1 - **s2; | |
298 | if (result == 0) | |
299 | result = strcmp (*s1, *s2); | |
300 | ||
301 | return result; | |
302 | #endif | |
303 | } | |
304 | ||
ccc6cda3 JA |
305 | /* Function equivalents for the macros defined in chartypes.h. */ |
306 | #undef _rl_uppercase_p | |
307 | int | |
308 | _rl_uppercase_p (c) | |
309 | int c; | |
310 | { | |
311 | return (isupper (c)); | |
312 | } | |
313 | ||
314 | #undef _rl_lowercase_p | |
315 | int | |
316 | _rl_lowercase_p (c) | |
317 | int c; | |
318 | { | |
319 | return (islower (c)); | |
320 | } | |
321 | ||
322 | #undef _rl_pure_alphabetic | |
323 | int | |
324 | _rl_pure_alphabetic (c) | |
325 | int c; | |
326 | { | |
327 | return (isupper (c) || islower (c)); | |
328 | } | |
329 | ||
330 | #undef _rl_digit_p | |
331 | int | |
332 | _rl_digit_p (c) | |
333 | int c; | |
334 | { | |
335 | return (isdigit (c)); | |
336 | } | |
337 | ||
338 | #undef _rl_to_lower | |
339 | int | |
340 | _rl_to_lower (c) | |
341 | int c; | |
342 | { | |
343 | return (isupper (c) ? tolower (c) : c); | |
344 | } | |
345 | ||
346 | #undef _rl_to_upper | |
347 | int | |
348 | _rl_to_upper (c) | |
349 | int c; | |
350 | { | |
351 | return (islower (c) ? toupper (c) : c); | |
352 | } | |
353 | ||
354 | #undef _rl_digit_value | |
355 | int | |
356 | _rl_digit_value (c) | |
357 | int c; | |
358 | { | |
359 | return (isdigit (c) ? c - '0' : c); | |
360 | } | |
cce855bc JA |
361 | |
362 | /* Backwards compatibility, now that savestring has been removed from | |
363 | all `public' readline header files. */ | |
364 | #undef _rl_savestring | |
365 | char * | |
366 | _rl_savestring (s) | |
28ef6c31 | 367 | const char *s; |
cce855bc | 368 | { |
28ef6c31 | 369 | return (strcpy (xmalloc (1 + (int)strlen (s)), (s))); |
cce855bc | 370 | } |