/* Top level stuff for GDB, the GNU debugger.
Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
- 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
- Free Software Foundation, Inc.
+ 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008,
+ 2009 Free Software Foundation, Inc.
This file is part of GDB.
/* Whether to enable writing into executable and core files */
extern int write_files;
+/* GDB as it has been invoked from the command line (i.e. argv[0]). */
+static char *gdb_program_name;
+
static void print_gdb_help (struct ui_file *);
/* These two are used to set the external editor commands when gdb is farming
extern char *external_editor_command;
+/* Compute the locations of init files that GDB should source and return
+ them in SYSTEM_GDBINIT, HOME_GDBINIT, LOCAL_GDBINIT. If there is
+ no system gdbinit (resp. home gdbinit and local gdbinit) to be loaded,
+ then SYSTEM_GDBINIT (resp. HOME_GDBINIT and LOCAL_GDBINIT) is set to
+ NULL. */
+static void
+get_init_files (char **system_gdbinit,
+ char **home_gdbinit,
+ char **local_gdbinit)
+{
+ static char *sysgdbinit = NULL;
+ static char *homeinit = NULL;
+ static char *localinit = NULL;
+ static int initialized = 0;
+
+ if (!initialized)
+ {
+ struct stat homebuf, cwdbuf, s;
+ char *homedir, *relocated_sysgdbinit;
+
+ sysgdbinit = SYSTEM_GDBINIT;
+ if (!sysgdbinit [0] || stat (sysgdbinit, &s) != 0)
+ sysgdbinit = NULL;
+
+#ifdef SYSTEM_GDBINIT_RELOCATABLE
+ relocated_sysgdbinit = make_relative_prefix (gdb_program_name, BINDIR,
+ SYSTEM_GDBINIT);
+ if (relocated_sysgdbinit)
+ {
+ struct stat s;
+ int res = 0;
+
+ if (stat (relocated_sysgdbinit, &s) == 0)
+ sysgdbinit = relocated_sysgdbinit;
+ else
+ xfree (relocated_sysgdbinit);
+ }
+#endif
+
+ homedir = getenv ("HOME");
+
+ /* If the .gdbinit file in the current directory is the same as
+ the $HOME/.gdbinit file, it should not be sourced. homebuf
+ and cwdbuf are used in that purpose. Make sure that the stats
+ are zero in case one of them fails (this guarantees that they
+ won't match if either exists). */
+
+ memset (&homebuf, 0, sizeof (struct stat));
+ memset (&cwdbuf, 0, sizeof (struct stat));
+
+ if (homedir)
+ {
+ homeinit = xstrprintf ("%s/%s", homedir, gdbinit);
+ if (stat (homeinit, &homebuf) != 0)
+ {
+ xfree (homeinit);
+ homeinit = NULL;
+ }
+ }
+
+ if (stat (gdbinit, &cwdbuf) == 0)
+ {
+ if (!homeinit
+ || memcmp ((char *) &homebuf, (char *) &cwdbuf,
+ sizeof (struct stat)))
+ localinit = gdbinit;
+ }
+
+ initialized = 1;
+ }
+
+ *system_gdbinit = sysgdbinit;
+ *home_gdbinit = homeinit;
+ *local_gdbinit = localinit;
+}
+
/* Call command_loop. If it happens to return, pass that through as a
non-zero return status. */
/* Number of elements used. */
int ndir;
- struct stat homebuf, cwdbuf;
- char *homedir;
+ /* gdb init files. */
+ char *system_gdbinit;
+ char *home_gdbinit;
+ char *local_gdbinit;
int i;
line[0] = '\0'; /* Terminate saved (now empty) cmd line */
instream = stdin;
- getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));
- current_directory = gdb_dirbuf;
-
gdb_stdout = stdio_fileopen (stdout);
gdb_stderr = stdio_fileopen (stderr);
gdb_stdlog = gdb_stderr; /* for moment */
gdb_stdtargerr = gdb_stderr; /* for moment */
gdb_stdtargin = gdb_stdin; /* for moment */
+ gdb_program_name = xstrdup (argv[0]);
+
+ if (! getcwd (gdb_dirbuf, sizeof (gdb_dirbuf)))
+ /* Don't use *_filtered or warning() (which relies on
+ current_target) until after initialize_all_files(). */
+ fprintf_unfiltered (gdb_stderr,
+ _("%s: warning: error finding working directory: %s\n"),
+ argv[0], safe_strerror (errno));
+
+ current_directory = gdb_dirbuf;
+
/* Set the sysroot path. */
#ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
gdb_sysroot = make_relative_prefix (argv[0], BINDIR, TARGET_SYSTEM_ROOT);
}
}
+ get_init_files (&system_gdbinit, &home_gdbinit, &local_gdbinit);
+
/* There will always be an interpreter. Either the one passed into
this captured main, or one specified by the user at start up, or
the console. Initialize the interpreter to the one requested by
if (interp == NULL)
error (_("Interpreter `%s' unrecognized"), interpreter_p);
/* Install it. */
- if (!interp_set (interp))
+ if (!interp_set (interp, 1))
{
fprintf_unfiltered (gdb_stderr,
"Interpreter `%s' failed to initialize.\n",
quit_pre_print = error_pre_print;
warning_pre_print = _("\nwarning: ");
+ /* Read and execute the system-wide gdbinit file, if it exists.
+ This is done *before* all the command line arguments are
+ processed; it sets global parameters, which are independent of
+ what file you are debugging or what directory you are in. */
+ if (system_gdbinit && !inhibit_gdbinit)
+ catch_command_errors (source_script, system_gdbinit, 0, RETURN_MASK_ALL);
+
/* Read and execute $HOME/.gdbinit file, if it exists. This is done
*before* all the command line arguments are processed; it sets
global parameters, which are independent of what file you are
debugging or what directory you are in. */
- homedir = getenv ("HOME");
- if (homedir)
- {
- char *homeinit = xstrprintf ("%s/%s", homedir, gdbinit);
- if (!inhibit_gdbinit)
- {
- catch_command_errors (source_script, homeinit, 0, RETURN_MASK_ALL);
- }
-
- /* Do stats; no need to do them elsewhere since we'll only
- need them if homedir is set. Make sure that they are
- zero in case one of them fails (this guarantees that they
- won't match if either exists). */
-
- memset (&homebuf, 0, sizeof (struct stat));
- memset (&cwdbuf, 0, sizeof (struct stat));
-
- stat (homeinit, &homebuf);
- stat (gdbinit, &cwdbuf); /* We'll only need this if
- homedir was set. */
- xfree (homeinit);
- }
+ if (home_gdbinit && !inhibit_gdbinit)
+ catch_command_errors (source_script, home_gdbinit, 0, RETURN_MASK_ALL);
/* Now perform all the actions indicated by the arguments. */
if (cdarg != NULL)
/* Read the .gdbinit file in the current directory, *if* it isn't
the same as the $HOME/.gdbinit file (it should exist, also). */
-
- if (!homedir
- || memcmp ((char *) &homebuf, (char *) &cwdbuf, sizeof (struct stat)))
- if (!inhibit_gdbinit)
- {
- catch_command_errors (source_script, gdbinit, 0, RETURN_MASK_ALL);
- }
+ if (local_gdbinit && !inhibit_gdbinit)
+ catch_command_errors (source_script, local_gdbinit, 0, RETURN_MASK_ALL);
for (i = 0; i < ncmd; i++)
{
-#if 0
- /* NOTE: cagney/1999-11-03: SET_TOP_LEVEL() was a macro that
- expanded into a call to setjmp(). */
- if (!SET_TOP_LEVEL ()) /* NB: This is #if 0'd out */
- {
- /* NOTE: I am commenting this out, because it is not clear
- where this feature is used. It is very old and
- undocumented. ezannoni: 1999-05-04 */
-#if 0
- if (cmdarg[i][0] == '-' && cmdarg[i][1] == '\0')
- read_command_file (stdin);
- else
-#endif
- source_script (cmdarg[i], !batch);
- do_cleanups (ALL_CLEANUPS);
- }
-#endif
if (cmdarg[i].type == CMDARG_FILE)
catch_command_errors (source_script, cmdarg[i].string,
!batch, RETURN_MASK_ALL);
quit_force (NULL, 0);
}
- /* Do any host- or target-specific hacks. This is used for i960 targets
- to force the user to set a nindy target and spec its parameters. */
-
-#ifdef BEFORE_MAIN_LOOP_HOOK
- BEFORE_MAIN_LOOP_HOOK;
-#endif
-
/* Show time and/or space usage. */
if (display_time)
#endif
}
-#if 0
- /* FIXME: cagney/1999-11-06: The original main loop was like: */
- while (1)
- {
- if (!SET_TOP_LEVEL ())
- {
- do_cleanups (ALL_CLEANUPS); /* Do complete cleanup */
- /* GUIs generally have their own command loop, mainloop, or
- whatever. This is a good place to gain control because
- many error conditions will end up here via longjmp(). */
- if (deprecated_command_loop_hook)
- deprecated_command_loop_hook ();
- else
- deprecated_command_loop ();
- quit_command ((char *) 0, instream == stdin);
- }
- }
- /* NOTE: If the command_loop() returned normally, the loop would
- attempt to exit by calling the function quit_command(). That
- function would either call exit() or throw an error returning
- control to SET_TOP_LEVEL. */
- /* NOTE: The function do_cleanups() was called once each time round
- the loop. The usefulness of the call isn't clear. If an error
- was thrown, everything would have already been cleaned up. If
- command_loop() returned normally and quit_command() was called,
- either exit() or error() (again cleaning up) would be called. */
-#endif
/* NOTE: cagney/1999-11-07: There is probably no reason for not
moving this loop and the code found in captured_command_loop()
into the command_loop() proper. The main thing holding back that
static void
print_gdb_help (struct ui_file *stream)
{
+ char *system_gdbinit;
+ char *home_gdbinit;
+ char *local_gdbinit;
+
+ get_init_files (&system_gdbinit, &home_gdbinit, &local_gdbinit);
+
fputs_unfiltered (_("\
This is the GNU debugger. Usage:\n\n\
gdb [options] [executable-file [core-file or process-id]]\n\
--xdb XDB compatibility mode.\n\
"), stream);
fputs_unfiltered (_("\n\
+At startup, GDB reads the following init files and executes their commands:\n\
+"), stream);
+ if (system_gdbinit)
+ fprintf_unfiltered (stream, _("\
+ * system-wide init file: %s\n\
+"), system_gdbinit);
+ if (home_gdbinit)
+ fprintf_unfiltered (stream, _("\
+ * user-specific init file: %s\n\
+"), home_gdbinit);
+ if (local_gdbinit)
+ fprintf_unfiltered (stream, _("\
+ * local init file: ./%s\n\
+"), local_gdbinit);
+ fputs_unfiltered (_("\n\
For more information, type \"help\" from within GDB, or consult the\n\
GDB manual (available as on-line info or a printed manual).\n\
-Report bugs to \"bug-gdb@gnu.org\".\
"), stream);
+ if (REPORT_BUGS_TO[0] && stream == gdb_stdout)
+ fprintf_unfiltered (stream, _("\
+Report bugs to \"%s\".\n\
+"), REPORT_BUGS_TO);
}