979 lines
36 KiB
Plaintext
979 lines
36 KiB
Plaintext
This is Info file readline.info, produced by Makeinfo-1.55 from the
|
||
input file rlman.texinfo.
|
||
|
||
This document describes the GNU Readline Library, a utility which
|
||
aids in the consistency of user interface across discrete programs that
|
||
need to provide a command line interface.
|
||
|
||
Copyright (C) 1988, 1991 Free Software Foundation, Inc.
|
||
|
||
Permission is granted to make and distribute verbatim copies of this
|
||
manual provided the copyright notice and this permission notice pare
|
||
preserved on all copies.
|
||
|
||
Permission is granted to copy and distribute modified versions of
|
||
this manual under the conditions for verbatim copying, provided that
|
||
the entire resulting derived work is distributed under the terms of a
|
||
permission notice identical to this one.
|
||
|
||
Permission is granted to copy and distribute translations of this
|
||
manual into another language, under the above conditions for modified
|
||
versions, except that this permission notice may be stated in a
|
||
translation approved by the Foundation.
|
||
|
||
|
||
File: readline.info, Node: Modifying Text, Next: Utility Functions, Prev: Redisplay, Up: Readline Convenience Functions
|
||
|
||
Modifying Text
|
||
--------------
|
||
|
||
- Function: int rl_insert_text (char *text)
|
||
Insert TEXT into the line at the current cursor position.
|
||
|
||
- Function: int rl_delete_text (int start, int end)
|
||
Delete the text between START and END in the current line.
|
||
|
||
- Function: char * rl_copy_text (int start, int end)
|
||
Return a copy of the text between START and END in the current
|
||
line.
|
||
|
||
- Function: int rl_kill_text (int start, int end)
|
||
Copy the text between START and END in the current line to the
|
||
kill ring, appending or prepending to the last kill if the last
|
||
command was a kill command. The text is deleted. If START is
|
||
less than END, the text is appended, otherwise prepended. If the
|
||
last command was not a kill, a new kill ring slot is used.
|
||
|
||
|
||
File: readline.info, Node: Utility Functions, Prev: Modifying Text, Up: Readline Convenience Functions
|
||
|
||
Utility Functions
|
||
-----------------
|
||
|
||
- Function: int rl_reset_terminal (char *terminal_name)
|
||
Reinitialize Readline's idea of the terminal settings using
|
||
TERMINAL_NAME as the terminal type (e.g., `vt100').
|
||
|
||
- Function: int alphabetic (int c)
|
||
Return 1 if C is an alphabetic character.
|
||
|
||
- Function: int numeric (int c)
|
||
Return 1 if C is a numeric character.
|
||
|
||
- Function: int ding ()
|
||
Ring the terminal bell, obeying the setting of `bell-style'.
|
||
|
||
The following are implemented as macros, defined in `chartypes.h'.
|
||
|
||
- Function: int uppercase_p (int c)
|
||
Return 1 if C is an uppercase alphabetic character.
|
||
|
||
- Function: int lowercase_p (int c)
|
||
Return 1 if C is a lowercase alphabetic character.
|
||
|
||
- Function: int digit_p (int c)
|
||
Return 1 if C is a numeric character.
|
||
|
||
- Function: int to_upper (int c)
|
||
If C is a lowercase alphabetic character, return the corresponding
|
||
uppercase character.
|
||
|
||
- Function: int to_lower (int c)
|
||
If C is an uppercase alphabetic character, return the corresponding
|
||
lowercase character.
|
||
|
||
- Function: int digit_value (int c)
|
||
If C is a number, return the value it represents.
|
||
|
||
An Example
|
||
----------
|
||
|
||
Here is a function which changes lowercase characters to their
|
||
uppercase equivalents, and uppercase characters to lowercase. If this
|
||
function was bound to `M-c', then typing `M-c' would change the case of
|
||
the character under point. Typing `M-1 0 M-c' would change the case of
|
||
the following 10 characters, leaving the cursor on the last character
|
||
changed.
|
||
|
||
/* Invert the case of the COUNT following characters. */
|
||
int
|
||
invert_case_line (count, key)
|
||
int count, key;
|
||
{
|
||
register int start, end, i;
|
||
|
||
start = rl_point;
|
||
|
||
if (rl_point >= rl_end)
|
||
return (0);
|
||
|
||
if (count < 0)
|
||
{
|
||
direction = -1;
|
||
count = -count;
|
||
}
|
||
else
|
||
direction = 1;
|
||
|
||
/* Find the end of the range to modify. */
|
||
end = start + (count * direction);
|
||
|
||
/* Force it to be within range. */
|
||
if (end > rl_end)
|
||
end = rl_end;
|
||
else if (end < 0)
|
||
end = 0;
|
||
|
||
if (start == end)
|
||
return (0);
|
||
|
||
if (start > end)
|
||
{
|
||
int temp = start;
|
||
start = end;
|
||
end = temp;
|
||
}
|
||
|
||
/* Tell readline that we are modifying the line, so it will save
|
||
the undo information. */
|
||
rl_modifying (start, end);
|
||
|
||
for (i = start; i != end; i++)
|
||
{
|
||
if (uppercase_p (rl_line_buffer[i]))
|
||
rl_line_buffer[i] = to_lower (rl_line_buffer[i]);
|
||
else if (lowercase_p (rl_line_buffer[i]))
|
||
rl_line_buffer[i] = to_upper (rl_line_buffer[i]);
|
||
}
|
||
/* Move point to on top of the last character changed. */
|
||
rl_point = (direction == 1) ? end - 1 : start;
|
||
return (0);
|
||
}
|
||
|
||
|
||
File: readline.info, Node: Custom Completers, Prev: Readline Convenience Functions, Up: Programming with GNU Readline
|
||
|
||
Custom Completers
|
||
=================
|
||
|
||
Typically, a program that reads commands from the user has a way of
|
||
disambiguating commands and data. If your program is one of these, then
|
||
it can provide completion for commands, data, or both. The following
|
||
sections describe how your program and Readline cooperate to provide
|
||
this service.
|
||
|
||
* Menu:
|
||
|
||
* How Completing Works:: The logic used to do completion.
|
||
* Completion Functions:: Functions provided by Readline.
|
||
* Completion Variables:: Variables which control completion.
|
||
* A Short Completion Example:: An example of writing completer subroutines.
|
||
|
||
|
||
File: readline.info, Node: How Completing Works, Next: Completion Functions, Up: Custom Completers
|
||
|
||
How Completing Works
|
||
--------------------
|
||
|
||
In order to complete some text, the full list of possible completions
|
||
must be available. That is, it is not possible to accurately expand a
|
||
partial word without knowing all of the possible words which make sense
|
||
in that context. The Readline library provides the user interface to
|
||
completion, and two of the most common completion functions: filename
|
||
and username. For completing other types of text, you must write your
|
||
own completion function. This section describes exactly what such
|
||
functions must do, and provides an example.
|
||
|
||
There are three major functions used to perform completion:
|
||
|
||
1. The user-interface function `rl_complete ()'. This function is
|
||
called with the same arguments as other Readline functions
|
||
intended for interactive use: COUNT and INVOKING_KEY. It
|
||
isolates the word to be completed and calls `completion_matches
|
||
()' to generate a list of possible completions. It then either
|
||
lists the possible completions, inserts the possible completions,
|
||
or actually performs the completion, depending on which behavior
|
||
is desired.
|
||
|
||
2. The internal function `completion_matches ()' uses your
|
||
"generator" function to generate the list of possible matches, and
|
||
then returns the array of these matches. You should place the
|
||
address of your generator function in
|
||
`rl_completion_entry_function'.
|
||
|
||
3. The generator function is called repeatedly from
|
||
`completion_matches ()', returning a string each time. The
|
||
arguments to the generator function are TEXT and STATE. TEXT is
|
||
the partial word to be completed. STATE is zero the first time
|
||
the function is called, allowing the generator to perform any
|
||
necessary initialization, and a positive non-zero integer for each
|
||
subsequent call. When the generator function returns `(char
|
||
*)NULL' this signals `completion_matches ()' that there are no
|
||
more possibilities left. Usually the generator function computes
|
||
the list of possible completions when STATE is zero, and returns
|
||
them one at a time on subsequent calls. Each string the generator
|
||
function returns as a match must be allocated with `malloc()';
|
||
Readline frees the strings when it has finished with them.
|
||
|
||
|
||
- Function: int rl_complete (int ignore, int invoking_key)
|
||
Complete the word at or before point. You have supplied the
|
||
function that does the initial simple matching selection algorithm
|
||
(see `completion_matches ()'). The default is to do filename
|
||
completion.
|
||
|
||
- Variable: Function * rl_completion_entry_function
|
||
This is a pointer to the generator function for `completion_matches
|
||
()'. If the value of `rl_completion_entry_function' is `(Function
|
||
*)NULL' then the default filename generator function,
|
||
`filename_entry_function ()', is used.
|
||
|
||
|
||
File: readline.info, Node: Completion Functions, Next: Completion Variables, Prev: How Completing Works, Up: Custom Completers
|
||
|
||
Completion Functions
|
||
--------------------
|
||
|
||
Here is the complete list of callable completion functions present in
|
||
Readline.
|
||
|
||
- Function: int rl_complete_internal (int what_to_do)
|
||
Complete the word at or before point. WHAT_TO_DO says what to do
|
||
with the completion. A value of `?' means list the possible
|
||
completions. `TAB' means do standard completion. `*' means
|
||
insert all of the possible completions. `!' means to display all
|
||
of the possible completions, if there is more than one, as well as
|
||
performing partial completion.
|
||
|
||
- Function: int rl_complete (int ignore, int invoking_key)
|
||
Complete the word at or before point. You have supplied the
|
||
function that does the initial simple matching selection algorithm
|
||
(see `completion_matches ()' and `rl_completion_entry_function').
|
||
The default is to do filename completion. This calls
|
||
`rl_complete_internal ()' with an argument depending on
|
||
INVOKING_KEY.
|
||
|
||
- Function: int rl_possible_completions (int count, int invoking_key))
|
||
List the possible completions. See description of `rl_complete
|
||
()'. This calls `rl_complete_internal ()' with an argument of `?'.
|
||
|
||
- Function: int rl_insert_completions (int count, int invoking_key))
|
||
Insert the list of possible completions into the line, deleting the
|
||
partially-completed word. See description of `rl_complete ()'.
|
||
This calls `rl_complete_internal ()' with an argument of `*'.
|
||
|
||
- Function: char ** completion_matches (char *text, CPFunction
|
||
*entry_func)
|
||
Returns an array of `(char *)' which is a list of completions for
|
||
TEXT. If there are no completions, returns `(char **)NULL'. The
|
||
first entry in the returned array is the substitution for TEXT.
|
||
The remaining entries are the possible completions. The array is
|
||
terminated with a `NULL' pointer.
|
||
|
||
ENTRY_FUNC is a function of two args, and returns a `(char *)'.
|
||
The first argument is TEXT. The second is a state argument; it is
|
||
zero on the first call, and non-zero on subsequent calls.
|
||
eNTRY_FUNC returns a `NULL' pointer to the caller when there are
|
||
no more matches.
|
||
|
||
- Function: char * filename_completion_function (char *text, int state)
|
||
A generator function for filename completion in the general case.
|
||
Note that completion in Bash is a little different because of all
|
||
the pathnames that must be followed when looking up completions
|
||
for a command. The Bash source is a useful reference for writing
|
||
custom completion functions.
|
||
|
||
- Function: char * username_completion_function (char *text, int state)
|
||
A completion generator for usernames. TEXT contains a partial
|
||
username preceded by a random character (usually `~'). As with all
|
||
completion generators, STATE is zero on the first call and non-zero
|
||
for subsequent calls.
|
||
|
||
|
||
File: readline.info, Node: Completion Variables, Next: A Short Completion Example, Prev: Completion Functions, Up: Custom Completers
|
||
|
||
Completion Variables
|
||
--------------------
|
||
|
||
- Variable: Function * rl_completion_entry_function
|
||
A pointer to the generator function for `completion_matches ()'.
|
||
`NULL' means to use `filename_entry_function ()', the default
|
||
filename completer.
|
||
|
||
- Variable: CPPFunction * rl_attempted_completion_function
|
||
A pointer to an alternative function to create matches. The
|
||
function is called with TEXT, START, and END. START and END are
|
||
indices in `rl_line_buffer' saying what the boundaries of TEXT
|
||
are. If this function exists and returns `NULL', or if this
|
||
variable is set to `NULL', then `rl_complete ()' will call the
|
||
value of `rl_completion_entry_function' to generate matches,
|
||
otherwise the array of strings returned will be used.
|
||
|
||
- Variable: int rl_completion_query_items
|
||
Up to this many items will be displayed in response to a
|
||
possible-completions call. After that, we ask the user if she is
|
||
sure she wants to see them all. The default value is 100.
|
||
|
||
- Variable: char * rl_basic_word_break_characters
|
||
The basic list of characters that signal a break between words for
|
||
the completer routine. The default value of this variable is the
|
||
characters which break words for completion in Bash, i.e., `"
|
||
\t\n\"\\'`@$><=;|&{("'.
|
||
|
||
- Variable: char * rl_completer_word_break_characters
|
||
The list of characters that signal a break between words for
|
||
`rl_complete_internal ()'. The default list is the value of
|
||
`rl_basic_word_break_characters'.
|
||
|
||
- Variable: char * rl_special_prefixes
|
||
The list of characters that are word break characters, but should
|
||
be left in TEXT when it is passed to the completion function.
|
||
Programs can use this to help determine what kind of completing to
|
||
do. For instance, Bash sets this variable to "$@" so that it can
|
||
complete shell variables and hostnames.
|
||
|
||
- Variable: int rl_ignore_completion_duplicates
|
||
If non-zero, then disallow duplicates in the matches. Default is
|
||
1.
|
||
|
||
- Variable: int rl_filename_completion_desired
|
||
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
|
||
within a completion entry generator function. If it is set to a
|
||
non-zero value, directory names have a slash appended and Readline
|
||
attempts to quote completed filenames if they contain any embedded
|
||
word break characters.
|
||
|
||
- Variable: int rl_filename_quoting_desired
|
||
Non-zero means that the results of the matches are to be quoted
|
||
using double quotes (or an application-specific quoting mechanism)
|
||
if the completed filename contains any characters in
|
||
`rl_completer_word_break_chars'. This is *always* non-zero on
|
||
entry, and can only be changed within a completion entry generator
|
||
function.
|
||
|
||
- Variable: Function * rl_ignore_some_completions_function
|
||
This function, if defined, is called by the completer when real
|
||
filename completion is done, after all the matching names have
|
||
been generated. It is passed a `NULL' terminated array of matches.
|
||
The first element (`matches[0]') is the maximal substring common
|
||
to all matches. This function can re-arrange the list of matches
|
||
as required, but each element deleted from the array must be freed.
|
||
|
||
- Variable: char * rl_completer_quote_characters
|
||
List of characters which can be used to quote a substring of the
|
||
line. Completion occurs on the entire substring, and within the
|
||
substring `rl_completer_word_break_characters' are treated as any
|
||
other character, unless they also appear within this list.
|
||
|
||
|
||
File: readline.info, Node: A Short Completion Example, Prev: Completion Variables, Up: Custom Completers
|
||
|
||
A Short Completion Example
|
||
--------------------------
|
||
|
||
Here is a small application demonstrating the use of the GNU Readline
|
||
library. It is called `fileman', and the source code resides in
|
||
`examples/fileman.c'. This sample application provides completion of
|
||
command names, line editing features, and access to the history list.
|
||
|
||
/* fileman.c -- A tiny application which demonstrates how to use the
|
||
GNU Readline library. This application interactively allows users
|
||
to manipulate files and their modes. */
|
||
|
||
#include <stdio.h>
|
||
#include <sys/types.h>
|
||
#include <sys/file.h>
|
||
#include <sys/stat.h>
|
||
#include <sys/errno.h>
|
||
|
||
#include <readline/readline.h>
|
||
#include <readline/history.h>
|
||
|
||
extern char *getwd ();
|
||
extern char *xmalloc ();
|
||
|
||
/* The names of functions that actually do the manipulation. */
|
||
int com_list (), com_view (), com_rename (), com_stat (), com_pwd ();
|
||
int com_delete (), com_help (), com_cd (), com_quit ();
|
||
|
||
/* A structure which contains information on the commands this program
|
||
can understand. */
|
||
|
||
typedef struct {
|
||
char *name; /* User printable name of the function. */
|
||
Function *func; /* Function to call to do the job. */
|
||
char *doc; /* Documentation for this function. */
|
||
} COMMAND;
|
||
|
||
COMMAND commands[] = {
|
||
{ "cd", com_cd, "Change to directory DIR" },
|
||
{ "delete", com_delete, "Delete FILE" },
|
||
{ "help", com_help, "Display this text" },
|
||
{ "?", com_help, "Synonym for `help'" },
|
||
{ "list", com_list, "List files in DIR" },
|
||
{ "ls", com_list, "Synonym for `list'" },
|
||
{ "pwd", com_pwd, "Print the current working directory" },
|
||
{ "quit", com_quit, "Quit using Fileman" },
|
||
{ "rename", com_rename, "Rename FILE to NEWNAME" },
|
||
{ "stat", com_stat, "Print out statistics on FILE" },
|
||
{ "view", com_view, "View the contents of FILE" },
|
||
{ (char *)NULL, (Function *)NULL, (char *)NULL }
|
||
};
|
||
|
||
/* Forward declarations. */
|
||
char *stripwhite ();
|
||
COMMAND *find_command ();
|
||
|
||
/* The name of this program, as taken from argv[0]. */
|
||
char *progname;
|
||
|
||
/* When non-zero, this global means the user is done using this program. */
|
||
int done;
|
||
|
||
char *
|
||
dupstr (s)
|
||
int s;
|
||
{
|
||
char *r;
|
||
|
||
r = xmalloc (strlen (s) + 1);
|
||
strcpy (r, s);
|
||
return (r);
|
||
}
|
||
|
||
main (argc, argv)
|
||
int argc;
|
||
char **argv;
|
||
{
|
||
char *line, *s;
|
||
|
||
progname = argv[0];
|
||
|
||
initialize_readline (); /* Bind our completer. */
|
||
|
||
/* Loop reading and executing lines until the user quits. */
|
||
for ( ; done == 0; )
|
||
{
|
||
line = readline ("FileMan: ");
|
||
|
||
if (!line)
|
||
break;
|
||
|
||
/* Remove leading and trailing whitespace from the line.
|
||
Then, if there is anything left, add it to the history list
|
||
and execute it. */
|
||
s = stripwhite (line);
|
||
|
||
if (*s)
|
||
{
|
||
add_history (s);
|
||
execute_line (s);
|
||
}
|
||
|
||
free (line);
|
||
}
|
||
exit (0);
|
||
}
|
||
|
||
/* Execute a command line. */
|
||
int
|
||
execute_line (line)
|
||
char *line;
|
||
{
|
||
register int i;
|
||
COMMAND *command;
|
||
char *word;
|
||
|
||
/* Isolate the command word. */
|
||
i = 0;
|
||
while (line[i] && whitespace (line[i]))
|
||
i++;
|
||
word = line + i;
|
||
|
||
while (line[i] && !whitespace (line[i]))
|
||
i++;
|
||
|
||
if (line[i])
|
||
line[i++] = '\0';
|
||
|
||
command = find_command (word);
|
||
|
||
if (!command)
|
||
{
|
||
fprintf (stderr, "%s: No such command for FileMan.\n", word);
|
||
return (-1);
|
||
}
|
||
|
||
/* Get argument to command, if any. */
|
||
while (whitespace (line[i]))
|
||
i++;
|
||
|
||
word = line + i;
|
||
|
||
/* Call the function. */
|
||
return ((*(command->func)) (word));
|
||
}
|
||
|
||
/* Look up NAME as the name of a command, and return a pointer to that
|
||
command. Return a NULL pointer if NAME isn't a command name. */
|
||
COMMAND *
|
||
find_command (name)
|
||
char *name;
|
||
{
|
||
register int i;
|
||
|
||
for (i = 0; commands[i].name; i++)
|
||
if (strcmp (name, commands[i].name) == 0)
|
||
return (&commands[i]);
|
||
|
||
return ((COMMAND *)NULL);
|
||
}
|
||
|
||
/* Strip whitespace from the start and end of STRING. Return a pointer
|
||
into STRING. */
|
||
char *
|
||
stripwhite (string)
|
||
char *string;
|
||
{
|
||
register char *s, *t;
|
||
|
||
for (s = string; whitespace (*s); s++)
|
||
;
|
||
|
||
if (*s == 0)
|
||
return (s);
|
||
|
||
t = s + strlen (s) - 1;
|
||
while (t > s && whitespace (*t))
|
||
t--;
|
||
*++t = '\0';
|
||
|
||
return s;
|
||
}
|
||
|
||
/* **************************************************************** */
|
||
/* */
|
||
/* Interface to Readline Completion */
|
||
/* */
|
||
/* **************************************************************** */
|
||
|
||
char *command_generator ();
|
||
char **fileman_completion ();
|
||
|
||
/* Tell the GNU Readline library how to complete. We want to try to complete
|
||
on command names if this is the first word in the line, or on filenames
|
||
if not. */
|
||
initialize_readline ()
|
||
{
|
||
/* Allow conditional parsing of the ~/.inputrc file. */
|
||
rl_readline_name = "FileMan";
|
||
|
||
/* Tell the completer that we want a crack first. */
|
||
rl_attempted_completion_function = (CPPFunction *)fileman_completion;
|
||
}
|
||
|
||
/* Attempt to complete on the contents of TEXT. START and END show the
|
||
region of TEXT that contains the word to complete. We can use the
|
||
entire line in case we want to do some simple parsing. Return the
|
||
array of matches, or NULL if there aren't any. */
|
||
char **
|
||
fileman_completion (text, start, end)
|
||
char *text;
|
||
int start, end;
|
||
{
|
||
char **matches;
|
||
|
||
matches = (char **)NULL;
|
||
|
||
/* If this word is at the start of the line, then it is a command
|
||
to complete. Otherwise it is the name of a file in the current
|
||
directory. */
|
||
if (start == 0)
|
||
matches = completion_matches (text, command_generator);
|
||
|
||
return (matches);
|
||
}
|
||
|
||
/* Generator function for command completion. STATE lets us know whether
|
||
to start from scratch; without any state (i.e. STATE == 0), then we
|
||
start at the top of the list. */
|
||
char *
|
||
command_generator (text, state)
|
||
char *text;
|
||
int state;
|
||
{
|
||
static int list_index, len;
|
||
char *name;
|
||
|
||
/* If this is a new word to complete, initialize now. This includes
|
||
saving the length of TEXT for efficiency, and initializing the index
|
||
variable to 0. */
|
||
if (!state)
|
||
{
|
||
list_index = 0;
|
||
len = strlen (text);
|
||
}
|
||
|
||
/* Return the next name which partially matches from the command list. */
|
||
while (name = commands[list_index].name)
|
||
{
|
||
list_index++;
|
||
|
||
if (strncmp (name, text, len) == 0)
|
||
return (dupstr(name));
|
||
}
|
||
|
||
/* If no names matched, then return NULL. */
|
||
return ((char *)NULL);
|
||
}
|
||
|
||
/* **************************************************************** */
|
||
/* */
|
||
/* FileMan Commands */
|
||
/* */
|
||
/* **************************************************************** */
|
||
|
||
/* String to pass to system (). This is for the LIST, VIEW and RENAME
|
||
commands. */
|
||
static char syscom[1024];
|
||
|
||
/* List the file(s) named in arg. */
|
||
com_list (arg)
|
||
char *arg;
|
||
{
|
||
if (!arg)
|
||
arg = "";
|
||
|
||
sprintf (syscom, "ls -FClg %s", arg);
|
||
return (system (syscom));
|
||
}
|
||
|
||
com_view (arg)
|
||
char *arg;
|
||
{
|
||
if (!valid_argument ("view", arg))
|
||
return 1;
|
||
|
||
sprintf (syscom, "more %s", arg);
|
||
return (system (syscom));
|
||
}
|
||
|
||
com_rename (arg)
|
||
char *arg;
|
||
{
|
||
too_dangerous ("rename");
|
||
return (1);
|
||
}
|
||
|
||
com_stat (arg)
|
||
char *arg;
|
||
{
|
||
struct stat finfo;
|
||
|
||
if (!valid_argument ("stat", arg))
|
||
return (1);
|
||
|
||
if (stat (arg, &finfo) == -1)
|
||
{
|
||
perror (arg);
|
||
return (1);
|
||
}
|
||
|
||
printf ("Statistics for `%s':\n", arg);
|
||
|
||
printf ("%s has %d link%s, and is %d byte%s in length.\n", arg,
|
||
finfo.st_nlink,
|
||
(finfo.st_nlink == 1) ? "" : "s",
|
||
finfo.st_size,
|
||
(finfo.st_size == 1) ? "" : "s");
|
||
printf ("Inode Last Change at: %s", ctime (&finfo.st_ctime));
|
||
printf (" Last access at: %s", ctime (&finfo.st_atime));
|
||
printf (" Last modified at: %s", ctime (&finfo.st_mtime));
|
||
return (0);
|
||
}
|
||
|
||
com_delete (arg)
|
||
char *arg;
|
||
{
|
||
too_dangerous ("delete");
|
||
return (1);
|
||
}
|
||
|
||
/* Print out help for ARG, or for all of the commands if ARG is
|
||
not present. */
|
||
com_help (arg)
|
||
char *arg;
|
||
{
|
||
register int i;
|
||
int printed = 0;
|
||
|
||
for (i = 0; commands[i].name; i++)
|
||
{
|
||
if (!*arg || (strcmp (arg, commands[i].name) == 0))
|
||
{
|
||
printf ("%s\t\t%s.\n", commands[i].name, commands[i].doc);
|
||
printed++;
|
||
}
|
||
}
|
||
|
||
if (!printed)
|
||
{
|
||
printf ("No commands match `%s'. Possibilties are:\n", arg);
|
||
|
||
for (i = 0; commands[i].name; i++)
|
||
{
|
||
/* Print in six columns. */
|
||
if (printed == 6)
|
||
{
|
||
printed = 0;
|
||
printf ("\n");
|
||
}
|
||
|
||
printf ("%s\t", commands[i].name);
|
||
printed++;
|
||
}
|
||
|
||
if (printed)
|
||
printf ("\n");
|
||
}
|
||
return (0);
|
||
}
|
||
|
||
/* Change to the directory ARG. */
|
||
com_cd (arg)
|
||
char *arg;
|
||
{
|
||
if (chdir (arg) == -1)
|
||
{
|
||
perror (arg);
|
||
return 1;
|
||
}
|
||
|
||
com_pwd ("");
|
||
return (0);
|
||
}
|
||
|
||
/* Print out the current working directory. */
|
||
com_pwd (ignore)
|
||
char *ignore;
|
||
{
|
||
char dir[1024], *s;
|
||
|
||
s = getwd (dir);
|
||
if (s == 0)
|
||
{
|
||
printf ("Error getting pwd: %s\n", dir);
|
||
return 1;
|
||
}
|
||
|
||
printf ("Current directory is %s\n", dir);
|
||
return 0;
|
||
}
|
||
|
||
/* The user wishes to quit using this program. Just set DONE non-zero. */
|
||
com_quit (arg)
|
||
char *arg;
|
||
{
|
||
done = 1;
|
||
return (0);
|
||
}
|
||
|
||
/* Function which tells you that you can't do this. */
|
||
too_dangerous (caller)
|
||
char *caller;
|
||
{
|
||
fprintf (stderr,
|
||
"%s: Too dangerous for me to distribute. Write it yourself.\n",
|
||
caller);
|
||
}
|
||
|
||
/* Return non-zero if ARG is a valid argument for CALLER, else print
|
||
an error message and return zero. */
|
||
int
|
||
valid_argument (caller, arg)
|
||
char *caller, *arg;
|
||
{
|
||
if (!arg || !*arg)
|
||
{
|
||
fprintf (stderr, "%s: Argument required.\n", caller);
|
||
return (0);
|
||
}
|
||
|
||
return (1);
|
||
}
|
||
|
||
|
||
File: readline.info, Node: Concept Index, Next: Function and Variable Index, Prev: Programming with GNU Readline, Up: Top
|
||
|
||
Concept Index
|
||
*************
|
||
|
||
* Menu:
|
||
|
||
* interaction, readline: Readline Interaction.
|
||
* Kill ring: Readline Killing Commands.
|
||
* Killing text: Readline Killing Commands.
|
||
* readline, function: Basic Behavior.
|
||
* Yanking text: Readline Killing Commands.
|
||
|
||
|
||
File: readline.info, Node: Function and Variable Index, Prev: Concept Index, Up: Top
|
||
|
||
Function and Variable Index
|
||
***************************
|
||
|
||
* Menu:
|
||
|
||
* $else: Conditional Init Constructs.
|
||
* $endif: Conditional Init Constructs.
|
||
* $if: Conditional Init Constructs.
|
||
* abort (C-g): Miscellaneous Commands.
|
||
* accept-line (Newline, Return): Commands For History.
|
||
* alphabetic: Utility Functions.
|
||
* backward-char (C-b): Commands For Moving.
|
||
* backward-delete-char (Rubout): Commands For Text.
|
||
* backward-kill-line (C-x Rubout): Commands For Killing.
|
||
* backward-kill-word (M-DEL): Commands For Killing.
|
||
* backward-word (M-b): Commands For Moving.
|
||
* beginning-of-history (M-<): Commands For History.
|
||
* beginning-of-line (C-a): Commands For Moving.
|
||
* bell-style: Readline Init Syntax.
|
||
* call-last-kbd-macro (C-x e): Keyboard Macros.
|
||
* capitalize-word (M-c): Commands For Text.
|
||
* clear-screen (C-l): Commands For Moving.
|
||
* comment-begin: Readline Init Syntax.
|
||
* complete (TAB): Commands For Completion.
|
||
* completion-query-items: Readline Init Syntax.
|
||
* completion_matches: Completion Functions.
|
||
* convert-meta: Readline Init Syntax.
|
||
* delete-char (C-d): Commands For Text.
|
||
* delete-horizontal-space (): Commands For Killing.
|
||
* digit-argument (M-0, M-1, ... M-): Numeric Arguments.
|
||
* digit_p: Utility Functions.
|
||
* digit_value: Utility Functions.
|
||
* ding: Utility Functions.
|
||
* do-uppercase-version (M-a, M-b, ...): Miscellaneous Commands.
|
||
* downcase-word (M-l): Commands For Text.
|
||
* dump-functions (): Miscellaneous Commands.
|
||
* editing-mode: Readline Init Syntax.
|
||
* end-kbd-macro (C-x )): Keyboard Macros.
|
||
* end-of-history (M->): Commands For History.
|
||
* end-of-line (C-e): Commands For Moving.
|
||
* expand-tilde: Readline Init Syntax.
|
||
* filename_completion_function: Completion Functions.
|
||
* forward-char (C-f): Commands For Moving.
|
||
* forward-search-history (C-s): Commands For History.
|
||
* forward-word (M-f): Commands For Moving.
|
||
* free_undo_list: Allowing Undoing.
|
||
* history-search-backward (): Commands For History.
|
||
* history-search-forward (): Commands For History.
|
||
* horizontal-scroll-mode: Readline Init Syntax.
|
||
* insert-completions (): Commands For Completion.
|
||
* keymap: Readline Init Syntax.
|
||
* kill-line (C-k): Commands For Killing.
|
||
* kill-whole-line (): Commands For Killing.
|
||
* kill-word (M-d): Commands For Killing.
|
||
* lowercase_p: Utility Functions.
|
||
* mark-modified-lines: Readline Init Syntax.
|
||
* meta-flag: Readline Init Syntax.
|
||
* next-history (C-n): Commands For History.
|
||
* non-incremental-forward-search-history (M-n): Commands For History.
|
||
* non-incremental-reverse-search-history (M-p): Commands For History.
|
||
* numeric: Utility Functions.
|
||
* output-meta: Readline Init Syntax.
|
||
* possible-completions (M-?): Commands For Completion.
|
||
* prefix-meta (ESC): Miscellaneous Commands.
|
||
* previous-history (C-p): Commands For History.
|
||
* quoted-insert (C-q, C-v): Commands For Text.
|
||
* re-read-init-file (C-x C-r): Miscellaneous Commands.
|
||
* readline: Basic Behavior.
|
||
* redraw-current-line (): Commands For Moving.
|
||
* reverse-search-history (C-r): Commands For History.
|
||
* revert-line (M-r): Miscellaneous Commands.
|
||
* rl_add_defun: Function Naming.
|
||
* rl_add_undo: Allowing Undoing.
|
||
* rl_attempted_completion_function: Completion Variables.
|
||
* rl_basic_word_break_characters: Completion Variables.
|
||
* rl_begin_undo_group: Allowing Undoing.
|
||
* rl_bind_key: Binding Keys.
|
||
* rl_bind_key_in_map: Binding Keys.
|
||
* rl_clear_message: Redisplay.
|
||
* rl_complete: How Completing Works.
|
||
* rl_complete: Completion Functions.
|
||
* rl_completer_quote_characters: Completion Variables.
|
||
* rl_completer_word_break_characters: Completion Variables.
|
||
* rl_complete_internal: Completion Functions.
|
||
* rl_completion_entry_function: Completion Variables.
|
||
* rl_completion_entry_function: How Completing Works.
|
||
* rl_completion_query_items: Completion Variables.
|
||
* rl_copy_keymap: Keymaps.
|
||
* rl_copy_text: Modifying Text.
|
||
* rl_delete_text: Modifying Text.
|
||
* rl_discard_keymap: Keymaps.
|
||
* rl_done: Function Writing.
|
||
* rl_do_undo: Allowing Undoing.
|
||
* rl_end: Function Writing.
|
||
* rl_end_undo_group: Allowing Undoing.
|
||
* rl_filename_completion_desired: Completion Variables.
|
||
* rl_filename_quoting_desired: Completion Variables.
|
||
* rl_forced_update_display: Redisplay.
|
||
* rl_function_of_keyseq: Associating Function Names and Bindings.
|
||
* rl_generic_bind: Binding Keys.
|
||
* rl_get_keymap: Keymaps.
|
||
* rl_get_keymap_by_name: Keymaps.
|
||
* rl_ignore_completion_duplicates: Completion Variables.
|
||
* rl_ignore_some_completions_function: Completion Variables.
|
||
* rl_insert_completions: Completion Functions.
|
||
* rl_insert_text: Modifying Text.
|
||
* rl_instream: Function Writing.
|
||
* rl_invoking_keyseqs: Associating Function Names and Bindings.
|
||
* rl_invoking_keyseqs_in_map: Associating Function Names and Bindings.
|
||
* rl_kill_text: Modifying Text.
|
||
* rl_line_buffer: Function Writing.
|
||
* rl_make_bare_keymap: Keymaps.
|
||
* rl_make_keymap: Keymaps.
|
||
* rl_mark: Function Writing.
|
||
* rl_message: Redisplay.
|
||
* rl_modifying: Allowing Undoing.
|
||
* rl_named_function: Associating Function Names and Bindings.
|
||
* rl_on_new_line: Redisplay.
|
||
* rl_outstream: Function Writing.
|
||
* rl_parse_and_bind: Binding Keys.
|
||
* rl_pending_input: Function Writing.
|
||
* rl_point: Function Writing.
|
||
* rl_possible_completions: Completion Functions.
|
||
* rl_prompt: Function Writing.
|
||
* rl_readline_name: Function Writing.
|
||
* rl_redisplay: Redisplay.
|
||
* rl_reset_line_state: Redisplay.
|
||
* rl_reset_terminal: Utility Functions.
|
||
* rl_set_keymap: Keymaps.
|
||
* rl_special_prefixes: Completion Variables.
|
||
* rl_startup_hook: Function Writing.
|
||
* rl_terminal_name: Function Writing.
|
||
* rl_unbind_key: Binding Keys.
|
||
* rl_unbind_key_in_map: Binding Keys.
|
||
* self-insert (a, b, A, 1, !, ...): Commands For Text.
|
||
* show-all-if-ambiguous: Readline Init Syntax.
|
||
* start-kbd-macro (C-x (): Keyboard Macros.
|
||
* tab-insert (M-TAB): Commands For Text.
|
||
* tilde-expand (M-~): Miscellaneous Commands.
|
||
* to_lower: Utility Functions.
|
||
* to_upper: Utility Functions.
|
||
* transpose-chars (C-t): Commands For Text.
|
||
* transpose-words (M-t): Commands For Text.
|
||
* undo (C-_, C-x C-u): Miscellaneous Commands.
|
||
* universal-argument (): Numeric Arguments.
|
||
* unix-line-discard (C-u): Commands For Killing.
|
||
* unix-word-rubout (C-w): Commands For Killing.
|
||
* upcase-word (M-u): Commands For Text.
|
||
* uppercase_p: Utility Functions.
|
||
* username_completion_function: Completion Functions.
|
||
* yank (C-y): Commands For Killing.
|
||
* yank-last-arg (M-., M-_): Commands For History.
|
||
* yank-nth-arg (M-C-y): Commands For History.
|
||
* yank-pop (M-y): Commands For Killing.
|
||
|
||
|