static char *readline_line_completion_function (char *, int);
-/* NOTE 1999-04-29: this function will be static again, after we make the
- event loop be the default command loop for gdb, and we merge
- event-top.c into this file, top.c */
-/* static */ void command_loop_marker (void *);
-
static void while_command (char *, int);
static void if_command (char *, int);
The function receives two args: an input stream,
and a prompt string. */
-void (*window_hook) PARAMS ((FILE *, char *));
+void (*window_hook) (FILE *, char *);
int epoch_interface;
int xgdb_verbose;
/* Called after most modules have been initialized, but before taking users
command file. */
-void (*init_ui_hook) PARAMS ((char *argv0));
+void (*init_ui_hook) (char *argv0);
/* This hook is called from within gdb's many mini-event loops which could
steal control from a real user interface's event loop. It returns
non-zero if the user is requesting a detach, zero otherwise. */
-int (*ui_loop_hook) PARAMS ((int));
+int (*ui_loop_hook) (int);
/* Called instead of command_loop at top level. Can be invoked via
return_to_top_level. */
-void (*command_loop_hook) PARAMS ((void));
+void (*command_loop_hook) (void);
/* Called from print_frame_info to list the line we stopped in. */
-void (*print_frame_info_listing_hook) PARAMS ((struct symtab * s, int line,
- int stopline, int noerror));
+void (*print_frame_info_listing_hook) (struct symtab * s, int line,
+ int stopline, int noerror);
/* Replaces most of query. */
-int (*query_hook) PARAMS ((const char *, va_list));
+int (*query_hook) (const char *, va_list);
/* Replaces most of warning. */
-void (*warning_hook) PARAMS ((const char *, va_list));
+void (*warning_hook) (const char *, va_list);
/* These three functions support getting lines of text from the user. They
are used in sequence. First readline_begin_hook is called with a text
to notify the GUI that we are done with the interaction window and it
can close it. */
-void (*readline_begin_hook) PARAMS ((char *,...));
-char *(*readline_hook) PARAMS ((char *));
-void (*readline_end_hook) PARAMS ((void));
+void (*readline_begin_hook) (char *, ...);
+char *(*readline_hook) (char *);
+void (*readline_end_hook) (void);
/* Called as appropriate to notify the interface of the specified breakpoint
conditions. */
-void (*create_breakpoint_hook) PARAMS ((struct breakpoint * bpt));
-void (*delete_breakpoint_hook) PARAMS ((struct breakpoint * bpt));
-void (*modify_breakpoint_hook) PARAMS ((struct breakpoint * bpt));
+void (*create_breakpoint_hook) (struct breakpoint * bpt);
+void (*delete_breakpoint_hook) (struct breakpoint * bpt);
+void (*modify_breakpoint_hook) (struct breakpoint * bpt);
/* Called as appropriate to notify the interface that we have attached
to or detached from an already running process. */
-void (*attach_hook) PARAMS ((void));
-void (*detach_hook) PARAMS ((void));
+void (*attach_hook) (void);
+void (*detach_hook) (void);
/* Called during long calculations to allow GUI to repair window damage, and to
check for stop buttons, etc... */
-void (*interactive_hook) PARAMS ((void));
+void (*interactive_hook) (void);
/* Called when the registers have changed, as a hint to a GUI
to minimize window update. */
-void (*registers_changed_hook) PARAMS ((void));
+void (*registers_changed_hook) (void);
/* Tell the GUI someone changed the register REGNO. -1 means
that the caller does not know which register changed or
that several registers have changed (see value_assign). */
-void (*register_changed_hook) PARAMS ((int regno));
+void (*register_changed_hook) (int regno);
/* Tell the GUI someone changed LEN bytes of memory at ADDR */
-void (*memory_changed_hook) PARAMS ((CORE_ADDR addr, int len));
+void (*memory_changed_hook) (CORE_ADDR addr, int len);
/* Called when going to wait for the target. Usually allows the GUI to run
while waiting for target events. */
-int (*target_wait_hook) PARAMS ((int pid, struct target_waitstatus * status));
+int (*target_wait_hook) (int pid, struct target_waitstatus * status);
/* Used by UI as a wrapper around command execution. May do various things
like enabling/disabling buttons, etc... */
-void (*call_command_hook) PARAMS ((struct cmd_list_element * c, char *cmd,
- int from_tty));
+void (*call_command_hook) (struct cmd_list_element * c, char *cmd,
+ int from_tty);
/* Called after a `set' command has finished. Is only run if the
`set' command succeeded. */
/* Called when the current thread changes. Argument is thread id. */
-void (*context_hook) PARAMS ((int id));
+void (*context_hook) (int id);
/* Takes control from error (). Typically used to prevent longjmps out of the
middle of the GUI. Usually used in conjunction with a catch routine. */
/* Return for reason REASON to the nearest containing catch_errors(). */
NORETURN void
-return_to_top_level (reason)
- enum return_reason reason;
+return_to_top_level (enum return_reason reason)
{
quit_flag = 0;
immediate_quit = 0;
code also randomly used a SET_TOP_LEVEL macro that directly
initialize the longjmp buffers. */
-/* MAYBE: cagney/1999-11-05: Should the catch_erros and cleanups code
+/* MAYBE: cagney/1999-11-05: Should the catch_errors and cleanups code
be consolidated into a single file instead of being distributed
between utils.c and top.c? */
int
-catch_errors (func, args, errstring, mask)
- catch_errors_ftype *func;
- PTR args;
- char *errstring;
- return_mask mask;
+catch_errors (catch_errors_ftype *func, PTR args, char *errstring,
+ return_mask mask)
{
SIGJMP_BUF *saved_catch;
SIGJMP_BUF catch;
val = (*func) (args);
catch_return = saved_catch;
- /* FIXME: cagney/1999-11-05: A correct FUNC implementaton will
+ /* FIXME: cagney/1999-11-05: A correct FUNC implementation will
clean things up (restoring the cleanup chain) to the state they
- were just prior to the call. Unfortunatly, many FUNC's are not
+ were just prior to the call. Unfortunately, many FUNC's are not
that well behaved. This could be fixed by adding either a
do_cleanups call (to cover the problem) or an assertion check to
detect bad FUNCs code. */
/* FIXME: cagney/1999-11-07: Technically this do_cleanups() call
isn't needed. Instead an assertion check could be made that
simply confirmed that the called function correctly cleaned up
- after its self. Unfortunatly, old code (prior to 1999-11-04) in
+ after itself. Unfortunately, old code (prior to 1999-11-04) in
main.c was calling SET_TOP_LEVEL(), calling the command function,
and then *always* calling do_cleanups(). For the moment we
remain ``bug compatible'' with that old code.. */
#ifdef SIGHUP
static void
-disconnect (signo)
- int signo;
+disconnect (int signo)
{
catch_errors (quit_cover, NULL,
"Could not kill the program being debugged", RETURN_MASK_ALL);
gdb to use the event loop as the default command loop and we merge
event-top.c into this file, top.c */
/* static */ int
-quit_cover (s)
- PTR s;
+quit_cover (PTR s)
{
caution = 0; /* Throw caution to the wind -- we're exiting.
This prevents asking the user dumb questions. */
/* Read commands from STREAM. */
void
-read_command_file (stream)
- FILE *stream;
+read_command_file (FILE *stream)
{
struct cleanup *cleanups;
\f
extern void init_proc (void);
-void (*pre_init_ui_hook) PARAMS ((void));
+void (*pre_init_ui_hook) (void);
#ifdef __MSDOS__
void
#endif
void
-gdb_init (argv0)
- char *argv0;
+gdb_init (char *argv0)
{
if (pre_init_ui_hook)
pre_init_ui_hook ();
control commands (if/while). */
static struct command_line *
-build_command_line (type, args)
- enum command_control_type type;
- char *args;
+build_command_line (enum command_control_type type, char *args)
{
struct command_line *cmd;
such as "if" and "while". */
static struct command_line *
-get_command_line (type, arg)
- enum command_control_type type;
- char *arg;
+get_command_line (enum command_control_type type, char *arg)
{
struct command_line *cmd;
struct cleanup *old_chain = NULL;
/* Recursively print a command (including full control structures). */
#ifdef UI_OUT
void
-print_command_lines (uiout, cmd, depth)
- struct ui_out *uiout;
- struct command_line *cmd;
- unsigned int depth;
+print_command_lines (struct ui_out *uiout, struct command_line *cmd,
+ unsigned int depth)
{
struct command_line *list;
}
#else
void
-print_command_line (cmd, depth, stream)
- struct command_line *cmd;
- unsigned int depth;
- struct ui_file *stream;
+print_command_line (struct command_line *cmd, unsigned int depth,
+ struct ui_file *stream)
{
unsigned int i;
/* Execute the command in CMD. */
enum command_control_type
-execute_control_command (cmd)
- struct command_line *cmd;
+execute_control_command (struct command_line *cmd)
{
struct expression *expr;
struct command_line *current;
loop condition is nonzero. */
static void
-while_command (arg, from_tty)
- char *arg;
- int from_tty;
+while_command (char *arg, int from_tty)
{
struct command_line *command = NULL;
on the value of the if conditional. */
static void
-if_command (arg, from_tty)
- char *arg;
- int from_tty;
+if_command (char *arg, int from_tty)
{
struct command_line *command = NULL;
$arg0, $arg1 ... $argMAXUSERARGS. */
static struct cleanup *
-setup_user_args (p)
- char *p;
+setup_user_args (char *p)
{
struct user_args *args;
struct cleanup *old_chain;
or NULL if P contains no arguments. */
static char *
-locate_arg (p)
- char *p;
+locate_arg (char *p)
{
while ((p = strchr (p, '$')))
{
arguments found in line, with the updated copy being placed into nline. */
static char *
-insert_args (line)
- char *line;
+insert_args (char *line)
{
char *p, *save_line, *new_line;
unsigned len, i;
}
void
-execute_user_command (c, args)
- struct cmd_list_element *c;
- char *args;
+execute_user_command (struct cmd_list_element *c, char *args)
{
register struct command_line *cmdlines;
struct cleanup *old_chain;
Pass FROM_TTY as second argument to the defining function. */
void
-execute_command (p, from_tty)
- char *p;
- int from_tty;
+execute_command (char *p, int from_tty)
{
register struct cmd_list_element *c;
register enum language flang;
}
}
-/* ARGSUSED */
-/* NOTE 1999-04-29: This function will be static again, once we modify
- gdb to use the event loop as the default command loop and we merge
- event-top.c into this file, top.c */
-/* static */ void
-command_loop_marker (void *foo)
-{
-}
-
/* Read commands from `instream' and execute them
until end of file or error reading instream. */
void
-command_loop ()
+command_loop (void)
{
struct cleanup *old_chain;
char *command;
quit_flag = 0;
if (instream == stdin && stdin_is_tty)
reinitialize_more_filter ();
- old_chain = make_cleanup (command_loop_marker, 0);
+ old_chain = make_cleanup (null_cleanup, 0);
#if defined(TUI)
/* A bit of paranoia: I want to make sure the "insert_mode" global
quit_flag = 0;
if (instream == stdin && stdin_is_tty)
reinitialize_more_filter ();
- old_chain = make_cleanup (command_loop_marker, 0);
+ old_chain = make_cleanup (null_cleanup, 0);
/* Get a command-line. */
command = (*read_input_func) (instream == stdin ?
/* Commands call this if they do not want to be repeated by null lines. */
void
-dont_repeat ()
+dont_repeat (void)
{
if (server_command)
return;
A NULL return means end of file. */
char *
-gdb_readline (prompt_arg)
- char *prompt_arg;
+gdb_readline (char *prompt_arg)
{
int c;
char *result;
but don't want to complete on anything else either. */
/* ARGSUSED */
char **
-noop_completer (text, prefix)
- char *text;
- char *prefix;
+noop_completer (char *text, char *prefix)
{
return NULL;
}
/* Complete on filenames. */
char **
-filename_completer (text, word)
- char *text;
- char *word;
+filename_completer (char *text, char *word)
{
/* From readline. */
extern char *filename_completion_function (char *, int);
free the string. */
static char *
-line_completion_function (text, matches, line_buffer, point)
- char *text;
- int matches;
- char *line_buffer;
- int point;
+line_completion_function (char *text, int matches, char *line_buffer, int point)
{
static char **list = (char **) NULL; /* Cache of completions */
static int index; /* Next cached completion */
/* Line completion interface function for readline. */
static char *
-readline_line_completion_function (text, matches)
- char *text;
- int matches;
+readline_line_completion_function (char *text, int matches)
{
return line_completion_function (text, matches, rl_line_buffer, rl_point);
}
location after the "word". */
char *
-skip_quoted (str)
- char *str;
+skip_quoted (char *str)
{
char quote_char = '\0';
char *scan;
#ifdef STOP_SIGNAL
static void
-stop_sig (signo)
- int signo;
+stop_sig (int signo)
{
#if STOP_SIGNAL == SIGTSTP
signal (SIGTSTP, SIG_DFL);
/* Initialize signal handlers. */
static void
-do_nothing (signo)
- int signo;
+do_nothing (int signo)
{
/* Under System V the default disposition of a signal is reinstated after
the signal is caught and delivered to an application process. On such
}
static void
-init_signals ()
+init_signals (void)
{
signal (SIGINT, request_quit);
simple input as the user has requested. */
char *
-command_line_input (prompt_arg, repeat, annotation_suffix)
- char *prompt_arg;
- int repeat;
- char *annotation_suffix;
+command_line_input (char *prompt_arg, int repeat, char *annotation_suffix)
{
static char *linebuffer = 0;
static unsigned linelength = 0;
clause for an "if" command. */
static void
-realloc_body_list (command, new_length)
- struct command_line *command;
- int new_length;
+realloc_body_list (struct command_line *command, int new_length)
{
int n;
struct command_line **body_list;
"end", return such an indication to the caller. */
static enum misc_command_type
-read_next_line (command)
- struct command_line **command;
+read_next_line (struct command_line **command)
{
char *p, *p1, *prompt_ptr, control_prompt[256];
int i = 0;
following commands are nested. */
static enum command_control_type
-recurse_read_control_structure (current_cmd)
- struct command_line *current_cmd;
+recurse_read_control_structure (struct command_line *current_cmd)
{
int current_body, i;
enum misc_command_type val;
#define END_MESSAGE "End with a line saying just \"end\"."
struct command_line *
-read_command_lines (prompt_arg, from_tty)
- char *prompt_arg;
- int from_tty;
+read_command_lines (char *prompt_arg, int from_tty)
{
struct command_line *head, *tail, *next;
struct cleanup *old_chain;
/* Free a chain of struct command_line's. */
void
-free_command_lines (lptr)
- struct command_line **lptr;
+free_command_lines (struct command_line **lptr)
{
register struct command_line *l = *lptr;
register struct command_line *next;
struct cmd_list_element *
add_info (name, fun, doc)
char *name;
- void (*fun) PARAMS ((char *, int));
+ void (*fun) (char *, int);
char *doc;
{
return add_cmd (name, no_class, fun, doc, &infolist);
/* Add an alias to the list of info subcommands. */
struct cmd_list_element *
-add_info_alias (name, oldname, abbrev_flag)
- char *name;
- char *oldname;
- int abbrev_flag;
+add_info_alias (char *name, char *oldname, int abbrev_flag)
{
return add_alias_cmd (name, oldname, 0, abbrev_flag, &infolist);
}
/* ARGSUSED */
static void
-info_command (arg, from_tty)
- char *arg;
- int from_tty;
+info_command (char *arg, int from_tty)
{
printf_unfiltered ("\"info\" must be followed by the name of an info command.\n");
help_list (infolist, "info ", -1, gdb_stdout);
/* ARGSUSED */
static void
-complete_command (arg, from_tty)
- char *arg;
- int from_tty;
+complete_command (char *arg, int from_tty)
{
int i;
int argpoint;
/* ARGSUSED */
static void
-show_command (arg, from_tty)
- char *arg;
- int from_tty;
+show_command (char *arg, int from_tty)
{
cmd_show_list (showlist, from_tty, "");
}
add_com (name, class, fun, doc)
char *name;
enum command_class class;
- void (*fun) PARAMS ((char *, int));
+ void (*fun) (char *, int);
char *doc;
{
return add_cmd (name, class, fun, doc, &cmdlist);
/* Add an alias or abbreviation command to the list of commands. */
struct cmd_list_element *
-add_com_alias (name, oldname, class, abbrev_flag)
- char *name;
- char *oldname;
- enum command_class class;
- int abbrev_flag;
+add_com_alias (char *name, char *oldname, enum command_class class,
+ int abbrev_flag)
{
return add_alias_cmd (name, oldname, class, abbrev_flag, &cmdlist);
}
void
-error_no_arg (why)
- char *why;
+error_no_arg (char *why)
{
error ("Argument required (%s).", why);
}
}
\f
static void
-validate_comname (comname)
- char *comname;
+validate_comname (char *comname)
{
register char *p;
/* This is just a placeholder in the command data structures. */
static void
-user_defined_command (ignore, from_tty)
- char *ignore;
- int from_tty;
+user_defined_command (char *ignore, int from_tty)
{
}
static void
-define_command (comname, from_tty)
- char *comname;
- int from_tty;
+define_command (char *comname, int from_tty)
{
register struct command_line *cmds;
register struct cmd_list_element *c, *newc, *hookc = 0;
}
static void
-document_command (comname, from_tty)
- char *comname;
- int from_tty;
+document_command (char *comname, int from_tty)
{
struct command_line *doclines;
register struct cmd_list_element *c;
\f
/* Print the GDB banner. */
void
-print_gdb_version (stream)
- struct ui_file *stream;
+print_gdb_version (struct ui_file *stream)
{
/* From GNU coding standards, first line is meant to be easy for a
program to parse, and is just canonical program name and version
/* ARGSUSED */
static void
-show_version (args, from_tty)
- char *args;
- int from_tty;
+show_version (char *args, int from_tty)
{
immediate_quit++;
print_gdb_version (gdb_stdout);
static int gdb_prompt_escape;
static int
-get_prompt_1 (formatted_prompt)
- char *formatted_prompt;
+get_prompt_1 (void *data)
{
+ char *formatted_prompt = data;
char *local_prompt;
if (event_loop_p)
}
char *
-get_prompt ()
+get_prompt (void)
{
static char buf[MAX_PROMPT_SIZE];
}
void
-set_prompt (s)
- char *s;
+set_prompt (char *s)
{
/* ??rehrauer: I don't know why this fails, since it looks as though
assignments to prompt are wrapped in calls to savestring...
non-zero if we should quit, zero if we shouldn't. */
int
-quit_confirm ()
+quit_confirm (void)
{
if (inferior_pid != 0 && target_has_execution)
{
/* Quit without asking for confirmation. */
void
-quit_force (args, from_tty)
- char *args;
- int from_tty;
+quit_force (char *args, int from_tty)
{
int exit_code = 0;
/* Handle the quit command. */
void
-quit_command (args, from_tty)
- char *args;
- int from_tty;
+quit_command (char *args, int from_tty)
{
if (!quit_confirm ())
error ("Not confirmed.");
desires that questions be asked of them on that terminal. */
int
-input_from_terminal_p ()
+input_from_terminal_p (void)
{
return gdb_has_a_terminal () && (instream == stdin) & caution;
}
\f
/* ARGSUSED */
static void
-pwd_command (args, from_tty)
- char *args;
- int from_tty;
+pwd_command (char *args, int from_tty)
{
if (args)
error ("The \"pwd\" command does not take an argument: %s", args);
}
void
-cd_command (dir, from_tty)
- char *dir;
- int from_tty;
+cd_command (char *dir, int from_tty)
{
int len;
/* Found something other than leading repetitions of "/..". */
};
static void
-source_cleanup_lines (args)
- PTR args;
+source_cleanup_lines (PTR args)
{
struct source_cleanup_lines_args *p =
(struct source_cleanup_lines_args *) args;
}
void
-source_command (args, from_tty)
- char *args;
- int from_tty;
+source_command (char *args, int from_tty)
{
FILE *stream;
struct cleanup *old_cleanups;
/* ARGSUSED */
static void
-echo_command (text, from_tty)
- char *text;
- int from_tty;
+echo_command (char *text, int from_tty)
{
char *p = text;
register int c;
/* ARGSUSED */
static void
-dont_repeat_command (ignored, from_tty)
- char *ignored;
- int from_tty;
+dont_repeat_command (char *ignored, int from_tty)
{
*line = 0; /* Can't call dont_repeat here because we're not
necessarily reading from stdin. */
/* Number of commands to print in each call to show_commands. */
#define Hist_print 10
static void
-show_commands (args, from_tty)
- char *args;
- int from_tty;
+show_commands (char *args, int from_tty)
{
/* Index for history commands. Relative to history_base. */
int offset;
/* Called by do_setshow_command. */
/* ARGSUSED */
static void
-set_history_size_command (args, from_tty, c)
- char *args;
- int from_tty;
- struct cmd_list_element *c;
+set_history_size_command (char *args, int from_tty, struct cmd_list_element *c)
{
if (history_size == INT_MAX)
unstifle_history ();
/* ARGSUSED */
static void
-set_history (args, from_tty)
- char *args;
- int from_tty;
+set_history (char *args, int from_tty)
{
printf_unfiltered ("\"set history\" must be followed by the name of a history subcommand.\n");
help_list (sethistlist, "set history ", -1, gdb_stdout);
/* ARGSUSED */
static void
-show_history (args, from_tty)
- char *args;
- int from_tty;
+show_history (char *args, int from_tty)
{
cmd_show_list (showhistlist, from_tty, "");
}
/* Called by do_setshow_command. An elaborate joke. */
/* ARGSUSED */
static void
-set_verbose (args, from_tty, c)
- char *args;
- int from_tty;
- struct cmd_list_element *c;
+set_verbose (char *args, int from_tty, struct cmd_list_element *c)
{
char *cmdname = "verbose";
struct cmd_list_element *showcmd;
}
static void
-float_handler (signo)
- int signo;
+float_handler (int signo)
{
/* This message is based on ANSI C, section 4.7. Note that integer
divide by zero causes this, so "float" is a misnomer. */
}
static void
-set_debug (arg, from_tty)
- char *arg;
- int from_tty;
+set_debug (char *arg, int from_tty)
{
printf_unfiltered ("\"set debug\" must be followed by the name of a print subcommand.\n");
help_list (setdebuglist, "set debug ", -1, gdb_stdout);
}
static void
-show_debug (args, from_tty)
- char *args;
- int from_tty;
+show_debug (char *args, int from_tty)
{
cmd_show_list (showdebuglist, from_tty, "");
}
static void
-init_cmd_lists ()
+init_cmd_lists (void)
{
cmdlist = NULL;
infolist = NULL;
*/
void
-init_history ()
+init_history (void)
{
char *tmpenv;
}
static void
-init_main ()
+init_main (void)
{
struct cmd_list_element *c;
projects / deliverable / binutils-gdb.git / blobdiff