1 /* Top level stuff for GDB, the GNU debugger.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
3 1996, 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
24 #include "call-cmds.h"
25 #include "cli/cli-cmds.h"
26 #include "cli/cli-script.h"
27 #include "cli/cli-setshow.h"
32 #include "breakpoint.h"
34 #include "expression.h"
37 #include "terminal.h" /* For job_control. */
39 #include "completer.h"
44 /* readline include files */
45 #include <readline/readline.h>
46 #include <readline/history.h>
48 /* readline defines this. */
51 #include <sys/types.h>
55 #include "event-top.h"
56 #include "gdb_string.h"
64 /* Default command line prompt. This is overriden in some configs. */
66 #ifndef DEFAULT_PROMPT
67 #define DEFAULT_PROMPT "(gdb) "
70 /* Initialization file name for gdb. This is overridden in some configs. */
72 #ifndef GDBINIT_FILENAME
73 #define GDBINIT_FILENAME ".gdbinit"
75 char gdbinit
[] = GDBINIT_FILENAME
;
77 int inhibit_gdbinit
= 0;
79 /* If nonzero, and GDB has been configured to be able to use windows,
80 attempt to open them upon startup. */
84 extern char lang_frame_mismatch_warn
[]; /* language.c */
86 /* Flag for whether we want all the "from_tty" gubbish printed. */
88 int caution
= 1; /* Default is yes, sigh. */
90 /* stdio stream that command input is being read from. Set to stdin normally.
91 Set by source_command to the file we are sourcing. Set to NULL if we are
92 executing a user-defined command or interacting via a GUI. */
96 /* Current working directory. */
98 char *current_directory
;
100 /* The directory name is actually stored here (usually). */
101 char gdb_dirbuf
[1024];
103 /* Function to call before reading a command, if nonzero.
104 The function receives two args: an input stream,
105 and a prompt string. */
107 void (*window_hook
) (FILE *, char *);
112 /* gdb prints this when reading a command interactively */
113 static char *gdb_prompt_string
; /* the global prompt string */
115 /* Buffer used for reading command lines, and the size
116 allocated for it so far. */
121 /* Nonzero if the current command is modified by "server ". This
122 affects things like recording into the command history, commands
123 repeating on RETURN, etc. This is so a user interface (emacs, GUI,
124 whatever) can issue its own commands and also send along commands
125 from the user, and have the user not notice that the user interface
126 is issuing commands too. */
129 /* Baud rate specified for talking to serial target systems. Default
130 is left as -1, so targets can choose their own defaults. */
131 /* FIXME: This means that "show remotebaud" and gr_files_info can print -1
132 or (unsigned int)-1. This is a Bad User Interface. */
136 /* Timeout limit for response from target. */
138 /* The default value has been changed many times over the years. It
139 was originally 5 seconds. But that was thought to be a long time
140 to sit and wait, so it was changed to 2 seconds. That was thought
141 to be plenty unless the connection was going through some terminal
142 server or multiplexer or other form of hairy serial connection.
144 In mid-1996, remote_timeout was moved from remote.c to top.c and
145 it began being used in other remote-* targets. It appears that the
146 default was changed to 20 seconds at that time, perhaps because the
147 Hitachi E7000 ICE didn't always respond in a timely manner.
149 But if 5 seconds is a long time to sit and wait for retransmissions,
150 20 seconds is far worse. This demonstrates the difficulty of using
151 a single variable for all protocol timeouts.
153 As remote.c is used much more than remote-e7000.c, it was changed
154 back to 2 seconds in 1999. */
156 int remote_timeout
= 2;
158 /* Non-zero tells remote* modules to output debugging info. */
160 int remote_debug
= 0;
162 /* Non-zero means the target is running. Note: this is different from
163 saying that there is an active target and we are stopped at a
164 breakpoint, for instance. This is a real indicator whether the
165 target is off and running, which gdb is doing something else. */
166 int target_executing
= 0;
168 /* Level of control structure. */
169 static int control_level
;
171 /* Signal to catch ^Z typed while reading a command: SIGTSTP or SIGCONT. */
175 #define STOP_SIGNAL SIGTSTP
176 static void stop_sig (int);
180 /* Some System V have job control but not sigsetmask(). */
181 #if !defined (HAVE_SIGSETMASK)
183 #define HAVE_SIGSETMASK 1
185 #define HAVE_SIGSETMASK 0
189 #if 0 == (HAVE_SIGSETMASK)
190 #define sigsetmask(n)
193 /* Hooks for alternate command interfaces. */
195 /* Called after most modules have been initialized, but before taking users
198 void (*init_ui_hook
) (char *argv0
);
200 /* This hook is called from within gdb's many mini-event loops which could
201 steal control from a real user interface's event loop. It returns
202 non-zero if the user is requesting a detach, zero otherwise. */
204 int (*ui_loop_hook
) (int);
206 /* Called instead of command_loop at top level. Can be invoked via
207 return_to_top_level. */
209 void (*command_loop_hook
) (void);
212 /* Called from print_frame_info to list the line we stopped in. */
214 void (*print_frame_info_listing_hook
) (struct symtab
* s
, int line
,
215 int stopline
, int noerror
);
216 /* Replaces most of query. */
218 int (*query_hook
) (const char *, va_list);
220 /* Replaces most of warning. */
222 void (*warning_hook
) (const char *, va_list);
224 /* These three functions support getting lines of text from the user. They
225 are used in sequence. First readline_begin_hook is called with a text
226 string that might be (for example) a message for the user to type in a
227 sequence of commands to be executed at a breakpoint. If this function
228 calls back to a GUI, it might take this opportunity to pop up a text
229 interaction window with this message. Next, readline_hook is called
230 with a prompt that is emitted prior to collecting the user input.
231 It can be called multiple times. Finally, readline_end_hook is called
232 to notify the GUI that we are done with the interaction window and it
235 void (*readline_begin_hook
) (char *, ...);
236 char *(*readline_hook
) (char *);
237 void (*readline_end_hook
) (void);
239 /* Called as appropriate to notify the interface of the specified breakpoint
242 void (*create_breakpoint_hook
) (struct breakpoint
* bpt
);
243 void (*delete_breakpoint_hook
) (struct breakpoint
* bpt
);
244 void (*modify_breakpoint_hook
) (struct breakpoint
* bpt
);
246 /* Called as appropriate to notify the interface that we have attached
247 to or detached from an already running process. */
249 void (*attach_hook
) (void);
250 void (*detach_hook
) (void);
252 /* Called during long calculations to allow GUI to repair window damage, and to
253 check for stop buttons, etc... */
255 void (*interactive_hook
) (void);
257 /* Called when the registers have changed, as a hint to a GUI
258 to minimize window update. */
260 void (*registers_changed_hook
) (void);
262 /* Tell the GUI someone changed the register REGNO. -1 means
263 that the caller does not know which register changed or
264 that several registers have changed (see value_assign). */
265 void (*register_changed_hook
) (int regno
);
267 /* Tell the GUI someone changed LEN bytes of memory at ADDR */
268 void (*memory_changed_hook
) (CORE_ADDR addr
, int len
);
270 /* Called when going to wait for the target. Usually allows the GUI to run
271 while waiting for target events. */
273 ptid_t (*target_wait_hook
) (ptid_t ptid
,
274 struct target_waitstatus
* status
);
276 /* Used by UI as a wrapper around command execution. May do various things
277 like enabling/disabling buttons, etc... */
279 void (*call_command_hook
) (struct cmd_list_element
* c
, char *cmd
,
282 /* Called after a `set' command has finished. Is only run if the
283 `set' command succeeded. */
285 void (*set_hook
) (struct cmd_list_element
* c
);
287 /* Called when the current thread changes. Argument is thread id. */
289 void (*context_hook
) (int id
);
291 /* Takes control from error (). Typically used to prevent longjmps out of the
292 middle of the GUI. Usually used in conjunction with a catch routine. */
294 NORETURN
void (*error_hook
) (void) ATTR_NORETURN
;
297 /* One should use catch_errors rather than manipulating these
299 #if defined(HAVE_SIGSETJMP)
300 #define SIGJMP_BUF sigjmp_buf
301 #define SIGSETJMP(buf) sigsetjmp(buf, 1)
302 #define SIGLONGJMP(buf,val) siglongjmp(buf,val)
304 #define SIGJMP_BUF jmp_buf
305 #define SIGSETJMP(buf) setjmp(buf)
306 #define SIGLONGJMP(buf,val) longjmp(buf,val)
309 /* Where to go for return_to_top_level. */
310 static SIGJMP_BUF
*catch_return
;
312 /* Return for reason REASON to the nearest containing catch_errors(). */
315 return_to_top_level (enum return_reason reason
)
320 /* Perhaps it would be cleaner to do this via the cleanup chain (not sure
321 I can think of a reason why that is vital, though). */
322 bpstat_clear_actions (stop_bpstat
); /* Clear queued breakpoint commands */
324 disable_current_display ();
325 do_cleanups (ALL_CLEANUPS
);
326 if (event_loop_p
&& target_can_async_p () && !target_executing
)
327 do_exec_cleanups (ALL_CLEANUPS
);
328 if (event_loop_p
&& sync_execution
)
329 do_exec_error_cleanups (ALL_CLEANUPS
);
331 if (annotation_level
> 1)
342 /* Jump to the containing catch_errors() call, communicating REASON
343 to that call via setjmp's return value. Note that REASON can't
344 be zero, by definition in defs.h. */
346 (NORETURN
void) SIGLONGJMP (*catch_return
, (int) reason
);
349 /* Call FUNC with arg ARGS, catching any errors. If there is no
350 error, return the value returned by FUNC. If there is an error,
351 print ERRSTRING, print the specific error message, then return
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 catch_errors (catch_errors_ftype
*func
, void * args
, char *errstring
,
384 SIGJMP_BUF
*saved_catch
;
387 struct cleanup
*saved_cleanup_chain
;
388 char *saved_error_pre_print
;
389 char *saved_quit_pre_print
;
391 /* Return value from SIGSETJMP(): enum return_reason if error or
392 quit caught, 0 otherwise. */
395 /* Override error/quit messages during FUNC. */
397 saved_error_pre_print
= error_pre_print
;
398 saved_quit_pre_print
= quit_pre_print
;
400 if (mask
& RETURN_MASK_ERROR
)
401 error_pre_print
= errstring
;
402 if (mask
& RETURN_MASK_QUIT
)
403 quit_pre_print
= errstring
;
405 /* Prevent error/quit during FUNC from calling cleanups established
408 saved_cleanup_chain
= save_cleanups ();
410 /* Call FUNC, catching error/quit events. */
412 saved_catch
= catch_return
;
413 catch_return
= &catch;
414 caught
= SIGSETJMP (catch);
416 val
= (*func
) (args
);
419 catch_return
= saved_catch
;
421 /* FIXME: cagney/1999-11-05: A correct FUNC implementation will
422 clean things up (restoring the cleanup chain) to the state they
423 were just prior to the call. Unfortunately, many FUNC's are not
424 that well behaved. This could be fixed by adding either a
425 do_cleanups call (to cover the problem) or an assertion check to
426 detect bad FUNCs code. */
428 /* Restore the cleanup chain and error/quit messages to their
431 restore_cleanups (saved_cleanup_chain
);
433 if (mask
& RETURN_MASK_QUIT
)
434 quit_pre_print
= saved_quit_pre_print
;
435 if (mask
& RETURN_MASK_ERROR
)
436 error_pre_print
= saved_error_pre_print
;
438 /* Return normally if no error/quit event occurred. */
443 /* If the caller didn't request that the event be caught, relay the
444 event to the next containing catch_errors(). */
446 if (!(mask
& RETURN_MASK (caught
)))
447 return_to_top_level (caught
);
449 /* Tell the caller that an event was caught.
451 FIXME: nsd/2000-02-22: When MASK is RETURN_MASK_ALL, the caller
452 can't tell what type of event occurred.
454 A possible fix is to add a new interface, catch_event(), that
455 returns enum return_reason after catching an error or a quit.
457 When returning normally, i.e. without catching an error or a
458 quit, catch_event() could return RETURN_NORMAL, which would be
459 added to enum return_reason. FUNC would return information
460 exclusively via ARGS.
462 Alternatively, normal catch_event() could return FUNC's return
463 value. The caller would need to be aware of potential overlap
464 with enum return_reason, which could be publicly restricted to
465 negative values to simplify return value processing in FUNC and
471 struct captured_command_args
473 catch_command_errors_ftype
*command
;
479 do_captured_command (void *data
)
481 struct captured_command_args
*context
= data
;
482 context
->command (context
->arg
, context
->from_tty
);
483 /* FIXME: cagney/1999-11-07: Technically this do_cleanups() call
484 isn't needed. Instead an assertion check could be made that
485 simply confirmed that the called function correctly cleaned up
486 after itself. Unfortunately, old code (prior to 1999-11-04) in
487 main.c was calling SET_TOP_LEVEL(), calling the command function,
488 and then *always* calling do_cleanups(). For the moment we
489 remain ``bug compatible'' with that old code.. */
490 do_cleanups (ALL_CLEANUPS
);
495 catch_command_errors (catch_command_errors_ftype
* command
,
496 char *arg
, int from_tty
, return_mask mask
)
498 struct captured_command_args args
;
499 args
.command
= command
;
501 args
.from_tty
= from_tty
;
502 return catch_errors (do_captured_command
, &args
, "", mask
);
506 /* Handler for SIGHUP. */
509 /* Just a little helper function for disconnect(). */
511 /* NOTE 1999-04-29: This function will be static again, once we modify
512 gdb to use the event loop as the default command loop and we merge
513 event-top.c into this file, top.c */
517 caution
= 0; /* Throw caution to the wind -- we're exiting.
518 This prevents asking the user dumb questions. */
519 quit_command ((char *) 0, 0);
524 disconnect (int signo
)
526 catch_errors (quit_cover
, NULL
,
527 "Could not kill the program being debugged", RETURN_MASK_ALL
);
528 signal (SIGHUP
, SIG_DFL
);
529 kill (getpid (), SIGHUP
);
531 #endif /* defined SIGHUP */
533 /* Line number we are currently in in a file which is being sourced. */
534 /* NOTE 1999-04-29: This variable will be static again, once we modify
535 gdb to use the event loop as the default command loop and we merge
536 event-top.c into this file, top.c */
537 /* static */ int source_line_number
;
539 /* Name of the file we are sourcing. */
540 /* NOTE 1999-04-29: This variable will be static again, once we modify
541 gdb to use the event loop as the default command loop and we merge
542 event-top.c into this file, top.c */
543 /* static */ char *source_file_name
;
545 /* Buffer containing the error_pre_print used by the source stuff.
547 /* NOTE 1999-04-29: This variable will be static again, once we modify
548 gdb to use the event loop as the default command loop and we merge
549 event-top.c into this file, top.c */
550 /* static */ char *source_error
;
551 static int source_error_allocated
;
553 /* Something to glom on to the start of error_pre_print if source_file_name
555 /* NOTE 1999-04-29: This variable will be static again, once we modify
556 gdb to use the event loop as the default command loop and we merge
557 event-top.c into this file, top.c */
558 /* static */ char *source_pre_error
;
560 /* Clean up on error during a "source" command (or execution of a
561 user-defined command). */
564 do_restore_instream_cleanup (void *stream
)
566 /* Restore the previous input stream. */
570 /* Read commands from STREAM. */
572 read_command_file (FILE *stream
)
574 struct cleanup
*cleanups
;
576 cleanups
= make_cleanup (do_restore_instream_cleanup
, instream
);
579 do_cleanups (cleanups
);
582 void (*pre_init_ui_hook
) (void);
586 do_chdir_cleanup (void *old_dir
)
593 /* Execute the line P as a command.
594 Pass FROM_TTY as second argument to the defining function. */
597 execute_command (char *p
, int from_tty
)
599 register struct cmd_list_element
*c
;
600 register enum language flang
;
601 static int warned
= 0;
606 /* Force cleanup of any alloca areas if using C alloca instead of
610 /* This can happen when command_line_input hits end of file. */
614 serial_log_command (p
);
616 while (*p
== ' ' || *p
== '\t')
623 c
= lookup_cmd (&p
, cmdlist
, "", 0, 1);
625 /* If the target is running, we allow only a limited set of
627 if (event_loop_p
&& target_can_async_p () && target_executing
)
628 if (!strcmp (c
->name
, "help")
629 && !strcmp (c
->name
, "pwd")
630 && !strcmp (c
->name
, "show")
631 && !strcmp (c
->name
, "stop"))
632 error ("Cannot execute this command while the target is running.");
634 /* Pass null arg rather than an empty one. */
637 /* Clear off trailing whitespace, except for set and complete command. */
639 && c
->type
!= set_cmd
640 && !is_complete_command (c
->function
.cfunc
))
642 p
= arg
+ strlen (arg
) - 1;
643 while (p
>= arg
&& (*p
== ' ' || *p
== '\t'))
648 /* If this command has been pre-hooked, run the hook first. */
649 if ((c
->hook_pre
) && (!c
->hook_in
))
651 c
->hook_in
= 1; /* Prevent recursive hooking */
652 execute_user_command (c
->hook_pre
, (char *) 0);
653 c
->hook_in
= 0; /* Allow hook to work again once it is complete */
656 if (c
->flags
& DEPRECATED_WARN_USER
)
657 deprecated_cmd_warning (&line
);
659 if (c
->class == class_user
)
660 execute_user_command (c
, arg
);
661 else if (c
->type
== set_cmd
|| c
->type
== show_cmd
)
662 do_setshow_command (arg
, from_tty
& caution
, c
);
663 else if (c
->function
.cfunc
== NO_FUNCTION
)
664 error ("That is not a command, just a help topic.");
665 else if (call_command_hook
)
666 call_command_hook (c
, arg
, from_tty
& caution
);
668 (*c
->function
.cfunc
) (arg
, from_tty
& caution
);
670 /* If this command has been post-hooked, run the hook last. */
671 if ((c
->hook_post
) && (!c
->hook_in
))
673 c
->hook_in
= 1; /* Prevent recursive hooking */
674 execute_user_command (c
->hook_post
, (char *) 0);
675 c
->hook_in
= 0; /* allow hook to work again once it is complete */
680 /* Tell the user if the language has changed (except first time). */
681 if (current_language
!= expected_language
)
683 if (language_mode
== language_mode_auto
)
685 language_info (1); /* Print what changed. */
690 /* Warn the user if the working language does not match the
691 language of the current frame. Only warn the user if we are
692 actually running the program, i.e. there is a stack. */
693 /* FIXME: This should be cacheing the frame and only running when
694 the frame changes. */
696 if (target_has_stack
)
698 flang
= get_frame_language ();
700 && flang
!= language_unknown
701 && flang
!= current_language
->la_language
)
703 printf_filtered ("%s\n", lang_frame_mismatch_warn
);
709 /* Read commands from `instream' and execute them
710 until end of file or error reading instream. */
715 struct cleanup
*old_chain
;
717 int stdin_is_tty
= ISATTY (stdin
);
718 long time_at_cmd_start
;
720 long space_at_cmd_start
= 0;
722 extern int display_time
;
723 extern int display_space
;
725 while (instream
&& !feof (instream
))
727 if (window_hook
&& instream
== stdin
)
728 (*window_hook
) (instream
, get_prompt ());
731 if (instream
== stdin
&& stdin_is_tty
)
732 reinitialize_more_filter ();
733 old_chain
= make_cleanup (null_cleanup
, 0);
735 /* Get a command-line. This calls the readline package. */
736 command
= command_line_input (instream
== stdin
?
737 get_prompt () : (char *) NULL
,
738 instream
== stdin
, "prompt");
742 time_at_cmd_start
= get_run_time ();
747 extern char **environ
;
748 char *lim
= (char *) sbrk (0);
750 space_at_cmd_start
= (long) (lim
- (char *) &environ
);
754 execute_command (command
, instream
== stdin
);
755 /* Do any commands attached to breakpoint we stopped at. */
756 bpstat_do_actions (&stop_bpstat
);
757 do_cleanups (old_chain
);
761 long cmd_time
= get_run_time () - time_at_cmd_start
;
763 printf_unfiltered ("Command execution time: %ld.%06ld\n",
764 cmd_time
/ 1000000, cmd_time
% 1000000);
770 extern char **environ
;
771 char *lim
= (char *) sbrk (0);
772 long space_now
= lim
- (char *) &environ
;
773 long space_diff
= space_now
- space_at_cmd_start
;
775 printf_unfiltered ("Space used: %ld (%c%ld for this command)\n",
777 (space_diff
>= 0 ? '+' : '-'),
784 /* Read commands from `instream' and execute them until end of file or
785 error reading instream. This command loop doesnt care about any
786 such things as displaying time and space usage. If the user asks
787 for those, they won't work. */
789 simplified_command_loop (char *(*read_input_func
) (char *),
790 void (*execute_command_func
) (char *, int))
792 struct cleanup
*old_chain
;
794 int stdin_is_tty
= ISATTY (stdin
);
796 while (instream
&& !feof (instream
))
799 if (instream
== stdin
&& stdin_is_tty
)
800 reinitialize_more_filter ();
801 old_chain
= make_cleanup (null_cleanup
, 0);
803 /* Get a command-line. */
804 command
= (*read_input_func
) (instream
== stdin
?
805 get_prompt () : (char *) NULL
);
810 (*execute_command_func
) (command
, instream
== stdin
);
812 /* Do any commands attached to breakpoint we stopped at. */
813 bpstat_do_actions (&stop_bpstat
);
815 do_cleanups (old_chain
);
819 /* Commands call this if they do not want to be repeated by null lines. */
827 /* If we aren't reading from standard input, we are saving the last
828 thing read from stdin in line and don't want to delete it. Null lines
829 won't repeat here in any case. */
830 if (instream
== stdin
)
834 /* Read a line from the stream "instream" without command line editing.
836 It prints PROMPT_ARG once at the start.
837 Action is compatible with "readline", e.g. space for the result is
838 malloc'd and should be freed by the caller.
840 A NULL return means end of file. */
842 gdb_readline (char *prompt_arg
)
847 int result_size
= 80;
851 /* Don't use a _filtered function here. It causes the assumed
852 character position to be off, since the newline we read from
853 the user is not accounted for. */
854 fputs_unfiltered (prompt_arg
, gdb_stdout
);
855 /* OBSOLETE #ifdef MPW */
856 /* OBSOLETE Move to a new line so the entered line doesn't have a prompt */
857 /* OBSOLETE on the front of it. */
858 /* OBSOLETE fputs_unfiltered ("\n", gdb_stdout); */
859 /* OBSOLETE #endif *//* MPW */
860 gdb_flush (gdb_stdout
);
863 result
= (char *) xmalloc (result_size
);
867 /* Read from stdin if we are executing a user defined command.
868 This is the right thing for prompt_for_continue, at least. */
869 c
= fgetc (instream
? instream
: stdin
);
874 /* The last line does not end with a newline. Return it, and
875 if we are called again fgetc will still return EOF and
876 we'll return NULL then. */
883 #ifndef CRLF_SOURCE_FILES
887 if (input_index
> 0 && result
[input_index
- 1] == '\r')
893 result
[input_index
++] = c
;
894 while (input_index
>= result_size
)
897 result
= (char *) xrealloc (result
, result_size
);
901 result
[input_index
++] = '\0';
905 /* Variables which control command line editing and history
906 substitution. These variables are given default values at the end
908 static int command_editing_p
;
909 /* NOTE 1999-04-29: This variable will be static again, once we modify
910 gdb to use the event loop as the default command loop and we merge
911 event-top.c into this file, top.c */
912 /* static */ int history_expansion_p
;
913 static int write_history_p
;
914 static int history_size
;
915 static char *history_filename
;
922 #if STOP_SIGNAL == SIGTSTP
923 signal (SIGTSTP
, SIG_DFL
);
925 kill (getpid (), SIGTSTP
);
926 signal (SIGTSTP
, stop_sig
);
928 signal (STOP_SIGNAL
, stop_sig
);
930 printf_unfiltered ("%s", get_prompt ());
931 gdb_flush (gdb_stdout
);
933 /* Forget about any previous command -- null line now will do nothing. */
936 #endif /* STOP_SIGNAL */
938 /* Initialize signal handlers. */
940 float_handler (int signo
)
942 /* This message is based on ANSI C, section 4.7. Note that integer
943 divide by zero causes this, so "float" is a misnomer. */
944 signal (SIGFPE
, float_handler
);
945 error ("Erroneous arithmetic operation.");
949 do_nothing (int signo
)
951 /* Under System V the default disposition of a signal is reinstated after
952 the signal is caught and delivered to an application process. On such
953 systems one must restore the replacement signal handler if one wishes
954 to continue handling the signal in one's program. On BSD systems this
955 is not needed but it is harmless, and it simplifies the code to just do
956 it unconditionally. */
957 signal (signo
, do_nothing
);
963 signal (SIGINT
, request_quit
);
965 /* If SIGTRAP was set to SIG_IGN, then the SIG_IGN will get passed
966 to the inferior and breakpoints will be ignored. */
968 signal (SIGTRAP
, SIG_DFL
);
971 /* If we initialize SIGQUIT to SIG_IGN, then the SIG_IGN will get
972 passed to the inferior, which we don't want. It would be
973 possible to do a "signal (SIGQUIT, SIG_DFL)" after we fork, but
974 on BSD4.3 systems using vfork, that can affect the
975 GDB process as well as the inferior (the signal handling tables
976 might be in memory, shared between the two). Since we establish
977 a handler for SIGQUIT, when we call exec it will set the signal
978 to SIG_DFL for us. */
979 signal (SIGQUIT
, do_nothing
);
981 if (signal (SIGHUP
, do_nothing
) != SIG_IGN
)
982 signal (SIGHUP
, disconnect
);
984 signal (SIGFPE
, float_handler
);
986 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
987 signal (SIGWINCH
, SIGWINCH_HANDLER
);
991 /* Read one line from the command input stream `instream'
992 into the local static buffer `linebuffer' (whose current length
994 The buffer is made bigger as necessary.
995 Returns the address of the start of the line.
997 NULL is returned for end of file.
999 *If* the instream == stdin & stdin is a terminal, the line read
1000 is copied into the file line saver (global var char *line,
1001 length linesize) so that it can be duplicated.
1003 This routine either uses fancy command line editing or
1004 simple input as the user has requested. */
1007 command_line_input (char *prompt_arg
, int repeat
, char *annotation_suffix
)
1009 static char *linebuffer
= 0;
1010 static unsigned linelength
= 0;
1014 char *local_prompt
= prompt_arg
;
1018 /* The annotation suffix must be non-NULL. */
1019 if (annotation_suffix
== NULL
)
1020 annotation_suffix
= "";
1022 if (annotation_level
> 1 && instream
== stdin
)
1024 local_prompt
= alloca ((prompt_arg
== NULL
? 0 : strlen (prompt_arg
))
1025 + strlen (annotation_suffix
) + 40);
1026 if (prompt_arg
== NULL
)
1027 local_prompt
[0] = '\0';
1029 strcpy (local_prompt
, prompt_arg
);
1030 strcat (local_prompt
, "\n\032\032");
1031 strcat (local_prompt
, annotation_suffix
);
1032 strcat (local_prompt
, "\n");
1035 if (linebuffer
== 0)
1038 linebuffer
= (char *) xmalloc (linelength
);
1043 /* Control-C quits instantly if typed while in this loop
1044 since it should not wait until the user types a newline. */
1050 signal (STOP_SIGNAL
, handle_stop_sig
);
1052 signal (STOP_SIGNAL
, stop_sig
);
1058 /* Make sure that all output has been output. Some machines may let
1059 you get away with leaving out some of the gdb_flush, but not all. */
1061 gdb_flush (gdb_stdout
);
1062 gdb_flush (gdb_stderr
);
1064 if (source_file_name
!= NULL
)
1066 ++source_line_number
;
1067 sprintf (source_error
,
1068 "%s%s:%d: Error in sourced command file:\n",
1071 source_line_number
);
1072 error_pre_print
= source_error
;
1075 if (annotation_level
> 1 && instream
== stdin
)
1077 printf_unfiltered ("\n\032\032pre-");
1078 printf_unfiltered (annotation_suffix
);
1079 printf_unfiltered ("\n");
1082 /* Don't use fancy stuff if not talking to stdin. */
1083 if (readline_hook
&& instream
== NULL
)
1085 rl
= (*readline_hook
) (local_prompt
);
1087 else if (command_editing_p
&& instream
== stdin
&& ISATTY (instream
))
1089 rl
= readline (local_prompt
);
1093 rl
= gdb_readline (local_prompt
);
1096 if (annotation_level
> 1 && instream
== stdin
)
1098 printf_unfiltered ("\n\032\032post-");
1099 printf_unfiltered (annotation_suffix
);
1100 printf_unfiltered ("\n");
1103 if (!rl
|| rl
== (char *) EOF
)
1108 if (strlen (rl
) + 1 + (p
- linebuffer
) > linelength
)
1110 linelength
= strlen (rl
) + 1 + (p
- linebuffer
);
1111 nline
= (char *) xrealloc (linebuffer
, linelength
);
1112 p
+= nline
- linebuffer
;
1116 /* Copy line. Don't copy null at end. (Leaves line alone
1117 if this was just a newline) */
1121 xfree (rl
); /* Allocated in readline. */
1123 if (p
== linebuffer
|| *(p
- 1) != '\\')
1126 p
--; /* Put on top of '\'. */
1127 local_prompt
= (char *) 0;
1132 signal (STOP_SIGNAL
, SIG_DFL
);
1139 #define SERVER_COMMAND_LENGTH 7
1141 (p
- linebuffer
> SERVER_COMMAND_LENGTH
)
1142 && STREQN (linebuffer
, "server ", SERVER_COMMAND_LENGTH
);
1145 /* Note that we don't set `line'. Between this and the check in
1146 dont_repeat, this insures that repeating will still do the
1149 return linebuffer
+ SERVER_COMMAND_LENGTH
;
1152 /* Do history expansion if that is wished. */
1153 if (history_expansion_p
&& instream
== stdin
1154 && ISATTY (instream
))
1156 char *history_value
;
1159 *p
= '\0'; /* Insert null now. */
1160 expanded
= history_expand (linebuffer
, &history_value
);
1163 /* Print the changes. */
1164 printf_unfiltered ("%s\n", history_value
);
1166 /* If there was an error, call this function again. */
1169 xfree (history_value
);
1170 return command_line_input (prompt_arg
, repeat
, annotation_suffix
);
1172 if (strlen (history_value
) > linelength
)
1174 linelength
= strlen (history_value
) + 1;
1175 linebuffer
= (char *) xrealloc (linebuffer
, linelength
);
1177 strcpy (linebuffer
, history_value
);
1178 p
= linebuffer
+ strlen (linebuffer
);
1179 xfree (history_value
);
1183 /* If we just got an empty line, and that is supposed
1184 to repeat the previous command, return the value in the
1186 if (repeat
&& p
== linebuffer
)
1188 for (p1
= linebuffer
; *p1
== ' ' || *p1
== '\t'; p1
++);
1194 /* Add line to history if appropriate. */
1195 if (instream
== stdin
1196 && ISATTY (stdin
) && *linebuffer
)
1197 add_history (linebuffer
);
1199 /* Note: lines consisting solely of comments are added to the command
1200 history. This is useful when you type a command, and then
1201 realize you don't want to execute it quite yet. You can comment
1202 out the command and then later fetch it from the value history
1203 and remove the '#'. The kill ring is probably better, but some
1204 people are in the habit of commenting things out. */
1206 *p1
= '\0'; /* Found a comment. */
1208 /* Save into global buffer if appropriate. */
1211 if (linelength
> linesize
)
1213 line
= xrealloc (line
, linelength
);
1214 linesize
= linelength
;
1216 strcpy (line
, linebuffer
);
1223 /* Print the GDB banner. */
1225 print_gdb_version (struct ui_file
*stream
)
1227 /* From GNU coding standards, first line is meant to be easy for a
1228 program to parse, and is just canonical program name and version
1229 number, which starts after last space. */
1232 /* Print it console style until a format is defined */
1233 fprintf_filtered (stream
, "GNU gdb %s (MI_OUT)\n", version
);
1235 fprintf_filtered (stream
, "GNU gdb %s\n", version
);
1238 /* Second line is a copyright notice. */
1240 fprintf_filtered (stream
, "Copyright 2001 Free Software Foundation, Inc.\n");
1242 /* Following the copyright is a brief statement that the program is
1243 free software, that users are free to copy and change it on
1244 certain conditions, that it is covered by the GNU GPL, and that
1245 there is no warranty. */
1247 fprintf_filtered (stream
, "\
1248 GDB is free software, covered by the GNU General Public License, and you are\n\
1249 welcome to change it and/or distribute copies of it under certain conditions.\n\
1250 Type \"show copying\" to see the conditions.\n\
1251 There is absolutely no warranty for GDB. Type \"show warranty\" for details.\n");
1253 /* After the required info we print the configuration information. */
1255 fprintf_filtered (stream
, "This GDB was configured as \"");
1256 if (!STREQ (host_name
, target_name
))
1258 fprintf_filtered (stream
, "--host=%s --target=%s", host_name
, target_name
);
1262 fprintf_filtered (stream
, "%s", host_name
);
1264 fprintf_filtered (stream
, "\".");
1267 /* get_prompt: access method for the GDB prompt string. */
1269 #define MAX_PROMPT_SIZE 256
1272 * int get_prompt_1 (char * buf);
1274 * Work-horse for get_prompt (called via catch_errors).
1275 * Argument is buffer to hold the formatted prompt.
1277 * Returns: 1 for success (use formatted prompt)
1278 * 0 for failure (use gdb_prompt_string).
1281 static int gdb_prompt_escape
;
1284 get_prompt_1 (void *data
)
1286 char *formatted_prompt
= data
;
1290 local_prompt
= PROMPT (0);
1292 local_prompt
= gdb_prompt_string
;
1295 if (gdb_prompt_escape
== 0)
1297 return 0; /* do no formatting */
1300 /* formatted prompt */
1302 char fmt
[40], *promptp
, *outp
, *tmp
;
1309 struct type
*arg_type
, *elt_type
;
1311 promptp
= local_prompt
;
1312 outp
= formatted_prompt
;
1314 while (*promptp
!= '\0')
1316 int available
= MAX_PROMPT_SIZE
- (outp
- formatted_prompt
) - 1;
1318 if (*promptp
!= gdb_prompt_escape
)
1320 if (available
>= 1) /* overflow protect */
1321 *outp
++ = *promptp
++;
1325 /* GDB prompt string contains escape char. Parse for arg.
1326 Two consecutive escape chars followed by arg followed by
1327 a comma means to insert the arg using a default format.
1328 Otherwise a printf format string may be included between
1329 the two escape chars. eg:
1330 %%foo, insert foo using default format
1331 %2.2f%foo, insert foo using "%2.2f" format
1332 A mismatch between the format string and the data type
1333 of "foo" is an error (which we don't know how to protect
1336 fmt
[0] = '\0'; /* assume null format string */
1337 if (promptp
[1] == gdb_prompt_escape
) /* double esc char */
1339 promptp
+= 2; /* skip past two escape chars. */
1343 /* extract format string from between two esc chars */
1347 fmt
[i
++] = *promptp
++; /* copy format string */
1349 while (i
< sizeof (fmt
) - 1 &&
1350 *promptp
!= gdb_prompt_escape
&&
1353 if (*promptp
!= gdb_prompt_escape
)
1354 error ("Syntax error at prompt position %d",
1355 promptp
- local_prompt
);
1358 promptp
++; /* skip second escape char */
1359 fmt
[i
++] = '\0'; /* terminate the format string */
1363 arg_val
= parse_to_comma_and_eval (&promptp
);
1364 if (*promptp
== ',')
1365 promptp
++; /* skip past the comma */
1366 arg_type
= check_typedef (VALUE_TYPE (arg_val
));
1367 switch (TYPE_CODE (arg_type
))
1369 case TYPE_CODE_ARRAY
:
1370 elt_type
= check_typedef (TYPE_TARGET_TYPE (arg_type
));
1371 if (TYPE_LENGTH (arg_type
) > 0 &&
1372 TYPE_LENGTH (elt_type
) == 1 &&
1373 TYPE_CODE (elt_type
) == TYPE_CODE_INT
)
1375 int len
= TYPE_LENGTH (arg_type
);
1377 if (VALUE_LAZY (arg_val
))
1378 value_fetch_lazy (arg_val
);
1379 tmp
= VALUE_CONTENTS (arg_val
);
1381 if (len
> available
)
1382 len
= available
; /* overflow protect */
1384 /* FIXME: how to protect GDB from crashing
1385 from bad user-supplied format string? */
1387 sprintf (outp
, fmt
, tmp
);
1389 strncpy (outp
, tmp
, len
);
1394 elt_type
= check_typedef (TYPE_TARGET_TYPE (arg_type
));
1395 addrval
= value_as_pointer (arg_val
);
1397 if (TYPE_LENGTH (elt_type
) == 1 &&
1398 TYPE_CODE (elt_type
) == TYPE_CODE_INT
&&
1401 /* display it as a string */
1402 char *default_fmt
= "%s";
1406 /* Limiting the number of bytes that the following call
1407 will read protects us from sprintf overflow later. */
1408 i
= target_read_string (addrval
, /* src */
1410 available
, /* len */
1412 if (err
) /* read failed */
1413 error ("%s on target_read", safe_strerror (err
));
1415 tmp
[i
] = '\0'; /* force-terminate string */
1416 /* FIXME: how to protect GDB from crashing
1417 from bad user-supplied format string? */
1418 sprintf (outp
, fmt
[0] == 0 ? default_fmt
: fmt
,
1424 /* display it as a pointer */
1425 char *default_fmt
= "0x%x";
1427 /* FIXME: how to protect GDB from crashing
1428 from bad user-supplied format string? */
1429 if (available
>= 16 /*? */ ) /* overflow protect */
1430 sprintf (outp
, fmt
[0] == 0 ? default_fmt
: fmt
,
1436 char *default_fmt
= "%g";
1438 doubleval
= value_as_double (arg_val
);
1439 /* FIXME: how to protect GDB from crashing
1440 from bad user-supplied format string? */
1441 if (available
>= 16 /*? */ ) /* overflow protect */
1442 sprintf (outp
, fmt
[0] == 0 ? default_fmt
: fmt
,
1443 (double) doubleval
);
1448 char *default_fmt
= "%d";
1450 longval
= value_as_long (arg_val
);
1451 /* FIXME: how to protect GDB from crashing
1452 from bad user-supplied format string? */
1453 if (available
>= 16 /*? */ ) /* overflow protect */
1454 sprintf (outp
, fmt
[0] == 0 ? default_fmt
: fmt
,
1458 case TYPE_CODE_BOOL
:
1460 /* no default format for bool */
1461 longval
= value_as_long (arg_val
);
1462 if (available
>= 8 /*? */ ) /* overflow protect */
1465 strcpy (outp
, "<true>");
1467 strcpy (outp
, "<false>");
1471 case TYPE_CODE_ENUM
:
1473 /* no default format for enum */
1474 longval
= value_as_long (arg_val
);
1475 len
= TYPE_NFIELDS (arg_type
);
1476 /* find enum name if possible */
1477 for (i
= 0; i
< len
; i
++)
1478 if (TYPE_FIELD_BITPOS (arg_type
, i
) == longval
)
1479 break; /* match -- end loop */
1481 if (i
< len
) /* enum name found */
1483 char *name
= TYPE_FIELD_NAME (arg_type
, i
);
1485 strncpy (outp
, name
, available
);
1486 /* in casel available < strlen (name), */
1487 outp
[available
] = '\0';
1491 if (available
>= 16 /*? */ ) /* overflow protect */
1492 sprintf (outp
, "%ld", (long) longval
);
1496 case TYPE_CODE_VOID
:
1498 break; /* void type -- no output */
1500 error ("bad data type at prompt position %d",
1501 promptp
- local_prompt
);
1504 outp
+= strlen (outp
);
1507 *outp
++ = '\0'; /* terminate prompt string */
1515 static char buf
[MAX_PROMPT_SIZE
];
1517 if (catch_errors (get_prompt_1
, buf
, "bad formatted prompt: ",
1520 return &buf
[0]; /* successful formatted prompt */
1524 /* Prompt could not be formatted. */
1528 return gdb_prompt_string
;
1533 set_prompt (char *s
)
1535 /* ??rehrauer: I don't know why this fails, since it looks as though
1536 assignments to prompt are wrapped in calls to savestring...
1541 PROMPT (0) = savestring (s
, strlen (s
));
1543 gdb_prompt_string
= savestring (s
, strlen (s
));
1547 /* If necessary, make the user confirm that we should quit. Return
1548 non-zero if we should quit, zero if we shouldn't. */
1553 if (! ptid_equal (inferior_ptid
, null_ptid
) && target_has_execution
)
1557 /* This is something of a hack. But there's no reliable way to
1558 see if a GUI is running. The `use_windows' variable doesn't
1561 s
= "A debugging session is active.\nDo you still want to close the debugger?";
1562 else if (attach_flag
)
1563 s
= "The program is running. Quit anyway (and detach it)? ";
1565 s
= "The program is running. Exit anyway? ";
1574 /* Quit without asking for confirmation. */
1577 quit_force (char *args
, int from_tty
)
1581 /* An optional expression may be used to cause gdb to terminate with the
1582 value of that expression. */
1585 value_ptr val
= parse_and_eval (args
);
1587 exit_code
= (int) value_as_long (val
);
1590 if (! ptid_equal (inferior_ptid
, null_ptid
) && target_has_execution
)
1593 target_detach (args
, from_tty
);
1598 /* UDI wants this, to kill the TIP. */
1601 /* Save the history information if it is appropriate to do so. */
1602 if (write_history_p
&& history_filename
)
1603 write_history (history_filename
);
1605 do_final_cleanups (ALL_CLEANUPS
); /* Do any final cleanups before exiting */
1610 /* Returns whether GDB is running on a terminal and whether the user
1611 desires that questions be asked of them on that terminal. */
1614 input_from_terminal_p (void)
1616 return gdb_has_a_terminal () && (instream
== stdin
) & caution
;
1621 dont_repeat_command (char *ignored
, int from_tty
)
1623 *line
= 0; /* Can't call dont_repeat here because we're not
1624 necessarily reading from stdin. */
1627 /* Functions to manipulate command line editing control variables. */
1629 /* Number of commands to print in each call to show_commands. */
1630 #define Hist_print 10
1632 show_commands (char *args
, int from_tty
)
1634 /* Index for history commands. Relative to history_base. */
1637 /* Number of the history entry which we are planning to display next.
1638 Relative to history_base. */
1641 /* The first command in the history which doesn't exist (i.e. one more
1642 than the number of the last command). Relative to history_base. */
1645 /* Print out some of the commands from the command history. */
1646 /* First determine the length of the history list. */
1647 hist_len
= history_size
;
1648 for (offset
= 0; offset
< history_size
; offset
++)
1650 if (!history_get (history_base
+ offset
))
1659 if (args
[0] == '+' && args
[1] == '\0')
1660 /* "info editing +" should print from the stored position. */
1663 /* "info editing <exp>" should print around command number <exp>. */
1664 num
= (parse_and_eval_long (args
) - history_base
) - Hist_print
/ 2;
1666 /* "show commands" means print the last Hist_print commands. */
1669 num
= hist_len
- Hist_print
;
1675 /* If there are at least Hist_print commands, we want to display the last
1676 Hist_print rather than, say, the last 6. */
1677 if (hist_len
- num
< Hist_print
)
1679 num
= hist_len
- Hist_print
;
1684 for (offset
= num
; offset
< num
+ Hist_print
&& offset
< hist_len
; offset
++)
1686 printf_filtered ("%5d %s\n", history_base
+ offset
,
1687 (history_get (history_base
+ offset
))->line
);
1690 /* The next command we want to display is the next one that we haven't
1694 /* If the user repeats this command with return, it should do what
1695 "show commands +" does. This is unnecessary if arg is null,
1696 because "show commands +" is not useful after "show commands". */
1697 if (from_tty
&& args
)
1704 /* Called by do_setshow_command. */
1707 set_history_size_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1709 if (history_size
== INT_MAX
)
1710 unstifle_history ();
1711 else if (history_size
>= 0)
1712 stifle_history (history_size
);
1715 history_size
= INT_MAX
;
1716 error ("History size must be non-negative");
1722 set_history (char *args
, int from_tty
)
1724 printf_unfiltered ("\"set history\" must be followed by the name of a history subcommand.\n");
1725 help_list (sethistlist
, "set history ", -1, gdb_stdout
);
1730 show_history (char *args
, int from_tty
)
1732 cmd_show_list (showhistlist
, from_tty
, "");
1735 int info_verbose
= 0; /* Default verbose msgs off */
1737 /* Called by do_setshow_command. An elaborate joke. */
1740 set_verbose (char *args
, int from_tty
, struct cmd_list_element
*c
)
1742 char *cmdname
= "verbose";
1743 struct cmd_list_element
*showcmd
;
1745 showcmd
= lookup_cmd_1 (&cmdname
, showlist
, NULL
, 1);
1749 c
->doc
= "Set verbose printing of informational messages.";
1750 showcmd
->doc
= "Show verbose printing of informational messages.";
1754 c
->doc
= "Set verbosity.";
1755 showcmd
->doc
= "Show verbosity.";
1759 /* Init the history buffer. Note that we are called after the init file(s)
1760 * have been read so that the user can change the history file via his
1761 * .gdbinit file (for instance). The GDBHISTFILE environment variable
1762 * overrides all of this.
1770 tmpenv
= getenv ("HISTSIZE");
1772 history_size
= atoi (tmpenv
);
1773 else if (!history_size
)
1776 stifle_history (history_size
);
1778 tmpenv
= getenv ("GDBHISTFILE");
1780 history_filename
= savestring (tmpenv
, strlen (tmpenv
));
1781 else if (!history_filename
)
1783 /* We include the current directory so that if the user changes
1784 directories the file written will be the same as the one
1787 /* No leading dots in file names are allowed on MSDOS. */
1788 history_filename
= concat (current_directory
, "/_gdb_history", NULL
);
1790 history_filename
= concat (current_directory
, "/.gdb_history", NULL
);
1793 read_history (history_filename
);
1799 struct cmd_list_element
*c
;
1801 /* If we are running the asynchronous version,
1802 we initialize the prompts differently. */
1805 gdb_prompt_string
= savestring (DEFAULT_PROMPT
, strlen (DEFAULT_PROMPT
));
1809 /* initialize the prompt stack to a simple "(gdb) " prompt or to
1810 whatever the DEFAULT_PROMPT is. */
1811 the_prompts
.top
= 0;
1813 PROMPT (0) = savestring (DEFAULT_PROMPT
, strlen (DEFAULT_PROMPT
));
1815 /* Set things up for annotation_level > 1, if the user ever decides
1817 async_annotation_suffix
= "prompt";
1818 /* Set the variable associated with the setshow prompt command. */
1819 new_async_prompt
= savestring (PROMPT (0), strlen (PROMPT (0)));
1821 /* If gdb was started with --annotate=2, this is equivalent to
1822 the user entering the command 'set annotate 2' at the gdb
1823 prompt, so we need to do extra processing. */
1824 if (annotation_level
> 1)
1825 set_async_annotation_level (NULL
, 0, NULL
);
1827 gdb_prompt_escape
= 0; /* default to none. */
1829 /* Set the important stuff up for command editing. */
1830 command_editing_p
= 1;
1831 history_expansion_p
= 0;
1832 write_history_p
= 0;
1834 /* Setup important stuff for command line editing. */
1835 rl_completion_entry_function
= (int (*)()) readline_line_completion_function
;
1836 rl_completer_word_break_characters
=
1837 get_gdb_completer_word_break_characters ();
1838 rl_completer_quote_characters
= get_gdb_completer_quote_characters ();
1839 rl_readline_name
= "gdb";
1841 /* The set prompt command is different depending whether or not the
1842 async version is run. NOTE: this difference is going to
1843 disappear as we make the event loop be the default engine of
1848 (add_set_cmd ("prompt", class_support
, var_string
,
1849 (char *) &gdb_prompt_string
, "Set gdb's prompt",
1855 c
= add_set_cmd ("prompt", class_support
, var_string
,
1856 (char *) &new_async_prompt
, "Set gdb's prompt",
1858 add_show_from_set (c
, &showlist
);
1859 c
->function
.sfunc
= set_async_prompt
;
1863 (add_set_cmd ("prompt-escape-char", class_support
, var_zinteger
,
1864 (char *) &gdb_prompt_escape
,
1865 "Set escape character for formatting of gdb's prompt",
1869 add_com ("dont-repeat", class_support
, dont_repeat_command
, "Don't repeat this command.\n\
1870 Primarily used inside of user-defined commands that should not be repeated when\n\
1873 /* The set editing command is different depending whether or not the
1874 async version is run. NOTE: this difference is going to disappear
1875 as we make the event loop be the default engine of gdb. */
1879 (add_set_cmd ("editing", class_support
, var_boolean
, (char *) &command_editing_p
,
1880 "Set editing of command lines as they are typed.\n\
1881 Use \"on\" to enable the editing, and \"off\" to disable it.\n\
1882 Without an argument, command line editing is enabled. To edit, use\n\
1883 EMACS-like or VI-like commands like control-P or ESC.", &setlist
),
1888 c
= add_set_cmd ("editing", class_support
, var_boolean
, (char *) &async_command_editing_p
,
1889 "Set editing of command lines as they are typed.\n\
1890 Use \"on\" to enable the editing, and \"off\" to disable it.\n\
1891 Without an argument, command line editing is enabled. To edit, use\n\
1892 EMACS-like or VI-like commands like control-P or ESC.", &setlist
);
1894 add_show_from_set (c
, &showlist
);
1895 c
->function
.sfunc
= set_async_editing_command
;
1899 (add_set_cmd ("save", no_class
, var_boolean
, (char *) &write_history_p
,
1900 "Set saving of the history record on exit.\n\
1901 Use \"on\" to enable the saving, and \"off\" to disable it.\n\
1902 Without an argument, saving is enabled.", &sethistlist
),
1905 c
= add_set_cmd ("size", no_class
, var_integer
, (char *) &history_size
,
1906 "Set the size of the command history, \n\
1907 ie. the number of previous commands to keep a record of.", &sethistlist
);
1908 add_show_from_set (c
, &showhistlist
);
1909 c
->function
.sfunc
= set_history_size_command
;
1911 c
= add_set_cmd ("filename", no_class
, var_filename
,
1912 (char *) &history_filename
,
1913 "Set the filename in which to record the command history\n\
1914 (the list of previous commands of which a record is kept).", &sethistlist
);
1915 c
->completer
= filename_completer
;
1916 add_show_from_set (c
, &showhistlist
);
1919 (add_set_cmd ("confirm", class_support
, var_boolean
,
1921 "Set whether to confirm potentially dangerous operations.",
1925 /* The set annotate command is different depending whether or not
1926 the async version is run. NOTE: this difference is going to
1927 disappear as we make the event loop be the default engine of
1931 c
= add_set_cmd ("annotate", class_obscure
, var_zinteger
,
1932 (char *) &annotation_level
, "Set annotation_level.\n\
1933 0 == normal; 1 == fullname (for use when running under emacs)\n\
1934 2 == output annotated suitably for use by programs that control GDB.",
1936 c
= add_show_from_set (c
, &showlist
);
1940 c
= add_set_cmd ("annotate", class_obscure
, var_zinteger
,
1941 (char *) &annotation_level
, "Set annotation_level.\n\
1942 0 == normal; 1 == fullname (for use when running under emacs)\n\
1943 2 == output annotated suitably for use by programs that control GDB.",
1945 add_show_from_set (c
, &showlist
);
1946 c
->function
.sfunc
= set_async_annotation_level
;
1951 (add_set_cmd ("exec-done-display", class_support
, var_boolean
, (char *) &exec_done_display_p
,
1952 "Set notification of completion for asynchronous execution commands.\n\
1953 Use \"on\" to enable the notification, and \"off\" to disable it.", &setlist
),
1959 gdb_init (char *argv0
)
1961 if (pre_init_ui_hook
)
1962 pre_init_ui_hook ();
1964 /* Run the init function of each source file */
1966 getcwd (gdb_dirbuf
, sizeof (gdb_dirbuf
));
1967 current_directory
= gdb_dirbuf
;
1970 /* Make sure we return to the original directory upon exit, come
1971 what may, since the OS doesn't do that for us. */
1972 make_final_cleanup (do_chdir_cleanup
, xstrdup (current_directory
));
1975 init_cmd_lists (); /* This needs to be done first */
1976 initialize_targets (); /* Setup target_terminal macros for utils.c */
1977 initialize_utils (); /* Make errors and warnings possible */
1978 initialize_all_files ();
1979 initialize_current_architecture ();
1981 init_main (); /* But that omits this file! Do it now */
1983 /* The signal handling mechanism is different depending whether or
1984 not the async version is run. NOTE: in the future we plan to make
1985 the event loop be the default engine of gdb, and this difference
1988 async_init_signals ();
1992 /* We need a default language for parsing expressions, so simple things like
1993 "set width 0" won't fail if no language is explicitly set in a config file
1994 or implicitly set by reading an executable during startup. */
1995 set_language (language_c
);
1996 expected_language
= current_language
; /* don't warn about the change. */
1999 /* Install the default UI */
2002 uiout
= cli_out_new (gdb_stdout
);
2004 /* All the interpreters should have had a look at things by now.
2005 Initialize the selected interpreter. */
2008 fprintf_unfiltered (gdb_stderr
, "Interpreter `%s' unrecognized.\n",
2016 init_ui_hook (argv0
);