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