/* complete.c -- filename completion for readline. */
|
/* complete.c -- filename completion for readline. */
|
|
|
/* Copyright (C) 1987-2005 Free Software Foundation, Inc.
|
/* Copyright (C) 1987-2005 Free Software Foundation, Inc.
|
|
|
This file is part of the GNU Readline Library, a library for
|
This file is part of the GNU Readline Library, a library for
|
reading lines of text with interactive input and history editing.
|
reading lines of text with interactive input and history editing.
|
|
|
The GNU Readline Library is free software; you can redistribute it
|
The GNU Readline Library is free software; you can redistribute it
|
and/or modify it under the terms of the GNU General Public License
|
and/or modify it under the terms of the GNU General Public License
|
as published by the Free Software Foundation; either version 2, or
|
as published by the Free Software Foundation; either version 2, or
|
(at your option) any later version.
|
(at your option) any later version.
|
|
|
The GNU Readline Library is distributed in the hope that it will be
|
The GNU Readline Library is distributed in the hope that it will be
|
useful, but WITHOUT ANY WARRANTY; without even the implied warranty
|
useful, but WITHOUT ANY WARRANTY; without even the implied warranty
|
of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
The GNU General Public License is often shipped with GNU software, and
|
The GNU General Public License is often shipped with GNU software, and
|
is generally kept in a file called COPYING or LICENSE. If you do not
|
is generally kept in a file called COPYING or LICENSE. If you do not
|
have a copy of the license, write to the Free Software Foundation,
|
have a copy of the license, write to the Free Software Foundation,
|
59 Temple Place, Suite 330, Boston, MA 02111 USA. */
|
59 Temple Place, Suite 330, Boston, MA 02111 USA. */
|
#define READLINE_LIBRARY
|
#define READLINE_LIBRARY
|
|
|
#if defined (HAVE_CONFIG_H)
|
#if defined (HAVE_CONFIG_H)
|
# include <config.h>
|
# include <config.h>
|
#endif
|
#endif
|
|
|
#include <sys/types.h>
|
#include <sys/types.h>
|
#include <fcntl.h>
|
#include <fcntl.h>
|
#if defined (HAVE_SYS_FILE_H)
|
#if defined (HAVE_SYS_FILE_H)
|
# include <sys/file.h>
|
# include <sys/file.h>
|
#endif
|
#endif
|
|
|
#if defined (HAVE_UNISTD_H)
|
#if defined (HAVE_UNISTD_H)
|
# include <unistd.h>
|
# include <unistd.h>
|
#endif /* HAVE_UNISTD_H */
|
#endif /* HAVE_UNISTD_H */
|
|
|
#if defined (HAVE_STDLIB_H)
|
#if defined (HAVE_STDLIB_H)
|
# include <stdlib.h>
|
# include <stdlib.h>
|
#else
|
#else
|
# include "ansi_stdlib.h"
|
# include "ansi_stdlib.h"
|
#endif /* HAVE_STDLIB_H */
|
#endif /* HAVE_STDLIB_H */
|
|
|
#include <stdio.h>
|
#include <stdio.h>
|
|
|
#include <errno.h>
|
#include <errno.h>
|
#if !defined (errno)
|
#if !defined (errno)
|
extern int errno;
|
extern int errno;
|
#endif /* !errno */
|
#endif /* !errno */
|
|
|
#if defined (HAVE_PWD_H)
|
#if defined (HAVE_PWD_H)
|
#include <pwd.h>
|
#include <pwd.h>
|
#endif
|
#endif
|
|
|
#include "posixdir.h"
|
#include "posixdir.h"
|
#include "posixstat.h"
|
#include "posixstat.h"
|
|
|
/* System-specific feature definitions and include files. */
|
/* System-specific feature definitions and include files. */
|
#include "rldefs.h"
|
#include "rldefs.h"
|
#include "rlmbutil.h"
|
#include "rlmbutil.h"
|
|
|
/* Some standard library routines. */
|
/* Some standard library routines. */
|
#include "readline.h"
|
#include "readline.h"
|
#include "xmalloc.h"
|
#include "xmalloc.h"
|
#include "rlprivate.h"
|
#include "rlprivate.h"
|
|
|
#ifdef __STDC__
|
#ifdef __STDC__
|
typedef int QSFUNC (const void *, const void *);
|
typedef int QSFUNC (const void *, const void *);
|
#else
|
#else
|
typedef int QSFUNC ();
|
typedef int QSFUNC ();
|
#endif
|
#endif
|
|
|
#ifdef HAVE_LSTAT
|
#ifdef HAVE_LSTAT
|
# define LSTAT lstat
|
# define LSTAT lstat
|
#else
|
#else
|
# define LSTAT stat
|
# define LSTAT stat
|
#endif
|
#endif
|
|
|
/* Unix version of a hidden file. Could be different on other systems. */
|
/* Unix version of a hidden file. Could be different on other systems. */
|
#define HIDDEN_FILE(fname) ((fname)[0] == '.')
|
#define HIDDEN_FILE(fname) ((fname)[0] == '.')
|
|
|
/* Most systems don't declare getpwent in <pwd.h> if _POSIX_SOURCE is
|
/* Most systems don't declare getpwent in <pwd.h> if _POSIX_SOURCE is
|
defined. */
|
defined. */
|
#if defined (HAVE_GETPWENT) && (!defined (HAVE_GETPW_DECLS) || defined (_POSIX_SOURCE))
|
#if defined (HAVE_GETPWENT) && (!defined (HAVE_GETPW_DECLS) || defined (_POSIX_SOURCE))
|
extern struct passwd *getpwent PARAMS((void));
|
extern struct passwd *getpwent PARAMS((void));
|
#endif /* HAVE_GETPWENT && (!HAVE_GETPW_DECLS || _POSIX_SOURCE) */
|
#endif /* HAVE_GETPWENT && (!HAVE_GETPW_DECLS || _POSIX_SOURCE) */
|
|
|
/* If non-zero, then this is the address of a function to call when
|
/* If non-zero, then this is the address of a function to call when
|
completing a word would normally display the list of possible matches.
|
completing a word would normally display the list of possible matches.
|
This function is called instead of actually doing the display.
|
This function is called instead of actually doing the display.
|
It takes three arguments: (char **matches, int num_matches, int max_length)
|
It takes three arguments: (char **matches, int num_matches, int max_length)
|
where MATCHES is the array of strings that matched, NUM_MATCHES is the
|
where MATCHES is the array of strings that matched, NUM_MATCHES is the
|
number of strings in that array, and MAX_LENGTH is the length of the
|
number of strings in that array, and MAX_LENGTH is the length of the
|
longest string in that array. */
|
longest string in that array. */
|
rl_compdisp_func_t *rl_completion_display_matches_hook = (rl_compdisp_func_t *)NULL;
|
rl_compdisp_func_t *rl_completion_display_matches_hook = (rl_compdisp_func_t *)NULL;
|
|
|
#if defined (VISIBLE_STATS)
|
#if defined (VISIBLE_STATS)
|
# if !defined (X_OK)
|
# if !defined (X_OK)
|
# define X_OK 1
|
# define X_OK 1
|
# endif
|
# endif
|
static int stat_char PARAMS((char *));
|
static int stat_char PARAMS((char *));
|
#endif
|
#endif
|
|
|
static int path_isdir PARAMS((const char *));
|
static int path_isdir PARAMS((const char *));
|
|
|
static char *rl_quote_filename PARAMS((char *, int, char *));
|
static char *rl_quote_filename PARAMS((char *, int, char *));
|
|
|
static void set_completion_defaults PARAMS((int));
|
static void set_completion_defaults PARAMS((int));
|
static int get_y_or_n PARAMS((int));
|
static int get_y_or_n PARAMS((int));
|
static int _rl_internal_pager PARAMS((int));
|
static int _rl_internal_pager PARAMS((int));
|
static char *printable_part PARAMS((char *));
|
static char *printable_part PARAMS((char *));
|
static int fnwidth PARAMS((const char *));
|
static int fnwidth PARAMS((const char *));
|
static int fnprint PARAMS((const char *));
|
static int fnprint PARAMS((const char *));
|
static int print_filename PARAMS((char *, char *));
|
static int print_filename PARAMS((char *, char *));
|
|
|
static char **gen_completion_matches PARAMS((char *, int, int, rl_compentry_func_t *, int, int));
|
static char **gen_completion_matches PARAMS((char *, int, int, rl_compentry_func_t *, int, int));
|
|
|
static char **remove_duplicate_matches PARAMS((char **));
|
static char **remove_duplicate_matches PARAMS((char **));
|
static void insert_match PARAMS((char *, int, int, char *));
|
static void insert_match PARAMS((char *, int, int, char *));
|
static int append_to_match PARAMS((char *, int, int, int));
|
static int append_to_match PARAMS((char *, int, int, int));
|
static void insert_all_matches PARAMS((char **, int, char *));
|
static void insert_all_matches PARAMS((char **, int, char *));
|
static void display_matches PARAMS((char **));
|
static void display_matches PARAMS((char **));
|
static int compute_lcd_of_matches PARAMS((char **, int, const char *));
|
static int compute_lcd_of_matches PARAMS((char **, int, const char *));
|
static int postprocess_matches PARAMS((char ***, int));
|
static int postprocess_matches PARAMS((char ***, int));
|
|
|
static char *make_quoted_replacement PARAMS((char *, int, char *));
|
static char *make_quoted_replacement PARAMS((char *, int, char *));
|
|
|
/* **************************************************************** */
|
/* **************************************************************** */
|
/* */
|
/* */
|
/* Completion matching, from readline's point of view. */
|
/* Completion matching, from readline's point of view. */
|
/* */
|
/* */
|
/* **************************************************************** */
|
/* **************************************************************** */
|
|
|
/* Variables known only to the readline library. */
|
/* Variables known only to the readline library. */
|
|
|
/* If non-zero, non-unique completions always show the list of matches. */
|
/* If non-zero, non-unique completions always show the list of matches. */
|
int _rl_complete_show_all = 0;
|
int _rl_complete_show_all = 0;
|
|
|
/* If non-zero, non-unique completions show the list of matches, unless it
|
/* If non-zero, non-unique completions show the list of matches, unless it
|
is not possible to do partial completion and modify the line. */
|
is not possible to do partial completion and modify the line. */
|
int _rl_complete_show_unmodified = 0;
|
int _rl_complete_show_unmodified = 0;
|
|
|
/* If non-zero, completed directory names have a slash appended. */
|
/* If non-zero, completed directory names have a slash appended. */
|
int _rl_complete_mark_directories = 1;
|
int _rl_complete_mark_directories = 1;
|
|
|
/* If non-zero, the symlinked directory completion behavior introduced in
|
/* If non-zero, the symlinked directory completion behavior introduced in
|
readline-4.2a is disabled, and symlinks that point to directories have
|
readline-4.2a is disabled, and symlinks that point to directories have
|
a slash appended (subject to the value of _rl_complete_mark_directories).
|
a slash appended (subject to the value of _rl_complete_mark_directories).
|
This is user-settable via the mark-symlinked-directories variable. */
|
This is user-settable via the mark-symlinked-directories variable. */
|
int _rl_complete_mark_symlink_dirs = 0;
|
int _rl_complete_mark_symlink_dirs = 0;
|
|
|
/* If non-zero, completions are printed horizontally in alphabetical order,
|
/* If non-zero, completions are printed horizontally in alphabetical order,
|
like `ls -x'. */
|
like `ls -x'. */
|
int _rl_print_completions_horizontally;
|
int _rl_print_completions_horizontally;
|
|
|
/* Non-zero means that case is not significant in filename completion. */
|
/* Non-zero means that case is not significant in filename completion. */
|
#if defined (__MSDOS__) && !defined (__DJGPP__)
|
#if defined (__MSDOS__) && !defined (__DJGPP__)
|
int _rl_completion_case_fold = 1;
|
int _rl_completion_case_fold = 1;
|
#else
|
#else
|
int _rl_completion_case_fold;
|
int _rl_completion_case_fold;
|
#endif
|
#endif
|
|
|
/* If non-zero, don't match hidden files (filenames beginning with a `.' on
|
/* If non-zero, don't match hidden files (filenames beginning with a `.' on
|
Unix) when doing filename completion. */
|
Unix) when doing filename completion. */
|
int _rl_match_hidden_files = 1;
|
int _rl_match_hidden_files = 1;
|
|
|
/* Global variables available to applications using readline. */
|
/* Global variables available to applications using readline. */
|
|
|
#if defined (VISIBLE_STATS)
|
#if defined (VISIBLE_STATS)
|
/* Non-zero means add an additional character to each filename displayed
|
/* Non-zero means add an additional character to each filename displayed
|
during listing completion iff rl_filename_completion_desired which helps
|
during listing completion iff rl_filename_completion_desired which helps
|
to indicate the type of file being listed. */
|
to indicate the type of file being listed. */
|
int rl_visible_stats = 0;
|
int rl_visible_stats = 0;
|
#endif /* VISIBLE_STATS */
|
#endif /* VISIBLE_STATS */
|
|
|
/* If non-zero, then this is the address of a function to call when
|
/* If non-zero, then this is the address of a function to call when
|
completing on a directory name. The function is called with
|
completing on a directory name. The function is called with
|
the address of a string (the current directory name) as an arg. */
|
the address of a string (the current directory name) as an arg. */
|
rl_icppfunc_t *rl_directory_completion_hook = (rl_icppfunc_t *)NULL;
|
rl_icppfunc_t *rl_directory_completion_hook = (rl_icppfunc_t *)NULL;
|
|
|
rl_icppfunc_t *rl_directory_rewrite_hook = (rl_icppfunc_t *)NULL;
|
rl_icppfunc_t *rl_directory_rewrite_hook = (rl_icppfunc_t *)NULL;
|
|
|
/* Non-zero means readline completion functions perform tilde expansion. */
|
/* Non-zero means readline completion functions perform tilde expansion. */
|
int rl_complete_with_tilde_expansion = 0;
|
int rl_complete_with_tilde_expansion = 0;
|
|
|
/* Pointer to the generator function for completion_matches ().
|
/* Pointer to the generator function for completion_matches ().
|
NULL means to use rl_filename_completion_function (), the default filename
|
NULL means to use rl_filename_completion_function (), the default filename
|
completer. */
|
completer. */
|
rl_compentry_func_t *rl_completion_entry_function = (rl_compentry_func_t *)NULL;
|
rl_compentry_func_t *rl_completion_entry_function = (rl_compentry_func_t *)NULL;
|
|
|
/* Pointer to alternative function to create matches.
|
/* Pointer to alternative function to create matches.
|
Function is called with TEXT, START, and END.
|
Function is called with TEXT, START, and END.
|
START and END are indices in RL_LINE_BUFFER saying what the boundaries
|
START and END are indices in RL_LINE_BUFFER saying what the boundaries
|
of TEXT are.
|
of TEXT are.
|
If this function exists and returns NULL then call the value of
|
If this function exists and returns NULL then call the value of
|
rl_completion_entry_function to try to match, otherwise use the
|
rl_completion_entry_function to try to match, otherwise use the
|
array of strings returned. */
|
array of strings returned. */
|
rl_completion_func_t *rl_attempted_completion_function = (rl_completion_func_t *)NULL;
|
rl_completion_func_t *rl_attempted_completion_function = (rl_completion_func_t *)NULL;
|
|
|
/* Non-zero means to suppress normal filename completion after the
|
/* Non-zero means to suppress normal filename completion after the
|
user-specified completion function has been called. */
|
user-specified completion function has been called. */
|
int rl_attempted_completion_over = 0;
|
int rl_attempted_completion_over = 0;
|
|
|
/* Set to a character indicating the type of completion being performed
|
/* Set to a character indicating the type of completion being performed
|
by rl_complete_internal, available for use by application completion
|
by rl_complete_internal, available for use by application completion
|
functions. */
|
functions. */
|
int rl_completion_type = 0;
|
int rl_completion_type = 0;
|
|
|
/* Up to this many items will be displayed in response to a
|
/* Up to this many items will be displayed in response to a
|
possible-completions call. After that, we ask the user if
|
possible-completions call. After that, we ask the user if
|
she is sure she wants to see them all. A negative value means
|
she is sure she wants to see them all. A negative value means
|
don't ask. */
|
don't ask. */
|
int rl_completion_query_items = 100;
|
int rl_completion_query_items = 100;
|
|
|
int _rl_page_completions = 1;
|
int _rl_page_completions = 1;
|
|
|
/* The basic list of characters that signal a break between words for the
|
/* The basic list of characters that signal a break between words for the
|
completer routine. The contents of this variable is what breaks words
|
completer routine. The contents of this variable is what breaks words
|
in the shell, i.e. " \t\n\"\\'`@$><=" */
|
in the shell, i.e. " \t\n\"\\'`@$><=" */
|
const char *rl_basic_word_break_characters = " \t\n\"\\'`@$><=;|&{("; /* }) */
|
const char *rl_basic_word_break_characters = " \t\n\"\\'`@$><=;|&{("; /* }) */
|
|
|
/* List of basic quoting characters. */
|
/* List of basic quoting characters. */
|
const char *rl_basic_quote_characters = "\"'";
|
const char *rl_basic_quote_characters = "\"'";
|
|
|
/* The list of characters that signal a break between words for
|
/* The list of characters that signal a break between words for
|
rl_complete_internal. The default list is the contents of
|
rl_complete_internal. The default list is the contents of
|
rl_basic_word_break_characters. */
|
rl_basic_word_break_characters. */
|
/*const*/ char *rl_completer_word_break_characters = (/*const*/ char *)NULL;
|
/*const*/ char *rl_completer_word_break_characters = (/*const*/ char *)NULL;
|
|
|
/* Hook function to allow an application to set the completion word
|
/* Hook function to allow an application to set the completion word
|
break characters before readline breaks up the line. Allows
|
break characters before readline breaks up the line. Allows
|
position-dependent word break characters. */
|
position-dependent word break characters. */
|
rl_cpvfunc_t *rl_completion_word_break_hook = (rl_cpvfunc_t *)NULL;
|
rl_cpvfunc_t *rl_completion_word_break_hook = (rl_cpvfunc_t *)NULL;
|
|
|
/* List of characters which can be used to quote a substring of the line.
|
/* List of characters which can be used to quote a substring of the line.
|
Completion occurs on the entire substring, and within the substring
|
Completion occurs on the entire substring, and within the substring
|
rl_completer_word_break_characters are treated as any other character,
|
rl_completer_word_break_characters are treated as any other character,
|
unless they also appear within this list. */
|
unless they also appear within this list. */
|
const char *rl_completer_quote_characters = (const char *)NULL;
|
const char *rl_completer_quote_characters = (const char *)NULL;
|
|
|
/* List of characters that should be quoted in filenames by the completer. */
|
/* List of characters that should be quoted in filenames by the completer. */
|
const char *rl_filename_quote_characters = (const char *)NULL;
|
const char *rl_filename_quote_characters = (const char *)NULL;
|
|
|
/* List of characters that are word break characters, but should be left
|
/* List of characters that are word break characters, but should be left
|
in TEXT when it is passed to the completion function. The shell uses
|
in TEXT when it is passed to the completion function. The shell uses
|
this to help determine what kind of completing to do. */
|
this to help determine what kind of completing to do. */
|
const char *rl_special_prefixes = (const char *)NULL;
|
const char *rl_special_prefixes = (const char *)NULL;
|
|
|
/* If non-zero, then disallow duplicates in the matches. */
|
/* If non-zero, then disallow duplicates in the matches. */
|
int rl_ignore_completion_duplicates = 1;
|
int rl_ignore_completion_duplicates = 1;
|
|
|
/* Non-zero means that the results of the matches are to be treated
|
/* Non-zero means that the results of the matches are to be treated
|
as filenames. This is ALWAYS zero on entry, and can only be changed
|
as filenames. This is ALWAYS zero on entry, and can only be changed
|
within a completion entry finder function. */
|
within a completion entry finder function. */
|
int rl_filename_completion_desired = 0;
|
int rl_filename_completion_desired = 0;
|
|
|
/* Non-zero means that the results of the matches are to be quoted using
|
/* Non-zero means that the results of the matches are to be quoted using
|
double quotes (or an application-specific quoting mechanism) if the
|
double quotes (or an application-specific quoting mechanism) if the
|
filename contains any characters in rl_filename_quote_chars. This is
|
filename contains any characters in rl_filename_quote_chars. This is
|
ALWAYS non-zero on entry, and can only be changed within a completion
|
ALWAYS non-zero on entry, and can only be changed within a completion
|
entry finder function. */
|
entry finder function. */
|
int rl_filename_quoting_desired = 1;
|
int rl_filename_quoting_desired = 1;
|
|
|
/* This function, if defined, is called by the completer when real
|
/* This function, if defined, is called by the completer when real
|
filename completion is done, after all the matching names have been
|
filename completion is done, after all the matching names have been
|
generated. It is passed a (char**) known as matches in the code below.
|
generated. It is passed a (char**) known as matches in the code below.
|
It consists of a NULL-terminated array of pointers to potential
|
It consists of a NULL-terminated array of pointers to potential
|
matching strings. The 1st element (matches[0]) is the maximal
|
matching strings. The 1st element (matches[0]) is the maximal
|
substring that is common to all matches. This function can re-arrange
|
substring that is common to all matches. This function can re-arrange
|
the list of matches as required, but all elements of the array must be
|
the list of matches as required, but all elements of the array must be
|
free()'d if they are deleted. The main intent of this function is
|
free()'d if they are deleted. The main intent of this function is
|
to implement FIGNORE a la SunOS csh. */
|
to implement FIGNORE a la SunOS csh. */
|
rl_compignore_func_t *rl_ignore_some_completions_function = (rl_compignore_func_t *)NULL;
|
rl_compignore_func_t *rl_ignore_some_completions_function = (rl_compignore_func_t *)NULL;
|
|
|
/* Set to a function to quote a filename in an application-specific fashion.
|
/* Set to a function to quote a filename in an application-specific fashion.
|
Called with the text to quote, the type of match found (single or multiple)
|
Called with the text to quote, the type of match found (single or multiple)
|
and a pointer to the quoting character to be used, which the function can
|
and a pointer to the quoting character to be used, which the function can
|
reset if desired. */
|
reset if desired. */
|
rl_quote_func_t *rl_filename_quoting_function = rl_quote_filename;
|
rl_quote_func_t *rl_filename_quoting_function = rl_quote_filename;
|
|
|
/* Function to call to remove quoting characters from a filename. Called
|
/* Function to call to remove quoting characters from a filename. Called
|
before completion is attempted, so the embedded quotes do not interfere
|
before completion is attempted, so the embedded quotes do not interfere
|
with matching names in the file system. Readline doesn't do anything
|
with matching names in the file system. Readline doesn't do anything
|
with this; it's set only by applications. */
|
with this; it's set only by applications. */
|
rl_dequote_func_t *rl_filename_dequoting_function = (rl_dequote_func_t *)NULL;
|
rl_dequote_func_t *rl_filename_dequoting_function = (rl_dequote_func_t *)NULL;
|
|
|
/* Function to call to decide whether or not a word break character is
|
/* Function to call to decide whether or not a word break character is
|
quoted. If a character is quoted, it does not break words for the
|
quoted. If a character is quoted, it does not break words for the
|
completer. */
|
completer. */
|
rl_linebuf_func_t *rl_char_is_quoted_p = (rl_linebuf_func_t *)NULL;
|
rl_linebuf_func_t *rl_char_is_quoted_p = (rl_linebuf_func_t *)NULL;
|
|
|
/* If non-zero, the completion functions don't append anything except a
|
/* If non-zero, the completion functions don't append anything except a
|
possible closing quote. This is set to 0 by rl_complete_internal and
|
possible closing quote. This is set to 0 by rl_complete_internal and
|
may be changed by an application-specific completion function. */
|
may be changed by an application-specific completion function. */
|
int rl_completion_suppress_append = 0;
|
int rl_completion_suppress_append = 0;
|
|
|
/* Character appended to completed words when at the end of the line. The
|
/* Character appended to completed words when at the end of the line. The
|
default is a space. */
|
default is a space. */
|
int rl_completion_append_character = ' ';
|
int rl_completion_append_character = ' ';
|
|
|
/* If non-zero, the completion functions don't append any closing quote.
|
/* If non-zero, the completion functions don't append any closing quote.
|
This is set to 0 by rl_complete_internal and may be changed by an
|
This is set to 0 by rl_complete_internal and may be changed by an
|
application-specific completion function. */
|
application-specific completion function. */
|
int rl_completion_suppress_quote = 0;
|
int rl_completion_suppress_quote = 0;
|
|
|
/* Set to any quote character readline thinks it finds before any application
|
/* Set to any quote character readline thinks it finds before any application
|
completion function is called. */
|
completion function is called. */
|
int rl_completion_quote_character;
|
int rl_completion_quote_character;
|
|
|
/* Set to a non-zero value if readline found quoting anywhere in the word to
|
/* Set to a non-zero value if readline found quoting anywhere in the word to
|
be completed; set before any application completion function is called. */
|
be completed; set before any application completion function is called. */
|
int rl_completion_found_quote;
|
int rl_completion_found_quote;
|
|
|
/* If non-zero, a slash will be appended to completed filenames that are
|
/* If non-zero, a slash will be appended to completed filenames that are
|
symbolic links to directory names, subject to the value of the
|
symbolic links to directory names, subject to the value of the
|
mark-directories variable (which is user-settable). This exists so
|
mark-directories variable (which is user-settable). This exists so
|
that application completion functions can override the user's preference
|
that application completion functions can override the user's preference
|
(set via the mark-symlinked-directories variable) if appropriate.
|
(set via the mark-symlinked-directories variable) if appropriate.
|
It's set to the value of _rl_complete_mark_symlink_dirs in
|
It's set to the value of _rl_complete_mark_symlink_dirs in
|
rl_complete_internal before any application-specific completion
|
rl_complete_internal before any application-specific completion
|
function is called, so without that function doing anything, the user's
|
function is called, so without that function doing anything, the user's
|
preferences are honored. */
|
preferences are honored. */
|
int rl_completion_mark_symlink_dirs;
|
int rl_completion_mark_symlink_dirs;
|
|
|
/* If non-zero, inhibit completion (temporarily). */
|
/* If non-zero, inhibit completion (temporarily). */
|
int rl_inhibit_completion;
|
int rl_inhibit_completion;
|
|
|
/* Variables local to this file. */
|
/* Variables local to this file. */
|
|
|
/* Local variable states what happened during the last completion attempt. */
|
/* Local variable states what happened during the last completion attempt. */
|
static int completion_changed_buffer;
|
static int completion_changed_buffer;
|
|
|
/*************************************/
|
/*************************************/
|
/* */
|
/* */
|
/* Bindable completion functions */
|
/* Bindable completion functions */
|
/* */
|
/* */
|
/*************************************/
|
/*************************************/
|
|
|
/* Complete the word at or before point. You have supplied the function
|
/* Complete the word at or before point. You have supplied the function
|
that does the initial simple matching selection algorithm (see
|
that does the initial simple matching selection algorithm (see
|
rl_completion_matches ()). The default is to do filename completion. */
|
rl_completion_matches ()). The default is to do filename completion. */
|
int
|
int
|
rl_complete (ignore, invoking_key)
|
rl_complete (ignore, invoking_key)
|
int ignore, invoking_key;
|
int ignore, invoking_key;
|
{
|
{
|
if (rl_inhibit_completion)
|
if (rl_inhibit_completion)
|
return (_rl_insert_char (ignore, invoking_key));
|
return (_rl_insert_char (ignore, invoking_key));
|
else if (rl_last_func == rl_complete && !completion_changed_buffer)
|
else if (rl_last_func == rl_complete && !completion_changed_buffer)
|
return (rl_complete_internal ('?'));
|
return (rl_complete_internal ('?'));
|
else if (_rl_complete_show_all)
|
else if (_rl_complete_show_all)
|
return (rl_complete_internal ('!'));
|
return (rl_complete_internal ('!'));
|
else if (_rl_complete_show_unmodified)
|
else if (_rl_complete_show_unmodified)
|
return (rl_complete_internal ('@'));
|
return (rl_complete_internal ('@'));
|
else
|
else
|
return (rl_complete_internal (TAB));
|
return (rl_complete_internal (TAB));
|
}
|
}
|
|
|
/* List the possible completions. See description of rl_complete (). */
|
/* List the possible completions. See description of rl_complete (). */
|
int
|
int
|
rl_possible_completions (ignore, invoking_key)
|
rl_possible_completions (ignore, invoking_key)
|
int ignore, invoking_key;
|
int ignore, invoking_key;
|
{
|
{
|
return (rl_complete_internal ('?'));
|
return (rl_complete_internal ('?'));
|
}
|
}
|
|
|
int
|
int
|
rl_insert_completions (ignore, invoking_key)
|
rl_insert_completions (ignore, invoking_key)
|
int ignore, invoking_key;
|
int ignore, invoking_key;
|
{
|
{
|
return (rl_complete_internal ('*'));
|
return (rl_complete_internal ('*'));
|
}
|
}
|
|
|
/* Return the correct value to pass to rl_complete_internal performing
|
/* Return the correct value to pass to rl_complete_internal performing
|
the same tests as rl_complete. This allows consecutive calls to an
|
the same tests as rl_complete. This allows consecutive calls to an
|
application's completion function to list possible completions and for
|
application's completion function to list possible completions and for
|
an application-specific completion function to honor the
|
an application-specific completion function to honor the
|
show-all-if-ambiguous readline variable. */
|
show-all-if-ambiguous readline variable. */
|
int
|
int
|
rl_completion_mode (cfunc)
|
rl_completion_mode (cfunc)
|
rl_command_func_t *cfunc;
|
rl_command_func_t *cfunc;
|
{
|
{
|
if (rl_last_func == cfunc && !completion_changed_buffer)
|
if (rl_last_func == cfunc && !completion_changed_buffer)
|
return '?';
|
return '?';
|
else if (_rl_complete_show_all)
|
else if (_rl_complete_show_all)
|
return '!';
|
return '!';
|
else if (_rl_complete_show_unmodified)
|
else if (_rl_complete_show_unmodified)
|
return '@';
|
return '@';
|
else
|
else
|
return TAB;
|
return TAB;
|
}
|
}
|
|
|
/************************************/
|
/************************************/
|
/* */
|
/* */
|
/* Completion utility functions */
|
/* Completion utility functions */
|
/* */
|
/* */
|
/************************************/
|
/************************************/
|
|
|
/* Set default values for readline word completion. These are the variables
|
/* Set default values for readline word completion. These are the variables
|
that application completion functions can change or inspect. */
|
that application completion functions can change or inspect. */
|
static void
|
static void
|
set_completion_defaults (what_to_do)
|
set_completion_defaults (what_to_do)
|
int what_to_do;
|
int what_to_do;
|
{
|
{
|
/* Only the completion entry function can change these. */
|
/* Only the completion entry function can change these. */
|
rl_filename_completion_desired = 0;
|
rl_filename_completion_desired = 0;
|
rl_filename_quoting_desired = 1;
|
rl_filename_quoting_desired = 1;
|
rl_completion_type = what_to_do;
|
rl_completion_type = what_to_do;
|
rl_completion_suppress_append = rl_completion_suppress_quote = 0;
|
rl_completion_suppress_append = rl_completion_suppress_quote = 0;
|
|
|
/* The completion entry function may optionally change this. */
|
/* The completion entry function may optionally change this. */
|
rl_completion_mark_symlink_dirs = _rl_complete_mark_symlink_dirs;
|
rl_completion_mark_symlink_dirs = _rl_complete_mark_symlink_dirs;
|
}
|
}
|
|
|
/* The user must press "y" or "n". Non-zero return means "y" pressed. */
|
/* The user must press "y" or "n". Non-zero return means "y" pressed. */
|
static int
|
static int
|
get_y_or_n (for_pager)
|
get_y_or_n (for_pager)
|
int for_pager;
|
int for_pager;
|
{
|
{
|
int c;
|
int c;
|
|
|
for (;;)
|
for (;;)
|
{
|
{
|
RL_SETSTATE(RL_STATE_MOREINPUT);
|
RL_SETSTATE(RL_STATE_MOREINPUT);
|
c = rl_read_key ();
|
c = rl_read_key ();
|
RL_UNSETSTATE(RL_STATE_MOREINPUT);
|
RL_UNSETSTATE(RL_STATE_MOREINPUT);
|
|
|
if (c == 'y' || c == 'Y' || c == ' ')
|
if (c == 'y' || c == 'Y' || c == ' ')
|
return (1);
|
return (1);
|
if (c == 'n' || c == 'N' || c == RUBOUT)
|
if (c == 'n' || c == 'N' || c == RUBOUT)
|
return (0);
|
return (0);
|
if (c == ABORT_CHAR)
|
if (c == ABORT_CHAR)
|
_rl_abort_internal ();
|
_rl_abort_internal ();
|
if (for_pager && (c == NEWLINE || c == RETURN))
|
if (for_pager && (c == NEWLINE || c == RETURN))
|
return (2);
|
return (2);
|
if (for_pager && (c == 'q' || c == 'Q'))
|
if (for_pager && (c == 'q' || c == 'Q'))
|
return (0);
|
return (0);
|
rl_ding ();
|
rl_ding ();
|
}
|
}
|
}
|
}
|
|
|
static int
|
static int
|
_rl_internal_pager (lines)
|
_rl_internal_pager (lines)
|
int lines;
|
int lines;
|
{
|
{
|
int i;
|
int i;
|
|
|
fprintf (rl_outstream, "--More--");
|
fprintf (rl_outstream, "--More--");
|
fflush (rl_outstream);
|
fflush (rl_outstream);
|
i = get_y_or_n (1);
|
i = get_y_or_n (1);
|
_rl_erase_entire_line ();
|
_rl_erase_entire_line ();
|
if (i == 0)
|
if (i == 0)
|
return -1;
|
return -1;
|
else if (i == 2)
|
else if (i == 2)
|
return (lines - 1);
|
return (lines - 1);
|
else
|
else
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static int
|
static int
|
path_isdir (filename)
|
path_isdir (filename)
|
const char *filename;
|
const char *filename;
|
{
|
{
|
struct stat finfo;
|
struct stat finfo;
|
|
|
return (stat (filename, &finfo) == 0 && S_ISDIR (finfo.st_mode));
|
return (stat (filename, &finfo) == 0 && S_ISDIR (finfo.st_mode));
|
}
|
}
|
|
|
#if defined (VISIBLE_STATS)
|
#if defined (VISIBLE_STATS)
|
/* Return the character which best describes FILENAME.
|
/* Return the character which best describes FILENAME.
|
`@' for symbolic links
|
`@' for symbolic links
|
`/' for directories
|
`/' for directories
|
`*' for executables
|
`*' for executables
|
`=' for sockets
|
`=' for sockets
|
`|' for FIFOs
|
`|' for FIFOs
|
`%' for character special devices
|
`%' for character special devices
|
`#' for block special devices */
|
`#' for block special devices */
|
static int
|
static int
|
stat_char (filename)
|
stat_char (filename)
|
char *filename;
|
char *filename;
|
{
|
{
|
struct stat finfo;
|
struct stat finfo;
|
int character, r;
|
int character, r;
|
|
|
#if defined (HAVE_LSTAT) && defined (S_ISLNK)
|
#if defined (HAVE_LSTAT) && defined (S_ISLNK)
|
r = lstat (filename, &finfo);
|
r = lstat (filename, &finfo);
|
#else
|
#else
|
r = stat (filename, &finfo);
|
r = stat (filename, &finfo);
|
#endif
|
#endif
|
|
|
if (r == -1)
|
if (r == -1)
|
return (0);
|
return (0);
|
|
|
character = 0;
|
character = 0;
|
if (S_ISDIR (finfo.st_mode))
|
if (S_ISDIR (finfo.st_mode))
|
character = '/';
|
character = '/';
|
#if defined (S_ISCHR)
|
#if defined (S_ISCHR)
|
else if (S_ISCHR (finfo.st_mode))
|
else if (S_ISCHR (finfo.st_mode))
|
character = '%';
|
character = '%';
|
#endif /* S_ISCHR */
|
#endif /* S_ISCHR */
|
#if defined (S_ISBLK)
|
#if defined (S_ISBLK)
|
else if (S_ISBLK (finfo.st_mode))
|
else if (S_ISBLK (finfo.st_mode))
|
character = '#';
|
character = '#';
|
#endif /* S_ISBLK */
|
#endif /* S_ISBLK */
|
#if defined (S_ISLNK)
|
#if defined (S_ISLNK)
|
else if (S_ISLNK (finfo.st_mode))
|
else if (S_ISLNK (finfo.st_mode))
|
character = '@';
|
character = '@';
|
#endif /* S_ISLNK */
|
#endif /* S_ISLNK */
|
#if defined (S_ISSOCK)
|
#if defined (S_ISSOCK)
|
else if (S_ISSOCK (finfo.st_mode))
|
else if (S_ISSOCK (finfo.st_mode))
|
character = '=';
|
character = '=';
|
#endif /* S_ISSOCK */
|
#endif /* S_ISSOCK */
|
#if defined (S_ISFIFO)
|
#if defined (S_ISFIFO)
|
else if (S_ISFIFO (finfo.st_mode))
|
else if (S_ISFIFO (finfo.st_mode))
|
character = '|';
|
character = '|';
|
#endif
|
#endif
|
else if (S_ISREG (finfo.st_mode))
|
else if (S_ISREG (finfo.st_mode))
|
{
|
{
|
if (access (filename, X_OK) == 0)
|
if (access (filename, X_OK) == 0)
|
character = '*';
|
character = '*';
|
}
|
}
|
return (character);
|
return (character);
|
}
|
}
|
#endif /* VISIBLE_STATS */
|
#endif /* VISIBLE_STATS */
|
|
|
/* Return the portion of PATHNAME that should be output when listing
|
/* Return the portion of PATHNAME that should be output when listing
|
possible completions. If we are hacking filename completion, we
|
possible completions. If we are hacking filename completion, we
|
are only interested in the basename, the portion following the
|
are only interested in the basename, the portion following the
|
final slash. Otherwise, we return what we were passed. Since
|
final slash. Otherwise, we return what we were passed. Since
|
printing empty strings is not very informative, if we're doing
|
printing empty strings is not very informative, if we're doing
|
filename completion, and the basename is the empty string, we look
|
filename completion, and the basename is the empty string, we look
|
for the previous slash and return the portion following that. If
|
for the previous slash and return the portion following that. If
|
there's no previous slash, we just return what we were passed. */
|
there's no previous slash, we just return what we were passed. */
|
static char *
|
static char *
|
printable_part (pathname)
|
printable_part (pathname)
|
char *pathname;
|
char *pathname;
|
{
|
{
|
char *temp, *x;
|
char *temp, *x;
|
|
|
if (rl_filename_completion_desired == 0) /* don't need to do anything */
|
if (rl_filename_completion_desired == 0) /* don't need to do anything */
|
return (pathname);
|
return (pathname);
|
|
|
temp = strrchr (pathname, '/');
|
temp = strrchr (pathname, '/');
|
#if defined (__MSDOS__)
|
#if defined (__MSDOS__)
|
if (temp == 0 && ISALPHA ((unsigned char)pathname[0]) && pathname[1] == ':')
|
if (temp == 0 && ISALPHA ((unsigned char)pathname[0]) && pathname[1] == ':')
|
temp = pathname + 1;
|
temp = pathname + 1;
|
#endif
|
#endif
|
|
|
if (temp == 0 || *temp == '\0')
|
if (temp == 0 || *temp == '\0')
|
return (pathname);
|
return (pathname);
|
/* If the basename is NULL, we might have a pathname like '/usr/src/'.
|
/* If the basename is NULL, we might have a pathname like '/usr/src/'.
|
Look for a previous slash and, if one is found, return the portion
|
Look for a previous slash and, if one is found, return the portion
|
following that slash. If there's no previous slash, just return the
|
following that slash. If there's no previous slash, just return the
|
pathname we were passed. */
|
pathname we were passed. */
|
else if (temp[1] == '\0')
|
else if (temp[1] == '\0')
|
{
|
{
|
for (x = temp - 1; x > pathname; x--)
|
for (x = temp - 1; x > pathname; x--)
|
if (*x == '/')
|
if (*x == '/')
|
break;
|
break;
|
return ((*x == '/') ? x + 1 : pathname);
|
return ((*x == '/') ? x + 1 : pathname);
|
}
|
}
|
else
|
else
|
return ++temp;
|
return ++temp;
|
}
|
}
|
|
|
/* Compute width of STRING when displayed on screen by print_filename */
|
/* Compute width of STRING when displayed on screen by print_filename */
|
static int
|
static int
|
fnwidth (string)
|
fnwidth (string)
|
const char *string;
|
const char *string;
|
{
|
{
|
int width, pos;
|
int width, pos;
|
#if defined (HANDLE_MULTIBYTE)
|
#if defined (HANDLE_MULTIBYTE)
|
mbstate_t ps;
|
mbstate_t ps;
|
int left, w;
|
int left, w;
|
size_t clen;
|
size_t clen;
|
wchar_t wc;
|
wchar_t wc;
|
|
|
left = strlen (string) + 1;
|
left = strlen (string) + 1;
|
memset (&ps, 0, sizeof (mbstate_t));
|
memset (&ps, 0, sizeof (mbstate_t));
|
#endif
|
#endif
|
|
|
width = pos = 0;
|
width = pos = 0;
|
while (string[pos])
|
while (string[pos])
|
{
|
{
|
if (CTRL_CHAR (*string) || *string == RUBOUT)
|
if (CTRL_CHAR (*string) || *string == RUBOUT)
|
{
|
{
|
width += 2;
|
width += 2;
|
pos++;
|
pos++;
|
}
|
}
|
else
|
else
|
{
|
{
|
#if defined (HANDLE_MULTIBYTE)
|
#if defined (HANDLE_MULTIBYTE)
|
clen = mbrtowc (&wc, string + pos, left - pos, &ps);
|
clen = mbrtowc (&wc, string + pos, left - pos, &ps);
|
if (MB_INVALIDCH (clen))
|
if (MB_INVALIDCH (clen))
|
{
|
{
|
width++;
|
width++;
|
pos++;
|
pos++;
|
memset (&ps, 0, sizeof (mbstate_t));
|
memset (&ps, 0, sizeof (mbstate_t));
|
}
|
}
|
else if (MB_NULLWCH (clen))
|
else if (MB_NULLWCH (clen))
|
break;
|
break;
|
else
|
else
|
{
|
{
|
pos += clen;
|
pos += clen;
|
w = wcwidth (wc);
|
w = wcwidth (wc);
|
width += (w >= 0) ? w : 1;
|
width += (w >= 0) ? w : 1;
|
}
|
}
|
#else
|
#else
|
width++;
|
width++;
|
pos++;
|
pos++;
|
#endif
|
#endif
|
}
|
}
|
}
|
}
|
|
|
return width;
|
return width;
|
}
|
}
|
|
|
static int
|
static int
|
fnprint (to_print)
|
fnprint (to_print)
|
const char *to_print;
|
const char *to_print;
|
{
|
{
|
int printed_len;
|
int printed_len;
|
const char *s;
|
const char *s;
|
#if defined (HANDLE_MULTIBYTE)
|
#if defined (HANDLE_MULTIBYTE)
|
mbstate_t ps;
|
mbstate_t ps;
|
const char *end;
|
const char *end;
|
size_t tlen;
|
size_t tlen;
|
int width, w;
|
int width, w;
|
wchar_t wc;
|
wchar_t wc;
|
|
|
end = to_print + strlen (to_print) + 1;
|
end = to_print + strlen (to_print) + 1;
|
memset (&ps, 0, sizeof (mbstate_t));
|
memset (&ps, 0, sizeof (mbstate_t));
|
#endif
|
#endif
|
|
|
printed_len = 0;
|
printed_len = 0;
|
s = to_print;
|
s = to_print;
|
while (*s)
|
while (*s)
|
{
|
{
|
if (CTRL_CHAR (*s))
|
if (CTRL_CHAR (*s))
|
{
|
{
|
putc ('^', rl_outstream);
|
putc ('^', rl_outstream);
|
putc (UNCTRL (*s), rl_outstream);
|
putc (UNCTRL (*s), rl_outstream);
|
printed_len += 2;
|
printed_len += 2;
|
s++;
|
s++;
|
#if defined (HANDLE_MULTIBYTE)
|
#if defined (HANDLE_MULTIBYTE)
|
memset (&ps, 0, sizeof (mbstate_t));
|
memset (&ps, 0, sizeof (mbstate_t));
|
#endif
|
#endif
|
}
|
}
|
else if (*s == RUBOUT)
|
else if (*s == RUBOUT)
|
{
|
{
|
putc ('^', rl_outstream);
|
putc ('^', rl_outstream);
|
putc ('?', rl_outstream);
|
putc ('?', rl_outstream);
|
printed_len += 2;
|
printed_len += 2;
|
s++;
|
s++;
|
#if defined (HANDLE_MULTIBYTE)
|
#if defined (HANDLE_MULTIBYTE)
|
memset (&ps, 0, sizeof (mbstate_t));
|
memset (&ps, 0, sizeof (mbstate_t));
|
#endif
|
#endif
|
}
|
}
|
else
|
else
|
{
|
{
|
#if defined (HANDLE_MULTIBYTE)
|
#if defined (HANDLE_MULTIBYTE)
|
tlen = mbrtowc (&wc, s, end - s, &ps);
|
tlen = mbrtowc (&wc, s, end - s, &ps);
|
if (MB_INVALIDCH (tlen))
|
if (MB_INVALIDCH (tlen))
|
{
|
{
|
tlen = 1;
|
tlen = 1;
|
width = 1;
|
width = 1;
|
memset (&ps, 0, sizeof (mbstate_t));
|
memset (&ps, 0, sizeof (mbstate_t));
|
}
|
}
|
else if (MB_NULLWCH (tlen))
|
else if (MB_NULLWCH (tlen))
|
break;
|
break;
|
else
|
else
|
{
|
{
|
w = wcwidth (wc);
|
w = wcwidth (wc);
|
width = (w >= 0) ? w : 1;
|
width = (w >= 0) ? w : 1;
|
}
|
}
|
fwrite (s, 1, tlen, rl_outstream);
|
fwrite (s, 1, tlen, rl_outstream);
|
s += tlen;
|
s += tlen;
|
printed_len += width;
|
printed_len += width;
|
#else
|
#else
|
putc (*s, rl_outstream);
|
putc (*s, rl_outstream);
|
s++;
|
s++;
|
printed_len++;
|
printed_len++;
|
#endif
|
#endif
|
}
|
}
|
}
|
}
|
|
|
return printed_len;
|
return printed_len;
|
}
|
}
|
|
|
/* Output TO_PRINT to rl_outstream. If VISIBLE_STATS is defined and we
|
/* Output TO_PRINT to rl_outstream. If VISIBLE_STATS is defined and we
|
are using it, check for and output a single character for `special'
|
are using it, check for and output a single character for `special'
|
filenames. Return the number of characters we output. */
|
filenames. Return the number of characters we output. */
|
|
|
static int
|
static int
|
print_filename (to_print, full_pathname)
|
print_filename (to_print, full_pathname)
|
char *to_print, *full_pathname;
|
char *to_print, *full_pathname;
|
{
|
{
|
int printed_len, extension_char, slen, tlen;
|
int printed_len, extension_char, slen, tlen;
|
char *s, c, *new_full_pathname, *dn;
|
char *s, c, *new_full_pathname, *dn;
|
|
|
extension_char = 0;
|
extension_char = 0;
|
printed_len = fnprint (to_print);
|
printed_len = fnprint (to_print);
|
|
|
#if defined (VISIBLE_STATS)
|
#if defined (VISIBLE_STATS)
|
if (rl_filename_completion_desired && (rl_visible_stats || _rl_complete_mark_directories))
|
if (rl_filename_completion_desired && (rl_visible_stats || _rl_complete_mark_directories))
|
#else
|
#else
|
if (rl_filename_completion_desired && _rl_complete_mark_directories)
|
if (rl_filename_completion_desired && _rl_complete_mark_directories)
|
#endif
|
#endif
|
{
|
{
|
/* If to_print != full_pathname, to_print is the basename of the
|
/* If to_print != full_pathname, to_print is the basename of the
|
path passed. In this case, we try to expand the directory
|
path passed. In this case, we try to expand the directory
|
name before checking for the stat character. */
|
name before checking for the stat character. */
|
if (to_print != full_pathname)
|
if (to_print != full_pathname)
|
{
|
{
|
/* Terminate the directory name. */
|
/* Terminate the directory name. */
|
c = to_print[-1];
|
c = to_print[-1];
|
to_print[-1] = '\0';
|
to_print[-1] = '\0';
|
|
|
/* If setting the last slash in full_pathname to a NUL results in
|
/* If setting the last slash in full_pathname to a NUL results in
|
full_pathname being the empty string, we are trying to complete
|
full_pathname being the empty string, we are trying to complete
|
files in the root directory. If we pass a null string to the
|
files in the root directory. If we pass a null string to the
|
bash directory completion hook, for example, it will expand it
|
bash directory completion hook, for example, it will expand it
|
to the current directory. We just want the `/'. */
|
to the current directory. We just want the `/'. */
|
if (full_pathname == 0 || *full_pathname == 0)
|
if (full_pathname == 0 || *full_pathname == 0)
|
dn = "/";
|
dn = "/";
|
else if (full_pathname[0] != '/')
|
else if (full_pathname[0] != '/')
|
dn = full_pathname;
|
dn = full_pathname;
|
else if (full_pathname[1] == 0)
|
else if (full_pathname[1] == 0)
|
dn = "//"; /* restore trailing slash to `//' */
|
dn = "//"; /* restore trailing slash to `//' */
|
else if (full_pathname[1] == '/' && full_pathname[2] == 0)
|
else if (full_pathname[1] == '/' && full_pathname[2] == 0)
|
dn = "/"; /* don't turn /// into // */
|
dn = "/"; /* don't turn /// into // */
|
else
|
else
|
dn = full_pathname;
|
dn = full_pathname;
|
s = tilde_expand (dn);
|
s = tilde_expand (dn);
|
if (rl_directory_completion_hook)
|
if (rl_directory_completion_hook)
|
(*rl_directory_completion_hook) (&s);
|
(*rl_directory_completion_hook) (&s);
|
|
|
slen = strlen (s);
|
slen = strlen (s);
|
tlen = strlen (to_print);
|
tlen = strlen (to_print);
|
new_full_pathname = (char *)xmalloc (slen + tlen + 2);
|
new_full_pathname = (char *)xmalloc (slen + tlen + 2);
|
strcpy (new_full_pathname, s);
|
strcpy (new_full_pathname, s);
|
if (s[slen - 1] == '/')
|
if (s[slen - 1] == '/')
|
slen--;
|
slen--;
|
else
|
else
|
new_full_pathname[slen] = '/';
|
new_full_pathname[slen] = '/';
|
new_full_pathname[slen] = '/';
|
new_full_pathname[slen] = '/';
|
strcpy (new_full_pathname + slen + 1, to_print);
|
strcpy (new_full_pathname + slen + 1, to_print);
|
|
|
#if defined (VISIBLE_STATS)
|
#if defined (VISIBLE_STATS)
|
if (rl_visible_stats)
|
if (rl_visible_stats)
|
extension_char = stat_char (new_full_pathname);
|
extension_char = stat_char (new_full_pathname);
|
else
|
else
|
#endif
|
#endif
|
if (path_isdir (new_full_pathname))
|
if (path_isdir (new_full_pathname))
|
extension_char = '/';
|
extension_char = '/';
|
|
|
free (new_full_pathname);
|
free (new_full_pathname);
|
to_print[-1] = c;
|
to_print[-1] = c;
|
}
|
}
|
else
|
else
|
{
|
{
|
s = tilde_expand (full_pathname);
|
s = tilde_expand (full_pathname);
|
#if defined (VISIBLE_STATS)
|
#if defined (VISIBLE_STATS)
|
if (rl_visible_stats)
|
if (rl_visible_stats)
|
extension_char = stat_char (s);
|
extension_char = stat_char (s);
|
else
|
else
|
#endif
|
#endif
|
if (path_isdir (s))
|
if (path_isdir (s))
|
extension_char = '/';
|
extension_char = '/';
|
}
|
}
|
|
|
free (s);
|
free (s);
|
if (extension_char)
|
if (extension_char)
|
{
|
{
|
putc (extension_char, rl_outstream);
|
putc (extension_char, rl_outstream);
|
printed_len++;
|
printed_len++;
|
}
|
}
|
}
|
}
|
|
|
return printed_len;
|
return printed_len;
|
}
|
}
|
|
|
static char *
|
static char *
|
rl_quote_filename (s, rtype, qcp)
|
rl_quote_filename (s, rtype, qcp)
|
char *s;
|
char *s;
|
int rtype;
|
int rtype;
|
char *qcp;
|
char *qcp;
|
{
|
{
|
char *r;
|
char *r;
|
|
|
r = (char *)xmalloc (strlen (s) + 2);
|
r = (char *)xmalloc (strlen (s) + 2);
|
*r = *rl_completer_quote_characters;
|
*r = *rl_completer_quote_characters;
|
strcpy (r + 1, s);
|
strcpy (r + 1, s);
|
if (qcp)
|
if (qcp)
|
*qcp = *rl_completer_quote_characters;
|
*qcp = *rl_completer_quote_characters;
|
return r;
|
return r;
|
}
|
}
|
|
|
/* Find the bounds of the current word for completion purposes, and leave
|
/* Find the bounds of the current word for completion purposes, and leave
|
rl_point set to the end of the word. This function skips quoted
|
rl_point set to the end of the word. This function skips quoted
|
substrings (characters between matched pairs of characters in
|
substrings (characters between matched pairs of characters in
|
rl_completer_quote_characters). First we try to find an unclosed
|
rl_completer_quote_characters). First we try to find an unclosed
|
quoted substring on which to do matching. If one is not found, we use
|
quoted substring on which to do matching. If one is not found, we use
|
the word break characters to find the boundaries of the current word.
|
the word break characters to find the boundaries of the current word.
|
We call an application-specific function to decide whether or not a
|
We call an application-specific function to decide whether or not a
|
particular word break character is quoted; if that function returns a
|
particular word break character is quoted; if that function returns a
|
non-zero result, the character does not break a word. This function
|
non-zero result, the character does not break a word. This function
|
returns the opening quote character if we found an unclosed quoted
|
returns the opening quote character if we found an unclosed quoted
|
substring, '\0' otherwise. FP, if non-null, is set to a value saying
|
substring, '\0' otherwise. FP, if non-null, is set to a value saying
|
which (shell-like) quote characters we found (single quote, double
|
which (shell-like) quote characters we found (single quote, double
|
quote, or backslash) anywhere in the string. DP, if non-null, is set to
|
quote, or backslash) anywhere in the string. DP, if non-null, is set to
|
the value of the delimiter character that caused a word break. */
|
the value of the delimiter character that caused a word break. */
|
|
|
char
|
char
|
_rl_find_completion_word (fp, dp)
|
_rl_find_completion_word (fp, dp)
|
int *fp, *dp;
|
int *fp, *dp;
|
{
|
{
|
int scan, end, found_quote, delimiter, pass_next, isbrk;
|
int scan, end, found_quote, delimiter, pass_next, isbrk;
|
char quote_char, *brkchars;
|
char quote_char, *brkchars;
|
|
|
end = rl_point;
|
end = rl_point;
|
found_quote = delimiter = 0;
|
found_quote = delimiter = 0;
|
quote_char = '\0';
|
quote_char = '\0';
|
|
|
brkchars = 0;
|
brkchars = 0;
|
if (rl_completion_word_break_hook)
|
if (rl_completion_word_break_hook)
|
brkchars = (*rl_completion_word_break_hook) ();
|
brkchars = (*rl_completion_word_break_hook) ();
|
if (brkchars == 0)
|
if (brkchars == 0)
|
brkchars = rl_completer_word_break_characters;
|
brkchars = rl_completer_word_break_characters;
|
|
|
if (rl_completer_quote_characters)
|
if (rl_completer_quote_characters)
|
{
|
{
|
/* We have a list of characters which can be used in pairs to
|
/* We have a list of characters which can be used in pairs to
|
quote substrings for the completer. Try to find the start
|
quote substrings for the completer. Try to find the start
|
of an unclosed quoted substring. */
|
of an unclosed quoted substring. */
|
/* FOUND_QUOTE is set so we know what kind of quotes we found. */
|
/* FOUND_QUOTE is set so we know what kind of quotes we found. */
|
for (scan = pass_next = 0; scan < end; scan = MB_NEXTCHAR (rl_line_buffer, scan, 1, MB_FIND_ANY))
|
for (scan = pass_next = 0; scan < end; scan = MB_NEXTCHAR (rl_line_buffer, scan, 1, MB_FIND_ANY))
|
{
|
{
|
if (pass_next)
|
if (pass_next)
|
{
|
{
|
pass_next = 0;
|
pass_next = 0;
|
continue;
|
continue;
|
}
|
}
|
|
|
/* Shell-like semantics for single quotes -- don't allow backslash
|
/* Shell-like semantics for single quotes -- don't allow backslash
|
to quote anything in single quotes, especially not the closing
|
to quote anything in single quotes, especially not the closing
|
quote. If you don't like this, take out the check on the value
|
quote. If you don't like this, take out the check on the value
|
of quote_char. */
|
of quote_char. */
|
if (quote_char != '\'' && rl_line_buffer[scan] == '\\')
|
if (quote_char != '\'' && rl_line_buffer[scan] == '\\')
|
{
|
{
|
pass_next = 1;
|
pass_next = 1;
|
found_quote |= RL_QF_BACKSLASH;
|
found_quote |= RL_QF_BACKSLASH;
|
continue;
|
continue;
|
}
|
}
|
|
|
if (quote_char != '\0')
|
if (quote_char != '\0')
|
{
|
{
|
/* Ignore everything until the matching close quote char. */
|
/* Ignore everything until the matching close quote char. */
|
if (rl_line_buffer[scan] == quote_char)
|
if (rl_line_buffer[scan] == quote_char)
|
{
|
{
|
/* Found matching close. Abandon this substring. */
|
/* Found matching close. Abandon this substring. */
|
quote_char = '\0';
|
quote_char = '\0';
|
rl_point = end;
|
rl_point = end;
|
}
|
}
|
}
|
}
|
else if (strchr (rl_completer_quote_characters, rl_line_buffer[scan]))
|
else if (strchr (rl_completer_quote_characters, rl_line_buffer[scan]))
|
{
|
{
|
/* Found start of a quoted substring. */
|
/* Found start of a quoted substring. */
|
quote_char = rl_line_buffer[scan];
|
quote_char = rl_line_buffer[scan];
|
rl_point = scan + 1;
|
rl_point = scan + 1;
|
/* Shell-like quoting conventions. */
|
/* Shell-like quoting conventions. */
|
if (quote_char == '\'')
|
if (quote_char == '\'')
|
found_quote |= RL_QF_SINGLE_QUOTE;
|
found_quote |= RL_QF_SINGLE_QUOTE;
|
else if (quote_char == '"')
|
else if (quote_char == '"')
|
found_quote |= RL_QF_DOUBLE_QUOTE;
|
found_quote |= RL_QF_DOUBLE_QUOTE;
|
else
|
else
|
found_quote |= RL_QF_OTHER_QUOTE;
|
found_quote |= RL_QF_OTHER_QUOTE;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
if (rl_point == end && quote_char == '\0')
|
if (rl_point == end && quote_char == '\0')
|
{
|
{
|
/* We didn't find an unclosed quoted substring upon which to do
|
/* We didn't find an unclosed quoted substring upon which to do
|
completion, so use the word break characters to find the
|
completion, so use the word break characters to find the
|
substring on which to complete. */
|
substring on which to complete. */
|
while (rl_point = MB_PREVCHAR (rl_line_buffer, rl_point, MB_FIND_ANY))
|
while (rl_point = MB_PREVCHAR (rl_line_buffer, rl_point, MB_FIND_ANY))
|
{
|
{
|
scan = rl_line_buffer[rl_point];
|
scan = rl_line_buffer[rl_point];
|
|
|
if (strchr (brkchars, scan) == 0)
|
if (strchr (brkchars, scan) == 0)
|
continue;
|
continue;
|
|
|
/* Call the application-specific function to tell us whether
|
/* Call the application-specific function to tell us whether
|
this word break character is quoted and should be skipped. */
|
this word break character is quoted and should be skipped. */
|
if (rl_char_is_quoted_p && found_quote &&
|
if (rl_char_is_quoted_p && found_quote &&
|
(*rl_char_is_quoted_p) (rl_line_buffer, rl_point))
|
(*rl_char_is_quoted_p) (rl_line_buffer, rl_point))
|
continue;
|
continue;
|
|
|
/* Convoluted code, but it avoids an n^2 algorithm with calls
|
/* Convoluted code, but it avoids an n^2 algorithm with calls
|
to char_is_quoted. */
|
to char_is_quoted. */
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
/* If we are at an unquoted word break, then advance past it. */
|
/* If we are at an unquoted word break, then advance past it. */
|
scan = rl_line_buffer[rl_point];
|
scan = rl_line_buffer[rl_point];
|
|
|
/* If there is an application-specific function to say whether or not
|
/* If there is an application-specific function to say whether or not
|
a character is quoted and we found a quote character, let that
|
a character is quoted and we found a quote character, let that
|
function decide whether or not a character is a word break, even
|
function decide whether or not a character is a word break, even
|
if it is found in rl_completer_word_break_characters. Don't bother
|
if it is found in rl_completer_word_break_characters. Don't bother
|
if we're at the end of the line, though. */
|
if we're at the end of the line, though. */
|
if (scan)
|
if (scan)
|
{
|
{
|
if (rl_char_is_quoted_p)
|
if (rl_char_is_quoted_p)
|
isbrk = (found_quote == 0 ||
|
isbrk = (found_quote == 0 ||
|
(*rl_char_is_quoted_p) (rl_line_buffer, rl_point) == 0) &&
|
(*rl_char_is_quoted_p) (rl_line_buffer, rl_point) == 0) &&
|
strchr (brkchars, scan) != 0;
|
strchr (brkchars, scan) != 0;
|
else
|
else
|
isbrk = strchr (brkchars, scan) != 0;
|
isbrk = strchr (brkchars, scan) != 0;
|
|
|
if (isbrk)
|
if (isbrk)
|
{
|
{
|
/* If the character that caused the word break was a quoting
|
/* If the character that caused the word break was a quoting
|
character, then remember it as the delimiter. */
|
character, then remember it as the delimiter. */
|
if (rl_basic_quote_characters &&
|
if (rl_basic_quote_characters &&
|
strchr (rl_basic_quote_characters, scan) &&
|
strchr (rl_basic_quote_characters, scan) &&
|
(end - rl_point) > 1)
|
(end - rl_point) > 1)
|
delimiter = scan;
|
delimiter = scan;
|
|
|
/* If the character isn't needed to determine something special
|
/* If the character isn't needed to determine something special
|
about what kind of completion to perform, then advance past it. */
|
about what kind of completion to perform, then advance past it. */
|
if (rl_special_prefixes == 0 || strchr (rl_special_prefixes, scan) == 0)
|
if (rl_special_prefixes == 0 || strchr (rl_special_prefixes, scan) == 0)
|
rl_point++;
|
rl_point++;
|
}
|
}
|
}
|
}
|
|
|
if (fp)
|
if (fp)
|
*fp = found_quote;
|
*fp = found_quote;
|
if (dp)
|
if (dp)
|
*dp = delimiter;
|
*dp = delimiter;
|
|
|
return (quote_char);
|
return (quote_char);
|
}
|
}
|
|
|
static char **
|
static char **
|
gen_completion_matches (text, start, end, our_func, found_quote, quote_char)
|
gen_completion_matches (text, start, end, our_func, found_quote, quote_char)
|
char *text;
|
char *text;
|
int start, end;
|
int start, end;
|
rl_compentry_func_t *our_func;
|
rl_compentry_func_t *our_func;
|
int found_quote, quote_char;
|
int found_quote, quote_char;
|
{
|
{
|
char **matches, *temp;
|
char **matches, *temp;
|
|
|
rl_completion_found_quote = found_quote;
|
rl_completion_found_quote = found_quote;
|
rl_completion_quote_character = quote_char;
|
rl_completion_quote_character = quote_char;
|
|
|
/* If the user wants to TRY to complete, but then wants to give
|
/* If the user wants to TRY to complete, but then wants to give
|
up and use the default completion function, they set the
|
up and use the default completion function, they set the
|
variable rl_attempted_completion_function. */
|
variable rl_attempted_completion_function. */
|
if (rl_attempted_completion_function)
|
if (rl_attempted_completion_function)
|
{
|
{
|
matches = (*rl_attempted_completion_function) (text, start, end);
|
matches = (*rl_attempted_completion_function) (text, start, end);
|
|
|
if (matches || rl_attempted_completion_over)
|
if (matches || rl_attempted_completion_over)
|
{
|
{
|
rl_attempted_completion_over = 0;
|
rl_attempted_completion_over = 0;
|
return (matches);
|
return (matches);
|
}
|
}
|
}
|
}
|
|
|
/* Beware -- we're stripping the quotes here. Do this only if we know
|
/* Beware -- we're stripping the quotes here. Do this only if we know
|
we are doing filename completion and the application has defined a
|
we are doing filename completion and the application has defined a
|
filename dequoting function. */
|
filename dequoting function. */
|
temp = (char *)NULL;
|
temp = (char *)NULL;
|
|
|
if (found_quote && our_func == rl_filename_completion_function &&
|
if (found_quote && our_func == rl_filename_completion_function &&
|
rl_filename_dequoting_function)
|
rl_filename_dequoting_function)
|
{
|
{
|
/* delete single and double quotes */
|
/* delete single and double quotes */
|
temp = (*rl_filename_dequoting_function) (text, quote_char);
|
temp = (*rl_filename_dequoting_function) (text, quote_char);
|
text = temp; /* not freeing text is not a memory leak */
|
text = temp; /* not freeing text is not a memory leak */
|
}
|
}
|
|
|
matches = rl_completion_matches (text, our_func);
|
matches = rl_completion_matches (text, our_func);
|
FREE (temp);
|
FREE (temp);
|
return matches;
|
return matches;
|
}
|
}
|
|
|
/* Filter out duplicates in MATCHES. This frees up the strings in
|
/* Filter out duplicates in MATCHES. This frees up the strings in
|
MATCHES. */
|
MATCHES. */
|
static char **
|
static char **
|
remove_duplicate_matches (matches)
|
remove_duplicate_matches (matches)
|
char **matches;
|
char **matches;
|
{
|
{
|
char *lowest_common;
|
char *lowest_common;
|
int i, j, newlen;
|
int i, j, newlen;
|
char dead_slot;
|
char dead_slot;
|
char **temp_array;
|
char **temp_array;
|
|
|
/* Sort the items. */
|
/* Sort the items. */
|
for (i = 0; matches[i]; i++)
|
for (i = 0; matches[i]; i++)
|
;
|
;
|
|
|
/* Sort the array without matches[0], since we need it to
|
/* Sort the array without matches[0], since we need it to
|
stay in place no matter what. */
|
stay in place no matter what. */
|
if (i)
|
if (i)
|
qsort (matches+1, i-1, sizeof (char *), (QSFUNC *)_rl_qsort_string_compare);
|
qsort (matches+1, i-1, sizeof (char *), (QSFUNC *)_rl_qsort_string_compare);
|
|
|
/* Remember the lowest common denominator for it may be unique. */
|
/* Remember the lowest common denominator for it may be unique. */
|
lowest_common = savestring (matches[0]);
|
lowest_common = savestring (matches[0]);
|
|
|
for (i = newlen = 0; matches[i + 1]; i++)
|
for (i = newlen = 0; matches[i + 1]; i++)
|
{
|
{
|
if (strcmp (matches[i], matches[i + 1]) == 0)
|
if (strcmp (matches[i], matches[i + 1]) == 0)
|
{
|
{
|
free (matches[i]);
|
free (matches[i]);
|
matches[i] = (char *)&dead_slot;
|
matches[i] = (char *)&dead_slot;
|
}
|
}
|
else
|
else
|
newlen++;
|
newlen++;
|
}
|
}
|
|
|
/* We have marked all the dead slots with (char *)&dead_slot.
|
/* We have marked all the dead slots with (char *)&dead_slot.
|
Copy all the non-dead entries into a new array. */
|
Copy all the non-dead entries into a new array. */
|
temp_array = (char **)xmalloc ((3 + newlen) * sizeof (char *));
|
temp_array = (char **)xmalloc ((3 + newlen) * sizeof (char *));
|
for (i = j = 1; matches[i]; i++)
|
for (i = j = 1; matches[i]; i++)
|
{
|
{
|
if (matches[i] != (char *)&dead_slot)
|
if (matches[i] != (char *)&dead_slot)
|
temp_array[j++] = matches[i];
|
temp_array[j++] = matches[i];
|
}
|
}
|
temp_array[j] = (char *)NULL;
|
temp_array[j] = (char *)NULL;
|
|
|
if (matches[0] != (char *)&dead_slot)
|
if (matches[0] != (char *)&dead_slot)
|
free (matches[0]);
|
free (matches[0]);
|
|
|
/* Place the lowest common denominator back in [0]. */
|
/* Place the lowest common denominator back in [0]. */
|
temp_array[0] = lowest_common;
|
temp_array[0] = lowest_common;
|
|
|
/* If there is one string left, and it is identical to the
|
/* If there is one string left, and it is identical to the
|
lowest common denominator, then the LCD is the string to
|
lowest common denominator, then the LCD is the string to
|
insert. */
|
insert. */
|
if (j == 2 && strcmp (temp_array[0], temp_array[1]) == 0)
|
if (j == 2 && strcmp (temp_array[0], temp_array[1]) == 0)
|
{
|
{
|
free (temp_array[1]);
|
free (temp_array[1]);
|
temp_array[1] = (char *)NULL;
|
temp_array[1] = (char *)NULL;
|
}
|
}
|
return (temp_array);
|
return (temp_array);
|
}
|
}
|
|
|
/* Find the common prefix of the list of matches, and put it into
|
/* Find the common prefix of the list of matches, and put it into
|
matches[0]. */
|
matches[0]. */
|
static int
|
static int
|
compute_lcd_of_matches (match_list, matches, text)
|
compute_lcd_of_matches (match_list, matches, text)
|
char **match_list;
|
char **match_list;
|
int matches;
|
int matches;
|
const char *text;
|
const char *text;
|
{
|
{
|
register int i, c1, c2, si;
|
register int i, c1, c2, si;
|
int low; /* Count of max-matched characters. */
|
int low; /* Count of max-matched characters. */
|
char *dtext; /* dequoted TEXT, if needed */
|
char *dtext; /* dequoted TEXT, if needed */
|
#if defined (HANDLE_MULTIBYTE)
|
#if defined (HANDLE_MULTIBYTE)
|
int v;
|
int v;
|
mbstate_t ps1, ps2;
|
mbstate_t ps1, ps2;
|
wchar_t wc1, wc2;
|
wchar_t wc1, wc2;
|
#endif
|
#endif
|
|
|
/* If only one match, just use that. Otherwise, compare each
|
/* If only one match, just use that. Otherwise, compare each
|
member of the list with the next, finding out where they
|
member of the list with the next, finding out where they
|
stop matching. */
|
stop matching. */
|
if (matches == 1)
|
if (matches == 1)
|
{
|
{
|
match_list[0] = match_list[1];
|
match_list[0] = match_list[1];
|
match_list[1] = (char *)NULL;
|
match_list[1] = (char *)NULL;
|
return 1;
|
return 1;
|
}
|
}
|
|
|
for (i = 1, low = 100000; i < matches; i++)
|
for (i = 1, low = 100000; i < matches; i++)
|
{
|
{
|
#if defined (HANDLE_MULTIBYTE)
|
#if defined (HANDLE_MULTIBYTE)
|
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
|
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
|
{
|
{
|
memset (&ps1, 0, sizeof (mbstate_t));
|
memset (&ps1, 0, sizeof (mbstate_t));
|
memset (&ps2, 0, sizeof (mbstate_t));
|
memset (&ps2, 0, sizeof (mbstate_t));
|
}
|
}
|
#endif
|
#endif
|
if (_rl_completion_case_fold)
|
if (_rl_completion_case_fold)
|
{
|
{
|
for (si = 0;
|
for (si = 0;
|
(c1 = _rl_to_lower(match_list[i][si])) &&
|
(c1 = _rl_to_lower(match_list[i][si])) &&
|
(c2 = _rl_to_lower(match_list[i + 1][si]));
|
(c2 = _rl_to_lower(match_list[i + 1][si]));
|
si++)
|
si++)
|
#if defined (HANDLE_MULTIBYTE)
|
#if defined (HANDLE_MULTIBYTE)
|
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
|
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
|
{
|
{
|
v = mbrtowc (&wc1, match_list[i]+si, strlen (match_list[i]+si), &ps1);
|
v = mbrtowc (&wc1, match_list[i]+si, strlen (match_list[i]+si), &ps1);
|
mbrtowc (&wc2, match_list[i+1]+si, strlen (match_list[i+1]+si), &ps2);
|
mbrtowc (&wc2, match_list[i+1]+si, strlen (match_list[i+1]+si), &ps2);
|
wc1 = towlower (wc1);
|
wc1 = towlower (wc1);
|
wc2 = towlower (wc2);
|
wc2 = towlower (wc2);
|
if (wc1 != wc2)
|
if (wc1 != wc2)
|
break;
|
break;
|
else if (v > 1)
|
else if (v > 1)
|
si += v - 1;
|
si += v - 1;
|
}
|
}
|
else
|
else
|
#endif
|
#endif
|
if (c1 != c2)
|
if (c1 != c2)
|
break;
|
break;
|
}
|
}
|
else
|
else
|
{
|
{
|
for (si = 0;
|
for (si = 0;
|
(c1 = match_list[i][si]) &&
|
(c1 = match_list[i][si]) &&
|
(c2 = match_list[i + 1][si]);
|
(c2 = match_list[i + 1][si]);
|
si++)
|
si++)
|
#if defined (HANDLE_MULTIBYTE)
|
#if defined (HANDLE_MULTIBYTE)
|
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
|
if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
|
{
|
{
|
mbstate_t ps_back = ps1;
|
mbstate_t ps_back = ps1;
|
if (!_rl_compare_chars (match_list[i], si, &ps1, match_list[i+1], si, &ps2))
|
if (!_rl_compare_chars (match_list[i], si, &ps1, match_list[i+1], si, &ps2))
|
break;
|
break;
|
else if ((v = _rl_get_char_len (&match_list[i][si], &ps_back)) > 1)
|
else if ((v = _rl_get_char_len (&match_list[i][si], &ps_back)) > 1)
|
si += v - 1;
|
si += v - 1;
|
}
|
}
|
else
|
else
|
#endif
|
#endif
|
if (c1 != c2)
|
if (c1 != c2)
|
break;
|
break;
|
}
|
}
|
|
|
if (low > si)
|
if (low > si)
|
low = si;
|
low = si;
|
}
|
}
|
|
|
/* If there were multiple matches, but none matched up to even the
|
/* If there were multiple matches, but none matched up to even the
|
first character, and the user typed something, use that as the
|
first character, and the user typed something, use that as the
|
value of matches[0]. */
|
value of matches[0]. */
|
if (low == 0 && text && *text)
|
if (low == 0 && text && *text)
|
{
|
{
|
match_list[0] = (char *)xmalloc (strlen (text) + 1);
|
match_list[0] = (char *)xmalloc (strlen (text) + 1);
|
strcpy (match_list[0], text);
|
strcpy (match_list[0], text);
|
}
|
}
|
else
|
else
|
{
|
{
|
match_list[0] = (char *)xmalloc (low + 1);
|
match_list[0] = (char *)xmalloc (low + 1);
|
|
|
/* XXX - this might need changes in the presence of multibyte chars */
|
/* XXX - this might need changes in the presence of multibyte chars */
|
|
|
/* If we are ignoring case, try to preserve the case of the string
|
/* If we are ignoring case, try to preserve the case of the string
|
the user typed in the face of multiple matches differing in case. */
|
the user typed in the face of multiple matches differing in case. */
|
if (_rl_completion_case_fold)
|
if (_rl_completion_case_fold)
|
{
|
{
|
/* We're making an assumption here:
|
/* We're making an assumption here:
|
IF we're completing filenames AND
|
IF we're completing filenames AND
|
the application has defined a filename dequoting function AND
|
the application has defined a filename dequoting function AND
|
we found a quote character AND
|
we found a quote character AND
|
the application has requested filename quoting
|
the application has requested filename quoting
|
THEN
|
THEN
|
we assume that TEXT was dequoted before checking against
|
we assume that TEXT was dequoted before checking against
|
the file system and needs to be dequoted here before we
|
the file system and needs to be dequoted here before we
|
check against the list of matches
|
check against the list of matches
|
FI */
|
FI */
|
dtext = (char *)NULL;
|
dtext = (char *)NULL;
|
if (rl_filename_completion_desired &&
|
if (rl_filename_completion_desired &&
|
rl_filename_dequoting_function &&
|
rl_filename_dequoting_function &&
|
rl_completion_found_quote &&
|
rl_completion_found_quote &&
|
rl_filename_quoting_desired)
|
rl_filename_quoting_desired)
|
{
|
{
|
dtext = (*rl_filename_dequoting_function) ((char *)text, rl_completion_quote_character);
|
dtext = (*rl_filename_dequoting_function) ((char *)text, rl_completion_quote_character);
|
text = dtext;
|
text = dtext;
|
}
|
}
|
|
|
/* sort the list to get consistent answers. */
|
/* sort the list to get consistent answers. */
|
qsort (match_list+1, matches, sizeof(char *), (QSFUNC *)_rl_qsort_string_compare);
|
qsort (match_list+1, matches, sizeof(char *), (QSFUNC *)_rl_qsort_string_compare);
|
|
|
si = strlen (text);
|
si = strlen (text);
|
if (si <= low)
|
if (si <= low)
|
{
|
{
|
for (i = 1; i <= matches; i++)
|
for (i = 1; i <= matches; i++)
|
if (strncmp (match_list[i], text, si) == 0)
|
if (strncmp (match_list[i], text, si) == 0)
|
{
|
{
|
strncpy (match_list[0], match_list[i], low);
|
strncpy (match_list[0], match_list[i], low);
|
break;
|
break;
|
}
|
}
|
/* no casematch, use first entry */
|
/* no casematch, use first entry */
|
if (i > matches)
|
if (i > matches)
|
strncpy (match_list[0], match_list[1], low);
|
strncpy (match_list[0], match_list[1], low);
|
}
|
}
|
else
|
else
|
/* otherwise, just use the text the user typed. */
|
/* otherwise, just use the text the user typed. */
|
strncpy (match_list[0], text, low);
|
strncpy (match_list[0], text, low);
|
|
|
FREE (dtext);
|
FREE (dtext);
|
}
|
}
|
else
|
else
|
strncpy (match_list[0], match_list[1], low);
|
strncpy (match_list[0], match_list[1], low);
|
|
|
match_list[0][low] = '\0';
|
match_list[0][low] = '\0';
|
}
|
}
|
|
|
return matches;
|
return matches;
|
}
|
}
|
|
|
static int
|
static int
|
postprocess_matches (matchesp, matching_filenames)
|
postprocess_matches (matchesp, matching_filenames)
|
char ***matchesp;
|
char ***matchesp;
|
int matching_filenames;
|
int matching_filenames;
|
{
|
{
|
char *t, **matches, **temp_matches;
|
char *t, **matches, **temp_matches;
|
int nmatch, i;
|
int nmatch, i;
|
|
|
matches = *matchesp;
|
matches = *matchesp;
|
|
|
if (matches == 0)
|
if (matches == 0)
|
return 0;
|
return 0;
|
|
|
/* It seems to me that in all the cases we handle we would like
|
/* It seems to me that in all the cases we handle we would like
|
to ignore duplicate possiblilities. Scan for the text to
|
to ignore duplicate possiblilities. Scan for the text to
|
insert being identical to the other completions. */
|
insert being identical to the other completions. */
|
if (rl_ignore_completion_duplicates)
|
if (rl_ignore_completion_duplicates)
|
{
|
{
|
temp_matches = remove_duplicate_matches (matches);
|
temp_matches = remove_duplicate_matches (matches);
|
free (matches);
|
free (matches);
|
matches = temp_matches;
|
matches = temp_matches;
|
}
|
}
|
|
|
/* If we are matching filenames, then here is our chance to
|
/* If we are matching filenames, then here is our chance to
|
do clever processing by re-examining the list. Call the
|
do clever processing by re-examining the list. Call the
|
ignore function with the array as a parameter. It can
|
ignore function with the array as a parameter. It can
|
munge the array, deleting matches as it desires. */
|
munge the array, deleting matches as it desires. */
|
if (rl_ignore_some_completions_function && matching_filenames)
|
if (rl_ignore_some_completions_function && matching_filenames)
|
{
|
{
|
for (nmatch = 1; matches[nmatch]; nmatch++)
|
for (nmatch = 1; matches[nmatch]; nmatch++)
|
;
|
;
|
(void)(*rl_ignore_some_completions_function) (matches);
|
(void)(*rl_ignore_some_completions_function) (matches);
|
if (matches == 0 || matches[0] == 0)
|
if (matches == 0 || matches[0] == 0)
|
{
|
{
|
FREE (matches);
|
FREE (matches);
|
*matchesp = (char **)0;
|
*matchesp = (char **)0;
|
return 0;
|
return 0;
|
}
|
}
|
else
|
else
|
{
|
{
|
/* If we removed some matches, recompute the common prefix. */
|
/* If we removed some matches, recompute the common prefix. */
|
for (i = 1; matches[i]; i++)
|
for (i = 1; matches[i]; i++)
|
;
|
;
|
if (i > 1 && i < nmatch)
|
if (i > 1 && i < nmatch)
|
{
|
{
|
t = matches[0];
|
t = matches[0];
|
compute_lcd_of_matches (matches, i - 1, t);
|
compute_lcd_of_matches (matches, i - 1, t);
|
FREE (t);
|
FREE (t);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
*matchesp = matches;
|
*matchesp = matches;
|
return (1);
|
return (1);
|
}
|
}
|
|
|
/* A convenience function for displaying a list of strings in
|
/* A convenience function for displaying a list of strings in
|
columnar format on readline's output stream. MATCHES is the list
|
columnar format on readline's output stream. MATCHES is the list
|
of strings, in argv format, LEN is the number of strings in MATCHES,
|
of strings, in argv format, LEN is the number of strings in MATCHES,
|
and MAX is the length of the longest string in MATCHES. */
|
and MAX is the length of the longest string in MATCHES. */
|
void
|
void
|
rl_display_match_list (matches, len, max)
|
rl_display_match_list (matches, len, max)
|
char **matches;
|
char **matches;
|
int len, max;
|
int len, max;
|
{
|
{
|
int count, limit, printed_len, lines;
|
int count, limit, printed_len, lines;
|
int i, j, k, l;
|
int i, j, k, l;
|
char *temp;
|
char *temp;
|
|
|
/* How many items of MAX length can we fit in the screen window? */
|
/* How many items of MAX length can we fit in the screen window? */
|
max += 2;
|
max += 2;
|
limit = _rl_screenwidth / max;
|
limit = _rl_screenwidth / max;
|
if (limit != 1 && (limit * max == _rl_screenwidth))
|
if (limit != 1 && (limit * max == _rl_screenwidth))
|
limit--;
|
limit--;
|
|
|
/* Avoid a possible floating exception. If max > _rl_screenwidth,
|
/* Avoid a possible floating exception. If max > _rl_screenwidth,
|
limit will be 0 and a divide-by-zero fault will result. */
|
limit will be 0 and a divide-by-zero fault will result. */
|
if (limit == 0)
|
if (limit == 0)
|
limit = 1;
|
limit = 1;
|
|
|
/* How many iterations of the printing loop? */
|
/* How many iterations of the printing loop? */
|
count = (len + (limit - 1)) / limit;
|
count = (len + (limit - 1)) / limit;
|
|
|
/* Watch out for special case. If LEN is less than LIMIT, then
|
/* Watch out for special case. If LEN is less than LIMIT, then
|
just do the inner printing loop.
|
just do the inner printing loop.
|
0 < len <= limit implies count = 1. */
|
0 < len <= limit implies count = 1. */
|
|
|
/* Sort the items if they are not already sorted. */
|
/* Sort the items if they are not already sorted. */
|
if (rl_ignore_completion_duplicates == 0)
|
if (rl_ignore_completion_duplicates == 0)
|
qsort (matches + 1, len, sizeof (char *), (QSFUNC *)_rl_qsort_string_compare);
|
qsort (matches + 1, len, sizeof (char *), (QSFUNC *)_rl_qsort_string_compare);
|
|
|
rl_crlf ();
|
rl_crlf ();
|
|
|
lines = 0;
|
lines = 0;
|
if (_rl_print_completions_horizontally == 0)
|
if (_rl_print_completions_horizontally == 0)
|
{
|
{
|
/* Print the sorted items, up-and-down alphabetically, like ls. */
|
/* Print the sorted items, up-and-down alphabetically, like ls. */
|
for (i = 1; i <= count; i++)
|
for (i = 1; i <= count; i++)
|
{
|
{
|
for (j = 0, l = i; j < limit; j++)
|
for (j = 0, l = i; j < limit; j++)
|
{
|
{
|
if (l > len || matches[l] == 0)
|
if (l > len || matches[l] == 0)
|
break;
|
break;
|
else
|
else
|
{
|
{
|
temp = printable_part (matches[l]);
|
temp = printable_part (matches[l]);
|
printed_len = print_filename (temp, matches[l]);
|
printed_len = print_filename (temp, matches[l]);
|
|
|
if (j + 1 < limit)
|
if (j + 1 < limit)
|
for (k = 0; k < max - printed_len; k++)
|
for (k = 0; k < max - printed_len; k++)
|
putc (' ', rl_outstream);
|
putc (' ', rl_outstream);
|
}
|
}
|
l += count;
|
l += count;
|
}
|
}
|
rl_crlf ();
|
rl_crlf ();
|
lines++;
|
lines++;
|
if (_rl_page_completions && lines >= (_rl_screenheight - 1) && i < count)
|
if (_rl_page_completions && lines >= (_rl_screenheight - 1) && i < count)
|
{
|
{
|
lines = _rl_internal_pager (lines);
|
lines = _rl_internal_pager (lines);
|
if (lines < 0)
|
if (lines < 0)
|
return;
|
return;
|
}
|
}
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Print the sorted items, across alphabetically, like ls -x. */
|
/* Print the sorted items, across alphabetically, like ls -x. */
|
for (i = 1; matches[i]; i++)
|
for (i = 1; matches[i]; i++)
|
{
|
{
|
temp = printable_part (matches[i]);
|
temp = printable_part (matches[i]);
|
printed_len = print_filename (temp, matches[i]);
|
printed_len = print_filename (temp, matches[i]);
|
/* Have we reached the end of this line? */
|
/* Have we reached the end of this line? */
|
if (matches[i+1])
|
if (matches[i+1])
|
{
|
{
|
if (i && (limit > 1) && (i % limit) == 0)
|
if (i && (limit > 1) && (i % limit) == 0)
|
{
|
{
|
rl_crlf ();
|
rl_crlf ();
|
lines++;
|
lines++;
|
if (_rl_page_completions && lines >= _rl_screenheight - 1)
|
if (_rl_page_completions && lines >= _rl_screenheight - 1)
|
{
|
{
|
lines = _rl_internal_pager (lines);
|
lines = _rl_internal_pager (lines);
|
if (lines < 0)
|
if (lines < 0)
|
return;
|
return;
|
}
|
}
|
}
|
}
|
else
|
else
|
for (k = 0; k < max - printed_len; k++)
|
for (k = 0; k < max - printed_len; k++)
|
putc (' ', rl_outstream);
|
putc (' ', rl_outstream);
|
}
|
}
|
}
|
}
|
rl_crlf ();
|
rl_crlf ();
|
}
|
}
|
}
|
}
|
|
|
/* Display MATCHES, a list of matching filenames in argv format. This
|
/* Display MATCHES, a list of matching filenames in argv format. This
|
handles the simple case -- a single match -- first. If there is more
|
handles the simple case -- a single match -- first. If there is more
|
than one match, we compute the number of strings in the list and the
|
than one match, we compute the number of strings in the list and the
|
length of the longest string, which will be needed by the display
|
length of the longest string, which will be needed by the display
|
function. If the application wants to handle displaying the list of
|
function. If the application wants to handle displaying the list of
|
matches itself, it sets RL_COMPLETION_DISPLAY_MATCHES_HOOK to the
|
matches itself, it sets RL_COMPLETION_DISPLAY_MATCHES_HOOK to the
|
address of a function, and we just call it. If we're handling the
|
address of a function, and we just call it. If we're handling the
|
display ourselves, we just call rl_display_match_list. We also check
|
display ourselves, we just call rl_display_match_list. We also check
|
that the list of matches doesn't exceed the user-settable threshold,
|
that the list of matches doesn't exceed the user-settable threshold,
|
and ask the user if he wants to see the list if there are more matches
|
and ask the user if he wants to see the list if there are more matches
|
than RL_COMPLETION_QUERY_ITEMS. */
|
than RL_COMPLETION_QUERY_ITEMS. */
|
static void
|
static void
|
display_matches (matches)
|
display_matches (matches)
|
char **matches;
|
char **matches;
|
{
|
{
|
int len, max, i;
|
int len, max, i;
|
char *temp;
|
char *temp;
|
|
|
/* Move to the last visible line of a possibly-multiple-line command. */
|
/* Move to the last visible line of a possibly-multiple-line command. */
|
_rl_move_vert (_rl_vis_botlin);
|
_rl_move_vert (_rl_vis_botlin);
|
|
|
/* Handle simple case first. What if there is only one answer? */
|
/* Handle simple case first. What if there is only one answer? */
|
if (matches[1] == 0)
|
if (matches[1] == 0)
|
{
|
{
|
temp = printable_part (matches[0]);
|
temp = printable_part (matches[0]);
|
rl_crlf ();
|
rl_crlf ();
|
print_filename (temp, matches[0]);
|
print_filename (temp, matches[0]);
|
rl_crlf ();
|
rl_crlf ();
|
|
|
rl_forced_update_display ();
|
rl_forced_update_display ();
|
rl_display_fixed = 1;
|
rl_display_fixed = 1;
|
|
|
return;
|
return;
|
}
|
}
|
|
|
/* There is more than one answer. Find out how many there are,
|
/* There is more than one answer. Find out how many there are,
|
and find the maximum printed length of a single entry. */
|
and find the maximum printed length of a single entry. */
|
for (max = 0, i = 1; matches[i]; i++)
|
for (max = 0, i = 1; matches[i]; i++)
|
{
|
{
|
temp = printable_part (matches[i]);
|
temp = printable_part (matches[i]);
|
len = fnwidth (temp);
|
len = fnwidth (temp);
|
|
|
if (len > max)
|
if (len > max)
|
max = len;
|
max = len;
|
}
|
}
|
|
|
len = i - 1;
|
len = i - 1;
|
|
|
/* If the caller has defined a display hook, then call that now. */
|
/* If the caller has defined a display hook, then call that now. */
|
if (rl_completion_display_matches_hook)
|
if (rl_completion_display_matches_hook)
|
{
|
{
|
(*rl_completion_display_matches_hook) (matches, len, max);
|
(*rl_completion_display_matches_hook) (matches, len, max);
|
return;
|
return;
|
}
|
}
|
|
|
/* If there are many items, then ask the user if she really wants to
|
/* If there are many items, then ask the user if she really wants to
|
see them all. */
|
see them all. */
|
if (rl_completion_query_items > 0 && len >= rl_completion_query_items)
|
if (rl_completion_query_items > 0 && len >= rl_completion_query_items)
|
{
|
{
|
rl_crlf ();
|
rl_crlf ();
|
fprintf (rl_outstream, "Display all %d possibilities? (y or n)", len);
|
fprintf (rl_outstream, "Display all %d possibilities? (y or n)", len);
|
fflush (rl_outstream);
|
fflush (rl_outstream);
|
if (get_y_or_n (0) == 0)
|
if (get_y_or_n (0) == 0)
|
{
|
{
|
rl_crlf ();
|
rl_crlf ();
|
|
|
rl_forced_update_display ();
|
rl_forced_update_display ();
|
rl_display_fixed = 1;
|
rl_display_fixed = 1;
|
|
|
return;
|
return;
|
}
|
}
|
}
|
}
|
|
|
rl_display_match_list (matches, len, max);
|
rl_display_match_list (matches, len, max);
|
|
|
rl_forced_update_display ();
|
rl_forced_update_display ();
|
rl_display_fixed = 1;
|
rl_display_fixed = 1;
|
}
|
}
|
|
|
static char *
|
static char *
|
make_quoted_replacement (match, mtype, qc)
|
make_quoted_replacement (match, mtype, qc)
|
char *match;
|
char *match;
|
int mtype;
|
int mtype;
|
char *qc; /* Pointer to quoting character, if any */
|
char *qc; /* Pointer to quoting character, if any */
|
{
|
{
|
int should_quote, do_replace;
|
int should_quote, do_replace;
|
char *replacement;
|
char *replacement;
|
|
|
/* If we are doing completion on quoted substrings, and any matches
|
/* If we are doing completion on quoted substrings, and any matches
|
contain any of the completer_word_break_characters, then auto-
|
contain any of the completer_word_break_characters, then auto-
|
matically prepend the substring with a quote character (just pick
|
matically prepend the substring with a quote character (just pick
|
the first one from the list of such) if it does not already begin
|
the first one from the list of such) if it does not already begin
|
with a quote string. FIXME: Need to remove any such automatically
|
with a quote string. FIXME: Need to remove any such automatically
|
inserted quote character when it no longer is necessary, such as
|
inserted quote character when it no longer is necessary, such as
|
if we change the string we are completing on and the new set of
|
if we change the string we are completing on and the new set of
|
matches don't require a quoted substring. */
|
matches don't require a quoted substring. */
|
replacement = match;
|
replacement = match;
|
|
|
should_quote = match && rl_completer_quote_characters &&
|
should_quote = match && rl_completer_quote_characters &&
|
rl_filename_completion_desired &&
|
rl_filename_completion_desired &&
|
rl_filename_quoting_desired;
|
rl_filename_quoting_desired;
|
|
|
if (should_quote)
|
if (should_quote)
|
should_quote = should_quote && (!qc || !*qc ||
|
should_quote = should_quote && (!qc || !*qc ||
|
(rl_completer_quote_characters && strchr (rl_completer_quote_characters, *qc)));
|
(rl_completer_quote_characters && strchr (rl_completer_quote_characters, *qc)));
|
|
|
if (should_quote)
|
if (should_quote)
|
{
|
{
|
/* If there is a single match, see if we need to quote it.
|
/* If there is a single match, see if we need to quote it.
|
This also checks whether the common prefix of several
|
This also checks whether the common prefix of several
|
matches needs to be quoted. */
|
matches needs to be quoted. */
|
should_quote = rl_filename_quote_characters
|
should_quote = rl_filename_quote_characters
|
? (_rl_strpbrk (match, rl_filename_quote_characters) != 0)
|
? (_rl_strpbrk (match, rl_filename_quote_characters) != 0)
|
: 0;
|
: 0;
|
|
|
do_replace = should_quote ? mtype : NO_MATCH;
|
do_replace = should_quote ? mtype : NO_MATCH;
|
/* Quote the replacement, since we found an embedded
|
/* Quote the replacement, since we found an embedded
|
word break character in a potential match. */
|
word break character in a potential match. */
|
if (do_replace != NO_MATCH && rl_filename_quoting_function)
|
if (do_replace != NO_MATCH && rl_filename_quoting_function)
|
replacement = (*rl_filename_quoting_function) (match, do_replace, qc);
|
replacement = (*rl_filename_quoting_function) (match, do_replace, qc);
|
}
|
}
|
return (replacement);
|
return (replacement);
|
}
|
}
|
|
|
static void
|
static void
|
insert_match (match, start, mtype, qc)
|
insert_match (match, start, mtype, qc)
|
char *match;
|
char *match;
|
int start, mtype;
|
int start, mtype;
|
char *qc;
|
char *qc;
|
{
|
{
|
char *replacement;
|
char *replacement;
|
char oqc;
|
char oqc;
|
|
|
oqc = qc ? *qc : '\0';
|
oqc = qc ? *qc : '\0';
|
replacement = make_quoted_replacement (match, mtype, qc);
|
replacement = make_quoted_replacement (match, mtype, qc);
|
|
|
/* Now insert the match. */
|
/* Now insert the match. */
|
if (replacement)
|
if (replacement)
|
{
|
{
|
/* Don't double an opening quote character. */
|
/* Don't double an opening quote character. */
|
if (qc && *qc && start && rl_line_buffer[start - 1] == *qc &&
|
if (qc && *qc && start && rl_line_buffer[start - 1] == *qc &&
|
replacement[0] == *qc)
|
replacement[0] == *qc)
|
start--;
|
start--;
|
/* If make_quoted_replacement changed the quoting character, remove
|
/* If make_quoted_replacement changed the quoting character, remove
|
the opening quote and insert the (fully-quoted) replacement. */
|
the opening quote and insert the (fully-quoted) replacement. */
|
else if (qc && (*qc != oqc) && start && rl_line_buffer[start - 1] == oqc &&
|
else if (qc && (*qc != oqc) && start && rl_line_buffer[start - 1] == oqc &&
|
replacement[0] != oqc)
|
replacement[0] != oqc)
|
start--;
|
start--;
|
_rl_replace_text (replacement, start, rl_point - 1);
|
_rl_replace_text (replacement, start, rl_point - 1);
|
if (replacement != match)
|
if (replacement != match)
|
free (replacement);
|
free (replacement);
|
}
|
}
|
}
|
}
|
|
|
/* Append any necessary closing quote and a separator character to the
|
/* Append any necessary closing quote and a separator character to the
|
just-inserted match. If the user has specified that directories
|
just-inserted match. If the user has specified that directories
|
should be marked by a trailing `/', append one of those instead. The
|
should be marked by a trailing `/', append one of those instead. The
|
default trailing character is a space. Returns the number of characters
|
default trailing character is a space. Returns the number of characters
|
appended. If NONTRIVIAL_MATCH is set, we test for a symlink (if the OS
|
appended. If NONTRIVIAL_MATCH is set, we test for a symlink (if the OS
|
has them) and don't add a suffix for a symlink to a directory. A
|
has them) and don't add a suffix for a symlink to a directory. A
|
nontrivial match is one that actually adds to the word being completed.
|
nontrivial match is one that actually adds to the word being completed.
|
The variable rl_completion_mark_symlink_dirs controls this behavior
|
The variable rl_completion_mark_symlink_dirs controls this behavior
|
(it's initially set to the what the user has chosen, indicated by the
|
(it's initially set to the what the user has chosen, indicated by the
|
value of _rl_complete_mark_symlink_dirs, but may be modified by an
|
value of _rl_complete_mark_symlink_dirs, but may be modified by an
|
application's completion function). */
|
application's completion function). */
|
static int
|
static int
|
append_to_match (text, delimiter, quote_char, nontrivial_match)
|
append_to_match (text, delimiter, quote_char, nontrivial_match)
|
char *text;
|
char *text;
|
int delimiter, quote_char, nontrivial_match;
|
int delimiter, quote_char, nontrivial_match;
|
{
|
{
|
char temp_string[4], *filename;
|
char temp_string[4], *filename;
|
int temp_string_index, s;
|
int temp_string_index, s;
|
struct stat finfo;
|
struct stat finfo;
|
|
|
temp_string_index = 0;
|
temp_string_index = 0;
|
if (quote_char && rl_point && rl_completion_suppress_quote == 0 &&
|
if (quote_char && rl_point && rl_completion_suppress_quote == 0 &&
|
rl_line_buffer[rl_point - 1] != quote_char)
|
rl_line_buffer[rl_point - 1] != quote_char)
|
temp_string[temp_string_index++] = quote_char;
|
temp_string[temp_string_index++] = quote_char;
|
|
|
if (delimiter)
|
if (delimiter)
|
temp_string[temp_string_index++] = delimiter;
|
temp_string[temp_string_index++] = delimiter;
|
else if (rl_completion_suppress_append == 0 && rl_completion_append_character)
|
else if (rl_completion_suppress_append == 0 && rl_completion_append_character)
|
temp_string[temp_string_index++] = rl_completion_append_character;
|
temp_string[temp_string_index++] = rl_completion_append_character;
|
|
|
temp_string[temp_string_index++] = '\0';
|
temp_string[temp_string_index++] = '\0';
|
|
|
if (rl_filename_completion_desired)
|
if (rl_filename_completion_desired)
|
{
|
{
|
filename = tilde_expand (text);
|
filename = tilde_expand (text);
|
s = (nontrivial_match && rl_completion_mark_symlink_dirs == 0)
|
s = (nontrivial_match && rl_completion_mark_symlink_dirs == 0)
|
? LSTAT (filename, &finfo)
|
? LSTAT (filename, &finfo)
|
: stat (filename, &finfo);
|
: stat (filename, &finfo);
|
if (s == 0 && S_ISDIR (finfo.st_mode))
|
if (s == 0 && S_ISDIR (finfo.st_mode))
|
{
|
{
|
if (_rl_complete_mark_directories /* && rl_completion_suppress_append == 0 */)
|
if (_rl_complete_mark_directories /* && rl_completion_suppress_append == 0 */)
|
{
|
{
|
/* This is clumsy. Avoid putting in a double slash if point
|
/* This is clumsy. Avoid putting in a double slash if point
|
is at the end of the line and the previous character is a
|
is at the end of the line and the previous character is a
|
slash. */
|
slash. */
|
if (rl_point && rl_line_buffer[rl_point] == '\0' && rl_line_buffer[rl_point - 1] == '/')
|
if (rl_point && rl_line_buffer[rl_point] == '\0' && rl_line_buffer[rl_point - 1] == '/')
|
;
|
;
|
else if (rl_line_buffer[rl_point] != '/')
|
else if (rl_line_buffer[rl_point] != '/')
|
rl_insert_text ("/");
|
rl_insert_text ("/");
|
}
|
}
|
}
|
}
|
#ifdef S_ISLNK
|
#ifdef S_ISLNK
|
/* Don't add anything if the filename is a symlink and resolves to a
|
/* Don't add anything if the filename is a symlink and resolves to a
|
directory. */
|
directory. */
|
else if (s == 0 && S_ISLNK (finfo.st_mode) &&
|
else if (s == 0 && S_ISLNK (finfo.st_mode) &&
|
stat (filename, &finfo) == 0 && S_ISDIR (finfo.st_mode))
|
stat (filename, &finfo) == 0 && S_ISDIR (finfo.st_mode))
|
;
|
;
|
#endif
|
#endif
|
else
|
else
|
{
|
{
|
if (rl_point == rl_end && temp_string_index)
|
if (rl_point == rl_end && temp_string_index)
|
rl_insert_text (temp_string);
|
rl_insert_text (temp_string);
|
}
|
}
|
free (filename);
|
free (filename);
|
}
|
}
|
else
|
else
|
{
|
{
|
if (rl_point == rl_end && temp_string_index)
|
if (rl_point == rl_end && temp_string_index)
|
rl_insert_text (temp_string);
|
rl_insert_text (temp_string);
|
}
|
}
|
|
|
return (temp_string_index);
|
return (temp_string_index);
|
}
|
}
|
|
|
static void
|
static void
|
insert_all_matches (matches, point, qc)
|
insert_all_matches (matches, point, qc)
|
char **matches;
|
char **matches;
|
int point;
|
int point;
|
char *qc;
|
char *qc;
|
{
|
{
|
int i;
|
int i;
|
char *rp;
|
char *rp;
|
|
|
rl_begin_undo_group ();
|
rl_begin_undo_group ();
|
/* remove any opening quote character; make_quoted_replacement will add
|
/* remove any opening quote character; make_quoted_replacement will add
|
it back. */
|
it back. */
|
if (qc && *qc && point && rl_line_buffer[point - 1] == *qc)
|
if (qc && *qc && point && rl_line_buffer[point - 1] == *qc)
|
point--;
|
point--;
|
rl_delete_text (point, rl_point);
|
rl_delete_text (point, rl_point);
|
rl_point = point;
|
rl_point = point;
|
|
|
if (matches[1])
|
if (matches[1])
|
{
|
{
|
for (i = 1; matches[i]; i++)
|
for (i = 1; matches[i]; i++)
|
{
|
{
|
rp = make_quoted_replacement (matches[i], SINGLE_MATCH, qc);
|
rp = make_quoted_replacement (matches[i], SINGLE_MATCH, qc);
|
rl_insert_text (rp);
|
rl_insert_text (rp);
|
rl_insert_text (" ");
|
rl_insert_text (" ");
|
if (rp != matches[i])
|
if (rp != matches[i])
|
free (rp);
|
free (rp);
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
rp = make_quoted_replacement (matches[0], SINGLE_MATCH, qc);
|
rp = make_quoted_replacement (matches[0], SINGLE_MATCH, qc);
|
rl_insert_text (rp);
|
rl_insert_text (rp);
|
rl_insert_text (" ");
|
rl_insert_text (" ");
|
if (rp != matches[0])
|
if (rp != matches[0])
|
free (rp);
|
free (rp);
|
}
|
}
|
rl_end_undo_group ();
|
rl_end_undo_group ();
|
}
|
}
|
|
|
void
|
void
|
_rl_free_match_list (matches)
|
_rl_free_match_list (matches)
|
char **matches;
|
char **matches;
|
{
|
{
|
register int i;
|
register int i;
|
|
|
if (matches == 0)
|
if (matches == 0)
|
return;
|
return;
|
|
|
for (i = 0; matches[i]; i++)
|
for (i = 0; matches[i]; i++)
|
free (matches[i]);
|
free (matches[i]);
|
free (matches);
|
free (matches);
|
}
|
}
|
|
|
/* Complete the word at or before point.
|
/* Complete the word at or before point.
|
WHAT_TO_DO says what to do with the completion.
|
WHAT_TO_DO says what to do with the completion.
|
`?' means list the possible completions.
|
`?' means list the possible completions.
|
TAB means do standard completion.
|
TAB means do standard completion.
|
`*' means insert all of the possible completions.
|
`*' means insert all of the possible completions.
|
`!' means to do standard completion, and list all possible completions if
|
`!' means to do standard completion, and list all possible completions if
|
there is more than one.
|
there is more than one.
|
`@' means to do standard completion, and list all possible completions if
|
`@' means to do standard completion, and list all possible completions if
|
there is more than one and partial completion is not possible. */
|
there is more than one and partial completion is not possible. */
|
int
|
int
|
rl_complete_internal (what_to_do)
|
rl_complete_internal (what_to_do)
|
int what_to_do;
|
int what_to_do;
|
{
|
{
|
char **matches;
|
char **matches;
|
rl_compentry_func_t *our_func;
|
rl_compentry_func_t *our_func;
|
int start, end, delimiter, found_quote, i, nontrivial_lcd;
|
int start, end, delimiter, found_quote, i, nontrivial_lcd;
|
char *text, *saved_line_buffer;
|
char *text, *saved_line_buffer;
|
char quote_char;
|
char quote_char;
|
|
|
RL_SETSTATE(RL_STATE_COMPLETING);
|
RL_SETSTATE(RL_STATE_COMPLETING);
|
|
|
set_completion_defaults (what_to_do);
|
set_completion_defaults (what_to_do);
|
|
|
saved_line_buffer = rl_line_buffer ? savestring (rl_line_buffer) : (char *)NULL;
|
saved_line_buffer = rl_line_buffer ? savestring (rl_line_buffer) : (char *)NULL;
|
our_func = rl_completion_entry_function
|
our_func = rl_completion_entry_function
|
? rl_completion_entry_function
|
? rl_completion_entry_function
|
: rl_filename_completion_function;
|
: rl_filename_completion_function;
|
/* We now look backwards for the start of a filename/variable word. */
|
/* We now look backwards for the start of a filename/variable word. */
|
end = rl_point;
|
end = rl_point;
|
found_quote = delimiter = 0;
|
found_quote = delimiter = 0;
|
quote_char = '\0';
|
quote_char = '\0';
|
|
|
if (rl_point)
|
if (rl_point)
|
/* This (possibly) changes rl_point. If it returns a non-zero char,
|
/* This (possibly) changes rl_point. If it returns a non-zero char,
|
we know we have an open quote. */
|
we know we have an open quote. */
|
quote_char = _rl_find_completion_word (&found_quote, &delimiter);
|
quote_char = _rl_find_completion_word (&found_quote, &delimiter);
|
|
|
start = rl_point;
|
start = rl_point;
|
rl_point = end;
|
rl_point = end;
|
|
|
text = rl_copy_text (start, end);
|
text = rl_copy_text (start, end);
|
matches = gen_completion_matches (text, start, end, our_func, found_quote, quote_char);
|
matches = gen_completion_matches (text, start, end, our_func, found_quote, quote_char);
|
/* nontrivial_lcd is set if the common prefix adds something to the word
|
/* nontrivial_lcd is set if the common prefix adds something to the word
|
being completed. */
|
being completed. */
|
nontrivial_lcd = matches && strcmp (text, matches[0]) != 0;
|
nontrivial_lcd = matches && strcmp (text, matches[0]) != 0;
|
free (text);
|
free (text);
|
|
|
if (matches == 0)
|
if (matches == 0)
|
{
|
{
|
rl_ding ();
|
rl_ding ();
|
FREE (saved_line_buffer);
|
FREE (saved_line_buffer);
|
completion_changed_buffer = 0;
|
completion_changed_buffer = 0;
|
RL_UNSETSTATE(RL_STATE_COMPLETING);
|
RL_UNSETSTATE(RL_STATE_COMPLETING);
|
return (0);
|
return (0);
|
}
|
}
|
|
|
/* If we are matching filenames, the attempted completion function will
|
/* If we are matching filenames, the attempted completion function will
|
have set rl_filename_completion_desired to a non-zero value. The basic
|
have set rl_filename_completion_desired to a non-zero value. The basic
|
rl_filename_completion_function does this. */
|
rl_filename_completion_function does this. */
|
i = rl_filename_completion_desired;
|
i = rl_filename_completion_desired;
|
|
|
if (postprocess_matches (&matches, i) == 0)
|
if (postprocess_matches (&matches, i) == 0)
|
{
|
{
|
rl_ding ();
|
rl_ding ();
|
FREE (saved_line_buffer);
|
FREE (saved_line_buffer);
|
completion_changed_buffer = 0;
|
completion_changed_buffer = 0;
|
RL_UNSETSTATE(RL_STATE_COMPLETING);
|
RL_UNSETSTATE(RL_STATE_COMPLETING);
|
return (0);
|
return (0);
|
}
|
}
|
|
|
switch (what_to_do)
|
switch (what_to_do)
|
{
|
{
|
case TAB:
|
case TAB:
|
case '!':
|
case '!':
|
case '@':
|
case '@':
|
/* Insert the first match with proper quoting. */
|
/* Insert the first match with proper quoting. */
|
if (*matches[0])
|
if (*matches[0])
|
insert_match (matches[0], start, matches[1] ? MULT_MATCH : SINGLE_MATCH, "e_char);
|
insert_match (matches[0], start, matches[1] ? MULT_MATCH : SINGLE_MATCH, "e_char);
|
|
|
/* If there are more matches, ring the bell to indicate.
|
/* If there are more matches, ring the bell to indicate.
|
If we are in vi mode, Posix.2 says to not ring the bell.
|
If we are in vi mode, Posix.2 says to not ring the bell.
|
If the `show-all-if-ambiguous' variable is set, display
|
If the `show-all-if-ambiguous' variable is set, display
|
all the matches immediately. Otherwise, if this was the
|
all the matches immediately. Otherwise, if this was the
|
only match, and we are hacking files, check the file to
|
only match, and we are hacking files, check the file to
|
see if it was a directory. If so, and the `mark-directories'
|
see if it was a directory. If so, and the `mark-directories'
|
variable is set, add a '/' to the name. If not, and we
|
variable is set, add a '/' to the name. If not, and we
|
are at the end of the line, then add a space. */
|
are at the end of the line, then add a space. */
|
if (matches[1])
|
if (matches[1])
|
{
|
{
|
if (what_to_do == '!')
|
if (what_to_do == '!')
|
{
|
{
|
display_matches (matches);
|
display_matches (matches);
|
break;
|
break;
|
}
|
}
|
else if (what_to_do == '@')
|
else if (what_to_do == '@')
|
{
|
{
|
if (nontrivial_lcd == 0)
|
if (nontrivial_lcd == 0)
|
display_matches (matches);
|
display_matches (matches);
|
break;
|
break;
|
}
|
}
|
else if (rl_editing_mode != vi_mode)
|
else if (rl_editing_mode != vi_mode)
|
rl_ding (); /* There are other matches remaining. */
|
rl_ding (); /* There are other matches remaining. */
|
}
|
}
|
else
|
else
|
append_to_match (matches[0], delimiter, quote_char, nontrivial_lcd);
|
append_to_match (matches[0], delimiter, quote_char, nontrivial_lcd);
|
|
|
break;
|
break;
|
|
|
case '*':
|
case '*':
|
insert_all_matches (matches, start, "e_char);
|
insert_all_matches (matches, start, "e_char);
|
break;
|
break;
|
|
|
case '?':
|
case '?':
|
display_matches (matches);
|
display_matches (matches);
|
break;
|
break;
|
|
|
default:
|
default:
|
fprintf (stderr, "\r\nreadline: bad value %d for what_to_do in rl_complete\n", what_to_do);
|
fprintf (stderr, "\r\nreadline: bad value %d for what_to_do in rl_complete\n", what_to_do);
|
rl_ding ();
|
rl_ding ();
|
FREE (saved_line_buffer);
|
FREE (saved_line_buffer);
|
RL_UNSETSTATE(RL_STATE_COMPLETING);
|
RL_UNSETSTATE(RL_STATE_COMPLETING);
|
return 1;
|
return 1;
|
}
|
}
|
|
|
_rl_free_match_list (matches);
|
_rl_free_match_list (matches);
|
|
|
/* Check to see if the line has changed through all of this manipulation. */
|
/* Check to see if the line has changed through all of this manipulation. */
|
if (saved_line_buffer)
|
if (saved_line_buffer)
|
{
|
{
|
completion_changed_buffer = strcmp (rl_line_buffer, saved_line_buffer) != 0;
|
completion_changed_buffer = strcmp (rl_line_buffer, saved_line_buffer) != 0;
|
free (saved_line_buffer);
|
free (saved_line_buffer);
|
}
|
}
|
|
|
RL_UNSETSTATE(RL_STATE_COMPLETING);
|
RL_UNSETSTATE(RL_STATE_COMPLETING);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/***************************************************************/
|
/***************************************************************/
|
/* */
|
/* */
|
/* Application-callable completion match generator functions */
|
/* Application-callable completion match generator functions */
|
/* */
|
/* */
|
/***************************************************************/
|
/***************************************************************/
|
|
|
/* Return an array of (char *) which is a list of completions for TEXT.
|
/* Return an array of (char *) which is a list of completions for TEXT.
|
If there are no completions, return a NULL pointer.
|
If there are no completions, return a NULL pointer.
|
The first entry in the returned array is the substitution for TEXT.
|
The first entry in the returned array is the substitution for TEXT.
|
The remaining entries are the possible completions.
|
The remaining entries are the possible completions.
|
The array is terminated with a NULL pointer.
|
The array is terminated with a NULL pointer.
|
|
|
ENTRY_FUNCTION is a function of two args, and returns a (char *).
|
ENTRY_FUNCTION is a function of two args, and returns a (char *).
|
The first argument is TEXT.
|
The first argument is TEXT.
|
The second is a state argument; it should be zero on the first call, and
|
The second is a state argument; it should be zero on the first call, and
|
non-zero on subsequent calls. It returns a NULL pointer to the caller
|
non-zero on subsequent calls. It returns a NULL pointer to the caller
|
when there are no more matches.
|
when there are no more matches.
|
*/
|
*/
|
char **
|
char **
|
rl_completion_matches (text, entry_function)
|
rl_completion_matches (text, entry_function)
|
const char *text;
|
const char *text;
|
rl_compentry_func_t *entry_function;
|
rl_compentry_func_t *entry_function;
|
{
|
{
|
/* Number of slots in match_list. */
|
/* Number of slots in match_list. */
|
int match_list_size;
|
int match_list_size;
|
|
|
/* The list of matches. */
|
/* The list of matches. */
|
char **match_list;
|
char **match_list;
|
|
|
/* Number of matches actually found. */
|
/* Number of matches actually found. */
|
int matches;
|
int matches;
|
|
|
/* Temporary string binder. */
|
/* Temporary string binder. */
|
char *string;
|
char *string;
|
|
|
matches = 0;
|
matches = 0;
|
match_list_size = 10;
|
match_list_size = 10;
|
match_list = (char **)xmalloc ((match_list_size + 1) * sizeof (char *));
|
match_list = (char **)xmalloc ((match_list_size + 1) * sizeof (char *));
|
match_list[1] = (char *)NULL;
|
match_list[1] = (char *)NULL;
|
|
|
while (string = (*entry_function) (text, matches))
|
while (string = (*entry_function) (text, matches))
|
{
|
{
|
if (matches + 1 == match_list_size)
|
if (matches + 1 == match_list_size)
|
match_list = (char **)xrealloc
|
match_list = (char **)xrealloc
|
(match_list, ((match_list_size += 10) + 1) * sizeof (char *));
|
(match_list, ((match_list_size += 10) + 1) * sizeof (char *));
|
|
|
match_list[++matches] = string;
|
match_list[++matches] = string;
|
match_list[matches + 1] = (char *)NULL;
|
match_list[matches + 1] = (char *)NULL;
|
}
|
}
|
|
|
/* If there were any matches, then look through them finding out the
|
/* If there were any matches, then look through them finding out the
|
lowest common denominator. That then becomes match_list[0]. */
|
lowest common denominator. That then becomes match_list[0]. */
|
if (matches)
|
if (matches)
|
compute_lcd_of_matches (match_list, matches, text);
|
compute_lcd_of_matches (match_list, matches, text);
|
else /* There were no matches. */
|
else /* There were no matches. */
|
{
|
{
|
free (match_list);
|
free (match_list);
|
match_list = (char **)NULL;
|
match_list = (char **)NULL;
|
}
|
}
|
return (match_list);
|
return (match_list);
|
}
|
}
|
|
|
/* A completion function for usernames.
|
/* A completion function for usernames.
|
TEXT contains a partial username preceded by a random
|
TEXT contains a partial username preceded by a random
|
character (usually `~'). */
|
character (usually `~'). */
|
char *
|
char *
|
rl_username_completion_function (text, state)
|
rl_username_completion_function (text, state)
|
const char *text;
|
const char *text;
|
int state;
|
int state;
|
{
|
{
|
#if defined (__WIN32__) || defined (__OPENNT)
|
#if defined (__WIN32__) || defined (__OPENNT)
|
return (char *)NULL;
|
return (char *)NULL;
|
#else /* !__WIN32__ && !__OPENNT) */
|
#else /* !__WIN32__ && !__OPENNT) */
|
static char *username = (char *)NULL;
|
static char *username = (char *)NULL;
|
static struct passwd *entry;
|
static struct passwd *entry;
|
static int namelen, first_char, first_char_loc;
|
static int namelen, first_char, first_char_loc;
|
char *value;
|
char *value;
|
|
|
if (state == 0)
|
if (state == 0)
|
{
|
{
|
FREE (username);
|
FREE (username);
|
|
|
first_char = *text;
|
first_char = *text;
|
first_char_loc = first_char == '~';
|
first_char_loc = first_char == '~';
|
|
|
username = savestring (&text[first_char_loc]);
|
username = savestring (&text[first_char_loc]);
|
namelen = strlen (username);
|
namelen = strlen (username);
|
setpwent ();
|
setpwent ();
|
}
|
}
|
|
|
#if defined (HAVE_GETPWENT)
|
#if defined (HAVE_GETPWENT)
|
while (entry = getpwent ())
|
while (entry = getpwent ())
|
{
|
{
|
/* Null usernames should result in all users as possible completions. */
|
/* Null usernames should result in all users as possible completions. */
|
if (namelen == 0 || (STREQN (username, entry->pw_name, namelen)))
|
if (namelen == 0 || (STREQN (username, entry->pw_name, namelen)))
|
break;
|
break;
|
}
|
}
|
#endif
|
#endif
|
|
|
if (entry == 0)
|
if (entry == 0)
|
{
|
{
|
#if defined (HAVE_GETPWENT)
|
#if defined (HAVE_GETPWENT)
|
endpwent ();
|
endpwent ();
|
#endif
|
#endif
|
return ((char *)NULL);
|
return ((char *)NULL);
|
}
|
}
|
else
|
else
|
{
|
{
|
value = (char *)xmalloc (2 + strlen (entry->pw_name));
|
value = (char *)xmalloc (2 + strlen (entry->pw_name));
|
|
|
*value = *text;
|
*value = *text;
|
|
|
strcpy (value + first_char_loc, entry->pw_name);
|
strcpy (value + first_char_loc, entry->pw_name);
|
|
|
if (first_char == '~')
|
if (first_char == '~')
|
rl_filename_completion_desired = 1;
|
rl_filename_completion_desired = 1;
|
|
|
return (value);
|
return (value);
|
}
|
}
|
#endif /* !__WIN32__ && !__OPENNT */
|
#endif /* !__WIN32__ && !__OPENNT */
|
}
|
}
|
|
|
/* Okay, now we write the entry_function for filename completion. In the
|
/* Okay, now we write the entry_function for filename completion. In the
|
general case. Note that completion in the shell is a little different
|
general case. Note that completion in the shell is a little different
|
because of all the pathnames that must be followed when looking up the
|
because of all the pathnames that must be followed when looking up the
|
completion for a command. */
|
completion for a command. */
|
char *
|
char *
|
rl_filename_completion_function (text, state)
|
rl_filename_completion_function (text, state)
|
const char *text;
|
const char *text;
|
int state;
|
int state;
|
{
|
{
|
static DIR *directory = (DIR *)NULL;
|
static DIR *directory = (DIR *)NULL;
|
static char *filename = (char *)NULL;
|
static char *filename = (char *)NULL;
|
static char *dirname = (char *)NULL;
|
static char *dirname = (char *)NULL;
|
static char *users_dirname = (char *)NULL;
|
static char *users_dirname = (char *)NULL;
|
static int filename_len;
|
static int filename_len;
|
char *temp;
|
char *temp;
|
int dirlen;
|
int dirlen;
|
struct dirent *entry;
|
struct dirent *entry;
|
|
|
/* If we don't have any state, then do some initialization. */
|
/* If we don't have any state, then do some initialization. */
|
if (state == 0)
|
if (state == 0)
|
{
|
{
|
/* If we were interrupted before closing the directory or reading
|
/* If we were interrupted before closing the directory or reading
|
all of its contents, close it. */
|
all of its contents, close it. */
|
if (directory)
|
if (directory)
|
{
|
{
|
closedir (directory);
|
closedir (directory);
|
directory = (DIR *)NULL;
|
directory = (DIR *)NULL;
|
}
|
}
|
FREE (dirname);
|
FREE (dirname);
|
FREE (filename);
|
FREE (filename);
|
FREE (users_dirname);
|
FREE (users_dirname);
|
|
|
filename = savestring (text);
|
filename = savestring (text);
|
if (*text == 0)
|
if (*text == 0)
|
text = ".";
|
text = ".";
|
dirname = savestring (text);
|
dirname = savestring (text);
|
|
|
temp = strrchr (dirname, '/');
|
temp = strrchr (dirname, '/');
|
|
|
#if defined (__MSDOS__)
|
#if defined (__MSDOS__)
|
/* special hack for //X/... */
|
/* special hack for //X/... */
|
if (dirname[0] == '/' && dirname[1] == '/' && ISALPHA ((unsigned char)dirname[2]) && dirname[3] == '/')
|
if (dirname[0] == '/' && dirname[1] == '/' && ISALPHA ((unsigned char)dirname[2]) && dirname[3] == '/')
|
temp = strrchr (dirname + 3, '/');
|
temp = strrchr (dirname + 3, '/');
|
#endif
|
#endif
|
|
|
if (temp)
|
if (temp)
|
{
|
{
|
strcpy (filename, ++temp);
|
strcpy (filename, ++temp);
|
*temp = '\0';
|
*temp = '\0';
|
}
|
}
|
#if defined (__MSDOS__)
|
#if defined (__MSDOS__)
|
/* searches from current directory on the drive */
|
/* searches from current directory on the drive */
|
else if (ISALPHA ((unsigned char)dirname[0]) && dirname[1] == ':')
|
else if (ISALPHA ((unsigned char)dirname[0]) && dirname[1] == ':')
|
{
|
{
|
strcpy (filename, dirname + 2);
|
strcpy (filename, dirname + 2);
|
dirname[2] = '\0';
|
dirname[2] = '\0';
|
}
|
}
|
#endif
|
#endif
|
else
|
else
|
{
|
{
|
dirname[0] = '.';
|
dirname[0] = '.';
|
dirname[1] = '\0';
|
dirname[1] = '\0';
|
}
|
}
|
|
|
/* We aren't done yet. We also support the "~user" syntax. */
|
/* We aren't done yet. We also support the "~user" syntax. */
|
|
|
/* Save the version of the directory that the user typed. */
|
/* Save the version of the directory that the user typed. */
|
users_dirname = savestring (dirname);
|
users_dirname = savestring (dirname);
|
|
|
if (*dirname == '~')
|
if (*dirname == '~')
|
{
|
{
|
temp = tilde_expand (dirname);
|
temp = tilde_expand (dirname);
|
free (dirname);
|
free (dirname);
|
dirname = temp;
|
dirname = temp;
|
}
|
}
|
|
|
if (rl_directory_rewrite_hook)
|
if (rl_directory_rewrite_hook)
|
(*rl_directory_rewrite_hook) (&dirname);
|
(*rl_directory_rewrite_hook) (&dirname);
|
|
|
if (rl_directory_completion_hook && (*rl_directory_completion_hook) (&dirname))
|
if (rl_directory_completion_hook && (*rl_directory_completion_hook) (&dirname))
|
{
|
{
|
free (users_dirname);
|
free (users_dirname);
|
users_dirname = savestring (dirname);
|
users_dirname = savestring (dirname);
|
}
|
}
|
|
|
directory = opendir (dirname);
|
directory = opendir (dirname);
|
filename_len = strlen (filename);
|
filename_len = strlen (filename);
|
|
|
rl_filename_completion_desired = 1;
|
rl_filename_completion_desired = 1;
|
}
|
}
|
|
|
/* At this point we should entertain the possibility of hacking wildcarded
|
/* At this point we should entertain the possibility of hacking wildcarded
|
filenames, like /usr/man/man<WILD>/te<TAB>. If the directory name
|
filenames, like /usr/man/man<WILD>/te<TAB>. If the directory name
|
contains globbing characters, then build an array of directories, and
|
contains globbing characters, then build an array of directories, and
|
then map over that list while completing. */
|
then map over that list while completing. */
|
/* *** UNIMPLEMENTED *** */
|
/* *** UNIMPLEMENTED *** */
|
|
|
/* Now that we have some state, we can read the directory. */
|
/* Now that we have some state, we can read the directory. */
|
|
|
entry = (struct dirent *)NULL;
|
entry = (struct dirent *)NULL;
|
while (directory && (entry = readdir (directory)))
|
while (directory && (entry = readdir (directory)))
|
{
|
{
|
/* Special case for no filename. If the user has disabled the
|
/* Special case for no filename. If the user has disabled the
|
`match-hidden-files' variable, skip filenames beginning with `.'.
|
`match-hidden-files' variable, skip filenames beginning with `.'.
|
All other entries except "." and ".." match. */
|
All other entries except "." and ".." match. */
|
if (filename_len == 0)
|
if (filename_len == 0)
|
{
|
{
|
if (_rl_match_hidden_files == 0 && HIDDEN_FILE (entry->d_name))
|
if (_rl_match_hidden_files == 0 && HIDDEN_FILE (entry->d_name))
|
continue;
|
continue;
|
|
|
if (entry->d_name[0] != '.' ||
|
if (entry->d_name[0] != '.' ||
|
(entry->d_name[1] &&
|
(entry->d_name[1] &&
|
(entry->d_name[1] != '.' || entry->d_name[2])))
|
(entry->d_name[1] != '.' || entry->d_name[2])))
|
break;
|
break;
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Otherwise, if these match up to the length of filename, then
|
/* Otherwise, if these match up to the length of filename, then
|
it is a match. */
|
it is a match. */
|
if (_rl_completion_case_fold)
|
if (_rl_completion_case_fold)
|
{
|
{
|
if ((_rl_to_lower (entry->d_name[0]) == _rl_to_lower (filename[0])) &&
|
if ((_rl_to_lower (entry->d_name[0]) == _rl_to_lower (filename[0])) &&
|
(((int)D_NAMLEN (entry)) >= filename_len) &&
|
(((int)D_NAMLEN (entry)) >= filename_len) &&
|
(_rl_strnicmp (filename, entry->d_name, filename_len) == 0))
|
(_rl_strnicmp (filename, entry->d_name, filename_len) == 0))
|
break;
|
break;
|
}
|
}
|
else
|
else
|
{
|
{
|
if ((entry->d_name[0] == filename[0]) &&
|
if ((entry->d_name[0] == filename[0]) &&
|
(((int)D_NAMLEN (entry)) >= filename_len) &&
|
(((int)D_NAMLEN (entry)) >= filename_len) &&
|
(strncmp (filename, entry->d_name, filename_len) == 0))
|
(strncmp (filename, entry->d_name, filename_len) == 0))
|
break;
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
if (entry == 0)
|
if (entry == 0)
|
{
|
{
|
if (directory)
|
if (directory)
|
{
|
{
|
closedir (directory);
|
closedir (directory);
|
directory = (DIR *)NULL;
|
directory = (DIR *)NULL;
|
}
|
}
|
if (dirname)
|
if (dirname)
|
{
|
{
|
free (dirname);
|
free (dirname);
|
dirname = (char *)NULL;
|
dirname = (char *)NULL;
|
}
|
}
|
if (filename)
|
if (filename)
|
{
|
{
|
free (filename);
|
free (filename);
|
filename = (char *)NULL;
|
filename = (char *)NULL;
|
}
|
}
|
if (users_dirname)
|
if (users_dirname)
|
{
|
{
|
free (users_dirname);
|
free (users_dirname);
|
users_dirname = (char *)NULL;
|
users_dirname = (char *)NULL;
|
}
|
}
|
|
|
return (char *)NULL;
|
return (char *)NULL;
|
}
|
}
|
else
|
else
|
{
|
{
|
/* dirname && (strcmp (dirname, ".") != 0) */
|
/* dirname && (strcmp (dirname, ".") != 0) */
|
if (dirname && (dirname[0] != '.' || dirname[1]))
|
if (dirname && (dirname[0] != '.' || dirname[1]))
|
{
|
{
|
if (rl_complete_with_tilde_expansion && *users_dirname == '~')
|
if (rl_complete_with_tilde_expansion && *users_dirname == '~')
|
{
|
{
|
dirlen = strlen (dirname);
|
dirlen = strlen (dirname);
|
temp = (char *)xmalloc (2 + dirlen + D_NAMLEN (entry));
|
temp = (char *)xmalloc (2 + dirlen + D_NAMLEN (entry));
|
strcpy (temp, dirname);
|
strcpy (temp, dirname);
|
/* Canonicalization cuts off any final slash present. We
|
/* Canonicalization cuts off any final slash present. We
|
may need to add it back. */
|
may need to add it back. */
|
if (dirname[dirlen - 1] != '/')
|
if (dirname[dirlen - 1] != '/')
|
{
|
{
|
temp[dirlen++] = '/';
|
temp[dirlen++] = '/';
|
temp[dirlen] = '\0';
|
temp[dirlen] = '\0';
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
dirlen = strlen (users_dirname);
|
dirlen = strlen (users_dirname);
|
temp = (char *)xmalloc (2 + dirlen + D_NAMLEN (entry));
|
temp = (char *)xmalloc (2 + dirlen + D_NAMLEN (entry));
|
strcpy (temp, users_dirname);
|
strcpy (temp, users_dirname);
|
/* Make sure that temp has a trailing slash here. */
|
/* Make sure that temp has a trailing slash here. */
|
if (users_dirname[dirlen - 1] != '/')
|
if (users_dirname[dirlen - 1] != '/')
|
temp[dirlen++] = '/';
|
temp[dirlen++] = '/';
|
}
|
}
|
|
|
strcpy (temp + dirlen, entry->d_name);
|
strcpy (temp + dirlen, entry->d_name);
|
}
|
}
|
else
|
else
|
temp = savestring (entry->d_name);
|
temp = savestring (entry->d_name);
|
|
|
return (temp);
|
return (temp);
|
}
|
}
|
}
|
}
|
|
|
/* An initial implementation of a menu completion function a la tcsh. The
|
/* An initial implementation of a menu completion function a la tcsh. The
|
first time (if the last readline command was not rl_menu_complete), we
|
first time (if the last readline command was not rl_menu_complete), we
|
generate the list of matches. This code is very similar to the code in
|
generate the list of matches. This code is very similar to the code in
|
rl_complete_internal -- there should be a way to combine the two. Then,
|
rl_complete_internal -- there should be a way to combine the two. Then,
|
for each item in the list of matches, we insert the match in an undoable
|
for each item in the list of matches, we insert the match in an undoable
|
fashion, with the appropriate character appended (this happens on the
|
fashion, with the appropriate character appended (this happens on the
|
second and subsequent consecutive calls to rl_menu_complete). When we
|
second and subsequent consecutive calls to rl_menu_complete). When we
|
hit the end of the match list, we restore the original unmatched text,
|
hit the end of the match list, we restore the original unmatched text,
|
ring the bell, and reset the counter to zero. */
|
ring the bell, and reset the counter to zero. */
|
int
|
int
|
rl_menu_complete (count, ignore)
|
rl_menu_complete (count, ignore)
|
int count, ignore;
|
int count, ignore;
|
{
|
{
|
rl_compentry_func_t *our_func;
|
rl_compentry_func_t *our_func;
|
int matching_filenames, found_quote;
|
int matching_filenames, found_quote;
|
|
|
static char *orig_text;
|
static char *orig_text;
|
static char **matches = (char **)0;
|
static char **matches = (char **)0;
|
static int match_list_index = 0;
|
static int match_list_index = 0;
|
static int match_list_size = 0;
|
static int match_list_size = 0;
|
static int orig_start, orig_end;
|
static int orig_start, orig_end;
|
static char quote_char;
|
static char quote_char;
|
static int delimiter;
|
static int delimiter;
|
|
|
/* The first time through, we generate the list of matches and set things
|
/* The first time through, we generate the list of matches and set things
|
up to insert them. */
|
up to insert them. */
|
if (rl_last_func != rl_menu_complete)
|
if (rl_last_func != rl_menu_complete)
|
{
|
{
|
/* Clean up from previous call, if any. */
|
/* Clean up from previous call, if any. */
|
FREE (orig_text);
|
FREE (orig_text);
|
if (matches)
|
if (matches)
|
_rl_free_match_list (matches);
|
_rl_free_match_list (matches);
|
|
|
match_list_index = match_list_size = 0;
|
match_list_index = match_list_size = 0;
|
matches = (char **)NULL;
|
matches = (char **)NULL;
|
|
|
/* Only the completion entry function can change these. */
|
/* Only the completion entry function can change these. */
|
set_completion_defaults ('%');
|
set_completion_defaults ('%');
|
|
|
our_func = rl_completion_entry_function
|
our_func = rl_completion_entry_function
|
? rl_completion_entry_function
|
? rl_completion_entry_function
|
: rl_filename_completion_function;
|
: rl_filename_completion_function;
|
|
|
/* We now look backwards for the start of a filename/variable word. */
|
/* We now look backwards for the start of a filename/variable word. */
|
orig_end = rl_point;
|
orig_end = rl_point;
|
found_quote = delimiter = 0;
|
found_quote = delimiter = 0;
|
quote_char = '\0';
|
quote_char = '\0';
|
|
|
if (rl_point)
|
if (rl_point)
|
/* This (possibly) changes rl_point. If it returns a non-zero char,
|
/* This (possibly) changes rl_point. If it returns a non-zero char,
|
we know we have an open quote. */
|
we know we have an open quote. */
|
quote_char = _rl_find_completion_word (&found_quote, &delimiter);
|
quote_char = _rl_find_completion_word (&found_quote, &delimiter);
|
|
|
orig_start = rl_point;
|
orig_start = rl_point;
|
rl_point = orig_end;
|
rl_point = orig_end;
|
|
|
orig_text = rl_copy_text (orig_start, orig_end);
|
orig_text = rl_copy_text (orig_start, orig_end);
|
matches = gen_completion_matches (orig_text, orig_start, orig_end,
|
matches = gen_completion_matches (orig_text, orig_start, orig_end,
|
our_func, found_quote, quote_char);
|
our_func, found_quote, quote_char);
|
|
|
/* If we are matching filenames, the attempted completion function will
|
/* If we are matching filenames, the attempted completion function will
|
have set rl_filename_completion_desired to a non-zero value. The basic
|
have set rl_filename_completion_desired to a non-zero value. The basic
|
rl_filename_completion_function does this. */
|
rl_filename_completion_function does this. */
|
matching_filenames = rl_filename_completion_desired;
|
matching_filenames = rl_filename_completion_desired;
|
|
|
if (matches == 0 || postprocess_matches (&matches, matching_filenames) == 0)
|
if (matches == 0 || postprocess_matches (&matches, matching_filenames) == 0)
|
{
|
{
|
rl_ding ();
|
rl_ding ();
|
FREE (matches);
|
FREE (matches);
|
matches = (char **)0;
|
matches = (char **)0;
|
FREE (orig_text);
|
FREE (orig_text);
|
orig_text = (char *)0;
|
orig_text = (char *)0;
|
completion_changed_buffer = 0;
|
completion_changed_buffer = 0;
|
return (0);
|
return (0);
|
}
|
}
|
|
|
for (match_list_size = 0; matches[match_list_size]; match_list_size++)
|
for (match_list_size = 0; matches[match_list_size]; match_list_size++)
|
;
|
;
|
/* matches[0] is lcd if match_list_size > 1, but the circular buffer
|
/* matches[0] is lcd if match_list_size > 1, but the circular buffer
|
code below should take care of it. */
|
code below should take care of it. */
|
}
|
}
|
|
|
/* Now we have the list of matches. Replace the text between
|
/* Now we have the list of matches. Replace the text between
|
rl_line_buffer[orig_start] and rl_line_buffer[rl_point] with
|
rl_line_buffer[orig_start] and rl_line_buffer[rl_point] with
|
matches[match_list_index], and add any necessary closing char. */
|
matches[match_list_index], and add any necessary closing char. */
|
|
|
if (matches == 0 || match_list_size == 0)
|
if (matches == 0 || match_list_size == 0)
|
{
|
{
|
rl_ding ();
|
rl_ding ();
|
FREE (matches);
|
FREE (matches);
|
matches = (char **)0;
|
matches = (char **)0;
|
completion_changed_buffer = 0;
|
completion_changed_buffer = 0;
|
return (0);
|
return (0);
|
}
|
}
|
|
|
match_list_index += count;
|
match_list_index += count;
|
if (match_list_index < 0)
|
if (match_list_index < 0)
|
match_list_index += match_list_size;
|
match_list_index += match_list_size;
|
else
|
else
|
match_list_index %= match_list_size;
|
match_list_index %= match_list_size;
|
|
|
if (match_list_index == 0 && match_list_size > 1)
|
if (match_list_index == 0 && match_list_size > 1)
|
{
|
{
|
rl_ding ();
|
rl_ding ();
|
insert_match (orig_text, orig_start, MULT_MATCH, "e_char);
|
insert_match (orig_text, orig_start, MULT_MATCH, "e_char);
|
}
|
}
|
else
|
else
|
{
|
{
|
insert_match (matches[match_list_index], orig_start, SINGLE_MATCH, "e_char);
|
insert_match (matches[match_list_index], orig_start, SINGLE_MATCH, "e_char);
|
append_to_match (matches[match_list_index], delimiter, quote_char,
|
append_to_match (matches[match_list_index], delimiter, quote_char,
|
strcmp (orig_text, matches[match_list_index]));
|
strcmp (orig_text, matches[match_list_index]));
|
}
|
}
|
|
|
completion_changed_buffer = 1;
|
completion_changed_buffer = 1;
|
return (0);
|
return (0);
|
}
|
}
|
|
|
