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"
45 /* readline include files */
46 #include <readline/readline.h>
47 #include <readline/history.h>
49 /* readline defines this. */
52 #include <sys/types.h>
56 #include "event-top.h"
57 #include "gdb_string.h"
65 /* Default command line prompt. This is overriden in some configs. */
67 #ifndef DEFAULT_PROMPT
68 #define DEFAULT_PROMPT "(gdb) "
71 /* Initialization file name for gdb. This is overridden in some configs. */
73 #ifndef GDBINIT_FILENAME
74 #define GDBINIT_FILENAME ".gdbinit"
76 char gdbinit
[] = GDBINIT_FILENAME
;
78 int inhibit_gdbinit
= 0;
80 /* If nonzero, and GDB has been configured to be able to use windows,
81 attempt to open them upon startup. */
85 extern char lang_frame_mismatch_warn
[]; /* language.c */
87 /* Flag for whether we want all the "from_tty" gubbish printed. */
89 int caution
= 1; /* Default is yes, sigh. */
91 /* stdio stream that command input is being read from. Set to stdin normally.
92 Set by source_command to the file we are sourcing. Set to NULL if we are
93 executing a user-defined command or interacting via a GUI. */
97 /* Current working directory. */
99 char *current_directory
;
101 /* The directory name is actually stored here (usually). */
102 char gdb_dirbuf
[1024];
104 /* Function to call before reading a command, if nonzero.
105 The function receives two args: an input stream,
106 and a prompt string. */
108 void (*window_hook
) (FILE *, char *);
113 /* gdb prints this when reading a command interactively */
114 static char *gdb_prompt_string
; /* the global prompt string */
116 /* Buffer used for reading command lines, and the size
117 allocated for it so far. */
122 /* Nonzero if the current command is modified by "server ". This
123 affects things like recording into the command history, commands
124 repeating on RETURN, etc. This is so a user interface (emacs, GUI,
125 whatever) can issue its own commands and also send along commands
126 from the user, and have the user not notice that the user interface
127 is issuing commands too. */
130 /* Baud rate specified for talking to serial target systems. Default
131 is left as -1, so targets can choose their own defaults. */
132 /* FIXME: This means that "show remotebaud" and gr_files_info can print -1
133 or (unsigned int)-1. This is a Bad User Interface. */
137 /* Timeout limit for response from target. */
139 /* The default value has been changed many times over the years. It
140 was originally 5 seconds. But that was thought to be a long time
141 to sit and wait, so it was changed to 2 seconds. That was thought
142 to be plenty unless the connection was going through some terminal
143 server or multiplexer or other form of hairy serial connection.
145 In mid-1996, remote_timeout was moved from remote.c to top.c and
146 it began being used in other remote-* targets. It appears that the
147 default was changed to 20 seconds at that time, perhaps because the
148 Hitachi E7000 ICE didn't always respond in a timely manner.
150 But if 5 seconds is a long time to sit and wait for retransmissions,
151 20 seconds is far worse. This demonstrates the difficulty of using
152 a single variable for all protocol timeouts.
154 As remote.c is used much more than remote-e7000.c, it was changed
155 back to 2 seconds in 1999. */
157 int remote_timeout
= 2;
159 /* Non-zero tells remote* modules to output debugging info. */
161 int remote_debug
= 0;
163 /* Non-zero means the target is running. Note: this is different from
164 saying that there is an active target and we are stopped at a
165 breakpoint, for instance. This is a real indicator whether the
166 target is off and running, which gdb is doing something else. */
167 int target_executing
= 0;
169 /* Level of control structure. */
170 static int control_level
;
172 /* Signal to catch ^Z typed while reading a command: SIGTSTP or SIGCONT. */
176 #define STOP_SIGNAL SIGTSTP
177 static void stop_sig (int);
181 /* Some System V have job control but not sigsetmask(). */
182 #if !defined (HAVE_SIGSETMASK)
184 #define HAVE_SIGSETMASK 1
186 #define HAVE_SIGSETMASK 0
190 #if 0 == (HAVE_SIGSETMASK)
191 #define sigsetmask(n)
194 /* Hooks for alternate command interfaces. */
196 /* Called after most modules have been initialized, but before taking users
199 void (*init_ui_hook
) (char *argv0
);
201 /* This hook is called from within gdb's many mini-event loops which could
202 steal control from a real user interface's event loop. It returns
203 non-zero if the user is requesting a detach, zero otherwise. */
205 int (*ui_loop_hook
) (int);
207 /* Called instead of command_loop at top level. Can be invoked via
208 return_to_top_level. */
210 void (*command_loop_hook
) (void);
213 /* Called from print_frame_info to list the line we stopped in. */
215 void (*print_frame_info_listing_hook
) (struct symtab
* s
, int line
,
216 int stopline
, int noerror
);
217 /* Replaces most of query. */
219 int (*query_hook
) (const char *, va_list);
221 /* Replaces most of warning. */
223 void (*warning_hook
) (const char *, va_list);
225 /* These three functions support getting lines of text from the user. They
226 are used in sequence. First readline_begin_hook is called with a text
227 string that might be (for example) a message for the user to type in a
228 sequence of commands to be executed at a breakpoint. If this function
229 calls back to a GUI, it might take this opportunity to pop up a text
230 interaction window with this message. Next, readline_hook is called
231 with a prompt that is emitted prior to collecting the user input.
232 It can be called multiple times. Finally, readline_end_hook is called
233 to notify the GUI that we are done with the interaction window and it
236 void (*readline_begin_hook
) (char *, ...);
237 char *(*readline_hook
) (char *);
238 void (*readline_end_hook
) (void);
240 /* Called as appropriate to notify the interface of the specified breakpoint
243 void (*create_breakpoint_hook
) (struct breakpoint
* bpt
);
244 void (*delete_breakpoint_hook
) (struct breakpoint
* bpt
);
245 void (*modify_breakpoint_hook
) (struct breakpoint
* bpt
);
247 /* Called as appropriate to notify the interface that we have attached
248 to or detached from an already running process. */
250 void (*attach_hook
) (void);
251 void (*detach_hook
) (void);
253 /* Called during long calculations to allow GUI to repair window damage, and to
254 check for stop buttons, etc... */
256 void (*interactive_hook
) (void);
258 /* Called when the registers have changed, as a hint to a GUI
259 to minimize window update. */
261 void (*registers_changed_hook
) (void);
263 /* Tell the GUI someone changed the register REGNO. -1 means
264 that the caller does not know which register changed or
265 that several registers have changed (see value_assign). */
266 void (*register_changed_hook
) (int regno
);
268 /* Tell the GUI someone changed LEN bytes of memory at ADDR */
269 void (*memory_changed_hook
) (CORE_ADDR addr
, int len
);
271 /* Called when going to wait for the target. Usually allows the GUI to run
272 while waiting for target events. */
274 ptid_t (*target_wait_hook
) (ptid_t ptid
,
275 struct target_waitstatus
* status
);
277 /* Used by UI as a wrapper around command execution. May do various things
278 like enabling/disabling buttons, etc... */
280 void (*call_command_hook
) (struct cmd_list_element
* c
, char *cmd
,
283 /* Called after a `set' command has finished. Is only run if the
284 `set' command succeeded. */
286 void (*set_hook
) (struct cmd_list_element
* c
);
288 /* Called when the current thread changes. Argument is thread id. */
290 void (*context_hook
) (int id
);
292 /* Takes control from error (). Typically used to prevent longjmps out of the
293 middle of the GUI. Usually used in conjunction with a catch routine. */
295 NORETURN
void (*error_hook
) (void) ATTR_NORETURN
;
298 /* One should use catch_errors rather than manipulating these
300 #if defined(HAVE_SIGSETJMP)
301 #define SIGJMP_BUF sigjmp_buf
302 #define SIGSETJMP(buf) sigsetjmp((buf), 1)
303 #define SIGLONGJMP(buf,val) siglongjmp((buf), (val))
305 #define SIGJMP_BUF jmp_buf
306 #define SIGSETJMP(buf) setjmp(buf)
307 #define SIGLONGJMP(buf,val) longjmp((buf), (val))
310 /* Where to go for return_to_top_level. */
311 static SIGJMP_BUF
*catch_return
;
313 /* Return for reason REASON to the nearest containing catch_errors(). */
316 return_to_top_level (enum return_reason reason
)
321 /* Perhaps it would be cleaner to do this via the cleanup chain (not sure
322 I can think of a reason why that is vital, though). */
323 bpstat_clear_actions (stop_bpstat
); /* Clear queued breakpoint commands */
325 disable_current_display ();
326 do_cleanups (ALL_CLEANUPS
);
327 if (event_loop_p
&& target_can_async_p () && !target_executing
)
328 do_exec_cleanups (ALL_CLEANUPS
);
329 if (event_loop_p
&& sync_execution
)
330 do_exec_error_cleanups (ALL_CLEANUPS
);
332 if (annotation_level
> 1)
343 /* Jump to the containing catch_errors() call, communicating REASON
344 to that call via setjmp's return value. Note that REASON can't
345 be zero, by definition in defs.h. */
347 (NORETURN
void) SIGLONGJMP (*catch_return
, (int) reason
);
350 /* Call FUNC with arg ARGS, catching any errors. If there is no
351 error, return the value returned by FUNC. If there is an error,
352 print ERRSTRING, print the specific error message, then return
355 Must not be called with immediate_quit in effect (bad things might
356 happen, say we got a signal in the middle of a memcpy to quit_return).
357 This is an OK restriction; with very few exceptions immediate_quit can
358 be replaced by judicious use of QUIT.
360 MASK specifies what to catch; it is normally set to
361 RETURN_MASK_ALL, if for no other reason than that the code which
362 calls catch_errors might not be set up to deal with a quit which
363 isn't caught. But if the code can deal with it, it generally
364 should be RETURN_MASK_ERROR, unless for some reason it is more
365 useful to abort only the portion of the operation inside the
366 catch_errors. Note that quit should return to the command line
367 fairly quickly, even if some further processing is being done. */
369 /* MAYBE: cagney/1999-11-05: catch_errors() in conjunction with
370 error() et.al. could maintain a set of flags that indicate the the
371 current state of each of the longjmp buffers. This would give the
372 longjmp code the chance to detect a longjmp botch (before it gets
373 to longjmperror()). Prior to 1999-11-05 this wasn't possible as
374 code also randomly used a SET_TOP_LEVEL macro that directly
375 initialize the longjmp buffers. */
377 /* MAYBE: cagney/1999-11-05: Should the catch_errors and cleanups code
378 be consolidated into a single file instead of being distributed
379 between utils.c and top.c? */
382 catch_errors (catch_errors_ftype
*func
, void * args
, char *errstring
,
385 SIGJMP_BUF
*saved_catch
;
388 struct cleanup
*saved_cleanup_chain
;
389 char *saved_error_pre_print
;
390 char *saved_quit_pre_print
;
392 /* Return value from SIGSETJMP(): enum return_reason if error or
393 quit caught, 0 otherwise. */
396 /* Override error/quit messages during FUNC. */
398 saved_error_pre_print
= error_pre_print
;
399 saved_quit_pre_print
= quit_pre_print
;
401 if (mask
& RETURN_MASK_ERROR
)
402 error_pre_print
= errstring
;
403 if (mask
& RETURN_MASK_QUIT
)
404 quit_pre_print
= errstring
;
406 /* Prevent error/quit during FUNC from calling cleanups established
409 saved_cleanup_chain
= save_cleanups ();
411 /* Call FUNC, catching error/quit events. */
413 saved_catch
= catch_return
;
414 catch_return
= &catch;
415 caught
= SIGSETJMP (catch);
417 val
= (*func
) (args
);
420 catch_return
= saved_catch
;
422 /* FIXME: cagney/1999-11-05: A correct FUNC implementation will
423 clean things up (restoring the cleanup chain) to the state they
424 were just prior to the call. Unfortunately, many FUNC's are not
425 that well behaved. This could be fixed by adding either a
426 do_cleanups call (to cover the problem) or an assertion check to
427 detect bad FUNCs code. */
429 /* Restore the cleanup chain and error/quit messages to their
432 restore_cleanups (saved_cleanup_chain
);
434 if (mask
& RETURN_MASK_QUIT
)
435 quit_pre_print
= saved_quit_pre_print
;
436 if (mask
& RETURN_MASK_ERROR
)
437 error_pre_print
= saved_error_pre_print
;
439 /* Return normally if no error/quit event occurred. */
444 /* If the caller didn't request that the event be caught, relay the
445 event to the next containing catch_errors(). */
447 if (!(mask
& RETURN_MASK (caught
)))
448 return_to_top_level (caught
);
450 /* Tell the caller that an event was caught.
452 FIXME: nsd/2000-02-22: When MASK is RETURN_MASK_ALL, the caller
453 can't tell what type of event occurred.
455 A possible fix is to add a new interface, catch_event(), that
456 returns enum return_reason after catching an error or a quit.
458 When returning normally, i.e. without catching an error or a
459 quit, catch_event() could return RETURN_NORMAL, which would be
460 added to enum return_reason. FUNC would return information
461 exclusively via ARGS.
463 Alternatively, normal catch_event() could return FUNC's return
464 value. The caller would need to be aware of potential overlap
465 with enum return_reason, which could be publicly restricted to
466 negative values to simplify return value processing in FUNC and
472 struct captured_command_args
474 catch_command_errors_ftype
*command
;
480 do_captured_command (void *data
)
482 struct captured_command_args
*context
= data
;
483 context
->command (context
->arg
, context
->from_tty
);
484 /* FIXME: cagney/1999-11-07: Technically this do_cleanups() call
485 isn't needed. Instead an assertion check could be made that
486 simply confirmed that the called function correctly cleaned up
487 after itself. Unfortunately, old code (prior to 1999-11-04) in
488 main.c was calling SET_TOP_LEVEL(), calling the command function,
489 and then *always* calling do_cleanups(). For the moment we
490 remain ``bug compatible'' with that old code.. */
491 do_cleanups (ALL_CLEANUPS
);
496 catch_command_errors (catch_command_errors_ftype
* command
,
497 char *arg
, int from_tty
, return_mask mask
)
499 struct captured_command_args args
;
500 args
.command
= command
;
502 args
.from_tty
= from_tty
;
503 return catch_errors (do_captured_command
, &args
, "", mask
);
507 /* Handler for SIGHUP. */
510 /* Just a little helper function for disconnect(). */
512 /* NOTE 1999-04-29: This function will be static again, once we modify
513 gdb to use the event loop as the default command loop and we merge
514 event-top.c into this file, top.c */
518 caution
= 0; /* Throw caution to the wind -- we're exiting.
519 This prevents asking the user dumb questions. */
520 quit_command ((char *) 0, 0);
525 disconnect (int signo
)
527 catch_errors (quit_cover
, NULL
,
528 "Could not kill the program being debugged", RETURN_MASK_ALL
);
529 signal (SIGHUP
, SIG_DFL
);
530 kill (getpid (), SIGHUP
);
532 #endif /* defined SIGHUP */
534 /* Line number we are currently in in a file which is being sourced. */
535 /* NOTE 1999-04-29: This variable will be static again, once we modify
536 gdb to use the event loop as the default command loop and we merge
537 event-top.c into this file, top.c */
538 /* static */ int source_line_number
;
540 /* Name of the file we are sourcing. */
541 /* NOTE 1999-04-29: This variable will be static again, once we modify
542 gdb to use the event loop as the default command loop and we merge
543 event-top.c into this file, top.c */
544 /* static */ char *source_file_name
;
546 /* Buffer containing the error_pre_print used by the source stuff.
548 /* NOTE 1999-04-29: This variable will be static again, once we modify
549 gdb to use the event loop as the default command loop and we merge
550 event-top.c into this file, top.c */
551 /* static */ char *source_error
;
552 static int source_error_allocated
;
554 /* Something to glom on to the start of error_pre_print if source_file_name
556 /* NOTE 1999-04-29: This variable will be static again, once we modify
557 gdb to use the event loop as the default command loop and we merge
558 event-top.c into this file, top.c */
559 /* static */ char *source_pre_error
;
561 /* Clean up on error during a "source" command (or execution of a
562 user-defined command). */
565 do_restore_instream_cleanup (void *stream
)
567 /* Restore the previous input stream. */
571 /* Read commands from STREAM. */
573 read_command_file (FILE *stream
)
575 struct cleanup
*cleanups
;
577 cleanups
= make_cleanup (do_restore_instream_cleanup
, instream
);
580 do_cleanups (cleanups
);
583 void (*pre_init_ui_hook
) (void);
587 do_chdir_cleanup (void *old_dir
)
594 /* Execute the line P as a command.
595 Pass FROM_TTY as second argument to the defining function. */
598 execute_command (char *p
, int from_tty
)
600 register struct cmd_list_element
*c
;
601 register enum language flang
;
602 static int warned
= 0;
607 /* Force cleanup of any alloca areas if using C alloca instead of
611 /* This can happen when command_line_input hits end of file. */
615 serial_log_command (p
);
617 while (*p
== ' ' || *p
== '\t')
624 c
= lookup_cmd (&p
, cmdlist
, "", 0, 1);
626 /* If the target is running, we allow only a limited set of
628 if (event_loop_p
&& target_can_async_p () && target_executing
)
629 if (!strcmp (c
->name
, "help")
630 && !strcmp (c
->name
, "pwd")
631 && !strcmp (c
->name
, "show")
632 && !strcmp (c
->name
, "stop"))
633 error ("Cannot execute this command while the target is running.");
635 /* Pass null arg rather than an empty one. */
638 /* Clear off trailing whitespace, except for set and complete command. */
640 && c
->type
!= set_cmd
641 && !is_complete_command (c
->function
.cfunc
))
643 p
= arg
+ strlen (arg
) - 1;
644 while (p
>= arg
&& (*p
== ' ' || *p
== '\t'))
649 /* If this command has been pre-hooked, run the hook first. */
650 if ((c
->hook_pre
) && (!c
->hook_in
))
652 c
->hook_in
= 1; /* Prevent recursive hooking */
653 execute_user_command (c
->hook_pre
, (char *) 0);
654 c
->hook_in
= 0; /* Allow hook to work again once it is complete */
657 if (c
->flags
& DEPRECATED_WARN_USER
)
658 deprecated_cmd_warning (&line
);
660 if (c
->class == class_user
)
661 execute_user_command (c
, arg
);
662 else if (c
->type
== set_cmd
|| c
->type
== show_cmd
)
663 do_setshow_command (arg
, from_tty
& caution
, c
);
664 else if (c
->function
.cfunc
== NO_FUNCTION
)
665 error ("That is not a command, just a help topic.");
666 else if (call_command_hook
)
667 call_command_hook (c
, arg
, from_tty
& caution
);
669 (*c
->function
.cfunc
) (arg
, from_tty
& caution
);
671 /* If this command has been post-hooked, run the hook last. */
672 if ((c
->hook_post
) && (!c
->hook_in
))
674 c
->hook_in
= 1; /* Prevent recursive hooking */
675 execute_user_command (c
->hook_post
, (char *) 0);
676 c
->hook_in
= 0; /* allow hook to work again once it is complete */
681 /* Tell the user if the language has changed (except first time). */
682 if (current_language
!= expected_language
)
684 if (language_mode
== language_mode_auto
)
686 language_info (1); /* Print what changed. */
691 /* Warn the user if the working language does not match the
692 language of the current frame. Only warn the user if we are
693 actually running the program, i.e. there is a stack. */
694 /* FIXME: This should be cacheing the frame and only running when
695 the frame changes. */
697 if (target_has_stack
)
699 flang
= get_frame_language ();
701 && flang
!= language_unknown
702 && flang
!= current_language
->la_language
)
704 printf_filtered ("%s\n", lang_frame_mismatch_warn
);
710 /* Read commands from `instream' and execute them
711 until end of file or error reading instream. */
716 struct cleanup
*old_chain
;
718 int stdin_is_tty
= ISATTY (stdin
);
719 long time_at_cmd_start
;
721 long space_at_cmd_start
= 0;
723 extern int display_time
;
724 extern int display_space
;
726 while (instream
&& !feof (instream
))
728 if (window_hook
&& instream
== stdin
)
729 (*window_hook
) (instream
, get_prompt ());
732 if (instream
== stdin
&& stdin_is_tty
)
733 reinitialize_more_filter ();
734 old_chain
= make_cleanup (null_cleanup
, 0);
736 /* Get a command-line. This calls the readline package. */
737 command
= command_line_input (instream
== stdin
?
738 get_prompt () : (char *) NULL
,
739 instream
== stdin
, "prompt");
743 time_at_cmd_start
= get_run_time ();
748 extern char **environ
;
749 char *lim
= (char *) sbrk (0);
751 space_at_cmd_start
= (long) (lim
- (char *) &environ
);
755 execute_command (command
, instream
== stdin
);
756 /* Do any commands attached to breakpoint we stopped at. */
757 bpstat_do_actions (&stop_bpstat
);
758 do_cleanups (old_chain
);
762 long cmd_time
= get_run_time () - time_at_cmd_start
;
764 printf_unfiltered ("Command execution time: %ld.%06ld\n",
765 cmd_time
/ 1000000, cmd_time
% 1000000);
771 extern char **environ
;
772 char *lim
= (char *) sbrk (0);
773 long space_now
= lim
- (char *) &environ
;
774 long space_diff
= space_now
- space_at_cmd_start
;
776 printf_unfiltered ("Space used: %ld (%c%ld for this command)\n",
778 (space_diff
>= 0 ? '+' : '-'),
785 /* Read commands from `instream' and execute them until end of file or
786 error reading instream. This command loop doesnt care about any
787 such things as displaying time and space usage. If the user asks
788 for those, they won't work. */
790 simplified_command_loop (char *(*read_input_func
) (char *),
791 void (*execute_command_func
) (char *, int))
793 struct cleanup
*old_chain
;
795 int stdin_is_tty
= ISATTY (stdin
);
797 while (instream
&& !feof (instream
))
800 if (instream
== stdin
&& stdin_is_tty
)
801 reinitialize_more_filter ();
802 old_chain
= make_cleanup (null_cleanup
, 0);
804 /* Get a command-line. */
805 command
= (*read_input_func
) (instream
== stdin
?
806 get_prompt () : (char *) NULL
);
811 (*execute_command_func
) (command
, instream
== stdin
);
813 /* Do any commands attached to breakpoint we stopped at. */
814 bpstat_do_actions (&stop_bpstat
);
816 do_cleanups (old_chain
);
820 /* Commands call this if they do not want to be repeated by null lines. */
828 /* If we aren't reading from standard input, we are saving the last
829 thing read from stdin in line and don't want to delete it. Null lines
830 won't repeat here in any case. */
831 if (instream
== stdin
)
835 /* Read a line from the stream "instream" without command line editing.
837 It prints PROMPT_ARG once at the start.
838 Action is compatible with "readline", e.g. space for the result is
839 malloc'd and should be freed by the caller.
841 A NULL return means end of file. */
843 gdb_readline (char *prompt_arg
)
848 int result_size
= 80;
852 /* Don't use a _filtered function here. It causes the assumed
853 character position to be off, since the newline we read from
854 the user is not accounted for. */
855 fputs_unfiltered (prompt_arg
, gdb_stdout
);
856 /* OBSOLETE #ifdef MPW */
857 /* OBSOLETE Move to a new line so the entered line doesn't have a prompt */
858 /* OBSOLETE on the front of it. */
859 /* OBSOLETE fputs_unfiltered ("\n", gdb_stdout); */
860 /* OBSOLETE #endif *//* MPW */
861 gdb_flush (gdb_stdout
);
864 result
= (char *) xmalloc (result_size
);
868 /* Read from stdin if we are executing a user defined command.
869 This is the right thing for prompt_for_continue, at least. */
870 c
= fgetc (instream
? instream
: stdin
);
875 /* The last line does not end with a newline. Return it, and
876 if we are called again fgetc will still return EOF and
877 we'll return NULL then. */
884 #ifndef CRLF_SOURCE_FILES
888 if (input_index
> 0 && result
[input_index
- 1] == '\r')
894 result
[input_index
++] = c
;
895 while (input_index
>= result_size
)
898 result
= (char *) xrealloc (result
, result_size
);
902 result
[input_index
++] = '\0';
906 /* Variables which control command line editing and history
907 substitution. These variables are given default values at the end
909 static int command_editing_p
;
910 /* NOTE 1999-04-29: This variable will be static again, once we modify
911 gdb to use the event loop as the default command loop and we merge
912 event-top.c into this file, top.c */
913 /* static */ int history_expansion_p
;
914 static int write_history_p
;
915 static int history_size
;
916 static char *history_filename
;
923 #if STOP_SIGNAL == SIGTSTP
924 signal (SIGTSTP
, SIG_DFL
);
926 kill (getpid (), SIGTSTP
);
927 signal (SIGTSTP
, stop_sig
);
929 signal (STOP_SIGNAL
, stop_sig
);
931 printf_unfiltered ("%s", get_prompt ());
932 gdb_flush (gdb_stdout
);
934 /* Forget about any previous command -- null line now will do nothing. */
937 #endif /* STOP_SIGNAL */
939 /* Initialize signal handlers. */
941 float_handler (int signo
)
943 /* This message is based on ANSI C, section 4.7. Note that integer
944 divide by zero causes this, so "float" is a misnomer. */
945 signal (SIGFPE
, float_handler
);
946 error ("Erroneous arithmetic operation.");
950 do_nothing (int signo
)
952 /* Under System V the default disposition of a signal is reinstated after
953 the signal is caught and delivered to an application process. On such
954 systems one must restore the replacement signal handler if one wishes
955 to continue handling the signal in one's program. On BSD systems this
956 is not needed but it is harmless, and it simplifies the code to just do
957 it unconditionally. */
958 signal (signo
, do_nothing
);
964 signal (SIGINT
, request_quit
);
966 /* If SIGTRAP was set to SIG_IGN, then the SIG_IGN will get passed
967 to the inferior and breakpoints will be ignored. */
969 signal (SIGTRAP
, SIG_DFL
);
972 /* If we initialize SIGQUIT to SIG_IGN, then the SIG_IGN will get
973 passed to the inferior, which we don't want. It would be
974 possible to do a "signal (SIGQUIT, SIG_DFL)" after we fork, but
975 on BSD4.3 systems using vfork, that can affect the
976 GDB process as well as the inferior (the signal handling tables
977 might be in memory, shared between the two). Since we establish
978 a handler for SIGQUIT, when we call exec it will set the signal
979 to SIG_DFL for us. */
980 signal (SIGQUIT
, do_nothing
);
982 if (signal (SIGHUP
, do_nothing
) != SIG_IGN
)
983 signal (SIGHUP
, disconnect
);
985 signal (SIGFPE
, float_handler
);
987 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
988 signal (SIGWINCH
, SIGWINCH_HANDLER
);
992 /* Read one line from the command input stream `instream'
993 into the local static buffer `linebuffer' (whose current length
995 The buffer is made bigger as necessary.
996 Returns the address of the start of the line.
998 NULL is returned for end of file.
1000 *If* the instream == stdin & stdin is a terminal, the line read
1001 is copied into the file line saver (global var char *line,
1002 length linesize) so that it can be duplicated.
1004 This routine either uses fancy command line editing or
1005 simple input as the user has requested. */
1008 command_line_input (char *prompt_arg
, int repeat
, char *annotation_suffix
)
1010 static char *linebuffer
= 0;
1011 static unsigned linelength
= 0;
1015 char *local_prompt
= prompt_arg
;
1019 /* The annotation suffix must be non-NULL. */
1020 if (annotation_suffix
== NULL
)
1021 annotation_suffix
= "";
1023 if (annotation_level
> 1 && instream
== stdin
)
1025 local_prompt
= alloca ((prompt_arg
== NULL
? 0 : strlen (prompt_arg
))
1026 + strlen (annotation_suffix
) + 40);
1027 if (prompt_arg
== NULL
)
1028 local_prompt
[0] = '\0';
1030 strcpy (local_prompt
, prompt_arg
);
1031 strcat (local_prompt
, "\n\032\032");
1032 strcat (local_prompt
, annotation_suffix
);
1033 strcat (local_prompt
, "\n");
1036 if (linebuffer
== 0)
1039 linebuffer
= (char *) xmalloc (linelength
);
1044 /* Control-C quits instantly if typed while in this loop
1045 since it should not wait until the user types a newline. */
1051 signal (STOP_SIGNAL
, handle_stop_sig
);
1053 signal (STOP_SIGNAL
, stop_sig
);
1059 /* Make sure that all output has been output. Some machines may let
1060 you get away with leaving out some of the gdb_flush, but not all. */
1062 gdb_flush (gdb_stdout
);
1063 gdb_flush (gdb_stderr
);
1065 if (source_file_name
!= NULL
)
1067 ++source_line_number
;
1068 sprintf (source_error
,
1069 "%s%s:%d: Error in sourced command file:\n",
1072 source_line_number
);
1073 error_pre_print
= source_error
;
1076 if (annotation_level
> 1 && instream
== stdin
)
1078 printf_unfiltered ("\n\032\032pre-");
1079 printf_unfiltered (annotation_suffix
);
1080 printf_unfiltered ("\n");
1083 /* Don't use fancy stuff if not talking to stdin. */
1084 if (readline_hook
&& instream
== NULL
)
1086 rl
= (*readline_hook
) (local_prompt
);
1088 else if (command_editing_p
&& instream
== stdin
&& ISATTY (instream
))
1090 rl
= readline (local_prompt
);
1094 rl
= gdb_readline (local_prompt
);
1097 if (annotation_level
> 1 && instream
== stdin
)
1099 printf_unfiltered ("\n\032\032post-");
1100 printf_unfiltered (annotation_suffix
);
1101 printf_unfiltered ("\n");
1104 if (!rl
|| rl
== (char *) EOF
)
1109 if (strlen (rl
) + 1 + (p
- linebuffer
) > linelength
)
1111 linelength
= strlen (rl
) + 1 + (p
- linebuffer
);
1112 nline
= (char *) xrealloc (linebuffer
, linelength
);
1113 p
+= nline
- linebuffer
;
1117 /* Copy line. Don't copy null at end. (Leaves line alone
1118 if this was just a newline) */
1122 xfree (rl
); /* Allocated in readline. */
1124 if (p
== linebuffer
|| *(p
- 1) != '\\')
1127 p
--; /* Put on top of '\'. */
1128 local_prompt
= (char *) 0;
1133 signal (STOP_SIGNAL
, SIG_DFL
);
1140 #define SERVER_COMMAND_LENGTH 7
1142 (p
- linebuffer
> SERVER_COMMAND_LENGTH
)
1143 && STREQN (linebuffer
, "server ", SERVER_COMMAND_LENGTH
);
1146 /* Note that we don't set `line'. Between this and the check in
1147 dont_repeat, this insures that repeating will still do the
1150 return linebuffer
+ SERVER_COMMAND_LENGTH
;
1153 /* Do history expansion if that is wished. */
1154 if (history_expansion_p
&& instream
== stdin
1155 && ISATTY (instream
))
1157 char *history_value
;
1160 *p
= '\0'; /* Insert null now. */
1161 expanded
= history_expand (linebuffer
, &history_value
);
1164 /* Print the changes. */
1165 printf_unfiltered ("%s\n", history_value
);
1167 /* If there was an error, call this function again. */
1170 xfree (history_value
);
1171 return command_line_input (prompt_arg
, repeat
, annotation_suffix
);
1173 if (strlen (history_value
) > linelength
)
1175 linelength
= strlen (history_value
) + 1;
1176 linebuffer
= (char *) xrealloc (linebuffer
, linelength
);
1178 strcpy (linebuffer
, history_value
);
1179 p
= linebuffer
+ strlen (linebuffer
);
1180 xfree (history_value
);
1184 /* If we just got an empty line, and that is supposed
1185 to repeat the previous command, return the value in the
1187 if (repeat
&& p
== linebuffer
)
1189 for (p1
= linebuffer
; *p1
== ' ' || *p1
== '\t'; p1
++);
1195 /* Add line to history if appropriate. */
1196 if (instream
== stdin
1197 && ISATTY (stdin
) && *linebuffer
)
1198 add_history (linebuffer
);
1200 /* Note: lines consisting solely of comments are added to the command
1201 history. This is useful when you type a command, and then
1202 realize you don't want to execute it quite yet. You can comment
1203 out the command and then later fetch it from the value history
1204 and remove the '#'. The kill ring is probably better, but some
1205 people are in the habit of commenting things out. */
1207 *p1
= '\0'; /* Found a comment. */
1209 /* Save into global buffer if appropriate. */
1212 if (linelength
> linesize
)
1214 line
= xrealloc (line
, linelength
);
1215 linesize
= linelength
;
1217 strcpy (line
, linebuffer
);
1224 /* Print the GDB banner. */
1226 print_gdb_version (struct ui_file
*stream
)
1228 /* From GNU coding standards, first line is meant to be easy for a
1229 program to parse, and is just canonical program name and version
1230 number, which starts after last space. */
1233 /* Print it console style until a format is defined */
1234 fprintf_filtered (stream
, "GNU gdb %s (MI_OUT)\n", version
);
1236 fprintf_filtered (stream
, "GNU gdb %s\n", version
);
1239 /* Second line is a copyright notice. */
1241 fprintf_filtered (stream
, "Copyright 2001 Free Software Foundation, Inc.\n");
1243 /* Following the copyright is a brief statement that the program is
1244 free software, that users are free to copy and change it on
1245 certain conditions, that it is covered by the GNU GPL, and that
1246 there is no warranty. */
1248 fprintf_filtered (stream
, "\
1249 GDB is free software, covered by the GNU General Public License, and you are\n\
1250 welcome to change it and/or distribute copies of it under certain conditions.\n\
1251 Type \"show copying\" to see the conditions.\n\
1252 There is absolutely no warranty for GDB. Type \"show warranty\" for details.\n");
1254 /* After the required info we print the configuration information. */
1256 fprintf_filtered (stream
, "This GDB was configured as \"");
1257 if (!STREQ (host_name
, target_name
))
1259 fprintf_filtered (stream
, "--host=%s --target=%s", host_name
, target_name
);
1263 fprintf_filtered (stream
, "%s", host_name
);
1265 fprintf_filtered (stream
, "\".");
1268 /* get_prompt: access method for the GDB prompt string. */
1270 #define MAX_PROMPT_SIZE 256
1273 * int get_prompt_1 (char * buf);
1275 * Work-horse for get_prompt (called via catch_errors).
1276 * Argument is buffer to hold the formatted prompt.
1278 * Returns: 1 for success (use formatted prompt)
1279 * 0 for failure (use gdb_prompt_string).
1282 static int gdb_prompt_escape
;
1285 get_prompt_1 (void *data
)
1287 char *formatted_prompt
= data
;
1291 local_prompt
= PROMPT (0);
1293 local_prompt
= gdb_prompt_string
;
1296 if (gdb_prompt_escape
== 0)
1298 return 0; /* do no formatting */
1301 /* formatted prompt */
1303 char fmt
[40], *promptp
, *outp
, *tmp
;
1310 struct type
*arg_type
, *elt_type
;
1312 promptp
= local_prompt
;
1313 outp
= formatted_prompt
;
1315 while (*promptp
!= '\0')
1317 int available
= MAX_PROMPT_SIZE
- (outp
- formatted_prompt
) - 1;
1319 if (*promptp
!= gdb_prompt_escape
)
1321 if (available
>= 1) /* overflow protect */
1322 *outp
++ = *promptp
++;
1326 /* GDB prompt string contains escape char. Parse for arg.
1327 Two consecutive escape chars followed by arg followed by
1328 a comma means to insert the arg using a default format.
1329 Otherwise a printf format string may be included between
1330 the two escape chars. eg:
1331 %%foo, insert foo using default format
1332 %2.2f%foo, insert foo using "%2.2f" format
1333 A mismatch between the format string and the data type
1334 of "foo" is an error (which we don't know how to protect
1337 fmt
[0] = '\0'; /* assume null format string */
1338 if (promptp
[1] == gdb_prompt_escape
) /* double esc char */
1340 promptp
+= 2; /* skip past two escape chars. */
1344 /* extract format string from between two esc chars */
1348 fmt
[i
++] = *promptp
++; /* copy format string */
1350 while (i
< sizeof (fmt
) - 1 &&
1351 *promptp
!= gdb_prompt_escape
&&
1354 if (*promptp
!= gdb_prompt_escape
)
1355 error ("Syntax error at prompt position %d",
1356 promptp
- local_prompt
);
1359 promptp
++; /* skip second escape char */
1360 fmt
[i
++] = '\0'; /* terminate the format string */
1364 arg_val
= parse_to_comma_and_eval (&promptp
);
1365 if (*promptp
== ',')
1366 promptp
++; /* skip past the comma */
1367 arg_type
= check_typedef (VALUE_TYPE (arg_val
));
1368 switch (TYPE_CODE (arg_type
))
1370 case TYPE_CODE_ARRAY
:
1371 elt_type
= check_typedef (TYPE_TARGET_TYPE (arg_type
));
1372 if (TYPE_LENGTH (arg_type
) > 0 &&
1373 TYPE_LENGTH (elt_type
) == 1 &&
1374 TYPE_CODE (elt_type
) == TYPE_CODE_INT
)
1376 int len
= TYPE_LENGTH (arg_type
);
1378 if (VALUE_LAZY (arg_val
))
1379 value_fetch_lazy (arg_val
);
1380 tmp
= VALUE_CONTENTS (arg_val
);
1382 if (len
> available
)
1383 len
= available
; /* overflow protect */
1385 /* FIXME: how to protect GDB from crashing
1386 from bad user-supplied format string? */
1388 sprintf (outp
, fmt
, tmp
);
1390 strncpy (outp
, tmp
, len
);
1395 elt_type
= check_typedef (TYPE_TARGET_TYPE (arg_type
));
1396 addrval
= value_as_pointer (arg_val
);
1398 if (TYPE_LENGTH (elt_type
) == 1 &&
1399 TYPE_CODE (elt_type
) == TYPE_CODE_INT
&&
1402 /* display it as a string */
1403 char *default_fmt
= "%s";
1407 /* Limiting the number of bytes that the following call
1408 will read protects us from sprintf overflow later. */
1409 i
= target_read_string (addrval
, /* src */
1411 available
, /* len */
1413 if (err
) /* read failed */
1414 error ("%s on target_read", safe_strerror (err
));
1416 tmp
[i
] = '\0'; /* force-terminate string */
1417 /* FIXME: how to protect GDB from crashing
1418 from bad user-supplied format string? */
1419 sprintf (outp
, fmt
[0] == 0 ? default_fmt
: fmt
,
1425 /* display it as a pointer */
1426 char *default_fmt
= "0x%x";
1428 /* FIXME: how to protect GDB from crashing
1429 from bad user-supplied format string? */
1430 if (available
>= 16 /*? */ ) /* overflow protect */
1431 sprintf (outp
, fmt
[0] == 0 ? default_fmt
: fmt
,
1437 char *default_fmt
= "%g";
1439 doubleval
= value_as_double (arg_val
);
1440 /* FIXME: how to protect GDB from crashing
1441 from bad user-supplied format string? */
1442 if (available
>= 16 /*? */ ) /* overflow protect */
1443 sprintf (outp
, fmt
[0] == 0 ? default_fmt
: fmt
,
1444 (double) doubleval
);
1449 char *default_fmt
= "%d";
1451 longval
= value_as_long (arg_val
);
1452 /* FIXME: how to protect GDB from crashing
1453 from bad user-supplied format string? */
1454 if (available
>= 16 /*? */ ) /* overflow protect */
1455 sprintf (outp
, fmt
[0] == 0 ? default_fmt
: fmt
,
1459 case TYPE_CODE_BOOL
:
1461 /* no default format for bool */
1462 longval
= value_as_long (arg_val
);
1463 if (available
>= 8 /*? */ ) /* overflow protect */
1466 strcpy (outp
, "<true>");
1468 strcpy (outp
, "<false>");
1472 case TYPE_CODE_ENUM
:
1474 /* no default format for enum */
1475 longval
= value_as_long (arg_val
);
1476 len
= TYPE_NFIELDS (arg_type
);
1477 /* find enum name if possible */
1478 for (i
= 0; i
< len
; i
++)
1479 if (TYPE_FIELD_BITPOS (arg_type
, i
) == longval
)
1480 break; /* match -- end loop */
1482 if (i
< len
) /* enum name found */
1484 char *name
= TYPE_FIELD_NAME (arg_type
, i
);
1486 strncpy (outp
, name
, available
);
1487 /* in casel available < strlen (name), */
1488 outp
[available
] = '\0';
1492 if (available
>= 16 /*? */ ) /* overflow protect */
1493 sprintf (outp
, "%ld", (long) longval
);
1497 case TYPE_CODE_VOID
:
1499 break; /* void type -- no output */
1501 error ("bad data type at prompt position %d",
1502 promptp
- local_prompt
);
1505 outp
+= strlen (outp
);
1508 *outp
++ = '\0'; /* terminate prompt string */
1516 static char buf
[MAX_PROMPT_SIZE
];
1518 if (catch_errors (get_prompt_1
, buf
, "bad formatted prompt: ",
1521 return &buf
[0]; /* successful formatted prompt */
1525 /* Prompt could not be formatted. */
1529 return gdb_prompt_string
;
1534 set_prompt (char *s
)
1536 /* ??rehrauer: I don't know why this fails, since it looks as though
1537 assignments to prompt are wrapped in calls to savestring...
1542 PROMPT (0) = savestring (s
, strlen (s
));
1544 gdb_prompt_string
= savestring (s
, strlen (s
));
1548 /* If necessary, make the user confirm that we should quit. Return
1549 non-zero if we should quit, zero if we shouldn't. */
1554 if (! ptid_equal (inferior_ptid
, null_ptid
) && target_has_execution
)
1558 /* This is something of a hack. But there's no reliable way to
1559 see if a GUI is running. The `use_windows' variable doesn't
1562 s
= "A debugging session is active.\nDo you still want to close the debugger?";
1563 else if (attach_flag
)
1564 s
= "The program is running. Quit anyway (and detach it)? ";
1566 s
= "The program is running. Exit anyway? ";
1575 /* Quit without asking for confirmation. */
1578 quit_force (char *args
, int from_tty
)
1582 /* An optional expression may be used to cause gdb to terminate with the
1583 value of that expression. */
1586 value_ptr val
= parse_and_eval (args
);
1588 exit_code
= (int) value_as_long (val
);
1591 if (! ptid_equal (inferior_ptid
, null_ptid
) && target_has_execution
)
1594 target_detach (args
, from_tty
);
1599 /* UDI wants this, to kill the TIP. */
1602 /* Save the history information if it is appropriate to do so. */
1603 if (write_history_p
&& history_filename
)
1604 write_history (history_filename
);
1606 do_final_cleanups (ALL_CLEANUPS
); /* Do any final cleanups before exiting */
1611 /* Returns whether GDB is running on a terminal and whether the user
1612 desires that questions be asked of them on that terminal. */
1615 input_from_terminal_p (void)
1617 return gdb_has_a_terminal () && (instream
== stdin
) & caution
;
1622 dont_repeat_command (char *ignored
, int from_tty
)
1624 *line
= 0; /* Can't call dont_repeat here because we're not
1625 necessarily reading from stdin. */
1628 /* Functions to manipulate command line editing control variables. */
1630 /* Number of commands to print in each call to show_commands. */
1631 #define Hist_print 10
1633 show_commands (char *args
, int from_tty
)
1635 /* Index for history commands. Relative to history_base. */
1638 /* Number of the history entry which we are planning to display next.
1639 Relative to history_base. */
1642 /* The first command in the history which doesn't exist (i.e. one more
1643 than the number of the last command). Relative to history_base. */
1646 /* Print out some of the commands from the command history. */
1647 /* First determine the length of the history list. */
1648 hist_len
= history_size
;
1649 for (offset
= 0; offset
< history_size
; offset
++)
1651 if (!history_get (history_base
+ offset
))
1660 if (args
[0] == '+' && args
[1] == '\0')
1661 /* "info editing +" should print from the stored position. */
1664 /* "info editing <exp>" should print around command number <exp>. */
1665 num
= (parse_and_eval_long (args
) - history_base
) - Hist_print
/ 2;
1667 /* "show commands" means print the last Hist_print commands. */
1670 num
= hist_len
- Hist_print
;
1676 /* If there are at least Hist_print commands, we want to display the last
1677 Hist_print rather than, say, the last 6. */
1678 if (hist_len
- num
< Hist_print
)
1680 num
= hist_len
- Hist_print
;
1685 for (offset
= num
; offset
< num
+ Hist_print
&& offset
< hist_len
; offset
++)
1687 printf_filtered ("%5d %s\n", history_base
+ offset
,
1688 (history_get (history_base
+ offset
))->line
);
1691 /* The next command we want to display is the next one that we haven't
1695 /* If the user repeats this command with return, it should do what
1696 "show commands +" does. This is unnecessary if arg is null,
1697 because "show commands +" is not useful after "show commands". */
1698 if (from_tty
&& args
)
1705 /* Called by do_setshow_command. */
1708 set_history_size_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1710 if (history_size
== INT_MAX
)
1711 unstifle_history ();
1712 else if (history_size
>= 0)
1713 stifle_history (history_size
);
1716 history_size
= INT_MAX
;
1717 error ("History size must be non-negative");
1723 set_history (char *args
, int from_tty
)
1725 printf_unfiltered ("\"set history\" must be followed by the name of a history subcommand.\n");
1726 help_list (sethistlist
, "set history ", -1, gdb_stdout
);
1731 show_history (char *args
, int from_tty
)
1733 cmd_show_list (showhistlist
, from_tty
, "");
1736 int info_verbose
= 0; /* Default verbose msgs off */
1738 /* Called by do_setshow_command. An elaborate joke. */
1741 set_verbose (char *args
, int from_tty
, struct cmd_list_element
*c
)
1743 char *cmdname
= "verbose";
1744 struct cmd_list_element
*showcmd
;
1746 showcmd
= lookup_cmd_1 (&cmdname
, showlist
, NULL
, 1);
1750 c
->doc
= "Set verbose printing of informational messages.";
1751 showcmd
->doc
= "Show verbose printing of informational messages.";
1755 c
->doc
= "Set verbosity.";
1756 showcmd
->doc
= "Show verbosity.";
1760 /* Init the history buffer. Note that we are called after the init file(s)
1761 * have been read so that the user can change the history file via his
1762 * .gdbinit file (for instance). The GDBHISTFILE environment variable
1763 * overrides all of this.
1771 tmpenv
= getenv ("HISTSIZE");
1773 history_size
= atoi (tmpenv
);
1774 else if (!history_size
)
1777 stifle_history (history_size
);
1779 tmpenv
= getenv ("GDBHISTFILE");
1781 history_filename
= savestring (tmpenv
, strlen (tmpenv
));
1782 else if (!history_filename
)
1784 /* We include the current directory so that if the user changes
1785 directories the file written will be the same as the one
1788 /* No leading dots in file names are allowed on MSDOS. */
1789 history_filename
= concat (current_directory
, "/_gdb_history", NULL
);
1791 history_filename
= concat (current_directory
, "/.gdb_history", NULL
);
1794 read_history (history_filename
);
1800 struct cmd_list_element
*c
;
1802 /* If we are running the asynchronous version,
1803 we initialize the prompts differently. */
1806 gdb_prompt_string
= savestring (DEFAULT_PROMPT
, strlen (DEFAULT_PROMPT
));
1810 /* initialize the prompt stack to a simple "(gdb) " prompt or to
1811 whatever the DEFAULT_PROMPT is. */
1812 the_prompts
.top
= 0;
1814 PROMPT (0) = savestring (DEFAULT_PROMPT
, strlen (DEFAULT_PROMPT
));
1816 /* Set things up for annotation_level > 1, if the user ever decides
1818 async_annotation_suffix
= "prompt";
1819 /* Set the variable associated with the setshow prompt command. */
1820 new_async_prompt
= savestring (PROMPT (0), strlen (PROMPT (0)));
1822 /* If gdb was started with --annotate=2, this is equivalent to
1823 the user entering the command 'set annotate 2' at the gdb
1824 prompt, so we need to do extra processing. */
1825 if (annotation_level
> 1)
1826 set_async_annotation_level (NULL
, 0, NULL
);
1828 gdb_prompt_escape
= 0; /* default to none. */
1830 /* Set the important stuff up for command editing. */
1831 command_editing_p
= 1;
1832 history_expansion_p
= 0;
1833 write_history_p
= 0;
1835 /* Setup important stuff for command line editing. */
1836 rl_completion_entry_function
= (int (*)()) readline_line_completion_function
;
1837 rl_completer_word_break_characters
=
1838 get_gdb_completer_word_break_characters ();
1839 rl_completer_quote_characters
= get_gdb_completer_quote_characters ();
1840 rl_readline_name
= "gdb";
1842 /* The set prompt command is different depending whether or not the
1843 async version is run. NOTE: this difference is going to
1844 disappear as we make the event loop be the default engine of
1849 (add_set_cmd ("prompt", class_support
, var_string
,
1850 (char *) &gdb_prompt_string
, "Set gdb's prompt",
1856 c
= add_set_cmd ("prompt", class_support
, var_string
,
1857 (char *) &new_async_prompt
, "Set gdb's prompt",
1859 add_show_from_set (c
, &showlist
);
1860 c
->function
.sfunc
= set_async_prompt
;
1864 (add_set_cmd ("prompt-escape-char", class_support
, var_zinteger
,
1865 (char *) &gdb_prompt_escape
,
1866 "Set escape character for formatting of gdb's prompt",
1870 add_com ("dont-repeat", class_support
, dont_repeat_command
, "Don't repeat this command.\n\
1871 Primarily used inside of user-defined commands that should not be repeated when\n\
1874 /* The set editing command is different depending whether or not the
1875 async version is run. NOTE: this difference is going to disappear
1876 as we make the event loop be the default engine of gdb. */
1880 (add_set_cmd ("editing", class_support
, var_boolean
, (char *) &command_editing_p
,
1881 "Set editing of command lines as they are typed.\n\
1882 Use \"on\" to enable the editing, and \"off\" to disable it.\n\
1883 Without an argument, command line editing is enabled. To edit, use\n\
1884 EMACS-like or VI-like commands like control-P or ESC.", &setlist
),
1889 c
= add_set_cmd ("editing", class_support
, var_boolean
, (char *) &async_command_editing_p
,
1890 "Set editing of command lines as they are typed.\n\
1891 Use \"on\" to enable the editing, and \"off\" to disable it.\n\
1892 Without an argument, command line editing is enabled. To edit, use\n\
1893 EMACS-like or VI-like commands like control-P or ESC.", &setlist
);
1895 add_show_from_set (c
, &showlist
);
1896 c
->function
.sfunc
= set_async_editing_command
;
1900 (add_set_cmd ("save", no_class
, var_boolean
, (char *) &write_history_p
,
1901 "Set saving of the history record on exit.\n\
1902 Use \"on\" to enable the saving, and \"off\" to disable it.\n\
1903 Without an argument, saving is enabled.", &sethistlist
),
1906 c
= add_set_cmd ("size", no_class
, var_integer
, (char *) &history_size
,
1907 "Set the size of the command history, \n\
1908 ie. the number of previous commands to keep a record of.", &sethistlist
);
1909 add_show_from_set (c
, &showhistlist
);
1910 c
->function
.sfunc
= set_history_size_command
;
1912 c
= add_set_cmd ("filename", no_class
, var_filename
,
1913 (char *) &history_filename
,
1914 "Set the filename in which to record the command history\n\
1915 (the list of previous commands of which a record is kept).", &sethistlist
);
1916 c
->completer
= filename_completer
;
1917 add_show_from_set (c
, &showhistlist
);
1920 (add_set_cmd ("confirm", class_support
, var_boolean
,
1922 "Set whether to confirm potentially dangerous operations.",
1926 /* The set annotate command is different depending whether or not
1927 the async version is run. NOTE: this difference is going to
1928 disappear as we make the event loop be the default engine of
1932 c
= add_set_cmd ("annotate", class_obscure
, var_zinteger
,
1933 (char *) &annotation_level
, "Set annotation_level.\n\
1934 0 == normal; 1 == fullname (for use when running under emacs)\n\
1935 2 == output annotated suitably for use by programs that control GDB.",
1937 c
= add_show_from_set (c
, &showlist
);
1941 c
= add_set_cmd ("annotate", class_obscure
, var_zinteger
,
1942 (char *) &annotation_level
, "Set annotation_level.\n\
1943 0 == normal; 1 == fullname (for use when running under emacs)\n\
1944 2 == output annotated suitably for use by programs that control GDB.",
1946 add_show_from_set (c
, &showlist
);
1947 c
->function
.sfunc
= set_async_annotation_level
;
1952 (add_set_cmd ("exec-done-display", class_support
, var_boolean
, (char *) &exec_done_display_p
,
1953 "Set notification of completion for asynchronous execution commands.\n\
1954 Use \"on\" to enable the notification, and \"off\" to disable it.", &setlist
),
1960 gdb_init (char *argv0
)
1962 if (pre_init_ui_hook
)
1963 pre_init_ui_hook ();
1965 /* Run the init function of each source file */
1967 getcwd (gdb_dirbuf
, sizeof (gdb_dirbuf
));
1968 current_directory
= gdb_dirbuf
;
1971 /* Make sure we return to the original directory upon exit, come
1972 what may, since the OS doesn't do that for us. */
1973 make_final_cleanup (do_chdir_cleanup
, xstrdup (current_directory
));
1976 init_cmd_lists (); /* This needs to be done first */
1977 initialize_targets (); /* Setup target_terminal macros for utils.c */
1978 initialize_utils (); /* Make errors and warnings possible */
1979 initialize_all_files ();
1980 initialize_current_architecture ();
1982 init_main (); /* But that omits this file! Do it now */
1984 /* The signal handling mechanism is different depending whether or
1985 not the async version is run. NOTE: in the future we plan to make
1986 the event loop be the default engine of gdb, and this difference
1989 async_init_signals ();
1993 /* We need a default language for parsing expressions, so simple things like
1994 "set width 0" won't fail if no language is explicitly set in a config file
1995 or implicitly set by reading an executable during startup. */
1996 set_language (language_c
);
1997 expected_language
= current_language
; /* don't warn about the change. */
2000 /* Install the default UI */
2003 uiout
= cli_out_new (gdb_stdout
);
2005 /* All the interpreters should have had a look at things by now.
2006 Initialize the selected interpreter. */
2009 fprintf_unfiltered (gdb_stderr
, "Interpreter `%s' unrecognized.\n",
2017 init_ui_hook (argv0
);