2011-10-15 14:56:47 +04:00
|
|
|
/*
|
|
|
|
Input line filename/username/hostname/variable/command completion.
|
1998-02-27 07:54:42 +03:00
|
|
|
(Let mc type for you...)
|
2010-03-30 12:10:25 +04:00
|
|
|
|
2024-01-01 09:46:17 +03:00
|
|
|
Copyright (C) 1995-2024
|
2014-02-12 10:33:10 +04:00
|
|
|
Free Software Foundation, Inc.
|
2010-03-30 12:10:25 +04:00
|
|
|
|
2011-10-15 14:56:47 +04:00
|
|
|
Written by:
|
|
|
|
Jakub Jelinek, 1995
|
2013-01-25 15:30:17 +04:00
|
|
|
Slava Zanko <slavazanko@gmail.com>, 2013
|
2021-10-10 17:08:52 +03:00
|
|
|
Andrew Borodin <aborodin@vmail.ru>, 2013-2022
|
2010-03-30 12:10:25 +04:00
|
|
|
|
2011-10-15 14:56:47 +04:00
|
|
|
This file is part of the Midnight Commander.
|
2010-03-30 12:10:25 +04:00
|
|
|
|
2011-10-15 14:56:47 +04:00
|
|
|
The Midnight Commander 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 3 of the License,
|
|
|
|
or (at your option) any later version.
|
|
|
|
|
|
|
|
The Midnight Commander is distributed in the hope that it will be useful,
|
1998-02-27 07:54:42 +03:00
|
|
|
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.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
2011-10-15 14:56:47 +04:00
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2012-08-31 18:05:29 +04:00
|
|
|
/** \file lib/widget/input_complete.c
|
2009-02-05 21:28:18 +03:00
|
|
|
* \brief Source: Input line filename/username/hostname/variable/command completion
|
|
|
|
*/
|
|
|
|
|
1998-02-27 07:54:42 +03:00
|
|
|
#include <config.h>
|
2005-02-08 12:04:03 +03:00
|
|
|
|
|
|
|
#include <ctype.h>
|
2017-04-16 07:56:22 +03:00
|
|
|
#include <limits.h> /* MB_LEN_MAX */
|
1998-02-27 07:54:42 +03:00
|
|
|
#include <stdio.h>
|
2005-02-08 12:04:03 +03:00
|
|
|
#include <stdlib.h>
|
1998-02-27 07:54:42 +03:00
|
|
|
#include <string.h>
|
2009-03-07 15:23:15 +03:00
|
|
|
#include <dirent.h>
|
1998-02-27 07:54:42 +03:00
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
2009-03-07 15:23:15 +03:00
|
|
|
#include <pwd.h>
|
2005-02-08 12:04:03 +03:00
|
|
|
#include <unistd.h>
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2010-01-20 18:11:52 +03:00
|
|
|
#include "lib/global.h"
|
2009-05-09 19:17:57 +04:00
|
|
|
|
2010-01-08 17:47:19 +03:00
|
|
|
#include "lib/tty/tty.h"
|
2010-03-30 12:10:25 +04:00
|
|
|
#include "lib/tty/key.h" /* XCTRL and ALT macros */
|
2011-02-15 16:44:17 +03:00
|
|
|
#include "lib/vfs/vfs.h"
|
2010-01-21 15:17:26 +03:00
|
|
|
#include "lib/strutil.h"
|
2010-11-11 16:58:29 +03:00
|
|
|
#include "lib/util.h"
|
2010-11-12 11:03:57 +03:00
|
|
|
#include "lib/widget.h"
|
2009-05-09 19:17:57 +04:00
|
|
|
|
2010-11-09 14:02:28 +03:00
|
|
|
/*** global variables ****************************************************************************/
|
|
|
|
|
|
|
|
/* Linux declares environ in <unistd.h>, so don't repeat it here. */
|
|
|
|
#if (!(defined(__linux__) && defined (__USE_GNU)) && !defined(__CYGWIN__))
|
|
|
|
extern char **environ;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*** file scope macro definitions ****************************************************************/
|
2003-10-25 02:11:57 +04:00
|
|
|
|
2009-04-24 02:47:22 +04:00
|
|
|
/* #define DO_COMPLETION_DEBUG */
|
2009-01-31 22:46:32 +03:00
|
|
|
#ifdef DO_COMPLETION_DEBUG
|
2010-11-09 14:02:28 +03:00
|
|
|
#define SHOW_C_CTX(func) fprintf(stderr, "%s: text='%s' flags=%s\n", func, text, show_c_flags(flags))
|
|
|
|
#else
|
|
|
|
#define SHOW_C_CTX(func)
|
|
|
|
#endif /* DO_CMPLETION_DEBUG */
|
|
|
|
|
|
|
|
#define DO_INSERTION 1
|
|
|
|
#define DO_QUERY 2
|
|
|
|
|
|
|
|
/*** file scope type declarations ****************************************************************/
|
|
|
|
|
2010-11-12 11:03:57 +03:00
|
|
|
typedef char *CompletionFunction (const char *text, int state, input_complete_t flags);
|
2010-11-09 14:02:28 +03:00
|
|
|
|
2013-01-25 15:30:17 +04:00
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
size_t in_command_position;
|
|
|
|
char *word;
|
|
|
|
char *p;
|
|
|
|
char *q;
|
|
|
|
char *r;
|
|
|
|
gboolean is_cd;
|
|
|
|
input_complete_t flags;
|
|
|
|
} try_complete_automation_state_t;
|
|
|
|
|
Update template for .c files.
Add section for forward declarations of local functions. This section is
located before file scope variables because functions can be used in
strucutres (see find.c for example):
/*** forward declarations (file scope functions) *************************************************/
/* button callbacks */
static int start_stop (WButton * button, int action);
static int find_do_view_file (WButton * button, int action);
static int find_do_edit_file (WButton * button, int action);
/*** file scope variables ************************************************************************/
static struct
{
...
bcback_fn callback;
} fbuts[] =
{
...
{ B_STOP, NORMAL_BUTTON, N_("S&uspend"), 0, 0, NULL, start_stop },
...
{ B_VIEW, NORMAL_BUTTON, N_("&View - F3"), 0, 0, NULL, find_do_view_file },
{ B_VIEW, NORMAL_BUTTON, N_("&Edit - F4"), 0, 0, NULL, find_do_edit_file }
};
Signed-off-by: Andrew Borodin <aborodin@vmail.ru>
2023-02-24 09:27:11 +03:00
|
|
|
/*** forward declarations (file scope functions) *************************************************/
|
|
|
|
|
|
|
|
char **try_complete (char *text, int *lc_start, int *lc_end, input_complete_t flags);
|
|
|
|
void complete_engine_fill_completions (WInput * in);
|
|
|
|
|
2010-11-09 14:02:28 +03:00
|
|
|
/*** file scope variables ************************************************************************/
|
|
|
|
|
|
|
|
static WInput *input;
|
|
|
|
static int min_end;
|
2010-12-19 20:10:59 +03:00
|
|
|
static int start = 0;
|
|
|
|
static int end = 0;
|
2010-11-09 14:02:28 +03:00
|
|
|
|
Update template for .c files.
Add section for forward declarations of local functions. This section is
located before file scope variables because functions can be used in
strucutres (see find.c for example):
/*** forward declarations (file scope functions) *************************************************/
/* button callbacks */
static int start_stop (WButton * button, int action);
static int find_do_view_file (WButton * button, int action);
static int find_do_edit_file (WButton * button, int action);
/*** file scope variables ************************************************************************/
static struct
{
...
bcback_fn callback;
} fbuts[] =
{
...
{ B_STOP, NORMAL_BUTTON, N_("S&uspend"), 0, 0, NULL, start_stop },
...
{ B_VIEW, NORMAL_BUTTON, N_("&View - F3"), 0, 0, NULL, find_do_view_file },
{ B_VIEW, NORMAL_BUTTON, N_("&Edit - F4"), 0, 0, NULL, find_do_edit_file }
};
Signed-off-by: Andrew Borodin <aborodin@vmail.ru>
2023-02-24 09:27:11 +03:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
2010-11-09 14:02:28 +03:00
|
|
|
/*** file scope functions ************************************************************************/
|
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
#ifdef DO_COMPLETION_DEBUG
|
|
|
|
/**
|
2009-01-31 22:46:32 +03:00
|
|
|
* Useful to print/debug completion flags
|
|
|
|
*/
|
2010-03-30 12:10:25 +04:00
|
|
|
static const char *
|
2010-11-12 11:03:57 +03:00
|
|
|
show_c_flags (input_complete_t flags)
|
2009-01-31 22:46:32 +03:00
|
|
|
{
|
|
|
|
static char s_cf[] = "FHCVUDS";
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2016-04-29 10:45:18 +03:00
|
|
|
s_cf[0] = (flags & INPUT_COMPLETE_FILENAMES) != 0 ? 'F' : ' ';
|
|
|
|
s_cf[1] = (flags & INPUT_COMPLETE_HOSTNAMES) != 0 ? 'H' : ' ';
|
|
|
|
s_cf[2] = (flags & INPUT_COMPLETE_COMMANDS) != 0 ? 'C' : ' ';
|
|
|
|
s_cf[3] = (flags & INPUT_COMPLETE_VARIABLES) != 0 ? 'V' : ' ';
|
|
|
|
s_cf[4] = (flags & INPUT_COMPLETE_USERNAMES) != 0 ? 'U' : ' ';
|
|
|
|
s_cf[5] = (flags & INPUT_COMPLETE_CD) != 0 ? 'D' : ' ';
|
|
|
|
s_cf[6] = (flags & INPUT_COMPLETE_SHELL_ESC) != 0 ? 'S' : ' ';
|
2009-01-31 22:46:32 +03:00
|
|
|
|
|
|
|
return s_cf;
|
|
|
|
}
|
|
|
|
#endif /* DO_CMPLETION_DEBUG */
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2010-11-09 14:02:28 +03:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
|
1998-12-03 00:27:27 +03:00
|
|
|
static char *
|
2010-11-12 11:03:57 +03:00
|
|
|
filename_completion_function (const char *text, int state, input_complete_t flags)
|
1998-02-27 07:54:42 +03:00
|
|
|
{
|
2012-09-23 10:24:52 +04:00
|
|
|
static DIR *directory = NULL;
|
1998-02-27 07:54:42 +03:00
|
|
|
static char *filename = NULL;
|
|
|
|
static char *dirname = NULL;
|
|
|
|
static char *users_dirname = NULL;
|
2016-04-29 10:45:18 +03:00
|
|
|
static size_t filename_len = 0;
|
2011-07-18 22:07:39 +04:00
|
|
|
static vfs_path_t *dirname_vpath = NULL;
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2016-04-29 10:45:18 +03:00
|
|
|
gboolean isdir = TRUE, isexec = FALSE;
|
2020-11-16 10:09:09 +03:00
|
|
|
struct vfs_dirent *entry = NULL;
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2010-03-30 12:10:25 +04:00
|
|
|
SHOW_C_CTX ("filename_completion_function");
|
2009-01-31 22:46:32 +03:00
|
|
|
|
2016-04-29 10:45:18 +03:00
|
|
|
if (text != NULL && (flags & INPUT_COMPLETE_SHELL_ESC) != 0)
|
2009-05-29 16:14:52 +04:00
|
|
|
{
|
2010-03-30 12:10:25 +04:00
|
|
|
char *u_text;
|
|
|
|
char *result;
|
|
|
|
char *e_result;
|
2009-05-29 16:14:52 +04:00
|
|
|
|
2024-03-09 14:41:08 +03:00
|
|
|
u_text = str_shell_unescape (text);
|
2009-05-29 16:14:52 +04:00
|
|
|
|
|
|
|
result = filename_completion_function (u_text, state, flags & (~INPUT_COMPLETE_SHELL_ESC));
|
|
|
|
g_free (u_text);
|
|
|
|
|
2024-03-09 14:41:08 +03:00
|
|
|
e_result = str_shell_escape (result);
|
2009-05-29 16:14:52 +04:00
|
|
|
g_free (result);
|
|
|
|
|
|
|
|
return e_result;
|
|
|
|
}
|
2009-02-01 14:28:31 +03:00
|
|
|
|
1998-02-27 07:54:42 +03:00
|
|
|
/* If we're starting the match process, initialize us a bit. */
|
2010-03-30 22:59:41 +04:00
|
|
|
if (state == 0)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2004-09-25 18:34:27 +04:00
|
|
|
const char *temp;
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2009-02-06 01:27:37 +03:00
|
|
|
g_free (dirname);
|
|
|
|
g_free (filename);
|
|
|
|
g_free (users_dirname);
|
2021-02-21 19:30:18 +03:00
|
|
|
vfs_path_free (dirname_vpath, TRUE);
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2010-03-30 22:59:41 +04:00
|
|
|
if ((*text != '\0') && (temp = strrchr (text, PATH_SEP)) != NULL)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
|
|
|
filename = g_strdup (++temp);
|
|
|
|
dirname = g_strndup (text, temp - text);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
dirname = g_strdup (".");
|
|
|
|
filename = g_strdup (text);
|
|
|
|
}
|
1998-02-27 07:54:42 +03:00
|
|
|
|
|
|
|
/* We aren't done yet. We also support the "~user" syntax. */
|
|
|
|
|
|
|
|
/* Save the version of the directory that the user typed. */
|
2001-06-25 17:59:04 +04:00
|
|
|
users_dirname = dirname;
|
2010-03-30 12:10:25 +04:00
|
|
|
dirname = tilde_expand (dirname);
|
|
|
|
canonicalize_pathname (dirname);
|
2012-09-23 10:24:52 +04:00
|
|
|
dirname_vpath = vfs_path_from_str (dirname);
|
2009-05-27 09:18:44 +04:00
|
|
|
|
2010-03-30 12:10:25 +04:00
|
|
|
/* Here we should do something with variable expansion
|
|
|
|
and `command`.
|
|
|
|
Maybe a dream - UNIMPLEMENTED yet. */
|
2009-05-27 09:18:44 +04:00
|
|
|
|
2011-07-18 22:07:39 +04:00
|
|
|
directory = mc_opendir (dirname_vpath);
|
1998-02-27 07:54:42 +03:00
|
|
|
filename_len = strlen (filename);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Now that we have some state, we can read the directory. */
|
|
|
|
|
2016-04-29 10:45:18 +03:00
|
|
|
while (directory != NULL && (entry = mc_readdir (directory)) != NULL)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
|
|
|
if (!str_is_valid_string (entry->d_name))
|
|
|
|
continue;
|
2009-05-27 09:18:44 +04:00
|
|
|
|
1998-02-27 07:54:42 +03:00
|
|
|
/* Special case for no filename.
|
2010-03-30 12:10:25 +04:00
|
|
|
All entries except "." and ".." match. */
|
|
|
|
if (filename_len == 0)
|
|
|
|
{
|
2013-07-13 21:02:34 +04:00
|
|
|
if (DIR_IS_DOT (entry->d_name) || DIR_IS_DOTDOT (entry->d_name))
|
2010-03-30 12:10:25 +04:00
|
|
|
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) ||
|
2016-04-29 10:45:18 +03:00
|
|
|
strncmp (filename, entry->d_name, filename_len) != 0)
|
2010-03-30 12:10:25 +04:00
|
|
|
continue;
|
|
|
|
}
|
2016-04-29 10:45:18 +03:00
|
|
|
|
|
|
|
isdir = TRUE;
|
|
|
|
isexec = FALSE;
|
|
|
|
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
|
|
|
struct stat tempstat;
|
2011-07-18 22:07:39 +04:00
|
|
|
vfs_path_t *tmp_vpath;
|
2010-03-30 12:10:25 +04:00
|
|
|
|
2011-07-18 22:07:39 +04:00
|
|
|
tmp_vpath = vfs_path_build_filename (dirname, entry->d_name, (char *) NULL);
|
2011-07-18 01:30:58 +04:00
|
|
|
|
2010-03-30 12:10:25 +04:00
|
|
|
/* Unix version */
|
2011-07-18 22:07:39 +04:00
|
|
|
if (mc_stat (tmp_vpath, &tempstat) == 0)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2016-04-29 10:45:18 +03:00
|
|
|
uid_t my_uid;
|
|
|
|
gid_t my_gid;
|
|
|
|
|
|
|
|
my_uid = getuid ();
|
|
|
|
my_gid = getgid ();
|
2010-03-30 12:10:25 +04:00
|
|
|
|
|
|
|
if (!S_ISDIR (tempstat.st_mode))
|
|
|
|
{
|
2016-04-29 10:45:18 +03:00
|
|
|
isdir = FALSE;
|
|
|
|
|
|
|
|
if ((my_uid == 0 && (tempstat.st_mode & 0111) != 0) ||
|
|
|
|
(my_uid == tempstat.st_uid && (tempstat.st_mode & 0100) != 0) ||
|
|
|
|
(my_gid == tempstat.st_gid && (tempstat.st_mode & 0010) != 0) ||
|
|
|
|
(tempstat.st_mode & 0001) != 0)
|
|
|
|
isexec = TRUE;
|
2010-03-30 12:10:25 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* stat failed, strange. not a dir in any case */
|
2016-04-29 10:45:18 +03:00
|
|
|
isdir = FALSE;
|
2010-03-30 12:10:25 +04:00
|
|
|
}
|
2021-02-21 19:30:18 +03:00
|
|
|
vfs_path_free (tmp_vpath, TRUE);
|
2010-03-30 12:10:25 +04:00
|
|
|
}
|
2016-04-29 10:45:18 +03:00
|
|
|
|
|
|
|
if ((flags & INPUT_COMPLETE_COMMANDS) != 0 && (isexec || isdir))
|
2010-03-30 12:10:25 +04:00
|
|
|
break;
|
2016-04-29 10:45:18 +03:00
|
|
|
if ((flags & INPUT_COMPLETE_CD) != 0 && isdir)
|
2010-03-30 12:10:25 +04:00
|
|
|
break;
|
2016-04-29 10:45:18 +03:00
|
|
|
if ((flags & INPUT_COMPLETE_FILENAMES) != 0)
|
2010-03-30 12:10:25 +04:00
|
|
|
break;
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
|
|
|
|
2010-03-30 22:59:41 +04:00
|
|
|
if (entry == NULL)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2016-04-29 10:45:18 +03:00
|
|
|
if (directory != NULL)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
|
|
|
mc_closedir (directory);
|
|
|
|
directory = NULL;
|
|
|
|
}
|
2014-08-05 11:18:30 +04:00
|
|
|
MC_PTR_FREE (dirname);
|
2021-02-21 19:30:18 +03:00
|
|
|
vfs_path_free (dirname_vpath, TRUE);
|
2011-07-18 22:07:39 +04:00
|
|
|
dirname_vpath = NULL;
|
2014-08-05 11:18:30 +04:00
|
|
|
MC_PTR_FREE (filename);
|
|
|
|
MC_PTR_FREE (users_dirname);
|
1998-02-27 07:54:42 +03:00
|
|
|
return NULL;
|
2010-03-30 12:10:25 +04:00
|
|
|
}
|
2013-01-26 17:10:06 +04:00
|
|
|
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2013-01-26 17:10:06 +04:00
|
|
|
GString *temp;
|
|
|
|
|
|
|
|
temp = g_string_sized_new (16);
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2013-01-26 17:10:06 +04:00
|
|
|
if (users_dirname != NULL && (users_dirname[0] != '.' || users_dirname[1] != '\0'))
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2013-01-26 17:10:06 +04:00
|
|
|
g_string_append (temp, users_dirname);
|
|
|
|
|
2013-05-26 10:11:06 +04:00
|
|
|
/* We need a '/' at the end. */
|
2015-01-07 11:34:53 +03:00
|
|
|
if (!IS_PATH_SEP (temp->str[temp->len - 1]))
|
2013-01-26 17:10:06 +04:00
|
|
|
g_string_append_c (temp, PATH_SEP);
|
2010-03-30 12:10:25 +04:00
|
|
|
}
|
2013-01-26 17:10:06 +04:00
|
|
|
g_string_append (temp, entry->d_name);
|
2010-03-30 12:10:25 +04:00
|
|
|
if (isdir)
|
2013-01-26 17:10:06 +04:00
|
|
|
g_string_append_c (temp, PATH_SEP);
|
2010-03-30 12:10:25 +04:00
|
|
|
|
2013-01-26 17:10:06 +04:00
|
|
|
return g_string_free (temp, FALSE);
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-09 14:02:28 +03:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
/** We assume here that text[0] == '~' , if you want to call it in another way,
|
1998-02-27 07:54:42 +03:00
|
|
|
you have to change the code */
|
2010-11-09 14:02:28 +03:00
|
|
|
|
1998-12-03 00:27:27 +03:00
|
|
|
static char *
|
2010-11-12 11:03:57 +03:00
|
|
|
username_completion_function (const char *text, int state, input_complete_t flags)
|
1998-02-27 07:54:42 +03:00
|
|
|
{
|
2016-04-29 10:45:18 +03:00
|
|
|
static struct passwd *entry = NULL;
|
|
|
|
static size_t userlen = 0;
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2009-04-24 02:47:22 +04:00
|
|
|
(void) flags;
|
2010-03-30 12:10:25 +04:00
|
|
|
SHOW_C_CTX ("username_completion_function");
|
2009-01-31 22:46:32 +03:00
|
|
|
|
2009-05-27 09:18:44 +04:00
|
|
|
if (text[0] == '\\' && text[1] == '~')
|
2010-03-30 12:10:25 +04:00
|
|
|
text++;
|
2010-03-30 22:59:41 +04:00
|
|
|
if (state == 0)
|
2010-03-30 12:10:25 +04:00
|
|
|
{ /* Initialization stuff */
|
1998-02-27 07:54:42 +03:00
|
|
|
setpwent ();
|
|
|
|
userlen = strlen (text + 1);
|
|
|
|
}
|
2016-04-29 10:45:18 +03:00
|
|
|
|
2010-03-30 12:10:25 +04:00
|
|
|
while ((entry = getpwent ()) != NULL)
|
|
|
|
{
|
1998-02-27 07:54:42 +03:00
|
|
|
/* Null usernames should result in all users as possible completions. */
|
2009-05-27 09:18:44 +04:00
|
|
|
if (userlen == 0)
|
1998-02-27 07:54:42 +03:00
|
|
|
break;
|
2016-04-29 10:45:18 +03:00
|
|
|
if (text[1] == entry->pw_name[0] && strncmp (text + 1, entry->pw_name, userlen) == 0)
|
2010-03-30 12:10:25 +04:00
|
|
|
break;
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
|
|
|
|
2010-03-30 22:59:41 +04:00
|
|
|
if (entry != NULL)
|
2010-03-30 12:10:25 +04:00
|
|
|
return g_strconcat ("~", entry->pw_name, PATH_SEP_STR, (char *) NULL);
|
2009-05-27 09:18:44 +04:00
|
|
|
|
|
|
|
endpwent ();
|
|
|
|
return NULL;
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
|
|
|
|
2010-11-09 14:02:28 +03:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
/** We assume text [0] == '$' and want to have a look at text [1], if it is
|
1998-02-27 07:54:42 +03:00
|
|
|
equal to '{', so that we should append '}' at the end */
|
2010-11-09 14:02:28 +03:00
|
|
|
|
1998-12-03 00:27:27 +03:00
|
|
|
static char *
|
2010-11-12 11:03:57 +03:00
|
|
|
variable_completion_function (const char *text, int state, input_complete_t flags)
|
1998-02-27 07:54:42 +03:00
|
|
|
{
|
2016-04-29 10:45:18 +03:00
|
|
|
static char **env_p = NULL;
|
|
|
|
static gboolean isbrace = FALSE;
|
|
|
|
static size_t varlen = 0;
|
2016-05-21 17:51:46 +03:00
|
|
|
const char *p = NULL;
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2009-04-24 02:47:22 +04:00
|
|
|
(void) flags;
|
2010-03-30 12:10:25 +04:00
|
|
|
SHOW_C_CTX ("variable_completion_function");
|
2009-01-31 22:46:32 +03:00
|
|
|
|
2010-03-30 22:59:41 +04:00
|
|
|
if (state == 0)
|
2010-03-30 12:10:25 +04:00
|
|
|
{ /* Initialization stuff */
|
2016-04-29 10:45:18 +03:00
|
|
|
isbrace = (text[1] == '{');
|
1998-02-27 07:54:42 +03:00
|
|
|
varlen = strlen (text + 1 + isbrace);
|
|
|
|
env_p = environ;
|
|
|
|
}
|
|
|
|
|
2016-04-29 10:45:18 +03:00
|
|
|
while (*env_p != NULL)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
|
|
|
p = strchr (*env_p, '=');
|
2016-04-29 10:45:18 +03:00
|
|
|
if (p != NULL && ((size_t) (p - *env_p) >= varlen)
|
|
|
|
&& strncmp (text + 1 + isbrace, *env_p, varlen) == 0)
|
2010-03-30 12:10:25 +04:00
|
|
|
break;
|
|
|
|
env_p++;
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
|
|
|
|
2010-03-30 22:59:41 +04:00
|
|
|
if (*env_p == NULL)
|
1998-02-27 07:54:42 +03:00
|
|
|
return NULL;
|
2010-03-30 22:59:41 +04:00
|
|
|
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2013-01-26 17:10:06 +04:00
|
|
|
GString *temp;
|
|
|
|
|
|
|
|
temp = g_string_new_len (*env_p, p - *env_p);
|
|
|
|
|
2016-04-29 10:45:18 +03:00
|
|
|
if (isbrace)
|
2013-01-26 17:10:06 +04:00
|
|
|
{
|
|
|
|
g_string_prepend_c (temp, '{');
|
|
|
|
g_string_append_c (temp, '}');
|
|
|
|
}
|
|
|
|
g_string_prepend_c (temp, '$');
|
|
|
|
|
1998-02-27 07:54:42 +03:00
|
|
|
env_p++;
|
2013-01-26 17:10:06 +04:00
|
|
|
|
|
|
|
return g_string_free (temp, FALSE);
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-09 14:02:28 +03:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2024-03-31 19:40:09 +03:00
|
|
|
static gboolean
|
|
|
|
host_equal_func (gconstpointer a, gconstpointer b)
|
|
|
|
{
|
|
|
|
return (strcmp ((const char *) a, (const char *) b) == 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
|
2010-03-30 12:10:25 +04:00
|
|
|
static void
|
2024-03-31 19:40:09 +03:00
|
|
|
fetch_hosts (const char *filename, GPtrArray * hosts)
|
1998-02-27 07:54:42 +03:00
|
|
|
{
|
2016-04-29 10:45:18 +03:00
|
|
|
FILE *file;
|
2024-04-06 09:02:42 +03:00
|
|
|
char buffer[BUF_MEDIUM];
|
2008-12-29 01:52:45 +03:00
|
|
|
char *bi;
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2016-04-29 10:45:18 +03:00
|
|
|
file = fopen (filename, "r");
|
|
|
|
if (file == NULL)
|
1998-02-27 07:54:42 +03:00
|
|
|
return;
|
|
|
|
|
2016-01-01 11:23:17 +03:00
|
|
|
while (fgets (buffer, sizeof (buffer) - 1, file) != NULL)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
1998-02-27 07:54:42 +03:00
|
|
|
/* Skip to first character. */
|
2016-04-29 10:45:18 +03:00
|
|
|
for (bi = buffer; bi[0] != '\0' && str_isspace (bi); str_next_char (&bi))
|
|
|
|
;
|
2010-03-30 12:10:25 +04:00
|
|
|
|
1998-02-27 07:54:42 +03:00
|
|
|
/* Ignore comments... */
|
2008-12-29 01:52:45 +03:00
|
|
|
if (bi[0] == '#')
|
1998-02-27 07:54:42 +03:00
|
|
|
continue;
|
2016-04-29 10:45:18 +03:00
|
|
|
|
1998-02-27 07:54:42 +03:00
|
|
|
/* Handle $include. */
|
2016-04-29 10:45:18 +03:00
|
|
|
if (strncmp (bi, "$include ", 9) == 0)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2016-04-29 10:45:18 +03:00
|
|
|
char *includefile, *t;
|
2010-03-30 12:10:25 +04:00
|
|
|
|
|
|
|
/* Find start of filename. */
|
2024-04-06 09:02:42 +03:00
|
|
|
for (includefile = bi + 9; includefile[0] != '\0' && whitespace (includefile[0]);
|
|
|
|
includefile++)
|
|
|
|
;
|
2010-03-30 12:10:25 +04:00
|
|
|
t = includefile;
|
|
|
|
|
|
|
|
/* Find end of filename. */
|
2024-04-06 09:02:42 +03:00
|
|
|
for (; t[0] != '\0' && !str_isspace (t); str_next_char (&t))
|
|
|
|
;
|
2010-03-30 12:10:25 +04:00
|
|
|
*t = '\0';
|
|
|
|
|
2024-03-31 19:40:09 +03:00
|
|
|
fetch_hosts (includefile, hosts);
|
2010-03-30 12:10:25 +04:00
|
|
|
continue;
|
|
|
|
}
|
1998-02-27 07:54:42 +03:00
|
|
|
|
|
|
|
/* Skip IP #s. */
|
2024-04-06 09:02:42 +03:00
|
|
|
for (; bi[0] != '\0' && !str_isspace (bi); str_next_char (&bi))
|
|
|
|
;
|
1998-02-27 07:54:42 +03:00
|
|
|
|
|
|
|
/* Get the host names separated by white space. */
|
2010-03-30 12:10:25 +04:00
|
|
|
while (bi[0] != '\0' && bi[0] != '#')
|
|
|
|
{
|
2024-04-06 09:02:42 +03:00
|
|
|
char *lc_start, *name;
|
|
|
|
|
|
|
|
for (; bi[0] != '\0' && str_isspace (bi); str_next_char (&bi))
|
|
|
|
;
|
2010-03-30 12:10:25 +04:00
|
|
|
if (bi[0] == '#')
|
|
|
|
continue;
|
2024-04-06 09:02:42 +03:00
|
|
|
|
2016-04-29 10:45:18 +03:00
|
|
|
for (lc_start = bi; bi[0] != '\0' && !str_isspace (bi); str_next_char (&bi))
|
|
|
|
;
|
2010-03-30 12:10:25 +04:00
|
|
|
|
2016-04-29 10:45:18 +03:00
|
|
|
if (bi == lc_start)
|
2010-03-30 12:10:25 +04:00
|
|
|
continue;
|
|
|
|
|
2010-11-10 12:20:09 +03:00
|
|
|
name = g_strndup (lc_start, bi - lc_start);
|
2024-03-31 19:40:09 +03:00
|
|
|
if (!g_ptr_array_find_with_equal_func (hosts, name, host_equal_func, NULL))
|
|
|
|
g_ptr_array_add (hosts, name);
|
|
|
|
else
|
|
|
|
g_free (name);
|
2010-03-30 12:10:25 +04:00
|
|
|
}
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
2016-04-29 10:45:18 +03:00
|
|
|
|
1998-02-27 07:54:42 +03:00
|
|
|
fclose (file);
|
|
|
|
}
|
|
|
|
|
2010-11-09 14:02:28 +03:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
|
1998-12-03 00:27:27 +03:00
|
|
|
static char *
|
2010-11-12 11:03:57 +03:00
|
|
|
hostname_completion_function (const char *text, int state, input_complete_t flags)
|
1998-02-27 07:54:42 +03:00
|
|
|
{
|
2024-03-31 19:40:09 +03:00
|
|
|
static GPtrArray *hosts = NULL;
|
|
|
|
static unsigned int host_p = 0;
|
2016-04-29 10:45:18 +03:00
|
|
|
static size_t textstart = 0;
|
|
|
|
static size_t textlen = 0;
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2009-04-24 02:47:22 +04:00
|
|
|
(void) flags;
|
2010-03-30 12:10:25 +04:00
|
|
|
SHOW_C_CTX ("hostname_completion_function");
|
2009-01-31 22:46:32 +03:00
|
|
|
|
2013-01-29 17:11:59 +04:00
|
|
|
if (state == 0)
|
2010-03-30 12:10:25 +04:00
|
|
|
{ /* Initialization stuff */
|
2004-08-30 02:38:06 +04:00
|
|
|
const char *p;
|
2010-03-30 12:10:25 +04:00
|
|
|
|
2024-03-31 19:40:09 +03:00
|
|
|
if (hosts != NULL)
|
|
|
|
g_ptr_array_free (hosts, TRUE);
|
|
|
|
hosts = g_ptr_array_new_with_free_func (g_free);
|
2013-01-29 17:11:59 +04:00
|
|
|
p = getenv ("HOSTFILE");
|
2024-03-31 19:40:09 +03:00
|
|
|
fetch_hosts (p != NULL ? p : "/etc/hosts", hosts);
|
|
|
|
host_p = 0;
|
2010-03-30 12:10:25 +04:00
|
|
|
textstart = (*text == '@') ? 1 : 0;
|
|
|
|
textlen = strlen (text + textstart);
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
2010-03-30 12:10:25 +04:00
|
|
|
|
2024-03-31 19:40:09 +03:00
|
|
|
for (; host_p < hosts->len; host_p++)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2013-01-29 17:11:59 +04:00
|
|
|
if (textlen == 0)
|
2010-03-30 12:10:25 +04:00
|
|
|
break; /* Match all of them */
|
2024-03-31 19:40:09 +03:00
|
|
|
if (strncmp (text + textstart, g_ptr_array_index (hosts, host_p), textlen) == 0)
|
2010-03-30 12:10:25 +04:00
|
|
|
break;
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
2010-03-30 12:10:25 +04:00
|
|
|
|
2024-03-31 19:40:09 +03:00
|
|
|
if (host_p == hosts->len)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2024-03-31 19:40:09 +03:00
|
|
|
g_ptr_array_free (hosts, TRUE);
|
2010-03-30 12:10:25 +04:00
|
|
|
hosts = NULL;
|
|
|
|
return NULL;
|
|
|
|
}
|
2013-01-26 17:10:06 +04:00
|
|
|
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2013-01-26 17:10:06 +04:00
|
|
|
GString *temp;
|
|
|
|
|
|
|
|
temp = g_string_sized_new (8);
|
2010-03-30 12:10:25 +04:00
|
|
|
|
2013-01-26 17:10:06 +04:00
|
|
|
if (textstart != 0)
|
|
|
|
g_string_append_c (temp, '@');
|
2024-03-31 19:40:09 +03:00
|
|
|
g_string_append (temp, g_ptr_array_index (hosts, host_p));
|
2010-03-30 12:10:25 +04:00
|
|
|
host_p++;
|
2013-01-26 17:10:06 +04:00
|
|
|
|
|
|
|
return g_string_free (temp, FALSE);
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-09 14:02:28 +03:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
/**
|
1998-12-03 00:27:27 +03:00
|
|
|
* This is the function to call when the word to complete is in a position
|
|
|
|
* where a command word can be found. It looks around $PATH, looking for
|
|
|
|
* commands that match. It also scans aliases, function names, and the
|
|
|
|
* table of shell built-ins.
|
|
|
|
*/
|
2010-11-09 14:02:28 +03:00
|
|
|
|
1998-12-03 00:27:27 +03:00
|
|
|
static char *
|
2016-04-28 18:24:05 +03:00
|
|
|
command_completion_function (const char *text, int state, input_complete_t flags)
|
1998-02-27 07:54:42 +03:00
|
|
|
{
|
2016-04-29 10:45:18 +03:00
|
|
|
static const char *path_end = NULL;
|
|
|
|
static gboolean isabsolute = FALSE;
|
|
|
|
static int phase = 0;
|
|
|
|
static size_t text_len = 0;
|
|
|
|
static const char *const *words = NULL;
|
|
|
|
static char *path = NULL;
|
|
|
|
static char *cur_path = NULL;
|
|
|
|
static char *cur_word = NULL;
|
|
|
|
static int init_state = 0;
|
2004-01-24 02:53:37 +03:00
|
|
|
static const char *const bash_reserved[] = {
|
2010-03-30 12:10:25 +04:00
|
|
|
"if", "then", "else", "elif", "fi", "case", "esac", "for",
|
|
|
|
"select", "while", "until", "do", "done", "in", "function", 0
|
2001-06-25 17:59:04 +04:00
|
|
|
};
|
2004-01-24 02:53:37 +03:00
|
|
|
static const char *const bash_builtins[] = {
|
2010-03-30 12:10:25 +04:00
|
|
|
"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
|
2001-06-25 17:59:04 +04:00
|
|
|
};
|
2016-04-29 10:45:18 +03:00
|
|
|
|
|
|
|
char *u_text;
|
2004-09-26 01:08:29 +04:00
|
|
|
char *p, *found;
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2010-03-30 12:10:25 +04:00
|
|
|
SHOW_C_CTX ("command_completion_function");
|
2009-01-31 22:46:32 +03:00
|
|
|
|
2016-04-29 10:45:18 +03:00
|
|
|
if ((flags & INPUT_COMPLETE_COMMANDS) == 0)
|
|
|
|
return NULL;
|
2010-03-30 22:59:41 +04:00
|
|
|
|
2024-03-09 14:41:08 +03:00
|
|
|
u_text = str_shell_unescape (text);
|
2009-02-01 14:28:31 +03:00
|
|
|
flags &= ~INPUT_COMPLETE_SHELL_ESC;
|
2009-01-31 22:46:32 +03:00
|
|
|
|
2010-03-30 22:59:41 +04:00
|
|
|
if (state == 0)
|
2010-03-30 12:10:25 +04:00
|
|
|
{ /* Initialize us a little bit */
|
2016-04-28 18:24:05 +03:00
|
|
|
isabsolute = strchr (u_text, PATH_SEP) != NULL;
|
2010-03-30 12:10:25 +04:00
|
|
|
if (!isabsolute)
|
|
|
|
{
|
|
|
|
words = bash_reserved;
|
|
|
|
phase = 0;
|
2016-04-28 18:24:05 +03:00
|
|
|
text_len = strlen (u_text);
|
2010-03-30 22:59:41 +04:00
|
|
|
|
|
|
|
if (path == NULL)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2010-03-30 22:59:41 +04:00
|
|
|
path = g_strdup (getenv ("PATH"));
|
|
|
|
if (path != NULL)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2010-03-30 22:59:41 +04:00
|
|
|
p = path;
|
|
|
|
path_end = strchr (p, '\0');
|
|
|
|
while ((p = strchr (p, PATH_ENV_SEP)) != NULL)
|
|
|
|
*p++ = '\0';
|
2010-03-30 12:10:25 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
2004-01-24 02:53:37 +03:00
|
|
|
|
2010-03-30 12:10:25 +04:00
|
|
|
if (isabsolute)
|
|
|
|
{
|
2016-04-28 18:24:05 +03:00
|
|
|
p = filename_completion_function (u_text, state, flags);
|
2009-05-27 09:18:44 +04:00
|
|
|
|
2010-03-30 22:59:41 +04:00
|
|
|
if (p != NULL)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
|
|
|
char *temp_p = p;
|
2013-01-29 17:11:59 +04:00
|
|
|
|
2024-03-09 14:41:08 +03:00
|
|
|
p = str_shell_escape (p);
|
2010-03-30 12:10:25 +04:00
|
|
|
g_free (temp_p);
|
|
|
|
}
|
2009-05-27 09:18:44 +04:00
|
|
|
|
2016-04-28 18:24:05 +03:00
|
|
|
g_free (u_text);
|
2010-03-30 12:10:25 +04:00
|
|
|
return p;
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
|
|
|
|
2004-01-24 02:53:37 +03:00
|
|
|
found = NULL;
|
2010-03-30 12:10:25 +04:00
|
|
|
switch (phase)
|
|
|
|
{
|
|
|
|
case 0: /* Reserved words */
|
2013-01-29 17:11:59 +04:00
|
|
|
for (; *words != NULL; words++)
|
2016-04-28 18:24:05 +03:00
|
|
|
if (strncmp (*words, u_text, text_len) == 0)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2016-04-28 18:24:05 +03:00
|
|
|
g_free (u_text);
|
2010-03-30 12:10:25 +04:00
|
|
|
return g_strdup (*(words++));
|
|
|
|
}
|
|
|
|
phase++;
|
|
|
|
words = bash_builtins;
|
2017-12-16 20:52:39 +03:00
|
|
|
MC_FALLTHROUGH;
|
2010-03-30 12:10:25 +04:00
|
|
|
case 1: /* Builtin commands */
|
2013-01-29 17:11:59 +04:00
|
|
|
for (; *words != NULL; words++)
|
2016-04-28 18:24:05 +03:00
|
|
|
if (strncmp (*words, u_text, text_len) == 0)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2016-04-28 18:24:05 +03:00
|
|
|
g_free (u_text);
|
2010-03-30 12:10:25 +04:00
|
|
|
return g_strdup (*(words++));
|
|
|
|
}
|
|
|
|
phase++;
|
2016-04-29 10:45:18 +03:00
|
|
|
if (path == NULL)
|
2010-03-30 12:10:25 +04:00
|
|
|
break;
|
|
|
|
cur_path = path;
|
|
|
|
cur_word = NULL;
|
2017-12-16 20:52:39 +03:00
|
|
|
MC_FALLTHROUGH;
|
2010-03-30 12:10:25 +04:00
|
|
|
case 2: /* And looking through the $PATH */
|
2016-04-29 10:45:18 +03:00
|
|
|
while (found == NULL)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2016-04-29 10:45:18 +03:00
|
|
|
if (cur_word == NULL)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
|
|
|
char *expanded;
|
|
|
|
|
|
|
|
if (cur_path >= path_end)
|
|
|
|
break;
|
2016-04-29 10:45:18 +03:00
|
|
|
expanded = tilde_expand (*cur_path != '\0' ? cur_path : ".");
|
2016-04-28 18:24:05 +03:00
|
|
|
cur_word = mc_build_filename (expanded, u_text, (char *) NULL);
|
2010-03-30 12:10:25 +04:00
|
|
|
g_free (expanded);
|
2016-04-29 10:45:18 +03:00
|
|
|
cur_path = strchr (cur_path, '\0') + 1;
|
2010-03-30 12:10:25 +04:00
|
|
|
init_state = state;
|
|
|
|
}
|
|
|
|
found = filename_completion_function (cur_word, state - init_state, flags);
|
2016-04-29 10:45:18 +03:00
|
|
|
if (found == NULL)
|
2014-08-05 11:18:30 +04:00
|
|
|
MC_PTR_FREE (cur_word);
|
2010-03-30 12:10:25 +04:00
|
|
|
}
|
2017-12-16 20:52:39 +03:00
|
|
|
MC_FALLTHROUGH;
|
2015-04-19 13:57:38 +03:00
|
|
|
default:
|
|
|
|
break;
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
2004-01-24 02:53:37 +03:00
|
|
|
|
2010-03-30 12:10:25 +04:00
|
|
|
if (found == NULL)
|
2014-08-05 11:18:30 +04:00
|
|
|
MC_PTR_FREE (path);
|
2010-03-30 22:59:41 +04:00
|
|
|
else
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2010-03-30 22:59:41 +04:00
|
|
|
p = strrchr (found, PATH_SEP);
|
|
|
|
if (p != NULL)
|
|
|
|
{
|
|
|
|
char *tmp = found;
|
2016-04-29 10:45:18 +03:00
|
|
|
|
2024-03-09 14:41:08 +03:00
|
|
|
found = str_shell_escape (p + 1);
|
2010-03-30 22:59:41 +04:00
|
|
|
g_free (tmp);
|
|
|
|
}
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
2009-05-27 09:18:44 +04:00
|
|
|
|
2016-04-28 18:24:05 +03:00
|
|
|
g_free (u_text);
|
1998-02-27 07:54:42 +03:00
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
2010-11-09 14:02:28 +03:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
|
1998-12-03 00:27:27 +03:00
|
|
|
static int
|
|
|
|
match_compare (const void *a, const void *b)
|
1998-02-27 07:54:42 +03:00
|
|
|
{
|
2016-02-20 13:46:35 +03:00
|
|
|
return strcmp (*(char *const *) a, *(char *const *) b);
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
|
|
|
|
2010-11-09 14:02:28 +03:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
/** Returns an array of char * matches with the longest common denominator
|
1998-02-27 07:54:42 +03:00
|
|
|
in the 1st entry. Then a NULL terminated list of different possible
|
|
|
|
completions follows.
|
|
|
|
You have to supply your own CompletionFunction with the word you
|
|
|
|
want to complete as the first argument and an count of previous matches
|
|
|
|
as the second.
|
|
|
|
In case no matches were found we return NULL. */
|
2010-11-09 14:02:28 +03:00
|
|
|
|
1998-12-03 00:27:27 +03:00
|
|
|
static char **
|
2010-11-12 11:03:57 +03:00
|
|
|
completion_matches (const char *text, CompletionFunction entry_function, input_complete_t flags)
|
1998-02-27 07:54:42 +03:00
|
|
|
{
|
|
|
|
/* Number of slots in match_list. */
|
2013-01-29 17:11:59 +04:00
|
|
|
size_t match_list_size = 30;
|
1998-02-27 07:54:42 +03:00
|
|
|
/* The list of matches. */
|
2013-01-29 17:11:59 +04:00
|
|
|
char **match_list;
|
1998-02-27 07:54:42 +03:00
|
|
|
/* Number of matches actually found. */
|
2013-01-29 17:11:59 +04:00
|
|
|
size_t matches = 0;
|
1998-02-27 07:54:42 +03:00
|
|
|
|
|
|
|
/* Temporary string binder. */
|
|
|
|
char *string;
|
|
|
|
|
2013-01-29 17:11:59 +04:00
|
|
|
match_list = g_new (char *, match_list_size + 1);
|
1998-02-27 07:54:42 +03:00
|
|
|
match_list[1] = NULL;
|
|
|
|
|
2010-03-30 12:10:25 +04:00
|
|
|
while ((string = (*entry_function) (text, matches, flags)) != NULL)
|
|
|
|
{
|
1998-02-27 07:54:42 +03:00
|
|
|
if (matches + 1 == match_list_size)
|
2013-01-29 17:11:59 +04:00
|
|
|
{
|
|
|
|
match_list_size += 30;
|
|
|
|
match_list = (char **) g_renew (char *, match_list, match_list_size + 1);
|
|
|
|
}
|
1998-02-27 07:54:42 +03:00
|
|
|
match_list[++matches] = string;
|
|
|
|
match_list[matches + 1] = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If there were any matches, then look through them finding out the
|
|
|
|
lowest common denominator. That then becomes match_list[0]. */
|
2016-04-29 10:45:18 +03:00
|
|
|
if (matches == 0)
|
|
|
|
MC_PTR_FREE (match_list); /* There were no matches. */
|
|
|
|
else
|
1998-02-27 07:54:42 +03:00
|
|
|
{
|
|
|
|
/* If only one match, just use that. */
|
2010-03-30 12:10:25 +04:00
|
|
|
if (matches == 1)
|
|
|
|
{
|
|
|
|
match_list[0] = match_list[1];
|
|
|
|
match_list[1] = NULL;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-10-15 10:34:04 +04:00
|
|
|
size_t i = 1;
|
|
|
|
int low = 4096; /* Count of max-matched characters. */
|
2013-01-29 17:11:59 +04:00
|
|
|
size_t j;
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2010-03-30 12:10:25 +04:00
|
|
|
qsort (match_list + 1, matches, sizeof (char *), match_compare);
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2010-03-30 12:10:25 +04:00
|
|
|
/* And compare each member of the list with
|
|
|
|
the next, finding out where they stop matching.
|
|
|
|
If we find two equal strings, we have to put one away... */
|
|
|
|
|
|
|
|
j = i + 1;
|
|
|
|
while (j < matches + 1)
|
|
|
|
{
|
2008-12-29 01:52:45 +03:00
|
|
|
char *si, *sj;
|
|
|
|
char *ni, *nj;
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2016-04-29 10:45:18 +03:00
|
|
|
for (si = match_list[i], sj = match_list[j]; si[0] != '\0' && sj[0] != '\0';)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2008-12-29 01:52:45 +03:00
|
|
|
|
|
|
|
ni = str_get_next_char (si);
|
|
|
|
nj = str_get_next_char (sj);
|
2010-03-30 12:10:25 +04:00
|
|
|
|
|
|
|
if (ni - si != nj - sj)
|
|
|
|
break;
|
|
|
|
if (strncmp (si, sj, ni - si) != 0)
|
|
|
|
break;
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2008-12-29 01:52:45 +03:00
|
|
|
si = ni;
|
|
|
|
sj = nj;
|
|
|
|
}
|
2010-03-30 12:10:25 +04:00
|
|
|
|
|
|
|
if (si[0] == '\0' && sj[0] == '\0')
|
|
|
|
{ /* Two equal strings */
|
|
|
|
g_free (match_list[j]);
|
|
|
|
j++;
|
|
|
|
if (j > matches)
|
|
|
|
break;
|
|
|
|
continue; /* Look for a run of equal strings */
|
|
|
|
}
|
|
|
|
else if (low > si - match_list[i])
|
|
|
|
low = si - match_list[i];
|
|
|
|
if (i + 1 != j) /* So there's some gap */
|
|
|
|
match_list[i + 1] = match_list[j];
|
|
|
|
i++;
|
|
|
|
j++;
|
|
|
|
}
|
|
|
|
matches = i;
|
|
|
|
match_list[matches + 1] = NULL;
|
|
|
|
match_list[0] = g_strndup (match_list[1], low);
|
|
|
|
}
|
|
|
|
}
|
2014-08-05 11:18:30 +04:00
|
|
|
|
1998-02-27 07:54:42 +03:00
|
|
|
return match_list;
|
|
|
|
}
|
|
|
|
|
2010-11-09 14:02:28 +03:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
/** Check if directory completion is needed */
|
2010-12-19 20:10:59 +03:00
|
|
|
static gboolean
|
2010-11-12 11:03:57 +03:00
|
|
|
check_is_cd (const char *text, int lc_start, input_complete_t flags)
|
1998-02-27 07:54:42 +03:00
|
|
|
{
|
2016-02-20 13:46:35 +03:00
|
|
|
const char *p, *q;
|
2003-11-25 00:22:00 +03:00
|
|
|
|
2010-03-30 12:10:25 +04:00
|
|
|
SHOW_C_CTX ("check_is_cd");
|
2010-12-30 17:45:56 +03:00
|
|
|
|
2010-12-19 20:10:59 +03:00
|
|
|
if ((flags & INPUT_COMPLETE_CD) == 0)
|
|
|
|
return FALSE;
|
2003-11-25 00:22:00 +03:00
|
|
|
|
|
|
|
/* Skip initial spaces */
|
2016-02-20 13:46:35 +03:00
|
|
|
p = text;
|
|
|
|
q = text + lc_start;
|
2008-12-29 01:52:45 +03:00
|
|
|
while (p < q && p[0] != '\0' && str_isspace (p))
|
2016-02-20 13:46:35 +03:00
|
|
|
str_cnext_char (&p);
|
2003-11-25 00:22:00 +03:00
|
|
|
|
|
|
|
/* Check if the command is "cd" and the cursor is after it */
|
2010-12-19 20:10:59 +03:00
|
|
|
return (p[0] == 'c' && p[1] == 'd' && str_isspace (p + 2) && p + 2 < q);
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
|
|
|
|
2010-11-09 14:02:28 +03:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2013-01-25 15:30:17 +04:00
|
|
|
static void
|
|
|
|
try_complete_commands_prepare (try_complete_automation_state_t * state, char *text, int *lc_start)
|
|
|
|
{
|
|
|
|
const char *command_separator_chars = ";|&{(`";
|
|
|
|
char *ti;
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2013-01-25 15:30:17 +04:00
|
|
|
if (*lc_start == 0)
|
|
|
|
ti = text;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ti = str_get_prev_char (&text[*lc_start]);
|
2016-12-11 21:31:22 +03:00
|
|
|
while (ti > text && whitespace (ti[0]))
|
2013-01-25 15:30:17 +04:00
|
|
|
str_prev_char (&ti);
|
|
|
|
}
|
2010-12-22 11:17:15 +03:00
|
|
|
|
2013-01-25 15:30:17 +04:00
|
|
|
if (ti == text)
|
|
|
|
state->in_command_position++;
|
|
|
|
else if (strchr (command_separator_chars, ti[0]) != NULL)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2013-01-25 15:30:17 +04:00
|
|
|
state->in_command_position++;
|
|
|
|
if (ti != text)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2013-10-15 10:34:04 +04:00
|
|
|
int this_char, prev_char;
|
|
|
|
|
2013-05-26 10:11:06 +04:00
|
|
|
/* Handle the two character tokens '>&', '<&', and '>|'.
|
2013-01-25 15:30:17 +04:00
|
|
|
We are not in a command position after one of these. */
|
|
|
|
this_char = ti[0];
|
|
|
|
prev_char = str_get_prev_char (ti)[0];
|
|
|
|
|
|
|
|
/* Quoted */
|
|
|
|
if ((this_char == '&' && (prev_char == '<' || prev_char == '>'))
|
|
|
|
|| (this_char == '|' && prev_char == '>') || (ti != text
|
|
|
|
&& str_get_prev_char (ti)[0] == '\\'))
|
|
|
|
state->in_command_position = 0;
|
2010-03-30 12:10:25 +04:00
|
|
|
}
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
2013-01-25 15:30:17 +04:00
|
|
|
}
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2013-01-25 15:30:17 +04:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
static void
|
|
|
|
try_complete_find_start_sign (try_complete_automation_state_t * state)
|
|
|
|
{
|
2016-04-29 10:45:18 +03:00
|
|
|
if ((state->flags & INPUT_COMPLETE_COMMANDS) != 0)
|
2013-01-25 15:30:17 +04:00
|
|
|
state->p = strrchr (state->word, '`');
|
2016-04-29 10:45:18 +03:00
|
|
|
if ((state->flags & (INPUT_COMPLETE_COMMANDS | INPUT_COMPLETE_VARIABLES)) != 0)
|
2012-02-18 19:43:45 +04:00
|
|
|
{
|
2013-01-25 15:30:17 +04:00
|
|
|
state->q = strrchr (state->word, '$');
|
2012-02-18 19:43:45 +04:00
|
|
|
|
|
|
|
/* don't substitute variable in \$ case */
|
2024-03-09 14:41:08 +03:00
|
|
|
if (str_is_char_escaped (state->word, state->q))
|
2012-02-18 19:43:45 +04:00
|
|
|
{
|
|
|
|
/* drop '\\' */
|
2018-01-21 10:24:40 +03:00
|
|
|
str_move (state->q - 1, state->q);
|
2012-02-18 19:43:45 +04:00
|
|
|
/* adjust flags */
|
2013-01-25 15:30:17 +04:00
|
|
|
state->flags &= ~INPUT_COMPLETE_VARIABLES;
|
|
|
|
state->q = NULL;
|
2012-02-18 19:43:45 +04:00
|
|
|
}
|
|
|
|
}
|
2016-04-29 10:45:18 +03:00
|
|
|
if ((state->flags & INPUT_COMPLETE_HOSTNAMES) != 0)
|
2013-01-25 15:30:17 +04:00
|
|
|
state->r = strrchr (state->word, '@');
|
2016-04-29 10:45:18 +03:00
|
|
|
if (state->q != NULL && state->q[1] == '(' && (state->flags & INPUT_COMPLETE_COMMANDS) != 0)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2013-01-25 15:30:17 +04:00
|
|
|
if (state->q > state->p)
|
|
|
|
state->p = str_get_next_char (state->q);
|
|
|
|
state->q = NULL;
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
2013-01-25 15:30:17 +04:00
|
|
|
}
|
2009-04-04 23:50:46 +04:00
|
|
|
|
2013-01-25 15:30:17 +04:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2013-01-25 15:30:17 +04:00
|
|
|
static char **
|
|
|
|
try_complete_all_possible (try_complete_automation_state_t * state, char *text, int *lc_start)
|
|
|
|
{
|
|
|
|
char **matches = NULL;
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2013-01-25 15:30:17 +04:00
|
|
|
if (state->in_command_position != 0)
|
2009-01-31 22:46:32 +03:00
|
|
|
{
|
2010-03-30 12:10:25 +04:00
|
|
|
SHOW_C_CTX ("try_complete:cmd_subst");
|
|
|
|
matches =
|
2013-01-25 15:30:17 +04:00
|
|
|
completion_matches (state->word, command_completion_function,
|
|
|
|
state->flags & (~INPUT_COMPLETE_FILENAMES));
|
2009-01-31 22:46:32 +03:00
|
|
|
}
|
2013-01-25 15:30:17 +04:00
|
|
|
else if ((state->flags & INPUT_COMPLETE_FILENAMES) != 0)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2013-01-25 15:30:17 +04:00
|
|
|
if (state->is_cd)
|
|
|
|
state->flags &= ~(INPUT_COMPLETE_FILENAMES | INPUT_COMPLETE_COMMANDS);
|
2010-03-30 12:10:25 +04:00
|
|
|
SHOW_C_CTX ("try_complete:filename_subst_1");
|
2013-01-25 15:30:17 +04:00
|
|
|
matches = completion_matches (state->word, filename_completion_function, state->flags);
|
|
|
|
|
2015-01-07 11:34:53 +03:00
|
|
|
if (matches == NULL && state->is_cd && !IS_PATH_SEP (*state->word) && *state->word != '~')
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2013-01-25 15:30:17 +04:00
|
|
|
state->q = text + *lc_start;
|
|
|
|
for (state->p = text;
|
2016-12-11 21:31:22 +03:00
|
|
|
*state->p != '\0' && state->p < state->q && whitespace (*state->p);
|
2013-01-25 15:30:17 +04:00
|
|
|
str_next_char (&state->p))
|
|
|
|
;
|
2016-04-29 10:45:18 +03:00
|
|
|
if (strncmp (state->p, "cd", 2) == 0)
|
2013-01-25 15:30:17 +04:00
|
|
|
for (state->p += 2;
|
2016-12-11 21:31:22 +03:00
|
|
|
*state->p != '\0' && state->p < state->q && whitespace (*state->p);
|
2013-01-25 15:30:17 +04:00
|
|
|
str_next_char (&state->p))
|
2013-01-26 17:10:06 +04:00
|
|
|
;
|
2013-01-25 15:30:17 +04:00
|
|
|
if (state->p == state->q)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2016-04-29 10:45:18 +03:00
|
|
|
char *cdpath_ref, *cdpath;
|
2013-10-15 10:34:04 +04:00
|
|
|
char c;
|
|
|
|
|
2016-04-29 10:45:18 +03:00
|
|
|
cdpath_ref = g_strdup (getenv ("CDPATH"));
|
|
|
|
cdpath = cdpath_ref;
|
2013-10-15 10:34:04 +04:00
|
|
|
c = (cdpath == NULL) ? '\0' : ':';
|
2010-03-30 12:10:25 +04:00
|
|
|
|
2016-04-29 10:45:18 +03:00
|
|
|
while (matches == NULL && c == ':')
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2013-10-15 10:34:04 +04:00
|
|
|
char *s;
|
|
|
|
|
2010-03-30 12:10:25 +04:00
|
|
|
s = strchr (cdpath, ':');
|
2013-10-10 16:21:26 +04:00
|
|
|
/* cppcheck-suppress nullPointer */
|
2010-03-30 12:10:25 +04:00
|
|
|
if (s == NULL)
|
2013-10-15 10:34:04 +04:00
|
|
|
s = strchr (cdpath, '\0');
|
2010-03-30 12:10:25 +04:00
|
|
|
c = *s;
|
2013-10-15 10:34:04 +04:00
|
|
|
*s = '\0';
|
|
|
|
if (*cdpath != '\0')
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2016-03-25 21:33:44 +03:00
|
|
|
state->r = mc_build_filename (cdpath, state->word, (char *) NULL);
|
2010-03-30 12:10:25 +04:00
|
|
|
SHOW_C_CTX ("try_complete:filename_subst_2");
|
2013-01-25 15:30:17 +04:00
|
|
|
matches =
|
|
|
|
completion_matches (state->r, filename_completion_function,
|
|
|
|
state->flags);
|
|
|
|
g_free (state->r);
|
2010-03-30 12:10:25 +04:00
|
|
|
}
|
|
|
|
*s = c;
|
|
|
|
cdpath = str_get_next_char (s);
|
|
|
|
}
|
|
|
|
g_free (cdpath_ref);
|
|
|
|
}
|
|
|
|
}
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
|
|
|
return matches;
|
|
|
|
}
|
|
|
|
|
2010-11-09 14:02:28 +03:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2013-01-29 17:11:59 +04:00
|
|
|
static gboolean
|
2010-03-30 12:10:25 +04:00
|
|
|
insert_text (WInput * in, char *text, ssize_t size)
|
1998-02-27 07:54:42 +03:00
|
|
|
{
|
2016-04-29 10:45:18 +03:00
|
|
|
size_t text_len;
|
2013-01-29 17:11:59 +04:00
|
|
|
int buff_len;
|
2021-10-10 17:08:52 +03:00
|
|
|
ssize_t new_size;
|
2009-12-12 13:54:22 +03:00
|
|
|
|
2016-04-29 10:45:18 +03:00
|
|
|
text_len = strlen (text);
|
2021-10-10 17:08:52 +03:00
|
|
|
buff_len = str_length (in->buffer->str);
|
2021-10-10 17:33:50 +03:00
|
|
|
if (size < 0)
|
|
|
|
size = (ssize_t) text_len;
|
|
|
|
else
|
|
|
|
size = MIN (size, (ssize_t) text_len);
|
2021-10-10 17:08:52 +03:00
|
|
|
|
|
|
|
new_size = size + start - end;
|
|
|
|
if (new_size != 0)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2021-10-10 17:08:52 +03:00
|
|
|
/* make a hole within buffer */
|
|
|
|
|
|
|
|
size_t tail_len;
|
2013-01-29 17:11:59 +04:00
|
|
|
|
2021-10-10 17:08:52 +03:00
|
|
|
tail_len = in->buffer->len - end;
|
|
|
|
if (tail_len != 0)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2021-10-10 17:08:52 +03:00
|
|
|
char *tail;
|
|
|
|
size_t hole_end;
|
|
|
|
|
|
|
|
tail = g_strndup (in->buffer->str + end, tail_len);
|
|
|
|
|
|
|
|
hole_end = end + new_size;
|
|
|
|
if (in->buffer->len < hole_end)
|
|
|
|
g_string_set_size (in->buffer, hole_end + tail_len);
|
|
|
|
|
|
|
|
g_string_overwrite_len (in->buffer, hole_end, tail, tail_len);
|
|
|
|
|
|
|
|
g_free (tail);
|
2010-03-30 12:10:25 +04:00
|
|
|
}
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
2016-04-29 10:45:18 +03:00
|
|
|
|
2021-10-10 17:08:52 +03:00
|
|
|
g_string_overwrite_len (in->buffer, start, text, size);
|
|
|
|
|
|
|
|
in->point += str_length (in->buffer->str) - buff_len;
|
|
|
|
input_update (in, TRUE);
|
|
|
|
end += new_size;
|
|
|
|
|
|
|
|
return new_size != 0;
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
|
|
|
|
2010-11-09 14:02:28 +03:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
|
2003-09-08 01:24:01 +04:00
|
|
|
static cb_ret_t
|
2020-04-09 08:11:24 +03:00
|
|
|
complete_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, void *data)
|
1998-02-27 07:54:42 +03:00
|
|
|
{
|
2008-12-29 01:52:45 +03:00
|
|
|
static int bl = 0;
|
2009-11-08 12:43:37 +03:00
|
|
|
|
2016-09-27 13:53:17 +03:00
|
|
|
WGroup *g = GROUP (w);
|
2012-09-28 15:05:43 +04:00
|
|
|
WDialog *h = DIALOG (w);
|
|
|
|
|
2010-03-30 12:10:25 +04:00
|
|
|
switch (msg)
|
|
|
|
{
|
2012-09-28 15:05:43 +04:00
|
|
|
case MSG_KEY:
|
2010-03-30 12:10:25 +04:00
|
|
|
switch (parm)
|
|
|
|
{
|
|
|
|
case KEY_LEFT:
|
|
|
|
case KEY_RIGHT:
|
2008-12-29 01:52:45 +03:00
|
|
|
bl = 0;
|
2010-03-30 12:10:25 +04:00
|
|
|
h->ret_value = 0;
|
2023-04-15 10:17:41 +03:00
|
|
|
dlg_close (h);
|
2010-03-30 12:10:25 +04:00
|
|
|
return MSG_HANDLED;
|
2002-08-22 19:34:25 +04:00
|
|
|
|
2010-03-30 12:10:25 +04:00
|
|
|
case KEY_BACKSPACE:
|
2008-12-29 01:52:45 +03:00
|
|
|
bl = 0;
|
2010-12-21 22:54:00 +03:00
|
|
|
/* exit from completion list if input line is empty */
|
|
|
|
if (end == 0)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
|
|
|
h->ret_value = 0;
|
2023-04-15 10:17:41 +03:00
|
|
|
dlg_close (h);
|
2010-03-30 12:10:25 +04:00
|
|
|
}
|
2010-12-21 22:54:00 +03:00
|
|
|
/* Refill the list box and start again */
|
|
|
|
else if (end == min_end)
|
|
|
|
{
|
2021-10-10 17:08:52 +03:00
|
|
|
end = str_get_prev_char (input->buffer->str + end) - input->buffer->str;
|
2010-12-21 22:54:00 +03:00
|
|
|
input_handle_char (input, parm);
|
|
|
|
h->ret_value = B_USER;
|
2023-04-15 10:17:41 +03:00
|
|
|
dlg_close (h);
|
2010-12-21 22:54:00 +03:00
|
|
|
}
|
2010-03-30 12:10:25 +04:00
|
|
|
else
|
|
|
|
{
|
2010-12-20 17:27:05 +03:00
|
|
|
int new_end;
|
2010-03-30 12:10:25 +04:00
|
|
|
int i;
|
|
|
|
GList *e;
|
|
|
|
|
2021-10-10 17:08:52 +03:00
|
|
|
new_end = str_get_prev_char (input->buffer->str + end) - input->buffer->str;
|
2010-12-20 17:27:05 +03:00
|
|
|
|
2016-09-27 13:53:17 +03:00
|
|
|
for (i = 0, e = listbox_get_first_link (LISTBOX (g->current->data));
|
2010-03-30 12:10:25 +04:00
|
|
|
e != NULL; i++, e = g_list_next (e))
|
|
|
|
{
|
2012-10-11 12:25:07 +04:00
|
|
|
WLEntry *le = LENTRY (e->data);
|
2010-03-30 12:10:25 +04:00
|
|
|
|
2021-10-10 17:08:52 +03:00
|
|
|
if (strncmp (input->buffer->str + start, le->text, new_end - start) == 0)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2023-04-15 14:56:07 +03:00
|
|
|
listbox_set_current (LISTBOX (g->current->data), i);
|
2010-12-20 17:27:05 +03:00
|
|
|
end = new_end;
|
2010-11-12 11:03:57 +03:00
|
|
|
input_handle_char (input, parm);
|
2016-09-27 13:53:17 +03:00
|
|
|
widget_draw (WIDGET (g->current->data));
|
2010-03-30 12:10:25 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return MSG_HANDLED;
|
|
|
|
|
|
|
|
default:
|
2010-12-20 17:27:05 +03:00
|
|
|
if (parm < 32 || parm > 255)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2008-12-29 01:52:45 +03:00
|
|
|
bl = 0;
|
2020-04-09 08:04:54 +03:00
|
|
|
if (widget_lookup_key (WIDGET (input), parm) != CK_Complete)
|
2010-03-30 12:10:25 +04:00
|
|
|
return MSG_NOT_HANDLED;
|
2010-12-20 17:27:05 +03:00
|
|
|
|
|
|
|
if (end == min_end)
|
|
|
|
return MSG_HANDLED;
|
|
|
|
|
|
|
|
/* This means we want to refill the list box and start again */
|
|
|
|
h->ret_value = B_USER;
|
2023-04-15 10:17:41 +03:00
|
|
|
dlg_close (h);
|
2010-03-30 12:10:25 +04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-10-15 10:34:04 +04:00
|
|
|
static char buff[MB_LEN_MAX] = "";
|
2010-03-30 12:10:25 +04:00
|
|
|
GList *e;
|
|
|
|
int i;
|
|
|
|
int need_redraw = 0;
|
|
|
|
int low = 4096;
|
|
|
|
char *last_text = NULL;
|
2002-08-22 19:34:25 +04:00
|
|
|
|
2010-12-20 17:27:05 +03:00
|
|
|
buff[bl++] = (char) parm;
|
2008-12-29 01:52:45 +03:00
|
|
|
buff[bl] = '\0';
|
2016-04-29 10:45:18 +03:00
|
|
|
|
2010-03-30 12:10:25 +04:00
|
|
|
switch (str_is_valid_char (buff, bl))
|
|
|
|
{
|
|
|
|
case -1:
|
|
|
|
bl = 0;
|
2017-12-16 20:52:39 +03:00
|
|
|
MC_FALLTHROUGH;
|
2010-03-30 12:10:25 +04:00
|
|
|
case -2:
|
|
|
|
return MSG_HANDLED;
|
2015-04-19 13:57:38 +03:00
|
|
|
default:
|
|
|
|
break;
|
2008-12-29 01:52:45 +03:00
|
|
|
}
|
2009-12-28 19:10:42 +03:00
|
|
|
|
2016-09-27 13:53:17 +03:00
|
|
|
for (i = 0, e = listbox_get_first_link (LISTBOX (g->current->data));
|
2010-03-30 12:10:25 +04:00
|
|
|
e != NULL; i++, e = g_list_next (e))
|
|
|
|
{
|
2012-10-11 12:25:07 +04:00
|
|
|
WLEntry *le = LENTRY (e->data);
|
2009-12-28 19:10:42 +03:00
|
|
|
|
2021-10-10 17:08:52 +03:00
|
|
|
if (strncmp (input->buffer->str + start, le->text, end - start) == 0
|
|
|
|
&& strncmp (le->text + end - start, buff, bl) == 0)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2010-12-20 17:27:05 +03:00
|
|
|
if (need_redraw == 0)
|
|
|
|
{
|
|
|
|
need_redraw = 1;
|
2023-04-15 14:56:07 +03:00
|
|
|
listbox_set_current (LISTBOX (g->current->data), i);
|
2010-12-20 17:27:05 +03:00
|
|
|
last_text = le->text;
|
|
|
|
}
|
|
|
|
else
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2010-12-20 17:27:05 +03:00
|
|
|
char *si, *sl;
|
|
|
|
int si_num = 0;
|
|
|
|
int sl_num = 0;
|
|
|
|
|
|
|
|
/* count symbols between start and end */
|
|
|
|
for (si = le->text + start; si < le->text + end;
|
|
|
|
str_next_char (&si), si_num++)
|
|
|
|
;
|
|
|
|
for (sl = last_text + start; sl < last_text + end;
|
|
|
|
str_next_char (&sl), sl_num++)
|
|
|
|
;
|
|
|
|
|
|
|
|
/* pointers to next symbols */
|
2011-10-15 14:56:47 +04:00
|
|
|
si = &le->text[str_offset_to_pos (le->text, ++si_num)];
|
|
|
|
sl = &last_text[str_offset_to_pos (last_text, ++sl_num)];
|
2010-12-20 17:27:05 +03:00
|
|
|
|
|
|
|
while (si[0] != '\0' && sl[0] != '\0')
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
|
|
|
char *nexti, *nextl;
|
2009-12-28 19:10:42 +03:00
|
|
|
|
2010-12-20 17:27:05 +03:00
|
|
|
nexti = str_get_next_char (si);
|
|
|
|
nextl = str_get_next_char (sl);
|
2009-12-28 19:10:42 +03:00
|
|
|
|
2011-10-15 14:56:47 +04:00
|
|
|
if (nexti - si != nextl - sl || strncmp (si, sl, nexti - si) != 0)
|
2010-12-20 17:27:05 +03:00
|
|
|
break;
|
2009-12-28 19:10:42 +03:00
|
|
|
|
2010-12-20 17:27:05 +03:00
|
|
|
si = nexti;
|
|
|
|
sl = nextl;
|
2009-12-28 19:10:42 +03:00
|
|
|
|
2010-12-20 17:27:05 +03:00
|
|
|
si_num++;
|
|
|
|
}
|
2008-12-29 01:52:45 +03:00
|
|
|
|
2010-12-20 17:27:05 +03:00
|
|
|
last_text = le->text;
|
2010-03-30 12:10:25 +04:00
|
|
|
|
2011-10-15 14:56:47 +04:00
|
|
|
si = &last_text[str_offset_to_pos (last_text, si_num)];
|
2010-12-20 17:27:05 +03:00
|
|
|
if (low > si - last_text)
|
|
|
|
low = si - last_text;
|
|
|
|
|
|
|
|
need_redraw = 2;
|
2010-03-30 12:10:25 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (need_redraw == 2)
|
|
|
|
{
|
|
|
|
insert_text (input, last_text, low);
|
2016-09-27 13:53:17 +03:00
|
|
|
widget_draw (WIDGET (g->current->data));
|
2010-03-30 12:10:25 +04:00
|
|
|
}
|
|
|
|
else if (need_redraw == 1)
|
|
|
|
{
|
|
|
|
h->ret_value = B_ENTER;
|
2023-04-15 10:17:41 +03:00
|
|
|
dlg_close (h);
|
2010-03-30 12:10:25 +04:00
|
|
|
}
|
2008-12-29 01:52:45 +03:00
|
|
|
bl = 0;
|
2010-03-30 12:10:25 +04:00
|
|
|
}
|
|
|
|
}
|
2015-05-10 18:12:39 +03:00
|
|
|
return MSG_HANDLED;
|
2003-09-08 01:24:01 +04:00
|
|
|
|
|
|
|
default:
|
2012-09-28 15:05:43 +04:00
|
|
|
return dlg_default_callback (w, sender, msg, parm, data);
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-09 14:02:28 +03:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
|
2016-04-29 10:45:18 +03:00
|
|
|
/** Returns TRUE if the user would like to see us again */
|
|
|
|
static gboolean
|
2010-03-30 12:10:25 +04:00
|
|
|
complete_engine (WInput * in, int what_to_do)
|
1998-02-27 07:54:42 +03:00
|
|
|
{
|
2021-10-10 17:08:52 +03:00
|
|
|
if (in->completions != NULL && str_offset_to_pos (in->buffer->str, in->point) != end)
|
2020-04-09 08:11:24 +03:00
|
|
|
input_complete_free (in);
|
2010-12-20 17:27:05 +03:00
|
|
|
|
2013-01-25 15:30:17 +04:00
|
|
|
if (in->completions == NULL)
|
|
|
|
complete_engine_fill_completions (in);
|
2009-04-04 23:50:46 +04:00
|
|
|
|
2016-04-29 10:45:18 +03:00
|
|
|
if (in->completions == NULL)
|
|
|
|
tty_beep ();
|
|
|
|
else
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2016-04-29 10:45:18 +03:00
|
|
|
if ((what_to_do & DO_INSERTION) != 0
|
|
|
|
|| ((what_to_do & DO_QUERY) != 0 && in->completions[1] == NULL))
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
|
|
|
char *lc_complete = in->completions[0];
|
2016-04-29 10:45:18 +03:00
|
|
|
|
2021-10-10 17:33:50 +03:00
|
|
|
if (!insert_text (in, lc_complete, -1) || in->completions[1] != NULL)
|
2010-03-30 12:10:25 +04:00
|
|
|
tty_beep ();
|
2016-04-29 10:45:18 +03:00
|
|
|
else
|
2020-04-09 08:11:24 +03:00
|
|
|
input_complete_free (in);
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
2016-04-29 10:45:18 +03:00
|
|
|
|
|
|
|
if ((what_to_do & DO_QUERY) != 0 && in->completions != NULL && in->completions[1] != NULL)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2016-04-29 10:45:18 +03:00
|
|
|
int maxlen = 0, count = 0, i;
|
2010-03-30 12:10:25 +04:00
|
|
|
int x, y, w, h;
|
|
|
|
int start_x, start_y;
|
|
|
|
char **p, *q;
|
2020-04-09 08:11:24 +03:00
|
|
|
WDialog *complete_dlg;
|
|
|
|
WListbox *complete_list;
|
2010-03-30 12:10:25 +04:00
|
|
|
|
2010-03-30 22:59:41 +04:00
|
|
|
for (p = in->completions + 1; *p != NULL; count++, p++)
|
2010-05-12 21:13:26 +04:00
|
|
|
{
|
2010-03-30 22:59:41 +04:00
|
|
|
i = str_term_width1 (*p);
|
|
|
|
if (i > maxlen)
|
2010-03-30 12:10:25 +04:00
|
|
|
maxlen = i;
|
2010-05-12 21:13:26 +04:00
|
|
|
}
|
2016-04-29 10:45:18 +03:00
|
|
|
|
2022-05-01 10:43:33 +03:00
|
|
|
start_x = WIDGET (in)->rect.x;
|
|
|
|
start_y = WIDGET (in)->rect.y;
|
2010-03-30 12:10:25 +04:00
|
|
|
if (start_y - 2 >= count)
|
|
|
|
{
|
|
|
|
y = start_y - 2 - count;
|
|
|
|
h = 2 + count;
|
|
|
|
}
|
2016-04-29 10:45:18 +03:00
|
|
|
else if (start_y >= LINES - start_y - 1)
|
|
|
|
{
|
|
|
|
y = 0;
|
|
|
|
h = start_y;
|
|
|
|
}
|
2010-03-30 12:10:25 +04:00
|
|
|
else
|
|
|
|
{
|
2016-04-29 10:45:18 +03:00
|
|
|
y = start_y + 1;
|
|
|
|
h = LINES - start_y - 1;
|
2010-03-30 12:10:25 +04:00
|
|
|
}
|
|
|
|
x = start - in->term_first_shown - 2 + start_x;
|
|
|
|
w = maxlen + 4;
|
|
|
|
if (x + w > COLS)
|
|
|
|
x = COLS - w;
|
|
|
|
if (x < 0)
|
|
|
|
x = 0;
|
|
|
|
if (x + w > COLS)
|
|
|
|
w = COLS;
|
2016-04-29 10:45:18 +03:00
|
|
|
|
2010-03-30 12:10:25 +04:00
|
|
|
input = in;
|
|
|
|
min_end = end;
|
2016-04-29 10:45:18 +03:00
|
|
|
|
2020-04-09 08:11:24 +03:00
|
|
|
complete_dlg =
|
2023-12-17 17:45:10 +03:00
|
|
|
dlg_create (TRUE, y, x, h, w, WPOS_KEEP_DEFAULT, TRUE,
|
2020-04-09 08:11:24 +03:00
|
|
|
dialog_colors, complete_callback, NULL, "[Completion]", NULL);
|
|
|
|
complete_list = listbox_new (1, 1, h - 2, w - 2, FALSE, NULL);
|
|
|
|
group_add_widget (GROUP (complete_dlg), complete_list);
|
2016-04-29 10:45:18 +03:00
|
|
|
|
|
|
|
for (p = in->completions + 1; *p != NULL; p++)
|
2020-04-09 08:11:24 +03:00
|
|
|
listbox_add_item (complete_list, LISTBOX_APPEND_AT_END, 0, *p, NULL, FALSE);
|
2016-04-29 10:45:18 +03:00
|
|
|
|
2020-04-09 08:11:24 +03:00
|
|
|
i = dlg_run (complete_dlg);
|
2010-03-30 12:10:25 +04:00
|
|
|
q = NULL;
|
2016-04-29 10:45:18 +03:00
|
|
|
if (i == B_ENTER)
|
2010-03-30 12:10:25 +04:00
|
|
|
{
|
2020-04-09 08:11:24 +03:00
|
|
|
listbox_get_current (complete_list, &q, NULL);
|
2016-04-29 10:45:18 +03:00
|
|
|
if (q != NULL)
|
2021-10-10 17:33:50 +03:00
|
|
|
insert_text (in, q, -1);
|
2010-03-30 12:10:25 +04:00
|
|
|
}
|
2016-04-29 10:45:18 +03:00
|
|
|
if (q != NULL || end != min_end)
|
2020-04-09 08:11:24 +03:00
|
|
|
input_complete_free (in);
|
2020-10-31 19:32:29 +03:00
|
|
|
widget_destroy (WIDGET (complete_dlg));
|
2016-04-29 10:45:18 +03:00
|
|
|
|
|
|
|
/* B_USER if user wants to start over again */
|
|
|
|
return (i == B_USER);
|
2010-03-30 12:10:25 +04:00
|
|
|
}
|
|
|
|
}
|
2016-04-29 10:45:18 +03:00
|
|
|
|
|
|
|
return FALSE;
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
|
|
|
|
2010-11-09 14:02:28 +03:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
/*** public functions ****************************************************************************/
|
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
|
2013-01-25 15:30:17 +04:00
|
|
|
/** Returns an array of matches, or NULL if none. */
|
|
|
|
char **
|
|
|
|
try_complete (char *text, int *lc_start, int *lc_end, input_complete_t flags)
|
|
|
|
{
|
|
|
|
try_complete_automation_state_t state;
|
|
|
|
char **matches = NULL;
|
|
|
|
|
2016-01-01 11:23:17 +03:00
|
|
|
memset (&state, 0, sizeof (state));
|
2013-01-25 15:30:17 +04:00
|
|
|
state.flags = flags;
|
|
|
|
|
|
|
|
SHOW_C_CTX ("try_complete");
|
|
|
|
state.word = g_strndup (text + *lc_start, *lc_end - *lc_start);
|
|
|
|
|
|
|
|
state.is_cd = check_is_cd (text, *lc_start, state.flags);
|
|
|
|
|
|
|
|
/* Determine if this could be a command word. It is if it appears at
|
|
|
|
the start of the line (ignoring preceding whitespace), or if it
|
|
|
|
appears after a character that separates commands. And we have to
|
|
|
|
be in a INPUT_COMPLETE_COMMANDS flagged Input line. */
|
2016-04-29 10:45:18 +03:00
|
|
|
if (!state.is_cd && (flags & INPUT_COMPLETE_COMMANDS) != 0)
|
2013-01-25 15:30:17 +04:00
|
|
|
try_complete_commands_prepare (&state, text, lc_start);
|
|
|
|
|
|
|
|
try_complete_find_start_sign (&state);
|
|
|
|
|
|
|
|
/* Command substitution? */
|
|
|
|
if (state.p > state.q && state.p > state.r)
|
|
|
|
{
|
|
|
|
SHOW_C_CTX ("try_complete:cmd_backq_subst");
|
|
|
|
matches = completion_matches (str_cget_next_char (state.p),
|
|
|
|
command_completion_function,
|
|
|
|
state.flags & (~INPUT_COMPLETE_FILENAMES));
|
2016-04-29 10:45:18 +03:00
|
|
|
if (matches != NULL)
|
2013-01-25 15:30:17 +04:00
|
|
|
*lc_start += str_get_next_char (state.p) - state.word;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Variable name? */
|
|
|
|
else if (state.q > state.p && state.q > state.r)
|
|
|
|
{
|
|
|
|
SHOW_C_CTX ("try_complete:var_subst");
|
|
|
|
matches = completion_matches (state.q, variable_completion_function, state.flags);
|
2016-04-29 10:45:18 +03:00
|
|
|
if (matches != NULL)
|
2013-01-25 15:30:17 +04:00
|
|
|
*lc_start += state.q - state.word;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Starts with '@', then look through the known hostnames for
|
|
|
|
completion first. */
|
|
|
|
else if (state.r > state.p && state.r > state.q)
|
|
|
|
{
|
|
|
|
SHOW_C_CTX ("try_complete:host_subst");
|
|
|
|
matches = completion_matches (state.r, hostname_completion_function, state.flags);
|
2016-04-29 10:45:18 +03:00
|
|
|
if (matches != NULL)
|
2013-01-25 15:30:17 +04:00
|
|
|
*lc_start += state.r - state.word;
|
|
|
|
}
|
|
|
|
|
2013-05-26 10:11:06 +04:00
|
|
|
/* Starts with '~' and there is no slash in the word, then
|
2013-01-25 15:30:17 +04:00
|
|
|
try completing this word as a username. */
|
2016-04-29 10:45:18 +03:00
|
|
|
if (matches == NULL && *state.word == '~' && (state.flags & INPUT_COMPLETE_USERNAMES) != 0
|
|
|
|
&& strchr (state.word, PATH_SEP) == NULL)
|
2013-01-25 15:30:17 +04:00
|
|
|
{
|
|
|
|
SHOW_C_CTX ("try_complete:user_subst");
|
|
|
|
matches = completion_matches (state.word, username_completion_function, state.flags);
|
|
|
|
}
|
|
|
|
|
2013-09-25 10:07:02 +04:00
|
|
|
/* If this word is in a command position, then
|
2013-01-25 15:30:17 +04:00
|
|
|
complete over possible command names, including aliases, functions,
|
|
|
|
and command names. */
|
|
|
|
if (matches == NULL)
|
|
|
|
matches = try_complete_all_possible (&state, text, lc_start);
|
|
|
|
|
2013-09-25 10:07:02 +04:00
|
|
|
/* And finally if nothing found, try complete directory name */
|
|
|
|
if (matches == NULL)
|
|
|
|
{
|
|
|
|
state.in_command_position = 0;
|
|
|
|
matches = try_complete_all_possible (&state, text, lc_start);
|
|
|
|
}
|
|
|
|
|
2013-01-25 15:30:17 +04:00
|
|
|
g_free (state.word);
|
|
|
|
|
2011-10-07 13:14:17 +04:00
|
|
|
if (matches != NULL &&
|
|
|
|
(flags & (INPUT_COMPLETE_FILENAMES | INPUT_COMPLETE_SHELL_ESC)) !=
|
2013-02-14 14:42:27 +04:00
|
|
|
(INPUT_COMPLETE_FILENAMES | INPUT_COMPLETE_SHELL_ESC))
|
2011-10-07 13:14:17 +04:00
|
|
|
{
|
|
|
|
/* FIXME: HACK? INPUT_COMPLETE_SHELL_ESC is used only in command line. */
|
|
|
|
char **m;
|
|
|
|
|
|
|
|
for (m = matches; *m != NULL; m++)
|
|
|
|
{
|
|
|
|
char *p;
|
|
|
|
|
|
|
|
p = *m;
|
2024-03-09 14:41:08 +03:00
|
|
|
*m = str_shell_escape (*m);
|
2011-10-07 13:14:17 +04:00
|
|
|
g_free (p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-25 15:30:17 +04:00
|
|
|
return matches;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
void
|
|
|
|
complete_engine_fill_completions (WInput * in)
|
|
|
|
{
|
|
|
|
char *s;
|
2013-01-29 15:59:47 +04:00
|
|
|
const char *word_separators;
|
|
|
|
|
|
|
|
word_separators = (in->completion_flags & INPUT_COMPLETE_SHELL_ESC) ? " \t;|<>" : "\t;|<>";
|
2013-01-25 15:30:17 +04:00
|
|
|
|
2021-10-10 17:08:52 +03:00
|
|
|
end = str_offset_to_pos (in->buffer->str, in->point);
|
2013-01-25 15:30:17 +04:00
|
|
|
|
2021-10-10 17:08:52 +03:00
|
|
|
s = in->buffer->str;
|
2013-01-25 15:30:17 +04:00
|
|
|
if (in->point != 0)
|
|
|
|
{
|
|
|
|
/* get symbol before in->point */
|
|
|
|
size_t i;
|
|
|
|
|
|
|
|
for (i = in->point - 1; i > 0; i--)
|
|
|
|
str_next_char (&s);
|
|
|
|
}
|
|
|
|
|
2021-10-10 17:08:52 +03:00
|
|
|
for (; s >= in->buffer->str; str_prev_char (&s))
|
2013-01-25 15:30:17 +04:00
|
|
|
{
|
2021-10-10 17:08:52 +03:00
|
|
|
start = s - in->buffer->str;
|
2024-03-09 14:41:08 +03:00
|
|
|
if (strchr (word_separators, *s) != NULL && !str_is_char_escaped (in->buffer->str, s))
|
2013-01-25 15:30:17 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (start < end)
|
|
|
|
{
|
|
|
|
str_next_char (&s);
|
2021-10-10 17:08:52 +03:00
|
|
|
start = s - in->buffer->str;
|
2013-01-25 15:30:17 +04:00
|
|
|
}
|
|
|
|
|
2021-10-10 17:08:52 +03:00
|
|
|
in->completions = try_complete (in->buffer->str, &start, &end, in->completion_flags);
|
2013-01-25 15:30:17 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
|
2010-11-12 11:03:57 +03:00
|
|
|
/* declared in lib/widget/input.h */
|
2010-03-30 12:10:25 +04:00
|
|
|
void
|
2020-04-09 08:11:24 +03:00
|
|
|
input_complete (WInput * in)
|
1998-02-27 07:54:42 +03:00
|
|
|
{
|
2005-07-06 15:16:08 +04:00
|
|
|
int engine_flags;
|
|
|
|
|
2021-10-10 17:08:52 +03:00
|
|
|
if (!str_is_valid_string (in->buffer->str))
|
2010-03-30 12:10:25 +04:00
|
|
|
return;
|
2009-04-04 23:50:46 +04:00
|
|
|
|
2010-11-12 11:03:57 +03:00
|
|
|
if (in->completions != NULL)
|
2010-03-30 12:10:25 +04:00
|
|
|
engine_flags = DO_QUERY;
|
2005-07-06 15:16:08 +04:00
|
|
|
else
|
|
|
|
{
|
2010-03-30 12:10:25 +04:00
|
|
|
engine_flags = DO_INSERTION;
|
2005-07-06 15:16:08 +04:00
|
|
|
|
2011-02-10 18:02:54 +03:00
|
|
|
if (mc_global.widget.show_all_if_ambiguous)
|
2010-03-30 12:10:25 +04:00
|
|
|
engine_flags |= DO_QUERY;
|
2005-07-06 15:16:08 +04:00
|
|
|
}
|
|
|
|
|
2010-11-12 11:03:57 +03:00
|
|
|
while (complete_engine (in, engine_flags))
|
|
|
|
;
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
2010-11-09 14:02:28 +03:00
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
2020-04-09 08:11:24 +03:00
|
|
|
|
|
|
|
void
|
|
|
|
input_complete_free (WInput * in)
|
|
|
|
{
|
|
|
|
g_strfreev (in->completions);
|
|
|
|
in->completions = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------------------------- */
|