Hi,
I am new to using readline library to my application. Please I want to no how to write code for command line switches(options), i.e when i press tab the option of command as to change.
eg:
ls -a
ls -d
...so on ls as many options, here i want options to be completed using tab
Please any one could help on this really appreciated.
Thank you
Do you want to setup auto-completion of options?
I think you've got something mixed up here.
readline is used if you want your application to present interactive input including line editing and history.
getopt from the GNU libc is used to parse command line options.
Command line completion as you describe it is provided by the shell, not the application. It's provided by the bash completion package for bash, and zsh is already shipped with that feature. These extensions are configured using shell commands and scripts.
Hi,
actually for command line auto completion i knew that using shell.....but we see interactive command line args completion can done by tab key using gnu readline library...up to this i knew but here i want command line switches completion using tab
---------- Post updated at 11:45 PM ---------- Previous update was at 11:29 PM ----------
here wht I want is:
Just type your command, a dash (-) and type tab. The shell will show you available switches.
For example, try:
root@ubuntu:~# ls -
and press tab - Surprise!
-a -c -b -d
-A -author -B -f .... so on options that available with ls command.
mhmm, if you are using Bash you could achieve this by using only Bash's built-in `complete' and a couple of other commands. Or as suggested by pludi you could have a look at the bash autocompletion package or I could post my own function which does the same job and which I have written a few years ago. Below is just an example of how it works:
sidorenko@sidorenko>
0 ~>autocomplete_options ls
sidorenko@sidorenko>
0 ~>ls - pressing tab
-1 -l
-a -L
-A -m
--author -n
-b -N
-B -o
--block-size= -p
-c -q
-C -Q
--color --quoting-style=
--color= -r
-d -R
-D -s
--dereference-command-line-symlink-to-dir -S
-f --show-control-chars
-F --si
--file-type --sort=
--format= -t
--full-time -T
-g
Though when I was reading the help for the `complete' built-in, I came across the following line:
I don't know what is meant here with Readline - maybe some C library or whatever. Do you mean this Readline?
---------- Post updated at 02:02 AM ---------- Previous update was at 01:53 AM ----------
On Linux I've indeed found such a function:
SYNOPSIS
#include <stdio.h>
#include <readline/readline.h>
#include <readline/history.h>
char *
readline (const char *prompt);
Hi,
Thank you so much for a usefull solution. Exactly this is what iam looking for but this is here for bash right? so now i want it using readline. Yes the same readline what i mean...which linux gnu readline library. Please can u post the function you have with you.which does same above action..which may help out from this issue.
Thanks again
---------- Post updated at 05:00 AM ---------- Previous update was at 04:52 AM ----------
And also you said you ahve your own fuction which is written few years back...........please could you provide me that fuction so that it may help me.
Again, the completion suggestions are done by the shell, not the application. Your application isn't even loaded at that point, and thus has no way of telling the shell what options are available. The readline library would only be of interest if you want that functionality inside your application (like GDB when used interactive), and even then you'd have to extend the functionality yourself.
Yeah exactly iam trying to develop for an application same like GDB. So if you can say how the gdb works with source code then that could may help me out. Here for my application i want to develop similar as what GDB does but doing using GNU Readline line(Linux). I am not understanding whether I can do it using GNU readline or not.
---------- Post updated at 05:56 AM ---------- Previous update was at 05:53 AM ----------
Yeah exactly iam trying to develop for an application same like GDB. So if you can say how the gdb works with source code then that could may help me out. Here for my application i want to develop similar as what GDB does but doing using GNU Readline line(Linux). I am not understanding whether I can do it using GNU readline or not.
So you want to develop a debugger? Or just add readline capability to GDB? For the later, take a look at how rlwrap does things, and try to build on top of that.
Actually here I post my code till where I have achieved command line completion,history.
/* 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>
#define ARRAY_SIZE 4
extern char *xmalloc ();
/* The names of functions that actually do the manipulation. */
int com_list __P((char *));
int com_view __P((char *));
int com_rename __P((char *));
int com_stat __P((char *));
int com_pwd __P((char *));
int com_delete __P((char *));
int com_help __P((char *));
int com_cd __P((char *));
int com_quit __P((char *));
/* A structure which contains information on the commands this program
can understand. */
typedef struct {
char *name; /* User printable name of the function. */
rl_icpfunc_t *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, (rl_icpfunc_t *)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 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 && whitespace (line))
i++;
word = line + i;
while (line && !whitespace (line))
i++;
if (line)
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++;
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.name; i++)
if (strcmp (name, commands.name) == 0)
return (&commands);
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 __P((const char *, int));
char **fileman_completion __P((const char *, int, int));
/* 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";
rl_attempted_completion_function = fileman_completion;
}
/* Attempt to complete on the contents of TEXT. START and END
bound the region of rl_line_buffer that contains the word to
complete. TEXT is the word to complete. We can use the entire
contents of rl_line_buffer in case we want to do some simple
parsing. Returnthe array of matches, or NULL if there aren't any. */
char **
fileman_completion (text, start, end)
const 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 = rl_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)
const 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.name; i++)
{
if (!*arg || (strcmp (arg, commands.name) == 0))
{
printf ("%s\t\t%s.\n", commands.name, commands.doc);
printed++;
}
}
if (!printed)
{
printf ("No commands match `%s'. Possibilties are:\n", arg);
for (i = 0; commands.name; i++)
{
/* Print in six columns. */
if (printed == 6)
{
printed = 0;
printf ("\n");
}
printf ("%s\t", commands.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 = getcwd (dir, sizeof(dir) - 1);
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.\n", caller);
fprintf (stderr, "Write it yourself.\n");
}
/* 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);
}
To which i need to add above said command line option completion: