1 /* Top level stuff for GDB, the GNU debugger.
3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
4 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
26 #include "call-cmds.h"
27 #include "cli/cli-cmds.h"
28 #include "cli/cli-script.h"
29 #include "cli/cli-setshow.h"
30 #include "cli/cli-decode.h"
35 #include "breakpoint.h"
37 #include "expression.h"
40 #include "terminal.h" /* For job_control. */
42 #include "completer.h"
47 #include "gdb_assert.h"
49 /* readline include files */
50 #include "readline/readline.h"
51 #include "readline/history.h"
53 /* readline defines this. */
56 #include <sys/types.h>
60 #include "event-top.h"
61 #include "gdb_string.h"
67 /* Default command line prompt. This is overriden in some configs. */
69 #ifndef DEFAULT_PROMPT
70 #define DEFAULT_PROMPT "(gdb) "
73 /* Initialization file name for gdb. This is overridden in some configs. */
75 #ifndef GDBINIT_FILENAME
76 #define GDBINIT_FILENAME ".gdbinit"
78 char gdbinit
[] = GDBINIT_FILENAME
;
80 int inhibit_gdbinit
= 0;
82 /* If nonzero, and GDB has been configured to be able to use windows,
83 attempt to open them upon startup. */
87 extern char lang_frame_mismatch_warn
[]; /* language.c */
89 /* Flag for whether we want all the "from_tty" gubbish printed. */
91 int caution
= 1; /* Default is yes, sigh. */
93 /* stdio stream that command input is being read from. Set to stdin normally.
94 Set by source_command to the file we are sourcing. Set to NULL if we are
95 executing a user-defined command or interacting via a GUI. */
99 /* Current working directory. */
101 char *current_directory
;
103 /* The directory name is actually stored here (usually). */
104 char gdb_dirbuf
[1024];
106 /* Function to call before reading a command, if nonzero.
107 The function receives two args: an input stream,
108 and a prompt string. */
110 void (*window_hook
) (FILE *, char *);
115 /* gdb prints this when reading a command interactively */
116 static char *gdb_prompt_string
; /* the global prompt string */
118 /* Buffer used for reading command lines, and the size
119 allocated for it so far. */
124 /* Nonzero if the current command is modified by "server ". This
125 affects things like recording into the command history, commands
126 repeating on RETURN, etc. This is so a user interface (emacs, GUI,
127 whatever) can issue its own commands and also send along commands
128 from the user, and have the user not notice that the user interface
129 is issuing commands too. */
132 /* Baud rate specified for talking to serial target systems. Default
133 is left as -1, so targets can choose their own defaults. */
134 /* FIXME: This means that "show remotebaud" and gr_files_info can print -1
135 or (unsigned int)-1. This is a Bad User Interface. */
139 /* Timeout limit for response from target. */
141 /* The default value has been changed many times over the years. It
142 was originally 5 seconds. But that was thought to be a long time
143 to sit and wait, so it was changed to 2 seconds. That was thought
144 to be plenty unless the connection was going through some terminal
145 server or multiplexer or other form of hairy serial connection.
147 In mid-1996, remote_timeout was moved from remote.c to top.c and
148 it began being used in other remote-* targets. It appears that the
149 default was changed to 20 seconds at that time, perhaps because the
150 Renesas E7000 ICE didn't always respond in a timely manner.
152 But if 5 seconds is a long time to sit and wait for retransmissions,
153 20 seconds is far worse. This demonstrates the difficulty of using
154 a single variable for all protocol timeouts.
156 As remote.c is used much more than remote-e7000.c, it was changed
157 back to 2 seconds in 1999. */
159 int remote_timeout
= 2;
161 /* Non-zero tells remote* modules to output debugging info. */
163 int remote_debug
= 0;
165 /* Non-zero means the target is running. Note: this is different from
166 saying that there is an active target and we are stopped at a
167 breakpoint, for instance. This is a real indicator whether the
168 target is off and running, which gdb is doing something else. */
169 int target_executing
= 0;
171 /* Level of control structure. */
172 static int control_level
;
174 /* Sbrk location on entry to main. Used for statistics only. */
179 /* Signal to catch ^Z typed while reading a command: SIGTSTP or SIGCONT. */
183 #define STOP_SIGNAL SIGTSTP
184 static void stop_sig (int);
188 /* Hooks for alternate command interfaces. */
190 /* Called after most modules have been initialized, but before taking users
193 If the UI fails to initialize and it wants GDB to continue
194 using the default UI, then it should clear this hook before returning. */
196 void (*deprecated_init_ui_hook
) (char *argv0
);
198 /* This hook is called from within gdb's many mini-event loops which could
199 steal control from a real user interface's event loop. It returns
200 non-zero if the user is requesting a detach, zero otherwise. */
202 int (*deprecated_ui_loop_hook
) (int);
204 /* Called instead of command_loop at top level. Can be invoked via
205 throw_exception(). */
207 void (*deprecated_command_loop_hook
) (void);
210 /* Called from print_frame_info to list the line we stopped in. */
212 void (*deprecated_print_frame_info_listing_hook
) (struct symtab
* s
, int line
,
213 int stopline
, int noerror
);
214 /* Replaces most of query. */
216 int (*deprecated_query_hook
) (const char *, va_list);
218 /* Replaces most of warning. */
220 void (*deprecated_warning_hook
) (const char *, va_list);
222 /* These three functions support getting lines of text from the user.
223 They are used in sequence. First deprecated_readline_begin_hook is
224 called with a text string that might be (for example) a message for
225 the user to type in a sequence of commands to be executed at a
226 breakpoint. If this function calls back to a GUI, it might take
227 this opportunity to pop up a text interaction window with this
228 message. Next, deprecated_readline_hook is called with a prompt
229 that is emitted prior to collecting the user input. It can be
230 called multiple times. Finally, deprecated_readline_end_hook is
231 called to notify the GUI that we are done with the interaction
232 window and it can close it. */
234 void (*deprecated_readline_begin_hook
) (char *, ...);
235 char *(*deprecated_readline_hook
) (char *);
236 void (*deprecated_readline_end_hook
) (void);
238 /* Called as appropriate to notify the interface of the specified breakpoint
241 void (*deprecated_create_breakpoint_hook
) (struct breakpoint
* bpt
);
242 void (*deprecated_delete_breakpoint_hook
) (struct breakpoint
* bpt
);
243 void (*deprecated_modify_breakpoint_hook
) (struct breakpoint
* bpt
);
245 /* Called as appropriate to notify the interface that we have attached
246 to or detached from an already running process. */
248 void (*deprecated_attach_hook
) (void);
249 void (*deprecated_detach_hook
) (void);
251 /* Called during long calculations to allow GUI to repair window damage, and to
252 check for stop buttons, etc... */
254 void (*deprecated_interactive_hook
) (void);
256 /* Called when the registers have changed, as a hint to a GUI
257 to minimize window update. */
259 void (*deprecated_registers_changed_hook
) (void);
261 /* Tell the GUI someone changed the register REGNO. -1 means
262 that the caller does not know which register changed or
263 that several registers have changed (see value_assign). */
264 void (*deprecated_register_changed_hook
) (int regno
);
266 /* Tell the GUI someone changed LEN bytes of memory at ADDR */
267 void (*deprecated_memory_changed_hook
) (CORE_ADDR addr
, int len
);
269 /* Called when going to wait for the target. Usually allows the GUI to run
270 while waiting for target events. */
272 ptid_t (*deprecated_target_wait_hook
) (ptid_t ptid
,
273 struct target_waitstatus
* status
);
275 /* Used by UI as a wrapper around command execution. May do various things
276 like enabling/disabling buttons, etc... */
278 void (*deprecated_call_command_hook
) (struct cmd_list_element
* c
, char *cmd
,
281 /* Called after a `set' command has finished. Is only run if the
282 `set' command succeeded. */
284 void (*deprecated_set_hook
) (struct cmd_list_element
* c
);
286 /* Called when the current thread changes. Argument is thread id. */
288 void (*deprecated_context_hook
) (int id
);
290 /* Takes control from error (). Typically used to prevent longjmps out of the
291 middle of the GUI. Usually used in conjunction with a catch routine. */
293 void (*deprecated_error_hook
) (void);
296 /* One should use catch_errors rather than manipulating these
298 #if defined(HAVE_SIGSETJMP)
299 #define SIGJMP_BUF sigjmp_buf
300 #define SIGSETJMP(buf) sigsetjmp((buf), 1)
301 #define SIGLONGJMP(buf,val) siglongjmp((buf), (val))
303 #define SIGJMP_BUF jmp_buf
304 #define SIGSETJMP(buf) setjmp(buf)
305 #define SIGLONGJMP(buf,val) longjmp((buf), (val))
308 /* Where to go for throw_exception(). */
309 static SIGJMP_BUF
*catch_return
;
311 /* Return for reason REASON to the nearest containing catch_errors(). */
314 throw_exception (enum return_reason reason
)
319 /* Perhaps it would be cleaner to do this via the cleanup chain (not sure
320 I can think of a reason why that is vital, though). */
321 bpstat_clear_actions (stop_bpstat
); /* Clear queued breakpoint commands */
323 disable_current_display ();
324 do_cleanups (ALL_CLEANUPS
);
325 if (target_can_async_p () && !target_executing
)
326 do_exec_cleanups (ALL_CLEANUPS
);
328 do_exec_error_cleanups (ALL_CLEANUPS
);
330 if (annotation_level
> 1)
341 /* Jump to the containing catch_errors() call, communicating REASON
342 to that call via setjmp's return value. Note that REASON can't
343 be zero, by definition in defs.h. */
345 (NORETURN
void) SIGLONGJMP (*catch_return
, (int) reason
);
348 /* Call FUNC() with args FUNC_UIOUT and FUNC_ARGS, catching any
349 errors. Set FUNC_CAUGHT to an ``enum return_reason'' if the
350 function is aborted (using throw_exception() or zero if the
351 function returns normally. Set FUNC_VAL to the value returned by
352 the function or 0 if the function was aborted.
354 Must not be called with immediate_quit in effect (bad things might
355 happen, say we got a signal in the middle of a memcpy to quit_return).
356 This is an OK restriction; with very few exceptions immediate_quit can
357 be replaced by judicious use of QUIT.
359 MASK specifies what to catch; it is normally set to
360 RETURN_MASK_ALL, if for no other reason than that the code which
361 calls catch_errors might not be set up to deal with a quit which
362 isn't caught. But if the code can deal with it, it generally
363 should be RETURN_MASK_ERROR, unless for some reason it is more
364 useful to abort only the portion of the operation inside the
365 catch_errors. Note that quit should return to the command line
366 fairly quickly, even if some further processing is being done. */
368 /* MAYBE: cagney/1999-11-05: catch_errors() in conjunction with
369 error() et.al. could maintain a set of flags that indicate the the
370 current state of each of the longjmp buffers. This would give the
371 longjmp code the chance to detect a longjmp botch (before it gets
372 to longjmperror()). Prior to 1999-11-05 this wasn't possible as
373 code also randomly used a SET_TOP_LEVEL macro that directly
374 initialize the longjmp buffers. */
376 /* MAYBE: cagney/1999-11-05: Should the catch_errors and cleanups code
377 be consolidated into a single file instead of being distributed
378 between utils.c and top.c? */
381 catcher (catch_exceptions_ftype
*func
,
382 struct ui_out
*func_uiout
,
385 enum return_reason
*func_caught
,
390 SIGJMP_BUF
*saved_catch
;
392 struct cleanup
*saved_cleanup_chain
;
393 char *saved_error_pre_print
;
394 char *saved_quit_pre_print
;
395 struct ui_out
*saved_uiout
;
397 /* Return value from SIGSETJMP(): enum return_reason if error or
398 quit caught, 0 otherwise. */
401 /* Return value from FUNC(): Hopefully non-zero. Explicitly set to
402 zero if an error quit was caught. */
405 /* Override error/quit messages during FUNC. */
407 saved_error_pre_print
= error_pre_print
;
408 saved_quit_pre_print
= quit_pre_print
;
410 if (mask
& RETURN_MASK_ERROR
)
411 error_pre_print
= errstring
;
412 if (mask
& RETURN_MASK_QUIT
)
413 quit_pre_print
= errstring
;
415 /* Override the global ``struct ui_out'' builder. */
420 /* Prevent error/quit during FUNC from calling cleanups established
423 saved_cleanup_chain
= save_cleanups ();
425 /* Call FUNC, catching error/quit events. */
427 saved_catch
= catch_return
;
428 catch_return
= &catch;
429 caught
= SIGSETJMP (catch);
431 val
= (*func
) (func_uiout
, func_args
);
435 /* If caller wants a copy of the low-level error message, make one.
436 This is used in the case of a silent error whereby the caller
437 may optionally want to issue the message. */
439 *gdberrmsg
= error_last_message ();
441 catch_return
= saved_catch
;
443 /* FIXME: cagney/1999-11-05: A correct FUNC implementation will
444 clean things up (restoring the cleanup chain) to the state they
445 were just prior to the call. Unfortunately, many FUNC's are not
446 that well behaved. This could be fixed by adding either a
447 do_cleanups call (to cover the problem) or an assertion check to
448 detect bad FUNCs code. */
450 /* Restore the cleanup chain, the error/quit messages, and the uiout
451 builder, to their original states. */
453 restore_cleanups (saved_cleanup_chain
);
457 if (mask
& RETURN_MASK_QUIT
)
458 quit_pre_print
= saved_quit_pre_print
;
459 if (mask
& RETURN_MASK_ERROR
)
460 error_pre_print
= saved_error_pre_print
;
462 /* Return normally if no error/quit event occurred or this catcher
463 can handle this exception. The caller analyses the func return
466 if (!caught
|| (mask
& RETURN_MASK (caught
)))
469 *func_caught
= caught
;
473 /* The caller didn't request that the event be caught, relay the
474 event to the next containing catch_errors(). */
476 throw_exception (caught
);
480 catch_exceptions (struct ui_out
*uiout
,
481 catch_exceptions_ftype
*func
,
487 enum return_reason caught
;
488 catcher (func
, uiout
, func_args
, &val
, &caught
, errstring
, NULL
, mask
);
489 gdb_assert (val
>= 0);
490 gdb_assert (caught
<= 0);
497 catch_exceptions_with_msg (struct ui_out
*uiout
,
498 catch_exceptions_ftype
*func
,
505 enum return_reason caught
;
506 catcher (func
, uiout
, func_args
, &val
, &caught
, errstring
, gdberrmsg
, mask
);
507 gdb_assert (val
>= 0);
508 gdb_assert (caught
<= 0);
514 struct catch_errors_args
516 catch_errors_ftype
*func
;
521 do_catch_errors (struct ui_out
*uiout
, void *data
)
523 struct catch_errors_args
*args
= data
;
524 return args
->func (args
->func_args
);
528 catch_errors (catch_errors_ftype
*func
, void *func_args
, char *errstring
,
532 enum return_reason caught
;
533 struct catch_errors_args args
;
535 args
.func_args
= func_args
;
536 catcher (do_catch_errors
, uiout
, &args
, &val
, &caught
, errstring
,
543 struct captured_command_args
545 catch_command_errors_ftype
*command
;
551 do_captured_command (void *data
)
553 struct captured_command_args
*context
= data
;
554 context
->command (context
->arg
, context
->from_tty
);
555 /* FIXME: cagney/1999-11-07: Technically this do_cleanups() call
556 isn't needed. Instead an assertion check could be made that
557 simply confirmed that the called function correctly cleaned up
558 after itself. Unfortunately, old code (prior to 1999-11-04) in
559 main.c was calling SET_TOP_LEVEL(), calling the command function,
560 and then *always* calling do_cleanups(). For the moment we
561 remain ``bug compatible'' with that old code.. */
562 do_cleanups (ALL_CLEANUPS
);
567 catch_command_errors (catch_command_errors_ftype
* command
,
568 char *arg
, int from_tty
, return_mask mask
)
570 struct captured_command_args args
;
571 args
.command
= command
;
573 args
.from_tty
= from_tty
;
574 return catch_errors (do_captured_command
, &args
, "", mask
);
578 /* Handler for SIGHUP. */
581 /* NOTE 1999-04-29: This function will be static again, once we modify
582 gdb to use the event loop as the default command loop and we merge
583 event-top.c into this file, top.c */
587 caution
= 0; /* Throw caution to the wind -- we're exiting.
588 This prevents asking the user dumb questions. */
589 quit_command ((char *) 0, 0);
592 #endif /* defined SIGHUP */
594 /* Line number we are currently in in a file which is being sourced. */
595 /* NOTE 1999-04-29: This variable will be static again, once we modify
596 gdb to use the event loop as the default command loop and we merge
597 event-top.c into this file, top.c */
598 /* static */ int source_line_number
;
600 /* Name of the file we are sourcing. */
601 /* NOTE 1999-04-29: This variable will be static again, once we modify
602 gdb to use the event loop as the default command loop and we merge
603 event-top.c into this file, top.c */
604 /* static */ char *source_file_name
;
606 /* Buffer containing the error_pre_print used by the source stuff.
608 /* NOTE 1999-04-29: This variable will be static again, once we modify
609 gdb to use the event loop as the default command loop and we merge
610 event-top.c into this file, top.c */
611 /* static */ char *source_error
;
612 static int source_error_allocated
;
614 /* Something to glom on to the start of error_pre_print if source_file_name
616 /* NOTE 1999-04-29: This variable will be static again, once we modify
617 gdb to use the event loop as the default command loop and we merge
618 event-top.c into this file, top.c */
619 /* static */ char *source_pre_error
;
621 /* Clean up on error during a "source" command (or execution of a
622 user-defined command). */
625 do_restore_instream_cleanup (void *stream
)
627 /* Restore the previous input stream. */
631 /* Read commands from STREAM. */
633 read_command_file (FILE *stream
)
635 struct cleanup
*cleanups
;
637 cleanups
= make_cleanup (do_restore_instream_cleanup
, instream
);
640 do_cleanups (cleanups
);
643 void (*pre_init_ui_hook
) (void);
647 do_chdir_cleanup (void *old_dir
)
654 /* Execute the line P as a command.
655 Pass FROM_TTY as second argument to the defining function. */
658 execute_command (char *p
, int from_tty
)
660 struct cmd_list_element
*c
;
662 static int warned
= 0;
667 /* Force cleanup of any alloca areas if using C alloca instead of
671 /* This can happen when command_line_input hits end of file. */
675 serial_log_command (p
);
677 while (*p
== ' ' || *p
== '\t')
684 c
= lookup_cmd (&p
, cmdlist
, "", 0, 1);
686 /* If the target is running, we allow only a limited set of
688 if (target_can_async_p () && target_executing
)
689 if (strcmp (c
->name
, "help") != 0
690 && strcmp (c
->name
, "pwd") != 0
691 && strcmp (c
->name
, "show") != 0
692 && strcmp (c
->name
, "stop") != 0)
693 error ("Cannot execute this command while the target is running.");
695 /* Pass null arg rather than an empty one. */
698 /* FIXME: cagney/2002-02-02: The c->type test is pretty dodgy
699 while the is_complete_command(cfunc) test is just plain
700 bogus. They should both be replaced by a test of the form
701 c->strip_trailing_white_space_p. */
702 /* NOTE: cagney/2002-02-02: The function.cfunc in the below
703 can't be replaced with func. This is because it is the
704 cfunc, and not the func, that has the value that the
705 is_complete_command hack is testing for. */
706 /* Clear off trailing whitespace, except for set and complete
709 && c
->type
!= set_cmd
710 && !is_complete_command (c
))
712 p
= arg
+ strlen (arg
) - 1;
713 while (p
>= arg
&& (*p
== ' ' || *p
== '\t'))
718 /* If this command has been pre-hooked, run the hook first. */
719 execute_cmd_pre_hook (c
);
721 if (c
->flags
& DEPRECATED_WARN_USER
)
722 deprecated_cmd_warning (&line
);
724 if (c
->class == class_user
)
725 execute_user_command (c
, arg
);
726 else if (c
->type
== set_cmd
|| c
->type
== show_cmd
)
727 do_setshow_command (arg
, from_tty
& caution
, c
);
728 else if (!cmd_func_p (c
))
729 error ("That is not a command, just a help topic.");
730 else if (deprecated_call_command_hook
)
731 deprecated_call_command_hook (c
, arg
, from_tty
& caution
);
733 cmd_func (c
, arg
, from_tty
& caution
);
735 /* If this command has been post-hooked, run the hook last. */
736 execute_cmd_post_hook (c
);
740 /* Tell the user if the language has changed (except first time). */
741 if (current_language
!= expected_language
)
743 if (language_mode
== language_mode_auto
)
745 language_info (1); /* Print what changed. */
750 /* Warn the user if the working language does not match the
751 language of the current frame. Only warn the user if we are
752 actually running the program, i.e. there is a stack. */
753 /* FIXME: This should be cacheing the frame and only running when
754 the frame changes. */
756 if (target_has_stack
)
758 flang
= get_frame_language ();
760 && flang
!= language_unknown
761 && flang
!= current_language
->la_language
)
763 printf_filtered ("%s\n", lang_frame_mismatch_warn
);
769 /* Read commands from `instream' and execute them
770 until end of file or error reading instream. */
775 struct cleanup
*old_chain
;
777 int stdin_is_tty
= ISATTY (stdin
);
778 long time_at_cmd_start
;
780 long space_at_cmd_start
= 0;
782 extern int display_time
;
783 extern int display_space
;
785 while (instream
&& !feof (instream
))
787 if (window_hook
&& instream
== stdin
)
788 (*window_hook
) (instream
, get_prompt ());
791 if (instream
== stdin
&& stdin_is_tty
)
792 reinitialize_more_filter ();
793 old_chain
= make_cleanup (null_cleanup
, 0);
795 /* Get a command-line. This calls the readline package. */
796 command
= command_line_input (instream
== stdin
?
797 get_prompt () : (char *) NULL
,
798 instream
== stdin
, "prompt");
802 time_at_cmd_start
= get_run_time ();
807 char *lim
= (char *) sbrk (0);
808 space_at_cmd_start
= lim
- lim_at_start
;
812 execute_command (command
, instream
== stdin
);
813 /* Do any commands attached to breakpoint we stopped at. */
814 bpstat_do_actions (&stop_bpstat
);
815 do_cleanups (old_chain
);
819 long cmd_time
= get_run_time () - time_at_cmd_start
;
821 printf_unfiltered ("Command execution time: %ld.%06ld\n",
822 cmd_time
/ 1000000, cmd_time
% 1000000);
828 char *lim
= (char *) sbrk (0);
829 long space_now
= lim
- lim_at_start
;
830 long space_diff
= space_now
- space_at_cmd_start
;
832 printf_unfiltered ("Space used: %ld (%c%ld for this command)\n",
834 (space_diff
>= 0 ? '+' : '-'),
841 /* Read commands from `instream' and execute them until end of file or
842 error reading instream. This command loop doesnt care about any
843 such things as displaying time and space usage. If the user asks
844 for those, they won't work. */
846 simplified_command_loop (char *(*read_input_func
) (char *),
847 void (*execute_command_func
) (char *, int))
849 struct cleanup
*old_chain
;
851 int stdin_is_tty
= ISATTY (stdin
);
853 while (instream
&& !feof (instream
))
856 if (instream
== stdin
&& stdin_is_tty
)
857 reinitialize_more_filter ();
858 old_chain
= make_cleanup (null_cleanup
, 0);
860 /* Get a command-line. */
861 command
= (*read_input_func
) (instream
== stdin
?
862 get_prompt () : (char *) NULL
);
867 (*execute_command_func
) (command
, instream
== stdin
);
869 /* Do any commands attached to breakpoint we stopped at. */
870 bpstat_do_actions (&stop_bpstat
);
872 do_cleanups (old_chain
);
876 /* Commands call this if they do not want to be repeated by null lines. */
884 /* If we aren't reading from standard input, we are saving the last
885 thing read from stdin in line and don't want to delete it. Null lines
886 won't repeat here in any case. */
887 if (instream
== stdin
)
891 /* Read a line from the stream "instream" without command line editing.
893 It prints PROMPT_ARG once at the start.
894 Action is compatible with "readline", e.g. space for the result is
895 malloc'd and should be freed by the caller.
897 A NULL return means end of file. */
899 gdb_readline (char *prompt_arg
)
904 int result_size
= 80;
908 /* Don't use a _filtered function here. It causes the assumed
909 character position to be off, since the newline we read from
910 the user is not accounted for. */
911 fputs_unfiltered (prompt_arg
, gdb_stdout
);
912 gdb_flush (gdb_stdout
);
915 result
= (char *) xmalloc (result_size
);
919 /* Read from stdin if we are executing a user defined command.
920 This is the right thing for prompt_for_continue, at least. */
921 c
= fgetc (instream
? instream
: stdin
);
926 /* The last line does not end with a newline. Return it, and
927 if we are called again fgetc will still return EOF and
928 we'll return NULL then. */
935 #ifndef CRLF_SOURCE_FILES
939 if (input_index
> 0 && result
[input_index
- 1] == '\r')
945 result
[input_index
++] = c
;
946 while (input_index
>= result_size
)
949 result
= (char *) xrealloc (result
, result_size
);
953 result
[input_index
++] = '\0';
957 /* Variables which control command line editing and history
958 substitution. These variables are given default values at the end
960 static int command_editing_p
;
961 /* NOTE 1999-04-29: This variable will be static again, once we modify
962 gdb to use the event loop as the default command loop and we merge
963 event-top.c into this file, top.c */
964 /* static */ int history_expansion_p
;
965 static int write_history_p
;
966 static int history_size
;
967 static char *history_filename
;
969 /* This is like readline(), but it has some gdb-specific behavior.
970 gdb can use readline in both the synchronous and async modes during
971 a single gdb invocation. At the ordinary top-level prompt we might
972 be using the async readline. That means we can't use
973 rl_pre_input_hook, since it doesn't work properly in async mode.
974 However, for a secondary prompt (" >", such as occurs during a
975 `define'), gdb just calls readline() directly, running it in
976 synchronous mode. So for operate-and-get-next to work in this
977 situation, we have to switch the hooks around. That is what
978 gdb_readline_wrapper is for. */
980 gdb_readline_wrapper (char *prompt
)
982 /* Set the hook that works in this case. */
983 if (after_char_processing_hook
)
985 rl_pre_input_hook
= (Function
*) after_char_processing_hook
;
986 after_char_processing_hook
= NULL
;
989 return readline (prompt
);
997 #if STOP_SIGNAL == SIGTSTP
998 signal (SIGTSTP
, SIG_DFL
);
1003 sigemptyset (&zero
);
1004 sigprocmask (SIG_SETMASK
, &zero
, 0);
1006 #elif HAVE_SIGSETMASK
1009 kill (getpid (), SIGTSTP
);
1010 signal (SIGTSTP
, stop_sig
);
1012 signal (STOP_SIGNAL
, stop_sig
);
1014 printf_unfiltered ("%s", get_prompt ());
1015 gdb_flush (gdb_stdout
);
1017 /* Forget about any previous command -- null line now will do nothing. */
1020 #endif /* STOP_SIGNAL */
1022 /* Initialize signal handlers. */
1024 float_handler (int signo
)
1026 /* This message is based on ANSI C, section 4.7. Note that integer
1027 divide by zero causes this, so "float" is a misnomer. */
1028 signal (SIGFPE
, float_handler
);
1029 error ("Erroneous arithmetic operation.");
1033 do_nothing (int signo
)
1035 /* Under System V the default disposition of a signal is reinstated after
1036 the signal is caught and delivered to an application process. On such
1037 systems one must restore the replacement signal handler if one wishes
1038 to continue handling the signal in one's program. On BSD systems this
1039 is not needed but it is harmless, and it simplifies the code to just do
1040 it unconditionally. */
1041 signal (signo
, do_nothing
);
1044 /* The current saved history number from operate-and-get-next.
1045 This is -1 if not valid. */
1046 static int operate_saved_history
= -1;
1048 /* This is put on the appropriate hook and helps operate-and-get-next
1051 gdb_rl_operate_and_get_next_completion (void)
1053 int delta
= where_history () - operate_saved_history
;
1054 /* The `key' argument to rl_get_previous_history is ignored. */
1055 rl_get_previous_history (delta
, 0);
1056 operate_saved_history
= -1;
1058 /* readline doesn't automatically update the display for us. */
1061 after_char_processing_hook
= NULL
;
1062 rl_pre_input_hook
= NULL
;
1065 /* This is a gdb-local readline command handler. It accepts the
1066 current command line (like RET does) and, if this command was taken
1067 from the history, arranges for the next command in the history to
1068 appear on the command line when the prompt returns.
1069 We ignore the arguments. */
1071 gdb_rl_operate_and_get_next (int count
, int key
)
1075 /* Use the async hook. */
1076 after_char_processing_hook
= gdb_rl_operate_and_get_next_completion
;
1078 /* Find the current line, and find the next line to use. */
1079 where
= where_history();
1081 /* FIXME: kettenis/20020817: max_input_history is renamed into
1082 history_max_entries in readline-4.2. When we do a new readline
1083 import, we should probably change it here too, even though
1084 readline maintains backwards compatibility for now by still
1085 defining max_input_history. */
1086 if ((history_is_stifled () && (history_length
>= max_input_history
)) ||
1087 (where
>= history_length
- 1))
1088 operate_saved_history
= where
;
1090 operate_saved_history
= where
+ 1;
1092 return rl_newline (1, key
);
1095 /* Read one line from the command input stream `instream'
1096 into the local static buffer `linebuffer' (whose current length
1098 The buffer is made bigger as necessary.
1099 Returns the address of the start of the line.
1101 NULL is returned for end of file.
1103 *If* the instream == stdin & stdin is a terminal, the line read
1104 is copied into the file line saver (global var char *line,
1105 length linesize) so that it can be duplicated.
1107 This routine either uses fancy command line editing or
1108 simple input as the user has requested. */
1111 command_line_input (char *prompt_arg
, int repeat
, char *annotation_suffix
)
1113 static char *linebuffer
= 0;
1114 static unsigned linelength
= 0;
1118 char *local_prompt
= prompt_arg
;
1122 /* The annotation suffix must be non-NULL. */
1123 if (annotation_suffix
== NULL
)
1124 annotation_suffix
= "";
1126 if (annotation_level
> 1 && instream
== stdin
)
1128 local_prompt
= alloca ((prompt_arg
== NULL
? 0 : strlen (prompt_arg
))
1129 + strlen (annotation_suffix
) + 40);
1130 if (prompt_arg
== NULL
)
1131 local_prompt
[0] = '\0';
1133 strcpy (local_prompt
, prompt_arg
);
1134 strcat (local_prompt
, "\n\032\032");
1135 strcat (local_prompt
, annotation_suffix
);
1136 strcat (local_prompt
, "\n");
1139 if (linebuffer
== 0)
1142 linebuffer
= (char *) xmalloc (linelength
);
1147 /* Control-C quits instantly if typed while in this loop
1148 since it should not wait until the user types a newline. */
1152 signal (STOP_SIGNAL
, handle_stop_sig
);
1157 /* Make sure that all output has been output. Some machines may let
1158 you get away with leaving out some of the gdb_flush, but not all. */
1160 gdb_flush (gdb_stdout
);
1161 gdb_flush (gdb_stderr
);
1163 if (source_file_name
!= NULL
)
1165 ++source_line_number
;
1166 sprintf (source_error
,
1167 "%s%s:%d: Error in sourced command file:\n",
1170 source_line_number
);
1171 error_pre_print
= source_error
;
1174 if (annotation_level
> 1 && instream
== stdin
)
1176 puts_unfiltered ("\n\032\032pre-");
1177 puts_unfiltered (annotation_suffix
);
1178 puts_unfiltered ("\n");
1181 /* Don't use fancy stuff if not talking to stdin. */
1182 if (deprecated_readline_hook
&& instream
== NULL
)
1184 rl
= (*deprecated_readline_hook
) (local_prompt
);
1186 else if (command_editing_p
&& instream
== stdin
&& ISATTY (instream
))
1188 rl
= gdb_readline_wrapper (local_prompt
);
1192 rl
= gdb_readline (local_prompt
);
1195 if (annotation_level
> 1 && instream
== stdin
)
1197 puts_unfiltered ("\n\032\032post-");
1198 puts_unfiltered (annotation_suffix
);
1199 puts_unfiltered ("\n");
1202 if (!rl
|| rl
== (char *) EOF
)
1207 if (strlen (rl
) + 1 + (p
- linebuffer
) > linelength
)
1209 linelength
= strlen (rl
) + 1 + (p
- linebuffer
);
1210 nline
= (char *) xrealloc (linebuffer
, linelength
);
1211 p
+= nline
- linebuffer
;
1215 /* Copy line. Don't copy null at end. (Leaves line alone
1216 if this was just a newline) */
1220 xfree (rl
); /* Allocated in readline. */
1222 if (p
== linebuffer
|| *(p
- 1) != '\\')
1225 p
--; /* Put on top of '\'. */
1226 local_prompt
= (char *) 0;
1231 signal (STOP_SIGNAL
, SIG_DFL
);
1238 #define SERVER_COMMAND_LENGTH 7
1240 (p
- linebuffer
> SERVER_COMMAND_LENGTH
)
1241 && strncmp (linebuffer
, "server ", SERVER_COMMAND_LENGTH
) == 0;
1244 /* Note that we don't set `line'. Between this and the check in
1245 dont_repeat, this insures that repeating will still do the
1248 return linebuffer
+ SERVER_COMMAND_LENGTH
;
1251 /* Do history expansion if that is wished. */
1252 if (history_expansion_p
&& instream
== stdin
1253 && ISATTY (instream
))
1255 char *history_value
;
1258 *p
= '\0'; /* Insert null now. */
1259 expanded
= history_expand (linebuffer
, &history_value
);
1262 /* Print the changes. */
1263 printf_unfiltered ("%s\n", history_value
);
1265 /* If there was an error, call this function again. */
1268 xfree (history_value
);
1269 return command_line_input (prompt_arg
, repeat
, annotation_suffix
);
1271 if (strlen (history_value
) > linelength
)
1273 linelength
= strlen (history_value
) + 1;
1274 linebuffer
= (char *) xrealloc (linebuffer
, linelength
);
1276 strcpy (linebuffer
, history_value
);
1277 p
= linebuffer
+ strlen (linebuffer
);
1278 xfree (history_value
);
1282 /* If we just got an empty line, and that is supposed
1283 to repeat the previous command, return the value in the
1285 if (repeat
&& p
== linebuffer
)
1287 for (p1
= linebuffer
; *p1
== ' ' || *p1
== '\t'; p1
++);
1293 /* Add line to history if appropriate. */
1294 if (instream
== stdin
1295 && ISATTY (stdin
) && *linebuffer
)
1296 add_history (linebuffer
);
1298 /* Note: lines consisting solely of comments are added to the command
1299 history. This is useful when you type a command, and then
1300 realize you don't want to execute it quite yet. You can comment
1301 out the command and then later fetch it from the value history
1302 and remove the '#'. The kill ring is probably better, but some
1303 people are in the habit of commenting things out. */
1305 *p1
= '\0'; /* Found a comment. */
1307 /* Save into global buffer if appropriate. */
1310 if (linelength
> linesize
)
1312 line
= xrealloc (line
, linelength
);
1313 linesize
= linelength
;
1315 strcpy (line
, linebuffer
);
1322 /* Print the GDB banner. */
1324 print_gdb_version (struct ui_file
*stream
)
1326 /* From GNU coding standards, first line is meant to be easy for a
1327 program to parse, and is just canonical program name and version
1328 number, which starts after last space. */
1330 fprintf_filtered (stream
, "GNU gdb %s\n", version
);
1332 /* Second line is a copyright notice. */
1334 fprintf_filtered (stream
, "Copyright 2004 Free Software Foundation, Inc.\n");
1336 /* Following the copyright is a brief statement that the program is
1337 free software, that users are free to copy and change it on
1338 certain conditions, that it is covered by the GNU GPL, and that
1339 there is no warranty. */
1341 fprintf_filtered (stream
, "\
1342 GDB is free software, covered by the GNU General Public License, and you are\n\
1343 welcome to change it and/or distribute copies of it under certain conditions.\n\
1344 Type \"show copying\" to see the conditions.\n\
1345 There is absolutely no warranty for GDB. Type \"show warranty\" for details.\n");
1347 /* After the required info we print the configuration information. */
1349 fprintf_filtered (stream
, "This GDB was configured as \"");
1350 if (strcmp (host_name
, target_name
) != 0)
1352 fprintf_filtered (stream
, "--host=%s --target=%s", host_name
, target_name
);
1356 fprintf_filtered (stream
, "%s", host_name
);
1358 fprintf_filtered (stream
, "\".");
1361 /* get_prompt: access method for the GDB prompt string. */
1370 set_prompt (char *s
)
1372 /* ??rehrauer: I don't know why this fails, since it looks as though
1373 assignments to prompt are wrapped in calls to savestring...
1377 PROMPT (0) = savestring (s
, strlen (s
));
1381 /* If necessary, make the user confirm that we should quit. Return
1382 non-zero if we should quit, zero if we shouldn't. */
1387 if (! ptid_equal (inferior_ptid
, null_ptid
) && target_has_execution
)
1391 /* This is something of a hack. But there's no reliable way to
1392 see if a GUI is running. The `use_windows' variable doesn't
1394 if (deprecated_init_ui_hook
)
1395 s
= "A debugging session is active.\nDo you still want to close the debugger?";
1396 else if (attach_flag
)
1397 s
= "The program is running. Quit anyway (and detach it)? ";
1399 s
= "The program is running. Exit anyway? ";
1401 if (!query ("%s", s
))
1408 /* Helper routine for quit_force that requires error handling. */
1417 quit_target (void *arg
)
1419 struct qt_args
*qt
= (struct qt_args
*)arg
;
1421 if (! ptid_equal (inferior_ptid
, null_ptid
) && target_has_execution
)
1424 target_detach (qt
->args
, qt
->from_tty
);
1429 /* UDI wants this, to kill the TIP. */
1430 target_close (¤t_target
, 1);
1432 /* Save the history information if it is appropriate to do so. */
1433 if (write_history_p
&& history_filename
)
1434 write_history (history_filename
);
1436 do_final_cleanups (ALL_CLEANUPS
); /* Do any final cleanups before exiting */
1441 /* Quit without asking for confirmation. */
1444 quit_force (char *args
, int from_tty
)
1449 /* An optional expression may be used to cause gdb to terminate with the
1450 value of that expression. */
1453 struct value
*val
= parse_and_eval (args
);
1455 exit_code
= (int) value_as_long (val
);
1459 qt
.from_tty
= from_tty
;
1461 /* We want to handle any quit errors and exit regardless. */
1462 catch_errors (quit_target
, &qt
,
1463 "Quitting: ", RETURN_MASK_ALL
);
1468 /* Returns whether GDB is running on a terminal and whether the user
1469 desires that questions be asked of them on that terminal. */
1472 input_from_terminal_p (void)
1474 return gdb_has_a_terminal () && (instream
== stdin
) & caution
;
1478 dont_repeat_command (char *ignored
, int from_tty
)
1480 *line
= 0; /* Can't call dont_repeat here because we're not
1481 necessarily reading from stdin. */
1484 /* Functions to manipulate command line editing control variables. */
1486 /* Number of commands to print in each call to show_commands. */
1487 #define Hist_print 10
1489 show_commands (char *args
, int from_tty
)
1491 /* Index for history commands. Relative to history_base. */
1494 /* Number of the history entry which we are planning to display next.
1495 Relative to history_base. */
1498 /* The first command in the history which doesn't exist (i.e. one more
1499 than the number of the last command). Relative to history_base. */
1502 /* Print out some of the commands from the command history. */
1503 /* First determine the length of the history list. */
1504 hist_len
= history_size
;
1505 for (offset
= 0; offset
< history_size
; offset
++)
1507 if (!history_get (history_base
+ offset
))
1516 if (args
[0] == '+' && args
[1] == '\0')
1517 /* "info editing +" should print from the stored position. */
1520 /* "info editing <exp>" should print around command number <exp>. */
1521 num
= (parse_and_eval_long (args
) - history_base
) - Hist_print
/ 2;
1523 /* "show commands" means print the last Hist_print commands. */
1526 num
= hist_len
- Hist_print
;
1532 /* If there are at least Hist_print commands, we want to display the last
1533 Hist_print rather than, say, the last 6. */
1534 if (hist_len
- num
< Hist_print
)
1536 num
= hist_len
- Hist_print
;
1541 for (offset
= num
; offset
< num
+ Hist_print
&& offset
< hist_len
; offset
++)
1543 printf_filtered ("%5d %s\n", history_base
+ offset
,
1544 (history_get (history_base
+ offset
))->line
);
1547 /* The next command we want to display is the next one that we haven't
1551 /* If the user repeats this command with return, it should do what
1552 "show commands +" does. This is unnecessary if arg is null,
1553 because "show commands +" is not useful after "show commands". */
1554 if (from_tty
&& args
)
1561 /* Called by do_setshow_command. */
1563 set_history_size_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1565 if (history_size
== INT_MAX
)
1566 unstifle_history ();
1567 else if (history_size
>= 0)
1568 stifle_history (history_size
);
1571 history_size
= INT_MAX
;
1572 error ("History size must be non-negative");
1577 set_history (char *args
, int from_tty
)
1579 printf_unfiltered ("\"set history\" must be followed by the name of a history subcommand.\n");
1580 help_list (sethistlist
, "set history ", -1, gdb_stdout
);
1584 show_history (char *args
, int from_tty
)
1586 cmd_show_list (showhistlist
, from_tty
, "");
1589 int info_verbose
= 0; /* Default verbose msgs off */
1591 /* Called by do_setshow_command. An elaborate joke. */
1593 set_verbose (char *args
, int from_tty
, struct cmd_list_element
*c
)
1595 char *cmdname
= "verbose";
1596 struct cmd_list_element
*showcmd
;
1598 showcmd
= lookup_cmd_1 (&cmdname
, showlist
, NULL
, 1);
1602 c
->doc
= "Set verbose printing of informational messages.";
1603 showcmd
->doc
= "Show verbose printing of informational messages.";
1607 c
->doc
= "Set verbosity.";
1608 showcmd
->doc
= "Show verbosity.";
1612 /* Init the history buffer. Note that we are called after the init file(s)
1613 * have been read so that the user can change the history file via his
1614 * .gdbinit file (for instance). The GDBHISTFILE environment variable
1615 * overrides all of this.
1623 tmpenv
= getenv ("HISTSIZE");
1625 history_size
= atoi (tmpenv
);
1626 else if (!history_size
)
1629 stifle_history (history_size
);
1631 tmpenv
= getenv ("GDBHISTFILE");
1633 history_filename
= savestring (tmpenv
, strlen (tmpenv
));
1634 else if (!history_filename
)
1636 /* We include the current directory so that if the user changes
1637 directories the file written will be the same as the one
1640 /* No leading dots in file names are allowed on MSDOS. */
1641 history_filename
= concat (current_directory
, "/_gdb_history", NULL
);
1643 history_filename
= concat (current_directory
, "/.gdb_history", NULL
);
1646 read_history (history_filename
);
1652 struct cmd_list_element
*c
;
1654 /* initialize the prompt stack to a simple "(gdb) " prompt or to
1655 whatever the DEFAULT_PROMPT is. */
1656 the_prompts
.top
= 0;
1658 PROMPT (0) = savestring (DEFAULT_PROMPT
, strlen (DEFAULT_PROMPT
));
1660 /* Set things up for annotation_level > 1, if the user ever decides
1662 async_annotation_suffix
= "prompt";
1663 /* Set the variable associated with the setshow prompt command. */
1664 new_async_prompt
= savestring (PROMPT (0), strlen (PROMPT (0)));
1666 /* If gdb was started with --annotate=2, this is equivalent to the
1667 user entering the command 'set annotate 2' at the gdb prompt, so
1668 we need to do extra processing. */
1669 if (annotation_level
> 1)
1670 set_async_annotation_level (NULL
, 0, NULL
);
1672 /* Set the important stuff up for command editing. */
1673 command_editing_p
= 1;
1674 history_expansion_p
= 0;
1675 write_history_p
= 0;
1677 /* Setup important stuff for command line editing. */
1678 rl_completion_entry_function
= readline_line_completion_function
;
1679 rl_completer_word_break_characters
= default_word_break_characters ();
1680 rl_completer_quote_characters
= get_gdb_completer_quote_characters ();
1681 rl_readline_name
= "gdb";
1682 rl_terminal_name
= getenv ("TERM");
1684 /* The name for this defun comes from Bash, where it originated.
1685 15 is Control-o, the same binding this function has in Bash. */
1686 rl_add_defun ("operate-and-get-next", gdb_rl_operate_and_get_next
, 15);
1688 c
= add_set_cmd ("prompt", class_support
, var_string
,
1689 (char *) &new_async_prompt
, "Set gdb's prompt",
1691 deprecated_add_show_from_set (c
, &showlist
);
1692 set_cmd_sfunc (c
, set_async_prompt
);
1694 add_com ("dont-repeat", class_support
, dont_repeat_command
, "Don't repeat this command.\n\
1695 Primarily used inside of user-defined commands that should not be repeated when\n\
1698 c
= add_set_cmd ("editing", class_support
, var_boolean
, (char *) &async_command_editing_p
,
1699 "Set editing of command lines as they are typed.\n\
1700 Use \"on\" to enable the editing, and \"off\" to disable it.\n\
1701 Without an argument, command line editing is enabled. To edit, use\n\
1702 EMACS-like or VI-like commands like control-P or ESC.", &setlist
);
1704 deprecated_add_show_from_set (c
, &showlist
);
1705 set_cmd_sfunc (c
, set_async_editing_command
);
1707 deprecated_add_show_from_set
1708 (add_set_cmd ("save", no_class
, var_boolean
, (char *) &write_history_p
,
1709 "Set saving of the history record on exit.\n\
1710 Use \"on\" to enable the saving, and \"off\" to disable it.\n\
1711 Without an argument, saving is enabled.", &sethistlist
),
1714 c
= add_set_cmd ("size", no_class
, var_integer
, (char *) &history_size
,
1715 "Set the size of the command history,\n\
1716 ie. the number of previous commands to keep a record of.", &sethistlist
);
1717 deprecated_add_show_from_set (c
, &showhistlist
);
1718 set_cmd_sfunc (c
, set_history_size_command
);
1720 c
= add_set_cmd ("filename", no_class
, var_filename
,
1721 (char *) &history_filename
,
1722 "Set the filename in which to record the command history\n\
1723 (the list of previous commands of which a record is kept).", &sethistlist
);
1724 set_cmd_completer (c
, filename_completer
);
1725 deprecated_add_show_from_set (c
, &showhistlist
);
1727 deprecated_add_show_from_set
1728 (add_set_cmd ("confirm", class_support
, var_boolean
,
1730 "Set whether to confirm potentially dangerous operations.",
1734 c
= add_set_cmd ("annotate", class_obscure
, var_zinteger
,
1735 (char *) &annotation_level
, "Set annotation_level.\n\
1736 0 == normal; 1 == fullname (for use when running under emacs)\n\
1737 2 == output annotated suitably for use by programs that control GDB.",
1739 deprecated_add_show_from_set (c
, &showlist
);
1740 set_cmd_sfunc (c
, set_async_annotation_level
);
1742 deprecated_add_show_from_set
1743 (add_set_cmd ("exec-done-display", class_support
, var_boolean
, (char *) &exec_done_display_p
,
1744 "Set notification of completion for asynchronous execution commands.\n\
1745 Use \"on\" to enable the notification, and \"off\" to disable it.", &setlist
),
1750 gdb_init (char *argv0
)
1752 if (pre_init_ui_hook
)
1753 pre_init_ui_hook ();
1755 /* Run the init function of each source file */
1757 getcwd (gdb_dirbuf
, sizeof (gdb_dirbuf
));
1758 current_directory
= gdb_dirbuf
;
1761 /* Make sure we return to the original directory upon exit, come
1762 what may, since the OS doesn't do that for us. */
1763 make_final_cleanup (do_chdir_cleanup
, xstrdup (current_directory
));
1766 init_cmd_lists (); /* This needs to be done first */
1767 initialize_targets (); /* Setup target_terminal macros for utils.c */
1768 initialize_utils (); /* Make errors and warnings possible */
1769 initialize_all_files ();
1770 initialize_current_architecture ();
1772 init_main (); /* But that omits this file! Do it now */
1774 async_init_signals ();
1776 /* We need a default language for parsing expressions, so simple things like
1777 "set width 0" won't fail if no language is explicitly set in a config file
1778 or implicitly set by reading an executable during startup. */
1779 set_language (language_c
);
1780 expected_language
= current_language
; /* don't warn about the change. */
1782 /* Allow another UI to initialize. If the UI fails to initialize,
1783 and it wants GDB to revert to the CLI, it should clear
1784 deprecated_init_ui_hook. */
1785 if (deprecated_init_ui_hook
)
1786 deprecated_init_ui_hook (argv0
);