1 /* General GDB/Guile code.
3 Copyright (C) 2014-2024 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 3 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, see <http://www.gnu.org/licenses/>. */
20 /* See README file in this directory for implementation notes, coding
21 conventions, et.al. */
23 #include "breakpoint.h"
24 #include "cli/cli-cmds.h"
25 #include "cli/cli-script.h"
26 #include "cli/cli-utils.h"
31 #include "extension-priv.h"
33 #include "gdbsupport/version.h"
36 #include "guile-internal.h"
39 #include "gdbsupport/block-signals.h"
41 /* The Guile version we're using.
42 We *could* use the macros in libguile/version.h but that would preclude
43 handling the user switching in a different version with, e.g.,
44 LD_LIBRARY_PATH (using a different version than what gdb was compiled with
45 is not something to be done lightly, but can be useful). */
46 int gdbscm_guile_major_version
;
47 int gdbscm_guile_minor_version
;
48 int gdbscm_guile_micro_version
;
51 /* The guile subdirectory within gdb's data-directory. */
52 static const char *guile_datadir
;
55 /* Declared constants and enum for guile exception printing. */
56 const char gdbscm_print_excp_none
[] = "none";
57 const char gdbscm_print_excp_full
[] = "full";
58 const char gdbscm_print_excp_message
[] = "message";
60 /* "set guile print-stack" choices. */
61 static const char *const guile_print_excp_enums
[] =
63 gdbscm_print_excp_none
,
64 gdbscm_print_excp_full
,
65 gdbscm_print_excp_message
,
69 /* The exception printing variable. 'full' if we want to print the
70 error message and stack, 'none' if we want to print nothing, and
71 'message' if we only want to print the error message. 'message' is
73 const char *gdbscm_print_excp
= gdbscm_print_excp_message
;
78 static void gdbscm_initialize (const struct extension_language_defn
*);
79 static int gdbscm_initialized (const struct extension_language_defn
*);
80 static void gdbscm_eval_from_control_command
81 (const struct extension_language_defn
*, struct command_line
*);
82 static script_sourcer_func gdbscm_source_script
;
83 static void gdbscm_set_backtrace (int enable
);
85 int gdb_scheme_initialized
;
87 /* Symbol for setting documentation strings. */
88 SCM gdbscm_documentation_symbol
;
90 /* Keywords used by various functions. */
91 static SCM from_tty_keyword
;
92 static SCM to_string_keyword
;
94 /* The name of the various modules (without the surrounding parens). */
95 const char gdbscm_module_name
[] = "gdb";
96 const char gdbscm_init_module_name
[] = "gdb";
98 /* The name of the bootstrap file. */
99 static const char boot_scm_filename
[] = "boot.scm";
101 /* The interface between gdb proper and loading of python scripts. */
103 static const struct extension_language_script_ops guile_extension_script_ops
=
105 gdbscm_source_script
,
106 gdbscm_source_objfile_script
,
107 gdbscm_execute_objfile_script
,
108 gdbscm_auto_load_enabled
111 /* The interface between gdb proper and guile scripting. */
113 static const struct extension_language_ops guile_extension_ops
=
119 gdbscm_eval_from_control_command
,
121 NULL
, /* gdbscm_start_type_printers, */
122 NULL
, /* gdbscm_apply_type_printers, */
123 NULL
, /* gdbscm_free_type_printers, */
125 gdbscm_apply_val_pretty_printer
,
127 NULL
, /* gdbscm_apply_frame_filter, */
129 gdbscm_preserve_values
,
131 gdbscm_breakpoint_has_cond
,
132 gdbscm_breakpoint_cond_says_stop
,
134 NULL
, /* gdbscm_set_quit_flag, */
135 NULL
, /* gdbscm_check_quit_flag, */
136 NULL
, /* gdbscm_before_prompt, */
137 NULL
, /* gdbscm_get_matching_xmethod_workers */
138 NULL
, /* gdbscm_colorize */
139 NULL
, /* gdbscm_print_insn */
143 /* The main struct describing GDB's interface to the Guile
144 extension language. */
145 extern const struct extension_language_defn extension_language_guile
=
157 &guile_extension_script_ops
,
166 /* Implementation of the gdb "guile-repl" command. */
169 guile_repl_command (const char *arg
, int from_tty
)
171 scoped_restore restore_async
= make_scoped_restore (¤t_ui
->async
, 0);
173 arg
= skip_spaces (arg
);
175 /* This explicitly rejects any arguments for now.
176 "It is easier to relax a restriction than impose one after the fact."
177 We would *like* to be able to pass arguments to the interactive shell
178 but that's not what python-interactive does. Until there is time to
179 sort it out, we forbid arguments. */
182 error (_("guile-repl currently does not take any arguments."));
186 gdbscm_enter_repl ();
190 /* Implementation of the gdb "guile" command.
191 Note: Contrary to the Python version this displays the result.
192 Have to see which is better.
194 TODO: Add the result to Guile's history? */
197 guile_command (const char *arg
, int from_tty
)
199 scoped_restore restore_async
= make_scoped_restore (¤t_ui
->async
, 0);
201 arg
= skip_spaces (arg
);
205 gdb::unique_xmalloc_ptr
<char> msg
= gdbscm_safe_eval_string (arg
, 1);
208 error ("%s", msg
.get ());
212 counted_command_line l
= get_command_line (guile_control
, "");
214 execute_control_command_untraced (l
.get ());
218 /* Given a command_line, return a command string suitable for passing
219 to Guile. Lines in the string are separated by newlines. The return
220 value is allocated using xmalloc and the caller is responsible for
224 compute_scheme_string (struct command_line
*l
)
226 struct command_line
*iter
;
231 for (iter
= l
; iter
; iter
= iter
->next
)
232 size
+= strlen (iter
->line
) + 1;
234 script
= (char *) xmalloc (size
+ 1);
236 for (iter
= l
; iter
; iter
= iter
->next
)
238 int len
= strlen (iter
->line
);
240 strcpy (&script
[here
], iter
->line
);
242 script
[here
++] = '\n';
248 /* Take a command line structure representing a "guile" command, and
249 evaluate its body using the Guile interpreter.
250 This is the extension_language_ops.eval_from_control_command "method". */
253 gdbscm_eval_from_control_command
254 (const struct extension_language_defn
*extlang
, struct command_line
*cmd
)
258 if (cmd
->body_list_1
!= nullptr)
259 error (_("Invalid \"guile\" block structure."));
261 script
= compute_scheme_string (cmd
->body_list_0
.get ());
262 gdb::unique_xmalloc_ptr
<char> msg
= gdbscm_safe_eval_string (script
, 0);
265 error ("%s", msg
.get ());
268 /* Read a file as Scheme code.
269 This is the extension_language_script_ops.script_sourcer "method".
270 FILE is the file to run. FILENAME is name of the file FILE.
271 This does not throw any errors. If an exception occurs an error message
275 gdbscm_source_script (const struct extension_language_defn
*extlang
,
276 FILE *file
, const char *filename
)
278 gdb::unique_xmalloc_ptr
<char> msg
= gdbscm_safe_source_script (filename
);
281 gdb_printf (gdb_stderr
, "%s\n", msg
.get ());
284 /* (execute string [#:from-tty boolean] [#:to-string boolean])
285 A Scheme function which evaluates a string using the gdb CLI. */
288 gdbscm_execute_gdb_command (SCM command_scm
, SCM rest
)
290 int from_tty_arg_pos
= -1, to_string_arg_pos
= -1;
291 int from_tty
= 0, to_string
= 0;
292 const SCM keywords
[] = { from_tty_keyword
, to_string_keyword
, SCM_BOOL_F
};
295 gdbscm_parse_function_args (FUNC_NAME
, SCM_ARG1
, keywords
, "s#tt",
296 command_scm
, &command
, rest
,
297 &from_tty_arg_pos
, &from_tty
,
298 &to_string_arg_pos
, &to_string
);
300 return gdbscm_wrap ([=]
302 gdb::unique_xmalloc_ptr
<char> command_holder (command
);
303 std::string to_string_res
;
305 scoped_restore restore_async
= make_scoped_restore (¤t_ui
->async
,
308 scoped_restore preventer
= prevent_dont_repeat ();
310 execute_command_to_string (to_string_res
, command
, from_tty
, false);
312 execute_command (command
, from_tty
);
314 /* Do any commands attached to breakpoint we stopped at. */
315 bpstat_do_actions ();
318 return gdbscm_scm_from_c_string (to_string_res
.c_str ());
319 return SCM_UNSPECIFIED
;
323 /* (data-directory) -> string */
326 gdbscm_data_directory (void)
328 return gdbscm_scm_from_c_string (gdb_datadir
.c_str ());
331 /* (guile-data-directory) -> string */
334 gdbscm_guile_data_directory (void)
336 return gdbscm_scm_from_c_string (guile_datadir
);
339 /* (gdb-version) -> string */
342 gdbscm_gdb_version (void)
344 return gdbscm_scm_from_c_string (version
);
347 /* (host-config) -> string */
350 gdbscm_host_config (void)
352 return gdbscm_scm_from_c_string (host_name
);
355 /* (target-config) -> string */
358 gdbscm_target_config (void)
360 return gdbscm_scm_from_c_string (target_name
);
363 #else /* ! HAVE_GUILE */
365 /* Dummy implementation of the gdb "guile-repl" and "guile"
369 guile_repl_command (const char *arg
, int from_tty
)
371 arg
= skip_spaces (arg
);
373 error (_("guile-repl currently does not take any arguments."));
374 error (_("Guile scripting is not supported in this copy of GDB."));
378 guile_command (const char *arg
, int from_tty
)
380 arg
= skip_spaces (arg
);
382 error (_("Guile scripting is not supported in this copy of GDB."));
385 /* Even if Guile isn't enabled, we still have to slurp the
386 command list to the corresponding "end". */
387 counted_command_line l
= get_command_line (guile_control
, "");
389 execute_control_command_untraced (l
.get ());
393 #endif /* ! HAVE_GUILE */
395 /* Lists for 'set,show,info guile' commands. */
397 static struct cmd_list_element
*set_guile_list
;
398 static struct cmd_list_element
*show_guile_list
;
399 static struct cmd_list_element
*info_guile_list
;
402 /* Initialization. */
406 static const scheme_function misc_guile_functions
[] =
408 { "execute", 1, 0, 1, as_a_scm_t_subr (gdbscm_execute_gdb_command
),
410 Execute the given GDB command.\n\
412 Arguments: string [#:to-string boolean] [#:from-tty boolean]\n\
413 If #:from-tty is true then the command executes as if entered\n\
414 from the keyboard. The default is false (#f).\n\
415 If #:to-string is true then the result is returned as a string.\n\
416 Otherwise output is sent to the current output port,\n\
417 which is the default.\n\
418 Returns: The result of the command if #:to-string is true.\n\
419 Otherwise returns unspecified." },
421 { "data-directory", 0, 0, 0, as_a_scm_t_subr (gdbscm_data_directory
),
423 Return the name of GDB's data directory." },
425 { "guile-data-directory", 0, 0, 0,
426 as_a_scm_t_subr (gdbscm_guile_data_directory
),
428 Return the name of the Guile directory within GDB's data directory." },
430 { "gdb-version", 0, 0, 0, as_a_scm_t_subr (gdbscm_gdb_version
),
432 Return GDB's version string." },
434 { "host-config", 0, 0, 0, as_a_scm_t_subr (gdbscm_host_config
),
436 Return the name of the host configuration." },
438 { "target-config", 0, 0, 0, as_a_scm_t_subr (gdbscm_target_config
),
440 Return the name of the target configuration." },
445 /* Load BOOT_SCM_FILE, the first Scheme file that gets loaded. */
448 boot_guile_support (void *boot_scm_file
)
450 /* Load boot.scm without compiling it (there's no need to compile it).
451 The other files should have been compiled already, and boot.scm is
452 expected to adjust '%load-compiled-path' accordingly. If they haven't
453 been compiled, Guile will auto-compile them. The important thing to keep
454 in mind is that there's a >= 100x speed difference between compiled and
455 non-compiled files. */
456 return scm_c_primitive_load ((const char *) boot_scm_file
);
459 /* Return non-zero if ARGS has the "standard" format for throw args.
460 The standard format is:
461 (function format-string (format-string-args-list) ...).
462 FUNCTION is #f if no function was recorded. */
465 standard_throw_args_p (SCM args
)
467 if (gdbscm_is_true (scm_list_p (args
))
468 && scm_ilength (args
) >= 3)
470 /* The function in which the error occurred. */
471 SCM arg0
= scm_list_ref (args
, scm_from_int (0));
472 /* The format string. */
473 SCM arg1
= scm_list_ref (args
, scm_from_int (1));
474 /* The arguments of the format string. */
475 SCM arg2
= scm_list_ref (args
, scm_from_int (2));
477 if ((scm_is_string (arg0
) || gdbscm_is_false (arg0
))
478 && scm_is_string (arg1
)
479 && gdbscm_is_true (scm_list_p (arg2
)))
486 /* Print the error recorded in a "standard" throw args. */
489 print_standard_throw_error (SCM args
)
491 /* The function in which the error occurred. */
492 SCM arg0
= scm_list_ref (args
, scm_from_int (0));
493 /* The format string. */
494 SCM arg1
= scm_list_ref (args
, scm_from_int (1));
495 /* The arguments of the format string. */
496 SCM arg2
= scm_list_ref (args
, scm_from_int (2));
498 /* ARG0 is #f if no function was recorded. */
499 if (gdbscm_is_true (arg0
))
501 scm_simple_format (scm_current_error_port (),
502 scm_from_latin1_string (_("Error in function ~s:~%")),
505 scm_simple_format (scm_current_error_port (), arg1
, arg2
);
508 /* Print the error message recorded in KEY, ARGS, the arguments to throw.
509 Normally we let Scheme print the error message.
510 This function is used when Scheme initialization fails.
511 We can still use the Scheme C API though. */
514 print_throw_error (SCM key
, SCM args
)
516 /* IWBN to call gdbscm_print_exception_with_stack here, but Guile didn't
517 boot successfully so play it safe and avoid it. The "format string" and
518 its args are embedded in ARGS, but the content of ARGS depends on KEY.
519 Make sure ARGS has the expected canonical content before trying to use
521 if (standard_throw_args_p (args
))
522 print_standard_throw_error (args
);
525 scm_simple_format (scm_current_error_port (),
526 scm_from_latin1_string (_("Throw to key `~a' with args `~s'.~%")),
527 scm_list_2 (key
, args
));
531 /* Handle an exception thrown while loading BOOT_SCM_FILE. */
534 handle_boot_error (void *boot_scm_file
, SCM key
, SCM args
)
536 gdb_printf (gdb_stderr
, ("Exception caught while booting Guile.\n"));
538 print_throw_error (key
, args
);
540 gdb_printf (gdb_stderr
, "\n");
541 warning (_("Could not complete Guile gdb module initialization from:\n"
543 "Limited Guile support is available.\n"
544 "Suggest passing --data-directory=/path/to/gdb/data-directory."),
545 (const char *) boot_scm_file
);
547 return SCM_UNSPECIFIED
;
550 /* Load gdb/boot.scm, the Scheme side of GDB/Guile support.
551 Note: This function assumes it's called within the gdb module. */
554 initialize_scheme_side (void)
558 guile_datadir
= concat (gdb_datadir
.c_str (), SLASH_STRING
, "guile",
560 boot_scm_path
= concat (guile_datadir
, SLASH_STRING
, "gdb",
561 SLASH_STRING
, boot_scm_filename
, (char *) NULL
);
563 scm_c_catch (SCM_BOOL_T
, boot_guile_support
, boot_scm_path
,
564 handle_boot_error
, boot_scm_path
, NULL
, NULL
);
566 xfree (boot_scm_path
);
569 /* Install the gdb scheme module.
570 The result is a boolean indicating success.
571 If initializing the gdb module fails an error message is printed.
572 Note: This function runs in the context of the gdb module. */
575 initialize_gdb_module (void *data
)
577 /* Computing these is a pain, so only do it once.
578 Also, do it here and save the result so that obtaining the values
580 gdbscm_guile_major_version
= gdbscm_scm_string_to_int (scm_major_version ());
581 gdbscm_guile_minor_version
= gdbscm_scm_string_to_int (scm_minor_version ());
582 gdbscm_guile_micro_version
= gdbscm_scm_string_to_int (scm_micro_version ());
584 /* The documentation symbol needs to be defined before any calls to
585 gdbscm_define_{variables,functions}. */
586 gdbscm_documentation_symbol
= scm_from_latin1_symbol ("documentation");
588 /* The smob and exception support must be initialized early. */
589 gdbscm_initialize_smobs ();
590 gdbscm_initialize_exceptions ();
592 /* The rest are initialized in alphabetical order. */
593 gdbscm_initialize_arches ();
594 gdbscm_initialize_auto_load ();
595 gdbscm_initialize_blocks ();
596 gdbscm_initialize_breakpoints ();
597 gdbscm_initialize_commands ();
598 gdbscm_initialize_disasm ();
599 gdbscm_initialize_frames ();
600 gdbscm_initialize_iterators ();
601 gdbscm_initialize_lazy_strings ();
602 gdbscm_initialize_math ();
603 gdbscm_initialize_objfiles ();
604 gdbscm_initialize_parameters ();
605 gdbscm_initialize_ports ();
606 gdbscm_initialize_pretty_printers ();
607 gdbscm_initialize_pspaces ();
608 gdbscm_initialize_strings ();
609 gdbscm_initialize_symbols ();
610 gdbscm_initialize_symtabs ();
611 gdbscm_initialize_types ();
612 gdbscm_initialize_values ();
614 gdbscm_define_functions (misc_guile_functions
, 1);
616 from_tty_keyword
= scm_from_latin1_keyword ("from-tty");
617 to_string_keyword
= scm_from_latin1_keyword ("to-string");
619 initialize_scheme_side ();
621 gdb_scheme_initialized
= 1;
624 /* Utility to call scm_c_define_module+initialize_gdb_module from
625 within scm_with_guile. */
628 call_initialize_gdb_module (void *data
)
630 /* Most of the initialization is done by initialize_gdb_module.
631 It is called via scm_c_define_module so that the initialization is
632 performed within the desired module. */
633 scm_c_define_module (gdbscm_module_name
, initialize_gdb_module
, NULL
);
635 #if HAVE_GUILE_MANUAL_FINALIZATION
636 scm_run_finalizers ();
642 /* A callback to initialize Guile after gdb has finished all its
643 initialization. This is the extension_language_ops.initialize "method". */
646 gdbscm_initialize (const struct extension_language_defn
*extlang
)
649 /* The Python support puts the C side in module "_gdb", leaving the
650 Python side to define module "gdb" which imports "_gdb". There is
651 evidently no similar convention in Guile so we skip this. */
653 #if HAVE_GUILE_MANUAL_FINALIZATION
654 /* Our SMOB free functions are not thread-safe, as GDB itself is not
655 intended to be thread-safe. Disable automatic finalization so that
656 finalizers aren't run in other threads. */
657 scm_set_automatic_finalization_enabled (0);
660 /* Before we initialize Guile, block signals needed by gdb (especially
661 SIGCHLD). This is done so that all threads created during Guile
662 initialization have SIGCHLD blocked. PR 17247. Really libgc and
663 Guile should do this, but we need to work with libgc 7.4.x. */
665 gdb::block_signals blocker
;
667 /* There are libguile versions (f.i. v3.0.5) that by default call
668 mp_get_memory_functions during initialization to install custom
669 libgmp memory functions. This is considered a bug and should be
670 fixed starting v3.0.6.
671 Before gdb commit 880ae75a2b7 "gdb delay guile initialization until
672 gdbscm_finish_initialization", that bug had no effect for gdb,
673 because gdb subsequently called mp_get_memory_functions to install
674 its own custom functions in _initialize_gmp_utils. However, since
675 aforementioned gdb commit the initialization order is reversed,
676 allowing libguile to install a custom malloc that is incompatible
677 with the custom free as used in gmp-utils.c, resulting in a
678 "double free or corruption (out)" error.
679 Work around the libguile bug by disabling the installation of the
680 libgmp memory functions by guile initialization. */
682 /* The scm_install_gmp_memory_functions variable should be removed after
683 version 3.0, so limit usage to 3.0 and before. */
684 #if SCM_MAJOR_VERSION < 3 || (SCM_MAJOR_VERSION == 3 && SCM_MINOR_VERSION == 0)
685 /* This variable is deprecated in Guile 3.0.8 and later but remains
686 available in the whole 3.0 series. */
687 #pragma GCC diagnostic push
688 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
689 scm_install_gmp_memory_functions
= 0;
690 #pragma GCC diagnostic pop
693 /* scm_with_guile is the most portable way to initialize Guile. Plus
694 we need to initialize the Guile support while in Guile mode (e.g.,
695 called from within a call to scm_with_guile). */
696 scm_with_guile (call_initialize_gdb_module
, NULL
);
699 /* Set Guile's backtrace to match the "set guile print-stack" default.
700 [N.B. The two settings are still separate.] But only do this after
701 we've initialized Guile, it's nice to see a backtrace if there's an
702 error during initialization. OTOH, if the error is that gdb/init.scm
703 wasn't found because gdb is being run from the build tree, the
704 backtrace is more noise than signal. Sigh. */
705 gdbscm_set_backtrace (0);
708 /* Restore the environment to the user interaction one. */
709 scm_set_current_module (scm_interaction_environment ());
712 /* The extension_language_ops.initialized "method". */
715 gdbscm_initialized (const struct extension_language_defn
*extlang
)
717 return gdb_scheme_initialized
;
720 /* Enable or disable Guile backtraces. */
723 gdbscm_set_backtrace (int enable
)
725 static const char disable_bt
[] = "(debug-disable 'backtrace)";
726 static const char enable_bt
[] = "(debug-enable 'backtrace)";
729 gdbscm_safe_eval_string (enable_bt
, 0);
731 gdbscm_safe_eval_string (disable_bt
, 0);
734 #endif /* HAVE_GUILE */
737 cmd_list_element
*guile_cmd_element
= nullptr;
739 /* Install the various gdb commands used by Guile. */
742 install_gdb_commands (void)
744 cmd_list_element
*guile_repl_cmd
745 = add_com ("guile-repl", class_obscure
, guile_repl_command
,
748 Start an interactive Guile prompt.\n\
750 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
752 #else /* HAVE_GUILE */
754 Start a Guile interactive prompt.\n\
756 Guile scripting is not supported in this copy of GDB.\n\
757 This command is only a placeholder.")
758 #endif /* HAVE_GUILE */
760 add_com_alias ("gr", guile_repl_cmd
, class_obscure
, 1);
762 /* Since "help guile" is easy to type, and intuitive, we add general help
763 in using GDB+Guile to this command. */
764 guile_cmd_element
= add_com ("guile", class_obscure
, guile_command
,
767 Evaluate one or more Guile expressions.\n\
769 The expression(s) can be given as an argument, for instance:\n\
771 guile (display 23)\n\
773 The result of evaluating the last expression is printed.\n\
775 If no argument is given, the following lines are read and passed\n\
776 to Guile for evaluation. Type a line containing \"end\" to indicate\n\
777 the end of the set of expressions.\n\
779 The Guile GDB module must first be imported before it can be used.\n\
781 (gdb) guile (use-modules (gdb))\n\
782 or if you want to import the (gdb) module with a prefix, use:\n\
783 (gdb) guile (use-modules ((gdb) #:renamer (symbol-prefix-proc 'gdb:)))\n\
785 The Guile interactive session, started with the \"guile-repl\"\n\
786 command, provides extensive help and apropos capabilities.\n\
787 Type \",help\" once in a Guile interactive session.")
788 #else /* HAVE_GUILE */
790 Evaluate a Guile expression.\n\
792 Guile scripting is not supported in this copy of GDB.\n\
793 This command is only a placeholder.")
794 #endif /* HAVE_GUILE */
796 add_com_alias ("gu", guile_cmd_element
, class_obscure
, 1);
798 set_show_commands setshow_guile_cmds
799 = add_setshow_prefix_cmd ("guile", class_obscure
,
801 Prefix command for Guile preference settings."),
803 Prefix command for Guile preference settings."),
804 &set_guile_list
, &show_guile_list
,
805 &setlist
, &showlist
);
807 add_alias_cmd ("gu", setshow_guile_cmds
.set
, class_obscure
, 1, &setlist
);
808 add_alias_cmd ("gu", setshow_guile_cmds
.show
, class_obscure
, 1, &showlist
);
810 cmd_list_element
*info_guile_cmd
811 = add_basic_prefix_cmd ("guile", class_obscure
,
812 _("Prefix command for Guile info displays."),
813 &info_guile_list
, 0, &infolist
);
814 add_info_alias ("gu", info_guile_cmd
, 1);
816 /* The name "print-stack" is carried over from Python.
817 A better name is "print-exception". */
818 add_setshow_enum_cmd ("print-stack", no_class
, guile_print_excp_enums
,
819 &gdbscm_print_excp
, _("\
820 Set mode for Guile exception printing on error."), _("\
821 Show the mode of Guile exception printing on error."), _("\
822 none == no stack or message will be printed.\n\
823 full == a message and a stack will be printed.\n\
824 message == an error message without a stack will be printed."),
826 &set_guile_list
, &show_guile_list
);
829 void _initialize_guile ();
833 install_gdb_commands ();