static char *
filename_completion_function (const char *text, int state, input_complete_t flags)
{
static DIR *directory = NULL;
static char *filename = NULL;
static char *dirname = NULL;
static char *users_dirname = NULL;
static size_t filename_len;
int isdir = 1, isexec = 0;
static vfs_path_t *dirname_vpath = NULL;
struct dirent *entry = NULL;
SHOW_C_CTX ("filename_completion_function");
if (text && (flags & INPUT_COMPLETE_SHELL_ESC))
{
char *u_text;
char *result;
char *e_result;
u_text = strutils_shell_unescape (text);
result = filename_completion_function (u_text, state, flags & (~INPUT_COMPLETE_SHELL_ESC));
g_free (u_text);
e_result = strutils_shell_escape (result);
g_free (result);
return e_result;
}
/* If we're starting the match process, initialize us a bit. */
if (state == 0)
{
const char *temp;
g_free (dirname);
g_free (filename);
g_free (users_dirname);
vfs_path_free (dirname_vpath);
if ((*text != '\0') && (temp = strrchr (text, PATH_SEP)) != NULL)
{
filename = g_strdup (++temp);
dirname = g_strndup (text, temp - text);
}
else
{
dirname = g_strdup (".");
filename = g_strdup (text);
}
/* We aren't done yet. We also support the "~user" syntax. */
/* Save the version of the directory that the user typed. */
users_dirname = dirname;
dirname = tilde_expand (dirname);
canonicalize_pathname (dirname);
dirname_vpath = vfs_path_from_str (dirname);
/* Here we should do something with variable expansion
and `command`.
Maybe a dream - UNIMPLEMENTED yet. */
directory = mc_opendir (dirname_vpath);
filename_len = strlen (filename);
}
/* Now that we have some state, we can read the directory. */
while (directory && (entry = mc_readdir (directory)))
{
if (!str_is_valid_string (entry->d_name))
continue;
/* Special case for no filename.
All entries except "." and ".." match. */
if (filename_len == 0)
{
if (DIR_IS_DOT (entry->d_name) || DIR_IS_DOTDOT (entry->d_name))
continue;
}
else
{
/* Otherwise, if these match up to the length of filename, then
it may be a match. */
if ((entry->d_name[0] != filename[0]) ||
((NLENGTH (entry)) < filename_len) ||
strncmp (filename, entry->d_name, filename_len))
continue;
}
isdir = 1;
isexec = 0;
{
struct stat tempstat;
vfs_path_t *tmp_vpath;
tmp_vpath = vfs_path_build_filename (dirname, entry->d_name, (char *) NULL);
/* Unix version */
if (mc_stat (tmp_vpath, &tempstat) == 0)
{
uid_t my_uid = getuid ();
gid_t my_gid = getgid ();
if (!S_ISDIR (tempstat.st_mode))
{
isdir = 0;
if ((!my_uid && (tempstat.st_mode & 0111)) ||
(my_uid == tempstat.st_uid && (tempstat.st_mode & 0100)) ||
(my_gid == tempstat.st_gid && (tempstat.st_mode & 0010)) ||
(tempstat.st_mode & 0001))
isexec = 1;
}
}
else
{
/* stat failed, strange. not a dir in any case */
isdir = 0;
}
vfs_path_free (tmp_vpath);
}
if ((flags & INPUT_COMPLETE_COMMANDS) && (isexec || isdir))
break;
if ((flags & INPUT_COMPLETE_CD) && isdir)
break;
if (flags & (INPUT_COMPLETE_FILENAMES))
break;
}
if (entry == NULL)
{
if (directory)
{
mc_closedir (directory);
directory = NULL;
}
g_free (dirname);
dirname = NULL;
vfs_path_free (dirname_vpath);
dirname_vpath = NULL;
g_free (filename);
filename = NULL;
g_free (users_dirname);
users_dirname = NULL;
return NULL;
}
{
GString *temp;
temp = g_string_sized_new (16);
if (users_dirname != NULL && (users_dirname[0] != '.' || users_dirname[1] != '\0'))
{
g_string_append (temp, users_dirname);
/* We need a '/' at the end. */
if (temp->str[temp->len - 1] != PATH_SEP)
g_string_append_c (temp, PATH_SEP);
}
g_string_append (temp, entry->d_name);
if (isdir)
g_string_append_c (temp, PATH_SEP);
return g_string_free (temp, FALSE);
}
}
static char *
command_completion_function (const char *_text, int state, input_complete_t flags)
{
char *text;
static const char *path_end;
static gboolean isabsolute;
static int phase;
static size_t text_len;
static const char *const *words;
static char *path;
static char *cur_path;
static char *cur_word;
static int init_state;
static const char *const bash_reserved[] = {
"if", "then", "else", "elif", "fi", "case", "esac", "for",
"select", "while", "until", "do", "done", "in", "function", 0
};
static const char *const bash_builtins[] = {
"alias", "bg", "bind", "break", "builtin", "cd", "command",
"continue", "declare", "dirs", "echo", "enable", "eval",
"exec", "exit", "export", "fc", "fg", "getopts", "hash",
"help", "history", "jobs", "kill", "let", "local", "logout",
"popd", "pushd", "pwd", "read", "readonly", "return", "set",
"shift", "source", "suspend", "test", "times", "trap", "type",
"typeset", "ulimit", "umask", "unalias", "unset", "wait", 0
};
char *p, *found;
SHOW_C_CTX ("command_completion_function");
if (!(flags & INPUT_COMPLETE_COMMANDS))
return 0;
text = strutils_shell_unescape (_text);
flags &= ~INPUT_COMPLETE_SHELL_ESC;
if (state == 0)
{ /* Initialize us a little bit */
isabsolute = strchr (text, PATH_SEP) != NULL;
if (!isabsolute)
{
words = bash_reserved;
phase = 0;
text_len = strlen (text);
if (path == NULL)
{
path = g_strdup (getenv ("PATH"));
if (path != NULL)
{
p = path;
path_end = strchr (p, '\0');
while ((p = strchr (p, PATH_ENV_SEP)) != NULL)
{
*p++ = '\0';
}
}
}
}
}
if (isabsolute)
{
p = filename_completion_function (text, state, flags);
if (p != NULL)
{
char *temp_p = p;
p = strutils_shell_escape (p);
g_free (temp_p);
}
g_free (text);
return p;
}
found = NULL;
switch (phase)
{
case 0: /* Reserved words */
while (*words)
{
if (strncmp (*words, text, text_len) == 0)
{
g_free (text);
return g_strdup (*(words++));
}
words++;
}
phase++;
words = bash_builtins;
case 1: /* Builtin commands */
while (*words)
{
if (strncmp (*words, text, text_len) == 0)
{
g_free (text);
return g_strdup (*(words++));
}
words++;
}
phase++;
if (!path)
break;
cur_path = path;
cur_word = NULL;
case 2: /* And looking through the $PATH */
while (!found)
{
if (!cur_word)
{
char *expanded;
if (cur_path >= path_end)
break;
expanded = tilde_expand (*cur_path ? cur_path : ".");
cur_word = mc_build_filename (expanded, text, NULL);
g_free (expanded);
canonicalize_pathname (cur_word);
cur_path = strchr (cur_path, 0) + 1;
init_state = state;
}
found = filename_completion_function (cur_word, state - init_state, flags);
if (!found)
{
g_free (cur_word);
cur_word = NULL;
}
}
}
if (found == NULL)
{
g_free (path);
path = NULL;
}
else
{
p = strrchr (found, PATH_SEP);
if (p != NULL)
{
char *tmp = found;
found = strutils_shell_escape (p + 1);
g_free (tmp);
}
}
g_free (text);
return found;
}
