/* GDB routines for supporting auto-loaded scripts.
- Copyright (C) 2012-2014 Free Software Foundation, Inc.
+ Copyright (C) 2012-2015 Free Software Foundation, Inc.
This file is part of GDB.
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
+#include <ctype.h>
#include "auto-load.h"
#include "progspace.h"
-#include "python/python.h"
#include "gdb_regex.h"
#include "ui-out.h"
#include "filenames.h"
#include "command.h"
#include "observer.h"
#include "objfiles.h"
-#include "exceptions.h"
#include "cli/cli-script.h"
#include "gdbcmd.h"
#include "cli/cli-cmds.h"
#include "fnmatch.h"
#include "top.h"
#include "filestuff.h"
+#include "extension.h"
+#include "gdb/section-scripts.h"
/* The section to look in for auto-loaded scripts (in file formats that
support sections).
followed by the path of a python script to load. */
#define AUTO_SECTION_NAME ".debug_gdb_scripts"
-/* The suffix of per-objfile scripts to auto-load as non-Python command files.
- E.g. When the program loads libfoo.so, look for libfoo-gdb.gdb. */
-#define GDB_AUTO_FILE_NAME "-gdb.gdb"
+static void maybe_print_unsupported_script_warning
+ (struct auto_load_pspace_info *, struct objfile *objfile,
+ const struct extension_language_defn *language,
+ const char *section_name, unsigned offset);
-static void source_gdb_script_for_objfile (struct objfile *objfile, FILE *file,
- const char *filename);
+static void maybe_print_script_not_found_warning
+ (struct auto_load_pspace_info *, struct objfile *objfile,
+ const struct extension_language_defn *language,
+ const char *section_name, unsigned offset);
/* Value of the 'set debug auto-load' configuration variable. */
static int debug_auto_load = 0;
/* Return non-zero if auto-loading gdb scripts is enabled. */
-static int
-auto_load_gdb_scripts_enabled (void)
+int
+auto_load_gdb_scripts_enabled (const struct extension_language_defn *extlang)
{
return auto_load_gdb_scripts;
}
auto_load_safe_path_vec_update ();
}
+/* "add-auto-load-scripts-directory" command for the auto_load_dir configuration
+ variable. */
+
+static void
+add_auto_load_dir (char *args, int from_tty)
+{
+ char *s;
+
+ if (args == NULL || *args == 0)
+ error (_("Directory argument required."));
+
+ s = xstrprintf ("%s%c%s", auto_load_dir, DIRNAME_SEPARATOR, args);
+ xfree (auto_load_dir);
+ auto_load_dir = s;
+}
+
/* Implementation for filename_is_in_pattern overwriting the caller's FILENAME
and PATTERN. */
return 0;
}
-/* Definition of script language for GDB canned sequences of commands. */
-
-static const struct script_language script_language_gdb =
-{
- "gdb",
- GDB_AUTO_FILE_NAME,
- auto_load_gdb_scripts_enabled,
- source_gdb_script_for_objfile
-};
-
-static void
-source_gdb_script_for_objfile (struct objfile *objfile, FILE *file,
- const char *filename)
-{
- volatile struct gdb_exception e;
-
- TRY_CATCH (e, RETURN_MASK_ALL)
- {
- script_from_file (file, filename);
- }
- exception_print (gdb_stderr, e);
-}
-
/* For scripts specified in .debug_gdb_scripts, multiple objfiles may load
the same script. There's no point in loading the script multiple times,
and there can be a lot of objfiles and scripts, so we keep track of scripts
struct auto_load_pspace_info
{
- /* For each program space we keep track of loaded scripts. */
- struct htab *loaded_scripts;
+ /* For each program space we keep track of loaded scripts, both when
+ specified as file names and as scripts to be executed directly. */
+ struct htab *loaded_script_files;
+ struct htab *loaded_script_texts;
+
+ /* Non-zero if we've issued the warning about an auto-load script not being
+ supported. We only want to issue this warning once. */
+ int unsupported_script_warning_printed;
/* Non-zero if we've issued the warning about an auto-load script not being
found. We only want to issue this warning once. */
int script_not_found_warning_printed;
};
-/* Objects of this type are stored in the loaded script hash table. */
+/* Objects of this type are stored in the loaded_script hash table. */
struct loaded_script
{
const char *name;
/* Full path name or NULL if script wasn't found (or was otherwise
- inaccessible). */
+ inaccessible), or NULL for loaded_script_texts. */
const char *full_path;
/* Non-zero if this script has been loaded. */
int loaded;
- const struct script_language *language;
+ const struct extension_language_defn *language;
};
/* Per-program-space data key. */
{
struct auto_load_pspace_info *info = arg;
- if (info->loaded_scripts)
- htab_delete (info->loaded_scripts);
+ if (info->loaded_script_files)
+ htab_delete (info->loaded_script_files);
+ if (info->loaded_script_texts)
+ htab_delete (info->loaded_script_texts);
xfree (info);
}
info = program_space_data (pspace, auto_load_pspace_data);
if (info == NULL)
{
- info = XZALLOC (struct auto_load_pspace_info);
+ info = XCNEW (struct auto_load_pspace_info);
set_program_space_data (pspace, auto_load_pspace_data, info);
}
Space for each entry is obtained with one malloc so we can free them
easily. */
- pspace_info->loaded_scripts = htab_create (31,
- hash_loaded_script_entry,
- eq_loaded_script_entry,
- xfree);
+ pspace_info->loaded_script_files = htab_create (31,
+ hash_loaded_script_entry,
+ eq_loaded_script_entry,
+ xfree);
+ pspace_info->loaded_script_texts = htab_create (31,
+ hash_loaded_script_entry,
+ eq_loaded_script_entry,
+ xfree);
+ pspace_info->unsupported_script_warning_printed = FALSE;
pspace_info->script_not_found_warning_printed = FALSE;
}
struct auto_load_pspace_info *info;
info = get_auto_load_pspace_data (pspace);
- if (info->loaded_scripts == NULL)
+ if (info->loaded_script_files == NULL)
init_loaded_scripts_info (info);
return info;
}
-/* Add script NAME in LANGUAGE to hash table of PSPACE_INFO. LOADED 1 if the
- script has been (is going to) be loaded, 0 otherwise (such as if it has not
- been found). FULL_PATH is NULL if the script wasn't found. The result is
- true if the script was already in the hash table. */
+/* Add script file NAME in LANGUAGE to hash table of PSPACE_INFO.
+ LOADED 1 if the script has been (is going to) be loaded, 0 otherwise
+ (such as if it has not been found).
+ FULL_PATH is NULL if the script wasn't found.
+ The result is true if the script was already in the hash table. */
-int
-maybe_add_script (struct auto_load_pspace_info *pspace_info, int loaded,
- const char *name, const char *full_path,
- const struct script_language *language)
+static int
+maybe_add_script_file (struct auto_load_pspace_info *pspace_info, int loaded,
+ const char *name, const char *full_path,
+ const struct extension_language_defn *language)
{
- struct htab *htab = pspace_info->loaded_scripts;
+ struct htab *htab = pspace_info->loaded_script_files;
struct loaded_script **slot, entry;
int in_hash_table;
/* If this script is not in the hash table, add it. */
- if (! in_hash_table)
+ if (!in_hash_table)
{
char *p;
return in_hash_table;
}
+/* Add script contents NAME in LANGUAGE to hash table of PSPACE_INFO.
+ LOADED 1 if the script has been (is going to) be loaded, 0 otherwise
+ (such as if it has not been found).
+ The result is true if the script was already in the hash table. */
+
+static int
+maybe_add_script_text (struct auto_load_pspace_info *pspace_info,
+ int loaded, const char *name,
+ const struct extension_language_defn *language)
+{
+ struct htab *htab = pspace_info->loaded_script_texts;
+ struct loaded_script **slot, entry;
+ int in_hash_table;
+
+ entry.name = name;
+ entry.language = language;
+ slot = (struct loaded_script **) htab_find_slot (htab, &entry, INSERT);
+ in_hash_table = *slot != NULL;
+
+ /* If this script is not in the hash table, add it. */
+
+ if (!in_hash_table)
+ {
+ char *p;
+
+ /* Allocate all space in one chunk so it's easier to free. */
+ *slot = xmalloc (sizeof (**slot) + strlen (name) + 1);
+ p = ((char*) *slot) + sizeof (**slot);
+ strcpy (p, name);
+ (*slot)->name = p;
+ (*slot)->full_path = NULL;
+ (*slot)->loaded = loaded;
+ (*slot)->language = language;
+ }
+
+ return in_hash_table;
+}
+
/* Clear the table of loaded section scripts. */
static void
struct auto_load_pspace_info *info;
info = program_space_data (pspace, auto_load_pspace_data);
- if (info != NULL && info->loaded_scripts != NULL)
+ if (info != NULL && info->loaded_script_files != NULL)
{
- htab_delete (info->loaded_scripts);
- info->loaded_scripts = NULL;
+ htab_delete (info->loaded_script_files);
+ htab_delete (info->loaded_script_texts);
+ info->loaded_script_files = NULL;
+ info->loaded_script_texts = NULL;
+ info->unsupported_script_warning_printed = FALSE;
info->script_not_found_warning_printed = FALSE;
}
}
static int
auto_load_objfile_script_1 (struct objfile *objfile, const char *realname,
- const struct script_language *language)
+ const struct extension_language_defn *language)
{
char *filename, *debugfile;
int len, retval;
FILE *input;
struct cleanup *cleanups;
+ const char *suffix = ext_lang_auto_load_suffix (language);
len = strlen (realname);
- filename = xmalloc (len + strlen (language->suffix) + 1);
+ filename = xmalloc (len + strlen (suffix) + 1);
memcpy (filename, realname, len);
- strcpy (filename + len, language->suffix);
+ strcpy (filename + len, suffix);
cleanups = make_cleanup (xfree, filename);
make_cleanup_fclose (input);
is_safe
- = file_is_auto_load_safe (filename,
+ = file_is_auto_load_safe (debugfile,
_("auto-load: Loading %s script \"%s\""
" by extension for objfile \"%s\".\n"),
- language->name, filename,
- objfile_name (objfile));
+ ext_lang_name (language),
+ debugfile, objfile_name (objfile));
/* Add this script to the hash table too so
"info auto-load ${lang}-scripts" can print it. */
pspace_info
= get_auto_load_pspace_data_for_loading (current_program_space);
- maybe_add_script (pspace_info, is_safe, filename, filename, language);
+ maybe_add_script_file (pspace_info, is_safe, debugfile, debugfile,
+ language);
/* To preserve existing behaviour we don't check for whether the
script was already in the table, and always load it.
and these scripts are required to be idempotent under multiple
loads anyway. */
if (is_safe)
- language->source_script_for_objfile (objfile, input, debugfile);
+ {
+ objfile_script_sourcer_func *sourcer
+ = ext_lang_objfile_script_sourcer (language);
+
+ /* We shouldn't get here if support for the language isn't
+ compiled in. And the extension language is required to implement
+ this function. */
+ gdb_assert (sourcer != NULL);
+ sourcer (language, objfile, input, debugfile);
+ }
retval = 1;
}
/* Look for the auto-load script in LANGUAGE associated with OBJFILE and load
it. */
-static void
+void
auto_load_objfile_script (struct objfile *objfile,
- const struct script_language *language)
+ const struct extension_language_defn *language)
{
- char *realname;
- struct cleanup *cleanups;
-
- /* Skip this script if support has not been compiled in or
- auto-loading it has been disabled. */
- if (language == NULL
- || !language->auto_load_enabled ())
- return;
-
- realname = gdb_realpath (objfile_name (objfile));
- cleanups = make_cleanup (xfree, realname);
+ char *realname = gdb_realpath (objfile_name (objfile));
+ struct cleanup *cleanups = make_cleanup (xfree, realname);
if (!auto_load_objfile_script_1 (objfile, realname, language))
{
do_cleanups (cleanups);
}
+/* Subroutine of source_section_scripts to simplify it.
+ Load FILE as a script in extension language LANGUAGE.
+ The script is from section SECTION_NAME in OBJFILE at offset OFFSET. */
+
+static void
+source_script_file (struct auto_load_pspace_info *pspace_info,
+ struct objfile *objfile,
+ const struct extension_language_defn *language,
+ const char *section_name, unsigned int offset,
+ const char *file)
+{
+ FILE *stream;
+ char *full_path;
+ int opened, in_hash_table;
+ struct cleanup *cleanups;
+ objfile_script_sourcer_func *sourcer;
+
+ /* Skip this script if support is not compiled in. */
+ sourcer = ext_lang_objfile_script_sourcer (language);
+ if (sourcer == NULL)
+ {
+ /* We don't throw an error, the program is still debuggable. */
+ maybe_print_unsupported_script_warning (pspace_info, objfile, language,
+ section_name, offset);
+ /* We *could* still try to open it, but there's no point. */
+ maybe_add_script_file (pspace_info, 0, file, NULL, language);
+ return;
+ }
+
+ /* Skip this script if auto-loading it has been disabled. */
+ if (!ext_lang_auto_load_enabled (language))
+ {
+ /* No message is printed, just skip it. */
+ return;
+ }
+
+ opened = find_and_open_script (file, 1 /*search_path*/,
+ &stream, &full_path);
+
+ cleanups = make_cleanup (null_cleanup, NULL);
+ if (opened)
+ {
+ make_cleanup_fclose (stream);
+ make_cleanup (xfree, full_path);
+
+ if (!file_is_auto_load_safe (full_path,
+ _("auto-load: Loading %s script "
+ "\"%s\" from section \"%s\" of "
+ "objfile \"%s\".\n"),
+ ext_lang_name (language), full_path,
+ section_name, objfile_name (objfile)))
+ opened = 0;
+ }
+ else
+ {
+ full_path = NULL;
+
+ /* If one script isn't found it's not uncommon for more to not be
+ found either. We don't want to print a message for each script,
+ too much noise. Instead, we print the warning once and tell the
+ user how to find the list of scripts that weren't loaded.
+ We don't throw an error, the program is still debuggable.
+
+ IWBN if complaints.c were more general-purpose. */
+
+ maybe_print_script_not_found_warning (pspace_info, objfile, language,
+ section_name, offset);
+ }
+
+ in_hash_table = maybe_add_script_file (pspace_info, opened, file, full_path,
+ language);
+
+ /* If this file is not currently loaded, load it. */
+ if (opened && !in_hash_table)
+ sourcer (language, objfile, stream, full_path);
+
+ do_cleanups (cleanups);
+}
+
+/* Subroutine of source_section_scripts to simplify it.
+ Execute SCRIPT as a script in extension language LANG.
+ The script is from section SECTION_NAME in OBJFILE at offset OFFSET. */
+
+static void
+execute_script_contents (struct auto_load_pspace_info *pspace_info,
+ struct objfile *objfile,
+ const struct extension_language_defn *language,
+ const char *section_name, unsigned int offset,
+ const char *script)
+{
+ objfile_script_executor_func *executor;
+ const char *newline, *script_text;
+ char *name, *end;
+ int is_safe, in_hash_table;
+ struct cleanup *cleanups;
+
+ cleanups = make_cleanup (null_cleanup, NULL);
+
+ /* The first line of the script is the name of the script.
+ It must not contain any kind of space character. */
+ name = NULL;
+ newline = strchr (script, '\n');
+ if (newline != NULL)
+ {
+ char *buf, *p;
+
+ /* Put the name in a buffer and validate it. */
+ buf = xstrndup (script, newline - script);
+ make_cleanup (xfree, buf);
+ for (p = buf; *p != '\0'; ++p)
+ {
+ if (isspace (*p))
+ break;
+ }
+ /* We don't allow nameless scripts, they're not helpful to the user. */
+ if (p != buf && *p == '\0')
+ name = buf;
+ }
+ if (name == NULL)
+ {
+ /* We don't throw an error, the program is still debuggable. */
+ warning (_("\
+Missing/bad script name in entry at offset %u in section %s\n\
+of file %s."),
+ offset, section_name, objfile_name (objfile));
+ do_cleanups (cleanups);
+ return;
+ }
+ script_text = newline + 1;
+
+ /* Skip this script if support is not compiled in. */
+ executor = ext_lang_objfile_script_executor (language);
+ if (executor == NULL)
+ {
+ /* We don't throw an error, the program is still debuggable. */
+ maybe_print_unsupported_script_warning (pspace_info, objfile, language,
+ section_name, offset);
+ maybe_add_script_text (pspace_info, 0, name, language);
+ do_cleanups (cleanups);
+ return;
+ }
+
+ /* Skip this script if auto-loading it has been disabled. */
+ if (!ext_lang_auto_load_enabled (language))
+ {
+ /* No message is printed, just skip it. */
+ do_cleanups (cleanups);
+ return;
+ }
+
+ is_safe = file_is_auto_load_safe (objfile_name (objfile),
+ _("auto-load: Loading %s script "
+ "\"%s\" from section \"%s\" of "
+ "objfile \"%s\".\n"),
+ ext_lang_name (language), name,
+ section_name, objfile_name (objfile));
+
+ in_hash_table = maybe_add_script_text (pspace_info, is_safe, name, language);
+
+ /* If this file is not currently loaded, load it. */
+ if (is_safe && !in_hash_table)
+ executor (language, objfile, name, script_text);
+
+ do_cleanups (cleanups);
+}
+
/* Load scripts specified in OBJFILE.
START,END delimit a buffer containing a list of nul-terminated
file names.
SECTION_NAME is used in error messages.
- Scripts are found per normal "source -s" command processing.
- First the script is looked for in $cwd. If not found there the
- source search path is used.
+ Scripts specified as file names are found per normal "source -s" command
+ processing. First the script is looked for in $cwd. If not found there
+ the source search path is used.
- The section contains a list of path names of script files to load.
- Each path is null-terminated. */
+ The section contains a list of path names of script files to load or
+ actual script contents. Each entry is nul-terminated. */
static void
source_section_scripts (struct objfile *objfile, const char *section_name,
for (p = start; p < end; ++p)
{
- const char *file;
- FILE *stream;
- char *full_path;
- int opened, in_hash_table;
- struct cleanup *back_to;
- /* At the moment we only support python scripts in .debug_gdb_scripts,
- but that can change. */
- const struct script_language *language = gdbpy_script_language_defn ();
-
- if (*p != 1)
+ const char *entry;
+ const struct extension_language_defn *language;
+ unsigned int offset = p - start;
+ int code = *p;
+
+ switch (code)
{
+ case SECTION_SCRIPT_ID_PYTHON_FILE:
+ case SECTION_SCRIPT_ID_PYTHON_TEXT:
+ language = get_ext_lang_defn (EXT_LANG_PYTHON);
+ break;
+ case SECTION_SCRIPT_ID_SCHEME_FILE:
+ case SECTION_SCRIPT_ID_SCHEME_TEXT:
+ language = get_ext_lang_defn (EXT_LANG_GUILE);
+ break;
+ default:
warning (_("Invalid entry in %s section"), section_name);
/* We could try various heuristics to find the next valid entry,
but it's safer to just punt. */
- break;
+ return;
}
- file = ++p;
+ entry = ++p;
while (p < end && *p != '\0')
++p;
if (p == end)
{
- char *buf = alloca (p - file + 1);
-
- memcpy (buf, file, p - file);
- buf[p - file] = '\0';
- warning (_("Non-null-terminated path in %s: %s"),
- section_name, buf);
- /* Don't load it. */
+ warning (_("Non-nul-terminated entry in %s at offset %u"),
+ section_name, offset);
+ /* Don't load/execute it. */
break;
}
- if (p == file)
- {
- warning (_("Empty path in %s"), section_name);
- continue;
- }
-
- /* Skip this script if support has not been compiled in or
- auto-loading it has been disabled. */
- if (language == NULL
- || !language->auto_load_enabled ())
- {
- /* No message is printed, just skip it. */
- continue;
- }
-
- opened = find_and_open_script (file, 1 /*search_path*/,
- &stream, &full_path);
-
- back_to = make_cleanup (null_cleanup, NULL);
- if (opened)
- {
- make_cleanup_fclose (stream);
- make_cleanup (xfree, full_path);
-
- if (!file_is_auto_load_safe (full_path,
- _("auto-load: Loading %s script "
- "\"%s\" from section \"%s\" of "
- "objfile \"%s\".\n"),
- language->name, full_path, section_name,
- objfile_name (objfile)))
- opened = 0;
- }
- else
- {
- full_path = NULL;
-
- /* If one script isn't found it's not uncommon for more to not be
- found either. We don't want to print a message for each script,
- too much noise. Instead, we print the warning once and tell the
- user how to find the list of scripts that weren't loaded.
- We don't throw an error, the program is still debuggable.
-
- IWBN if complaints.c were more general-purpose. */
-
- if (script_not_found_warning_print (pspace_info))
- warning (_("Missing auto-load scripts referenced in section %s\n\
-of file %s\n\
-Use `info auto-load %s-scripts [REGEXP]' to list them."),
- section_name, objfile_name (objfile), language->name);
- }
-
- in_hash_table = maybe_add_script (pspace_info, opened, file, full_path,
- language);
- /* If this file is not currently loaded, load it. */
- if (opened && !in_hash_table)
+ switch (code)
{
- gdb_assert (language->source_script_for_objfile != NULL);
- language->source_script_for_objfile (objfile, stream, full_path);
+ case SECTION_SCRIPT_ID_PYTHON_FILE:
+ case SECTION_SCRIPT_ID_SCHEME_FILE:
+ if (p == entry)
+ {
+ warning (_("Empty entry in %s at offset %u"),
+ section_name, offset);
+ continue;
+ }
+ source_script_file (pspace_info, objfile, language,
+ section_name, offset, entry);
+ break;
+ case SECTION_SCRIPT_ID_PYTHON_TEXT:
+ case SECTION_SCRIPT_ID_SCHEME_TEXT:
+ execute_script_contents (pspace_info, objfile, language,
+ section_name, offset, entry);
+ break;
}
-
- do_cleanups (back_to);
}
}
{
/* Return immediately if auto-loading has been globally disabled.
This is to handle sequencing of operations during gdb startup.
- Also return immediately if OBJFILE is not actually a file. */
- if (!global_auto_load || (objfile->flags & OBJF_NOT_FILENAME) != 0)
+ Also return immediately if OBJFILE was not created from a file
+ on the local filesystem. */
+ if (!global_auto_load
+ || (objfile->flags & OBJF_NOT_FILENAME) != 0
+ || is_target_filename (objfile->original_name))
return;
- /* Load any scripts for this objfile. e.g. foo-gdb.gdb, foo-gdb.py. */
- auto_load_objfile_script (objfile, &script_language_gdb);
- auto_load_objfile_script (objfile, gdbpy_script_language_defn ());
+ /* Load any extension language scripts for this objfile.
+ E.g., foo-gdb.gdb, foo-gdb.py. */
+ auto_load_ext_lang_scripts_for_objfile (objfile);
/* Load any scripts mentioned in AUTO_SECTION_NAME (.debug_gdb_scripts). */
auto_load_section_scripts (objfile, AUTO_SECTION_NAME);
{
VEC (loaded_script_ptr) **scripts_p;
- const struct script_language *language;
+ const struct extension_language_defn *language;
};
/* Traversal function for htab_traverse.
"info auto-load" invocation. Extra newline will be printed if needed. */
char auto_load_info_scripts_pattern_nl[] = "";
+/* Subroutine of auto_load_info_scripts to simplify it.
+ Print SCRIPTS. */
+
+static void
+print_scripts (VEC (loaded_script_ptr) *scripts)
+{
+ struct ui_out *uiout = current_uiout;
+ int i;
+ loaded_script_ptr script;
+
+ qsort (VEC_address (loaded_script_ptr, scripts),
+ VEC_length (loaded_script_ptr, scripts),
+ sizeof (loaded_script_ptr), sort_scripts_by_name);
+ for (i = 0; VEC_iterate (loaded_script_ptr, scripts, i, script); ++i)
+ print_script (script);
+}
+
/* Implementation for "info auto-load gdb-scripts"
(and "info auto-load python-scripts"). List scripts in LANGUAGE matching
PATTERN. FROM_TTY is the usual GDB boolean for user interactivity. */
void
auto_load_info_scripts (char *pattern, int from_tty,
- const struct script_language *language)
+ const struct extension_language_defn *language)
{
struct ui_out *uiout = current_uiout;
struct auto_load_pspace_info *pspace_info;
struct cleanup *script_chain;
- VEC (loaded_script_ptr) *scripts;
+ VEC (loaded_script_ptr) *script_files, *script_texts;
int nr_scripts;
dont_repeat ();
Plus we want to sort the scripts by name.
So first traverse the hash table collecting the matching scripts. */
- scripts = VEC_alloc (loaded_script_ptr, 10);
- script_chain = make_cleanup (VEC_cleanup (loaded_script_ptr), &scripts);
+ script_files = VEC_alloc (loaded_script_ptr, 10);
+ script_texts = VEC_alloc (loaded_script_ptr, 10);
+ script_chain = make_cleanup (VEC_cleanup (loaded_script_ptr), &script_files);
+ make_cleanup (VEC_cleanup (loaded_script_ptr), &script_texts);
- if (pspace_info != NULL && pspace_info->loaded_scripts != NULL)
+ if (pspace_info != NULL && pspace_info->loaded_script_files != NULL)
{
- struct collect_matching_scripts_data data = { &scripts, language };
+ struct collect_matching_scripts_data data = { &script_files, language };
/* Pass a pointer to scripts as VEC_safe_push can realloc space. */
- htab_traverse_noresize (pspace_info->loaded_scripts,
+ htab_traverse_noresize (pspace_info->loaded_script_files,
collect_matching_scripts, &data);
}
- nr_scripts = VEC_length (loaded_script_ptr, scripts);
+ if (pspace_info != NULL && pspace_info->loaded_script_texts != NULL)
+ {
+ struct collect_matching_scripts_data data = { &script_texts, language };
+
+ /* Pass a pointer to scripts as VEC_safe_push can realloc space. */
+ htab_traverse_noresize (pspace_info->loaded_script_texts,
+ collect_matching_scripts, &data);
+ }
+
+ nr_scripts = (VEC_length (loaded_script_ptr, script_files)
+ + VEC_length (loaded_script_ptr, script_texts));
/* Table header shifted right by preceding "gdb-scripts: " would not match
its columns. */
if (nr_scripts > 0 && pattern == auto_load_info_scripts_pattern_nl)
ui_out_text (uiout, "\n");
+ /* Note: This creates a cleanup to output the table end marker. */
make_cleanup_ui_out_table_begin_end (uiout, 2, nr_scripts,
"AutoLoadedScriptsTable");
ui_out_table_header (uiout, 70, ui_left, "script", "Script");
ui_out_table_body (uiout);
- if (nr_scripts > 0)
- {
- int i;
- loaded_script_ptr script;
-
- qsort (VEC_address (loaded_script_ptr, scripts),
- VEC_length (loaded_script_ptr, scripts),
- sizeof (loaded_script_ptr), sort_scripts_by_name);
- for (i = 0; VEC_iterate (loaded_script_ptr, scripts, i, script); ++i)
- print_script (script);
- }
+ print_scripts (script_files);
+ print_scripts (script_texts);
+ /* Finish up the table before checking for no matching scripts. */
do_cleanups (script_chain);
if (nr_scripts == 0)
static void
info_auto_load_gdb_scripts (char *pattern, int from_tty)
{
- auto_load_info_scripts (pattern, from_tty, &script_language_gdb);
+ auto_load_info_scripts (pattern, from_tty, &extension_language_gdb);
}
/* Implement 'info auto-load local-gdbinit'. */
auto_load_local_gdbinit_pathname);
}
+/* Print an "unsupported script" warning if it has not already been printed.
+ The script is in language LANGUAGE at offset OFFSET in section SECTION_NAME
+ of OBJFILE. */
+
+static void
+maybe_print_unsupported_script_warning
+ (struct auto_load_pspace_info *pspace_info,
+ struct objfile *objfile, const struct extension_language_defn *language,
+ const char *section_name, unsigned offset)
+{
+ if (!pspace_info->unsupported_script_warning_printed)
+ {
+ warning (_("\
+Unsupported auto-load script at offset %u in section %s\n\
+of file %s.\n\
+Use `info auto-load %s-scripts [REGEXP]' to list them."),
+ offset, section_name, objfile_name (objfile),
+ ext_lang_name (language));
+ pspace_info->unsupported_script_warning_printed = 1;
+ }
+}
+
/* Return non-zero if SCRIPT_NOT_FOUND_WARNING_PRINTED of PSPACE_INFO was unset
before calling this function. Always set SCRIPT_NOT_FOUND_WARNING_PRINTED
of PSPACE_INFO. */
-int
-script_not_found_warning_print (struct auto_load_pspace_info *pspace_info)
+static void
+maybe_print_script_not_found_warning
+ (struct auto_load_pspace_info *pspace_info,
+ struct objfile *objfile, const struct extension_language_defn *language,
+ const char *section_name, unsigned offset)
{
- int retval = !pspace_info->script_not_found_warning_printed;
-
- pspace_info->script_not_found_warning_printed = 1;
-
- return retval;
+ if (!pspace_info->script_not_found_warning_printed)
+ {
+ warning (_("\
+Missing auto-load script at offset %u in section %s\n\
+of file %s.\n\
+Use `info auto-load %s-scripts [REGEXP]' to list them."),
+ offset, section_name, objfile_name (objfile),
+ ext_lang_name (language));
+ pspace_info->script_not_found_warning_printed = 1;
+ }
}
/* The only valid "set auto-load" argument is off|0|no|disable. */
_initialize_auto_load (void)
{
struct cmd_list_element *cmd;
- char *scripts_directory_help;
+ char *scripts_directory_help, *gdb_name_help, *python_name_help;
+ char *guile_name_help;
+ const char *suffix;
auto_load_pspace_data
= register_program_space_data_with_cleanup (NULL,
auto_load_info_cmdlist_get ());
auto_load_dir = xstrdup (AUTO_LOAD_DIR);
- scripts_directory_help = xstrprintf (
+
+ suffix = ext_lang_auto_load_suffix (get_ext_lang_defn (EXT_LANG_GDB));
+ gdb_name_help
+ = xstrprintf (_("\
+GDB scripts: OBJFILE%s\n"),
+ suffix);
+ python_name_help = NULL;
#ifdef HAVE_PYTHON
- _("\
-Automatically loaded Python scripts (named OBJFILE%s) and GDB scripts\n\
-(named OBJFILE%s) are located in one of the directories listed by this\n\
-option.\n\
-%s"),
- GDBPY_AUTO_FILE_NAME,
-#else
- _("\
-Automatically loaded GDB scripts (named OBJFILE%s) are located in one\n\
-of the directories listed by this option.\n\
-%s"),
+ suffix = ext_lang_auto_load_suffix (get_ext_lang_defn (EXT_LANG_PYTHON));
+ python_name_help
+ = xstrprintf (_("\
+Python scripts: OBJFILE%s\n"),
+ suffix);
#endif
- GDB_AUTO_FILE_NAME,
- _("\
+ guile_name_help = NULL;
+#ifdef HAVE_GUILE
+ suffix = ext_lang_auto_load_suffix (get_ext_lang_defn (EXT_LANG_GUILE));
+ guile_name_help
+ = xstrprintf (_("\
+Guile scripts: OBJFILE%s\n"),
+ suffix);
+#endif
+ scripts_directory_help
+ = xstrprintf (_("\
+Automatically loaded scripts are located in one of the directories listed\n\
+by this option.\n\
+\n\
+Script names:\n\
+%s%s%s\
+\n\
This option is ignored for the kinds of scripts \
having 'set auto-load ... off'.\n\
Directories listed here need to be present also \
in the 'set auto-load safe-path'\n\
-option."));
+option."),
+ gdb_name_help,
+ python_name_help ? python_name_help : "",
+ guile_name_help ? guile_name_help : "");
+
add_setshow_optional_filename_cmd ("scripts-directory", class_support,
&auto_load_dir, _("\
Set the list of directories from which to load auto-loaded scripts."), _("\
auto_load_set_cmdlist_get (),
auto_load_show_cmdlist_get ());
xfree (scripts_directory_help);
+ xfree (python_name_help);
+ xfree (gdb_name_help);
+ xfree (guile_name_help);
auto_load_safe_path = xstrdup (AUTO_LOAD_SAFE_PATH);
auto_load_safe_path_vec_update ();
&cmdlist);
set_cmd_completer (cmd, filename_completer);
+ cmd = add_cmd ("add-auto-load-scripts-directory", class_support,
+ add_auto_load_dir,
+ _("Add entries to the list of directories from which to load "
+ "auto-loaded scripts.\n\
+See the commands 'set auto-load scripts-directory' and\n\
+'show auto-load scripts-directory' to access the current full list setting."),
+ &cmdlist);
+ set_cmd_completer (cmd, filename_completer);
+
add_setshow_boolean_cmd ("auto-load", class_maintenance,
&debug_auto_load, _("\
Set auto-load verifications debugging."), _("\
projects / deliverable / binutils-gdb.git / blobdiff