|
2996
|
1 /* tilde.c -- Tilde expansion code (~/foo := $HOME/foo). */ |
|
|
2 |
|
|
3 /* Copyright (C) 1988,1989 Free Software Foundation, Inc. |
|
|
4 |
|
|
5 This file is part of GNU Readline, a library for reading lines |
|
|
6 of text with interactive input and history editing. |
|
|
7 |
|
|
8 Readline is free software; you can redistribute it and/or modify it |
|
|
9 under the terms of the GNU General Public License as published by the |
|
|
10 Free Software Foundation; either version 1, or (at your option) any |
|
|
11 later version. |
|
|
12 |
|
|
13 Readline is distributed in the hope that it will be useful, but |
|
|
14 WITHOUT ANY WARRANTY; without even the implied warranty of |
|
|
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
|
|
16 General Public License for more details. |
|
|
17 |
|
|
18 You should have received a copy of the GNU General Public License |
|
|
19 along with Readline; see the file COPYING. If not, write to the Free |
|
|
20 Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ |
|
|
21 |
|
|
22 #if defined (HAVE_CONFIG_H) |
|
|
23 # include <config.h> |
|
|
24 #endif |
|
|
25 |
|
|
26 #if defined (HAVE_UNISTD_H) |
|
|
27 # include <unistd.h> |
|
|
28 #endif |
|
|
29 |
|
|
30 #if defined (HAVE_STRING_H) |
|
|
31 # include <string.h> |
|
|
32 #else /* !HAVE_STRING_H */ |
|
|
33 # include <strings.h> |
|
|
34 #endif /* !HAVE_STRING_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 |
|
|
42 #include <sys/types.h> |
|
|
43 #include <pwd.h> |
|
|
44 |
|
|
45 #include "tilde.h" |
|
|
46 |
|
|
47 #ifdef SHELL |
|
|
48 #include "shell.h" |
|
|
49 #endif |
|
|
50 |
|
|
51 #if !defined (HAVE_GETPW_DECLS) |
|
|
52 extern struct passwd *getpwuid (), *getpwnam (); |
|
|
53 #endif /* !HAVE_GETPW_DECLS */ |
|
|
54 |
|
|
55 #if !defined (savestring) |
|
|
56 extern char *xmalloc (); |
|
|
57 # ifndef strcpy |
|
|
58 extern char *strcpy (); |
|
|
59 # endif |
|
|
60 #define savestring(x) strcpy (xmalloc (1 + strlen (x)), (x)) |
|
|
61 #endif /* !savestring */ |
|
|
62 |
|
|
63 #if !defined (NULL) |
|
|
64 # if defined (__STDC__) |
|
|
65 # define NULL ((void *) 0) |
|
|
66 # else |
|
|
67 # define NULL 0x0 |
|
|
68 # endif /* !__STDC__ */ |
|
|
69 #endif /* !NULL */ |
|
|
70 |
|
|
71 #if defined (TEST) || defined (STATIC_MALLOC) |
|
|
72 static char *xmalloc (), *xrealloc (); |
|
|
73 #else |
|
|
74 extern char *xmalloc (), *xrealloc (); |
|
|
75 #endif /* TEST || STATIC_MALLOC */ |
|
|
76 |
|
|
77 /* The default value of tilde_additional_prefixes. This is set to |
|
|
78 whitespace preceding a tilde so that simple programs which do not |
|
|
79 perform any word separation get desired behaviour. */ |
|
|
80 static char *default_prefixes[] = |
|
|
81 { " ~", "\t~", (char *)NULL }; |
|
|
82 |
|
|
83 /* The default value of tilde_additional_suffixes. This is set to |
|
|
84 whitespace or newline so that simple programs which do not |
|
|
85 perform any word separation get desired behaviour. */ |
|
|
86 static char *default_suffixes[] = |
|
|
87 { " ", "\n", (char *)NULL }; |
|
|
88 |
|
|
89 /* If non-null, this contains the address of a function that the application |
|
|
90 wants called before trying the standard tilde expansions. The function |
|
|
91 is called with the text sans tilde, and returns a malloc()'ed string |
|
|
92 which is the expansion, or a NULL pointer if the expansion fails. */ |
|
|
93 CPFunction *tilde_expansion_preexpansion_hook = (CPFunction *)NULL; |
|
|
94 |
|
|
95 /* If non-null, this contains the address of a function to call if the |
|
|
96 standard meaning for expanding a tilde fails. The function is called |
|
|
97 with the text (sans tilde, as in "foo"), and returns a malloc()'ed string |
|
|
98 which is the expansion, or a NULL pointer if there is no expansion. */ |
|
|
99 CPFunction *tilde_expansion_failure_hook = (CPFunction *)NULL; |
|
|
100 |
|
|
101 /* When non-null, this is a NULL terminated array of strings which |
|
|
102 are duplicates for a tilde prefix. Bash uses this to expand |
|
|
103 `=~' and `:~'. */ |
|
|
104 char **tilde_additional_prefixes = default_prefixes; |
|
|
105 |
|
|
106 /* When non-null, this is a NULL terminated array of strings which match |
|
|
107 the end of a username, instead of just "/". Bash sets this to |
|
|
108 `:' and `=~'. */ |
|
|
109 char **tilde_additional_suffixes = default_suffixes; |
|
|
110 |
|
|
111 /* Find the start of a tilde expansion in STRING, and return the index of |
|
|
112 the tilde which starts the expansion. Place the length of the text |
|
|
113 which identified this tilde starter in LEN, excluding the tilde itself. */ |
|
|
114 static int |
|
|
115 tilde_find_prefix (string, len) |
|
|
116 char *string; |
|
|
117 int *len; |
|
|
118 { |
|
|
119 register int i, j, string_len; |
|
|
120 register char **prefixes = tilde_additional_prefixes; |
|
|
121 |
|
|
122 string_len = strlen (string); |
|
|
123 *len = 0; |
|
|
124 |
|
|
125 if (*string == '\0' || *string == '~') |
|
|
126 return (0); |
|
|
127 |
|
|
128 if (prefixes) |
|
|
129 { |
|
|
130 for (i = 0; i < string_len; i++) |
|
|
131 { |
|
|
132 for (j = 0; prefixes[j]; j++) |
|
|
133 { |
|
|
134 if (strncmp (string + i, prefixes[j], strlen (prefixes[j])) == 0) |
|
|
135 { |
|
|
136 *len = strlen (prefixes[j]) - 1; |
|
|
137 return (i + *len); |
|
|
138 } |
|
|
139 } |
|
|
140 } |
|
|
141 } |
|
|
142 return (string_len); |
|
|
143 } |
|
|
144 |
|
|
145 /* Find the end of a tilde expansion in STRING, and return the index of |
|
|
146 the character which ends the tilde definition. */ |
|
|
147 static int |
|
|
148 tilde_find_suffix (string) |
|
|
149 char *string; |
|
|
150 { |
|
|
151 register int i, j, string_len; |
|
|
152 register char **suffixes; |
|
|
153 |
|
|
154 suffixes = tilde_additional_suffixes; |
|
|
155 string_len = strlen (string); |
|
|
156 |
|
|
157 for (i = 0; i < string_len; i++) |
|
|
158 { |
|
|
159 if (string[i] == '/' /* || !string[i] */) |
|
|
160 break; |
|
|
161 |
|
|
162 for (j = 0; suffixes && suffixes[j]; j++) |
|
|
163 { |
|
|
164 if (strncmp (string + i, suffixes[j], strlen (suffixes[j])) == 0) |
|
|
165 return (i); |
|
|
166 } |
|
|
167 } |
|
|
168 return (i); |
|
|
169 } |
|
|
170 |
|
|
171 #if !defined (SHELL) |
|
|
172 static char * |
|
|
173 get_string_value (varname) |
|
|
174 char *varname; |
|
|
175 { |
|
|
176 return ((char *)getenv (varname)); |
|
|
177 } |
|
|
178 #endif |
|
|
179 |
|
|
180 /* Return a new string which is the result of tilde expanding STRING. */ |
|
|
181 char * |
|
|
182 tilde_expand (string) |
|
|
183 char *string; |
|
|
184 { |
|
|
185 char *result; |
|
|
186 int result_size, result_index; |
|
|
187 |
|
|
188 result_index = result_size = 0; |
|
|
189 if (result = strchr (string, '~')) |
|
|
190 result = xmalloc (result_size = (strlen (string) + 16)); |
|
|
191 else |
|
|
192 result = xmalloc (result_size = strlen (string)); |
|
|
193 |
|
|
194 /* Scan through STRING expanding tildes as we come to them. */ |
|
|
195 while (1) |
|
|
196 { |
|
|
197 register int start, end; |
|
|
198 char *tilde_word, *expansion; |
|
|
199 int len; |
|
|
200 |
|
|
201 /* Make START point to the tilde which starts the expansion. */ |
|
|
202 start = tilde_find_prefix (string, &len); |
|
|
203 |
|
|
204 /* Copy the skipped text into the result. */ |
|
|
205 if ((result_index + start + 1) > result_size) |
|
|
206 result = xrealloc (result, 1 + (result_size += (start + 20))); |
|
|
207 |
|
|
208 strncpy (result + result_index, string, start); |
|
|
209 result_index += start; |
|
|
210 |
|
|
211 /* Advance STRING to the starting tilde. */ |
|
|
212 string += start; |
|
|
213 |
|
|
214 /* Make END be the index of one after the last character of the |
|
|
215 username. */ |
|
|
216 end = tilde_find_suffix (string); |
|
|
217 |
|
|
218 /* If both START and END are zero, we are all done. */ |
|
|
219 if (!start && !end) |
|
|
220 break; |
|
|
221 |
|
|
222 /* Expand the entire tilde word, and copy it into RESULT. */ |
|
|
223 tilde_word = xmalloc (1 + end); |
|
|
224 strncpy (tilde_word, string, end); |
|
|
225 tilde_word[end] = '\0'; |
|
|
226 string += end; |
|
|
227 |
|
|
228 expansion = tilde_expand_word (tilde_word); |
|
|
229 free (tilde_word); |
|
|
230 |
|
|
231 len = strlen (expansion); |
|
|
232 if ((result_index + len + 1) > result_size) |
|
|
233 result = xrealloc (result, 1 + (result_size += (len + 20))); |
|
|
234 |
|
|
235 strcpy (result + result_index, expansion); |
|
|
236 result_index += len; |
|
|
237 free (expansion); |
|
|
238 } |
|
|
239 |
|
|
240 result[result_index] = '\0'; |
|
|
241 |
|
|
242 return (result); |
|
|
243 } |
|
|
244 |
|
|
245 /* Take FNAME and return the tilde prefix we want expanded. If LENP is |
|
|
246 non-null, the index of the end of the prefix into FNAME is returned in |
|
|
247 the location it points to. */ |
|
|
248 static char * |
|
|
249 isolate_tilde_prefix (fname, lenp) |
|
|
250 char *fname; |
|
|
251 int *lenp; |
|
|
252 { |
|
|
253 char *ret; |
|
|
254 int i; |
|
|
255 |
|
|
256 ret = xmalloc (strlen (fname)); |
|
|
257 for (i = 1; fname[i] && fname[i] != '/'; i++) |
|
|
258 ret[i - 1] = fname[i]; |
|
|
259 ret[i - 1] = '\0'; |
|
|
260 if (lenp) |
|
|
261 *lenp = i; |
|
|
262 return ret; |
|
|
263 } |
|
|
264 |
|
|
265 /* Return a string that is PREFIX concatenated with SUFFIX starting at |
|
|
266 SUFFIND. */ |
|
|
267 static char * |
|
|
268 glue_prefix_and_suffix (prefix, suffix, suffind) |
|
|
269 char *prefix, *suffix; |
|
|
270 int suffind; |
|
|
271 { |
|
|
272 char *ret; |
|
|
273 int plen, slen; |
|
|
274 |
|
|
275 plen = (prefix && *prefix) ? strlen (prefix) : 0; |
|
|
276 slen = strlen (suffix + suffind); |
|
|
277 ret = xmalloc (plen + slen + 1); |
|
|
278 if (prefix && *prefix) |
|
|
279 strcpy (ret, prefix); |
|
|
280 strcpy (ret + plen, suffix + suffind); |
|
|
281 return ret; |
|
|
282 } |
|
|
283 |
|
|
284 static char * |
|
|
285 get_home_dir () |
|
|
286 { |
|
|
287 char *home_dir; |
|
|
288 |
|
|
289 #ifdef SHELL |
|
|
290 home_dir = (char *)NULL; |
|
|
291 if (current_user.home_dir == 0) |
|
|
292 get_current_user_info (); |
|
|
293 home_dir = current_user.home_dir; |
|
|
294 #else |
|
|
295 struct passwd *entry; |
|
|
296 |
|
|
297 home_dir = (char *)NULL; |
|
|
298 entry = getpwuid (getuid ()); |
|
|
299 if (entry) |
|
|
300 home_dir = entry->pw_dir; |
|
|
301 #endif |
|
|
302 return (home_dir); |
|
|
303 } |
|
|
304 |
|
|
305 /* Do the work of tilde expansion on FILENAME. FILENAME starts with a |
|
|
306 tilde. If there is no expansion, call tilde_expansion_failure_hook. |
|
|
307 This always returns a newly-allocated string, never static storage. */ |
|
|
308 char * |
|
|
309 tilde_expand_word (filename) |
|
|
310 char *filename; |
|
|
311 { |
|
|
312 char *dirname, *expansion, *username; |
|
|
313 int user_len; |
|
|
314 struct passwd *user_entry; |
|
|
315 |
|
|
316 if (filename == 0) |
|
|
317 return ((char *)NULL); |
|
|
318 |
|
|
319 if (*filename != '~') |
|
|
320 return (savestring (filename)); |
|
|
321 |
|
|
322 /* A leading `~/' or a bare `~' is *always* translated to the value of |
|
|
323 $HOME or the home directory of the current user, regardless of any |
|
|
324 preexpansion hook. */ |
|
|
325 if (filename[1] == '\0' || filename[1] == '/') |
|
|
326 { |
|
|
327 /* Prefix $HOME to the rest of the string. */ |
|
|
328 expansion = get_string_value ("HOME"); |
|
|
329 |
|
|
330 /* If there is no HOME variable, look up the directory in |
|
|
331 the password database. */ |
|
|
332 if (expansion == 0) |
|
|
333 expansion = get_home_dir (); |
|
|
334 |
|
|
335 return (glue_prefix_and_suffix (expansion, filename, 1)); |
|
|
336 } |
|
|
337 |
|
|
338 username = isolate_tilde_prefix (filename, &user_len); |
|
|
339 |
|
|
340 if (tilde_expansion_preexpansion_hook) |
|
|
341 { |
|
|
342 expansion = (*tilde_expansion_preexpansion_hook) (username); |
|
|
343 if (expansion) |
|
|
344 { |
|
|
345 dirname = glue_prefix_and_suffix (expansion, filename, user_len); |
|
|
346 free (username); |
|
|
347 free (expansion); |
|
|
348 return (dirname); |
|
|
349 } |
|
|
350 } |
|
|
351 |
|
|
352 /* No preexpansion hook, or the preexpansion hook failed. Look in the |
|
|
353 password database. */ |
|
|
354 dirname = (char *)NULL; |
|
|
355 user_entry = getpwnam (username); |
|
|
356 if (user_entry == 0) |
|
|
357 { |
|
|
358 /* If the calling program has a special syntax for expanding tildes, |
|
|
359 and we couldn't find a standard expansion, then let them try. */ |
|
|
360 if (tilde_expansion_failure_hook) |
|
|
361 { |
|
|
362 expansion = (*tilde_expansion_failure_hook) (username); |
|
|
363 if (expansion) |
|
|
364 { |
|
|
365 dirname = glue_prefix_and_suffix (expansion, filename, user_len); |
|
|
366 free (expansion); |
|
|
367 } |
|
|
368 } |
|
|
369 free (username); |
|
|
370 /* If we don't have a failure hook, or if the failure hook did not |
|
|
371 expand the tilde, return a copy of what we were passed. */ |
|
|
372 if (dirname == 0) |
|
|
373 dirname = savestring (filename); |
|
|
374 } |
|
|
375 else |
|
|
376 { |
|
|
377 free (username); |
|
|
378 dirname = glue_prefix_and_suffix (user_entry->pw_dir, filename, user_len); |
|
|
379 } |
|
|
380 |
|
|
381 endpwent (); |
|
|
382 return (dirname); |
|
|
383 } |
|
|
384 |
|
|
385 |
|
|
386 #if defined (TEST) |
|
|
387 #undef NULL |
|
|
388 #include <stdio.h> |
|
|
389 |
|
|
390 main (argc, argv) |
|
|
391 int argc; |
|
|
392 char **argv; |
|
|
393 { |
|
|
394 char *result, line[512]; |
|
|
395 int done = 0; |
|
|
396 |
|
|
397 while (!done) |
|
|
398 { |
|
|
399 printf ("~expand: "); |
|
|
400 fflush (stdout); |
|
|
401 |
|
|
402 if (!gets (line)) |
|
|
403 strcpy (line, "done"); |
|
|
404 |
|
|
405 if ((strcmp (line, "done") == 0) || |
|
|
406 (strcmp (line, "quit") == 0) || |
|
|
407 (strcmp (line, "exit") == 0)) |
|
|
408 { |
|
|
409 done = 1; |
|
|
410 break; |
|
|
411 } |
|
|
412 |
|
|
413 result = tilde_expand (line); |
|
|
414 printf (" --> %s\n", result); |
|
|
415 free (result); |
|
|
416 } |
|
|
417 exit (0); |
|
|
418 } |
|
|
419 |
|
|
420 static void memory_error_and_abort (); |
|
|
421 |
|
|
422 static char * |
|
|
423 xmalloc (bytes) |
|
|
424 int bytes; |
|
|
425 { |
|
|
426 char *temp = (char *)malloc (bytes); |
|
|
427 |
|
|
428 if (!temp) |
|
|
429 memory_error_and_abort (); |
|
|
430 return (temp); |
|
|
431 } |
|
|
432 |
|
|
433 static char * |
|
|
434 xrealloc (pointer, bytes) |
|
|
435 char *pointer; |
|
|
436 int bytes; |
|
|
437 { |
|
|
438 char *temp; |
|
|
439 |
|
|
440 if (!pointer) |
|
|
441 temp = (char *)malloc (bytes); |
|
|
442 else |
|
|
443 temp = (char *)realloc (pointer, bytes); |
|
|
444 |
|
|
445 if (!temp) |
|
|
446 memory_error_and_abort (); |
|
|
447 |
|
|
448 return (temp); |
|
|
449 } |
|
|
450 |
|
|
451 static void |
|
|
452 memory_error_and_abort () |
|
|
453 { |
|
|
454 fprintf (stderr, "readline: out of virtual memory\n"); |
|
|
455 abort (); |
|
|
456 } |
|
|
457 |
|
|
458 /* |
|
|
459 * Local variables: |
|
|
460 * compile-command: "gcc -g -DTEST -o tilde tilde.c" |
|
|
461 * end: |
|
|
462 */ |
|
|
463 #endif /* TEST */ |
