OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /or1k/tags/start/gdb-5.0/readline/examples
    from Rev 579 to Rev 1765
    ↔ Reverse comparison
  •

Rev 579 → Rev 1765

/Makefile.in
0,0 → 1,55
# This is the Makefile for the examples subdirectory of readline. -*- text -*-
#
SHELL = @MAKE_SHELL@
RM = rm -f
 
srcdir = @srcdir@
VPATH = .:@srcdir@
top_srcdir = @top_srcdir@
BUILD_DIR = .
 
DEFS = @DEFS@
CC = @CC@
CFLAGS = @CFLAGS@
LOCAL_CFLAGS = @LOCAL_CFLAGS@
CPPFLAGS = @CPPFLAGS@
 
INCLUDES = -I$(srcdir) -I$(top_srcdir) -I..
 
CCFLAGS = $(DEFS) $(LOCAL_CFLAGS) $(CPPFLAGS) $(INCLUDES) $(CFLAGS)
LDFLAGS = -g -L..
 
TERMCAP_LIB = @TERMCAP_LIB@
 
.c.o:
${RM} $@
$(CC) $(CCFLAGS) -c $<
 
EXECUTABLES = fileman rltest rl rlversion
OBJECTS = fileman.o rltest.o rl.o rlversion.o
 
all: $(EXECUTABLES)
 
rl: rl.o
$(CC) $(LDFLAGS) -o $@ rl.o -lreadline $(TERMCAP_LIB)
 
fileman: fileman.o
$(CC) $(LDFLAGS) -o $@ fileman.o -lreadline $(TERMCAP_LIB)
 
rltest: rltest.o
$(CC) $(LDFLAGS) -o $@ rltest.o -lreadline $(TERMCAP_LIB)
 
rlversion: rlversion.o
$(CC) $(LDFLAGS) -o $@ rlversion.o -lreadline $(TERMCAP_LIB)
 
clean mostlyclean:
$(RM) $(OBJECTS)
$(RM) $(EXECUTABLES)
 
distclean maintainer-clean: clean
$(RM) Makefile
 
fileman.o: fileman.c
rltest.o: rltest.c
rl.o: rl.c
rlversion.o: rlversion.c
/histexamp.c
0,0 → 1,82
main ()
{
char line[1024], *t;
int len, done = 0;
 
line[0] = 0;
 
using_history ();
while (!done)
{
printf ("history$ ");
fflush (stdout);
t = fgets (line, sizeof (line) - 1, stdin);
if (t && *t)
{
len = strlen (t);
if (t[len - 1] == '\n')
t[len - 1] = '\0';
}
 
if (!t)
strcpy (line, "quit");
 
if (line[0])
{
char *expansion;
int result;
 
using_history ();
 
result = history_expand (line, &expansion);
if (result)
fprintf (stderr, "%s\n", expansion);
 
if (result < 0 || result == 2)
{
free (expansion);
continue;
}
 
add_history (expansion);
strncpy (line, expansion, sizeof (line) - 1);
free (expansion);
}
 
if (strcmp (line, "quit") == 0)
done = 1;
else if (strcmp (line, "save") == 0)
write_history ("history_file");
else if (strcmp (line, "read") == 0)
read_history ("history_file");
else if (strcmp (line, "list") == 0)
{
register HIST_ENTRY **the_list;
register int i;
 
the_list = history_list ();
if (the_list)
for (i = 0; the_list[i]; i++)
printf ("%d: %s\n", i + history_base, the_list[i]->line);
}
else if (strncmp (line, "delete", 6) == 0)
{
int which;
if ((sscanf (line + 6, "%d", &which)) == 1)
{
HIST_ENTRY *entry = remove_history (which);
if (!entry)
fprintf (stderr, "No such entry %d\n", which);
else
{
free (entry->line);
free (entry);
}
}
else
{
fprintf (stderr, "non-numeric arg given to `delete'\n");
}
}
}
}
/Inputrc
0,0 → 1,65
# My ~/.inputrc file is in -*- text -*- for easy editing with Emacs.
#
# Notice the various bindings which are conditionalized depending
# on which program is running, or what terminal is active.
#
 
# In all programs, all terminals, make sure this is bound.
"\C-x\C-r": re-read-init-file
 
# Hp terminals (and some others) have ugly default behaviour for C-h.
"\C-h": backward-delete-char
"\e\C-h": backward-kill-word
"\C-xd": dump-functions
 
# In xterm windows, make the arrow keys do the right thing.
$if TERM=xterm
"\e[A": previous-history
"\e[B": next-history
"\e[C": forward-char
"\e[D": backward-char
 
# alternate arrow key prefix
"\eOA": previous-history
"\eOB": next-history
"\eOC": forward-char
"\eOD": backward-char
 
# Under Xterm in Bash, we bind local Function keys to do something useful.
$if Bash
"\e[11~": "Function Key 1"
"\e[12~": "Function Key 2"
"\e[13~": "Function Key 3"
"\e[14~": "Function Key 4"
"\e[15~": "Function Key 5"
 
# I know the following escape sequence numbers are 1 greater than
# the function key. Don't ask me why, I didn't design the xterm terminal.
"\e[17~": "Function Key 6"
"\e[18~": "Function Key 7"
"\e[19~": "Function Key 8"
"\e[20~": "Function Key 9"
"\e[21~": "Function Key 10"
$endif
$endif
 
# For Bash, all terminals, add some Bash specific hacks.
$if Bash
"\C-xv": show-bash-version
"\C-x\C-e": shell-expand-line
 
# Here is one for editing my path.
"\C-xp": "$PATH\C-x\C-e\C-e\"\C-aPATH=\":\C-b"
 
# Make C-x r read my mail in emacs.
# "\C-xr": "emacs -f rmail\C-j"
$endif
 
# For FTP, different hacks:
$if Ftp
"\C-xg": "get \M-?"
"\C-xt": "put \M-?"
"\M-.": yank-last-arg
$endif
 
" ": self-insert
/rlversion.c
0,0 → 1,21
/*
* rlversion -- print out readline's version number
*/
 
#define READLINE_LIBRARY
 
#if defined (HAVE_CONFIG_H)
# include <config.h>
#endif
 
#include <stdio.h>
#include <sys/types.h>
#include "posixstat.h"
 
#include "readline.h"
 
main()
{
printf ("%s\n", rl_library_version ? rl_library_version : "unknown");
exit (0);
}
/manexamp.c
0,0 → 1,94
/* manexamp.c -- The examples which appear in the documentation are here. */
 
#include <stdio.h>
#include <readline/readline.h>
 
 
/* **************************************************************** */
/* */
* How to Emulate gets () */
/* */
/* **************************************************************** */
 
/* A static variable for holding the line. */
static char *line_read = (char *)NULL;
 
/* Read a string, and return a pointer to it. Returns NULL on EOF. */
char *
rl_gets ()
{
/* If the buffer has already been allocated, return the memory
to the free pool. */
if (line_read)
{
free (line_read);
line_read = (char *)NULL;
}
 
/* Get a line from the user. */
line_read = readline ("");
 
/* If the line has any text in it, save it on the history. */
if (line_read && *line_read)
add_history (line_read);
 
return (line_read);
}
 
/* **************************************************************** */
/* */
/* Writing a Function to be Called by Readline. */
/* */
/* **************************************************************** */
 
/* Invert the case of the COUNT following characters. */
invert_case_line (count, key)
int count, key;
{
register int start, end;
 
start = rl_point;
 
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 = -1;
 
if (start > end)
{
int temp = start;
start = end;
end = temp;
}
 
if (start == end)
return;
 
/* Tell readline that we are modifying the line, so save the undo
information. */
rl_modifying (start, end);
 
for (; start != end; start += direction)
{
if (uppercase_p (rl_line_buffer[start]))
rl_line_buffer[start] = to_lower (rl_line_buffer[start]);
else if (lowercase_p (rl_line_buffer[start]))
rl_line_buffer[start] = to_upper (rl_line_buffer[start]);
}
 
/* Move point to on top of the last character changed. */
rl_point = end - direction;
}
 
/fileman.c
0,0 → 1,450
/* 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. */
/*
* Remove the next line if you're compiling this against an installed
* libreadline.a
*/
#define READLINE_LIBRARY
 
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
 
#include <sys/types.h>
#ifdef HAVE_SYS_FILE_H
#include <sys/file.h>
#endif
#include <sys/stat.h>
 
#include <stdio.h>
#include <errno.h>
 
#if defined (HAVE_STRING_H)
# include <string.h>
#else /* !HAVE_STRING_H */
# include <strings.h>
#endif /* !HAVE_STRING_H */
 
#ifdef READLINE_LIBRARY
# include "readline.h"
# include "history.h"
#else
# include <readline/readline.h>
# include <readline/history.h>
#endif
 
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)
char *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 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. 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);
}
/rl.c
0,0 → 1,118
/*
* rl - command-line interface to read a line from the standard input
* (or another fd) using readline.
*
* usage: rl [-p prompt] [-u unit] [-d default]
*/
 
/*
* Remove the next line if you're compiling this against an installed
* libreadline.a
*/
#define READLINE_LIBRARY
 
#if defined (HAVE_CONFIG_H)
# include <config.h>
#endif
 
#include <stdio.h>
#include <sys/types.h>
#include "posixstat.h"
#include "readline.h"
#include "history.h"
 
extern int optind;
extern char *optarg;
 
#if !defined (strchr) && !defined (__STDC__)
extern char *strrchr();
#endif
 
static char *progname;
static char *deftext;
 
static int
set_deftext ()
{
if (deftext)
{
rl_insert_text (deftext);
deftext = (char *)NULL;
rl_startup_hook = (Function *)NULL;
}
}
 
static void
usage()
{
fprintf (stderr, "%s: usage: %s [-p prompt] [-u unit] [-d default]\n",
progname, progname);
}
 
main (argc, argv)
int argc;
char **argv;
{
char *temp, *prompt;
struct stat sb;
int opt, fd;
FILE *ifp;
 
progname = strrchr(argv[0], '/');
if (progname == 0)
progname = argv[0];
else
progname++;
 
/* defaults */
prompt = "readline$ ";
fd = 0;
deftext = (char *)0;
 
while ((opt = getopt(argc, argv, "p:u:d:")) != EOF)
{
switch (opt)
{
case 'p':
prompt = optarg;
break;
case 'u':
fd = atoi(optarg);
if (fd < 0)
{
fprintf (stderr, "%s: bad file descriptor `%s'\n", progname, optarg);
exit (2);
}
break;
case 'd':
deftext = optarg;
break;
default:
usage ();
exit (2);
}
}
 
if (fd != 0)
{
if (fstat (fd, &sb) < 0)
{
fprintf (stderr, "%s: %d: bad file descriptor\n", progname, fd);
exit (1);
}
ifp = fdopen (fd, "r");
rl_instream = ifp;
}
 
if (deftext && *deftext)
rl_startup_hook = set_deftext;
 
temp = readline (prompt);
 
/* Test for EOF. */
if (temp == 0)
exit (1);
 
puts (temp);
exit (0);
}
/rltest.c
0,0 → 1,67
/* **************************************************************** */
/* */
/* Testing Readline */
/* */
/* **************************************************************** */
 
/*
* Remove the next line if you're compiling this against an installed
* libreadline.a
*/
#define READLINE_LIBRARY
 
#if defined (HAVE_CONFIG_H)
#include <config.h>
#endif
 
#include <stdio.h>
#include <sys/types.h>
#include "readline.h"
#include "history.h"
 
extern HIST_ENTRY **history_list ();
 
main ()
{
char *temp, *prompt;
int done;
 
temp = (char *)NULL;
prompt = "readline$ ";
done = 0;
 
while (!done)
{
temp = readline (prompt);
 
/* Test for EOF. */
if (!temp)
exit (1);
 
/* If there is anything on the line, print it and remember it. */
if (*temp)
{
fprintf (stderr, "%s\r\n", temp);
add_history (temp);
}
 
/* Check for `command' that we handle. */
if (strcmp (temp, "quit") == 0)
done = 1;
 
if (strcmp (temp, "list") == 0)
{
HIST_ENTRY **list;
register int i;
 
list = history_list ();
if (list)
{
for (i = 0; list[i]; i++)
fprintf (stderr, "%d: %s\r\n", i, list[i]->line);
}
}
free (temp);
}
exit (0);
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.