1 /* Interface between gdb and its extension languages.
3 Copyright (C) 2014-2018 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 /* Note: With few exceptions, external functions and variables in this file
21 have "ext_lang" in the name, and no other symbol in gdb does. */
26 #include "auto-load.h"
27 #include "breakpoint.h"
28 #include "event-top.h"
29 #include "extension.h"
30 #include "extension-priv.h"
31 #include "observable.h"
32 #include "cli/cli-script.h"
33 #include "python/python.h"
34 #include "guile/guile.h"
36 /* Iterate over all external extension languages, regardless of whether the
37 support has been compiled in or not.
38 This does not include GDB's own scripting language. */
40 #define ALL_EXTENSION_LANGUAGES(i, extlang) \
41 for (/*int*/ i = 0, extlang = extension_languages[0]; \
43 extlang = extension_languages[++i])
45 /* Iterate over all external extension languages that are supported.
46 This does not include GDB's own scripting language. */
48 #define ALL_ENABLED_EXTENSION_LANGUAGES(i, extlang) \
49 for (/*int*/ i = 0, extlang = extension_languages[0]; \
51 extlang = extension_languages[++i]) \
52 if (extlang->ops != NULL)
54 static script_sourcer_func source_gdb_script;
55 static objfile_script_sourcer_func source_gdb_objfile_script;
57 /* GDB's own scripting language.
58 This exists, in part, to support auto-loading ${prog}-gdb.gdb scripts. */
60 static const struct extension_language_script_ops
61 extension_language_gdb_script_ops =
64 source_gdb_objfile_script,
65 NULL, /* objfile_script_executor */
66 auto_load_gdb_scripts_enabled
69 const struct extension_language_defn extension_language_gdb =
75 /* We fall back to interpreting a script as a GDB script if it doesn't
76 match the other scripting languages, but for consistency's sake
77 give it a formal suffix. */
81 /* cli_control_type: This is never used: GDB's own scripting language
82 has a variety of control types (if, while, etc.). */
85 &extension_language_gdb_script_ops,
87 /* The rest of the extension language interface isn't supported by GDB's own
88 extension/scripting language. */
92 /* NULL-terminated table of all external (non-native) extension languages.
94 The order of appearance in the table is important.
95 When multiple extension languages provide the same feature, for example
96 a pretty-printer for a particular type, which one gets used?
97 The algorithm employed here is "the first one wins". For example, in
98 the case of pretty-printers this means the first one to provide a
99 pretty-printed value is the one that is used. This algorithm is employed
102 static const struct extension_language_defn * const extension_languages[] =
104 /* To preserve existing behaviour, python should always appear first. */
105 &extension_language_python,
106 &extension_language_guile,
110 /* Return a pointer to the struct extension_language_defn object of
111 extension language LANG.
112 This always returns a non-NULL pointer, even if support for the language
113 is not compiled into this copy of GDB. */
115 const struct extension_language_defn *
116 get_ext_lang_defn (enum extension_language lang)
119 const struct extension_language_defn *extlang;
121 gdb_assert (lang != EXT_LANG_NONE);
123 if (lang == EXT_LANG_GDB)
124 return &extension_language_gdb;
126 ALL_EXTENSION_LANGUAGES (i, extlang)
128 if (extlang->language == lang)
132 gdb_assert_not_reached ("unable to find extension_language_defn");
135 /* Return TRUE if FILE has extension EXTENSION. */
138 has_extension (const char *file, const char *extension)
140 int file_len = strlen (file);
141 int extension_len = strlen (extension);
143 return (file_len > extension_len
144 && strcmp (&file[file_len - extension_len], extension) == 0);
147 /* Return the extension language of FILE, or NULL if
148 the extension language of FILE is not recognized.
149 This is done by looking at the file's suffix. */
151 const struct extension_language_defn *
152 get_ext_lang_of_file (const char *file)
155 const struct extension_language_defn *extlang;
157 ALL_EXTENSION_LANGUAGES (i, extlang)
159 if (has_extension (file, extlang->suffix))
166 /* Return non-zero if support for the specified extension language
170 ext_lang_present_p (const struct extension_language_defn *extlang)
172 return extlang->script_ops != NULL;
175 /* Return non-zero if the specified extension language has successfully
179 ext_lang_initialized_p (const struct extension_language_defn *extlang)
181 if (extlang->ops != NULL)
183 /* This method is required. */
184 gdb_assert (extlang->ops->initialized != NULL);
185 return extlang->ops->initialized (extlang);
191 /* Throw an error indicating EXTLANG is not supported in this copy of GDB. */
194 throw_ext_lang_unsupported (const struct extension_language_defn *extlang)
196 error (_("Scripting in the \"%s\" language is not supported"
197 " in this copy of GDB."),
198 ext_lang_capitalized_name (extlang));
201 /* Methods for GDB's own extension/scripting language. */
203 /* The extension_language_script_ops.script_sourcer "method". */
206 source_gdb_script (const struct extension_language_defn *extlang,
207 FILE *stream, const char *file)
209 script_from_file (stream, file);
212 /* The extension_language_script_ops.objfile_script_sourcer "method". */
215 source_gdb_objfile_script (const struct extension_language_defn *extlang,
216 struct objfile *objfile,
217 FILE *stream, const char *file)
219 script_from_file (stream, file);
222 /* Accessors for "public" attributes of struct extension_language. */
224 /* Return the "name" field of EXTLANG. */
227 ext_lang_name (const struct extension_language_defn *extlang)
229 return extlang->name;
232 /* Return the "capitalized_name" field of EXTLANG. */
235 ext_lang_capitalized_name (const struct extension_language_defn *extlang)
237 return extlang->capitalized_name;
240 /* Return the "suffix" field of EXTLANG. */
243 ext_lang_suffix (const struct extension_language_defn *extlang)
245 return extlang->suffix;
248 /* Return the "auto_load_suffix" field of EXTLANG. */
251 ext_lang_auto_load_suffix (const struct extension_language_defn *extlang)
253 return extlang->auto_load_suffix;
256 /* extension_language_script_ops wrappers. */
258 /* Return the script "sourcer" function for EXTLANG.
259 This is the function that loads and processes a script.
260 If support for this language isn't compiled in, NULL is returned. */
262 script_sourcer_func *
263 ext_lang_script_sourcer (const struct extension_language_defn *extlang)
265 if (extlang->script_ops == NULL)
268 /* The extension language is required to implement this function. */
269 gdb_assert (extlang->script_ops->script_sourcer != NULL);
271 return extlang->script_ops->script_sourcer;
274 /* Return the objfile script "sourcer" function for EXTLANG.
275 This is the function that loads and processes a script for a particular
277 If support for this language isn't compiled in, NULL is returned. */
279 objfile_script_sourcer_func *
280 ext_lang_objfile_script_sourcer (const struct extension_language_defn *extlang)
282 if (extlang->script_ops == NULL)
285 /* The extension language is required to implement this function. */
286 gdb_assert (extlang->script_ops->objfile_script_sourcer != NULL);
288 return extlang->script_ops->objfile_script_sourcer;
291 /* Return the objfile script "executor" function for EXTLANG.
292 This is the function that executes a script for a particular objfile.
293 If support for this language isn't compiled in, NULL is returned.
294 The extension language is not required to implement this function. */
296 objfile_script_executor_func *
297 ext_lang_objfile_script_executor
298 (const struct extension_language_defn *extlang)
300 if (extlang->script_ops == NULL)
303 return extlang->script_ops->objfile_script_executor;
306 /* Return non-zero if auto-loading of EXTLANG scripts is enabled.
307 Zero is returned if support for this language isn't compiled in. */
310 ext_lang_auto_load_enabled (const struct extension_language_defn *extlang)
312 if (extlang->script_ops == NULL)
315 /* The extension language is required to implement this function. */
316 gdb_assert (extlang->script_ops->auto_load_enabled != NULL);
318 return extlang->script_ops->auto_load_enabled (extlang);
321 /* Functions that iterate over all extension languages.
322 These only iterate over external extension languages, not including
323 GDB's own extension/scripting language, unless otherwise indicated. */
325 /* Wrapper to call the extension_language_ops.finish_initialization "method"
326 for each compiled-in extension language. */
329 finish_ext_lang_initialization (void)
332 const struct extension_language_defn *extlang;
334 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
336 if (extlang->ops->finish_initialization != NULL)
337 extlang->ops->finish_initialization (extlang);
341 /* Invoke the appropriate extension_language_ops.eval_from_control_command
342 method to perform CMD, which is a list of commands in an extension language.
344 This function is what implements, for example:
353 eval_ext_lang_from_control_command (struct command_line *cmd)
356 const struct extension_language_defn *extlang;
358 ALL_EXTENSION_LANGUAGES (i, extlang)
360 if (extlang->cli_control_type == cmd->control_type)
362 if (extlang->ops != NULL
363 && extlang->ops->eval_from_control_command != NULL)
365 extlang->ops->eval_from_control_command (extlang, cmd);
368 /* The requested extension language is not supported in this GDB. */
369 throw_ext_lang_unsupported (extlang);
373 gdb_assert_not_reached ("unknown extension language in command_line");
376 /* Search for and load scripts for OBJFILE written in extension languages.
377 This includes GDB's own scripting language.
379 This function is what implements the loading of OBJFILE-gdb.py and
383 auto_load_ext_lang_scripts_for_objfile (struct objfile *objfile)
386 const struct extension_language_defn *extlang;
388 extlang = &extension_language_gdb;
389 if (ext_lang_auto_load_enabled (extlang))
390 auto_load_objfile_script (objfile, extlang);
392 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
394 if (ext_lang_auto_load_enabled (extlang))
395 auto_load_objfile_script (objfile, extlang);
399 /* Interface to type pretty-printers implemented in an extension language. */
401 /* Call this at the start when preparing to pretty-print a type.
402 The result is a pointer to an opaque object (to the caller) to be passed
403 to apply_ext_lang_type_printers and free_ext_lang_type_printers.
405 We don't know in advance which extension language will provide a
406 pretty-printer for the type, so all are initialized. */
408 struct ext_lang_type_printers *
409 start_ext_lang_type_printers (void)
411 struct ext_lang_type_printers *printers
412 = XCNEW (struct ext_lang_type_printers);
414 const struct extension_language_defn *extlang;
416 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
418 if (extlang->ops->start_type_printers != NULL)
419 extlang->ops->start_type_printers (extlang, printers);
425 /* Iteratively try the type pretty-printers specified by PRINTERS
426 according to the standard search order (specified by extension_languages),
427 returning the result of the first one that succeeds.
428 If there was an error, or if no printer succeeds, then NULL is returned. */
431 apply_ext_lang_type_printers (struct ext_lang_type_printers *printers,
435 const struct extension_language_defn *extlang;
437 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
442 if (extlang->ops->apply_type_printers == NULL)
444 rc = extlang->ops->apply_type_printers (extlang, printers, type,
449 gdb_assert (result != NULL);
451 case EXT_LANG_RC_ERROR:
453 case EXT_LANG_RC_NOP:
456 gdb_assert_not_reached ("bad return from apply_type_printers");
463 /* Call this after pretty-printing a type to release all memory held
467 free_ext_lang_type_printers (struct ext_lang_type_printers *printers)
470 const struct extension_language_defn *extlang;
472 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
474 if (extlang->ops->free_type_printers != NULL)
475 extlang->ops->free_type_printers (extlang, printers);
481 /* Try to pretty-print a value of type TYPE located at VAL's contents
482 buffer + EMBEDDED_OFFSET, which came from the inferior at address
483 ADDRESS + EMBEDDED_OFFSET, onto stdio stream STREAM according to
485 VAL is the whole object that came from ADDRESS.
486 Returns non-zero if the value was successfully pretty-printed.
488 Extension languages are tried in the order specified by
489 extension_languages. The first one to provide a pretty-printed
492 If an error is encountered in a pretty-printer, no further extension
494 Note: This is different than encountering a memory error trying to read a
495 value for pretty-printing. Here we're referring to, e.g., programming
496 errors that trigger an exception in the extension language. */
499 apply_ext_lang_val_pretty_printer (struct type *type,
500 LONGEST embedded_offset, CORE_ADDR address,
501 struct ui_file *stream, int recurse,
503 const struct value_print_options *options,
504 const struct language_defn *language)
507 const struct extension_language_defn *extlang;
509 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
513 if (extlang->ops->apply_val_pretty_printer == NULL)
515 rc = extlang->ops->apply_val_pretty_printer (extlang, type,
516 embedded_offset, address,
517 stream, recurse, val,
523 case EXT_LANG_RC_ERROR:
525 case EXT_LANG_RC_NOP:
528 gdb_assert_not_reached ("bad return from apply_val_pretty_printer");
535 /* GDB access to the "frame filter" feature.
536 FRAME is the source frame to start frame-filter invocation. FLAGS is an
537 integer holding the flags for printing. The following elements of
538 the FRAME_FILTER_FLAGS enum denotes the make-up of FLAGS:
539 PRINT_LEVEL is a flag indicating whether to print the frame's
540 relative level in the output. PRINT_FRAME_INFO is a flag that
541 indicates whether this function should print the frame
542 information, PRINT_ARGS is a flag that indicates whether to print
543 frame arguments, and PRINT_LOCALS, likewise, with frame local
544 variables. ARGS_TYPE is an enumerator describing the argument
545 format, OUT is the output stream to print. FRAME_LOW is the
546 beginning of the slice of frames to print, and FRAME_HIGH is the
547 upper limit of the frames to count. Returns EXT_LANG_BT_ERROR on error,
548 or EXT_LANG_BT_COMPLETED on success.
550 Extension languages are tried in the order specified by
551 extension_languages. The first one to provide a filter "wins".
552 If there is an error (EXT_LANG_BT_ERROR) it is reported immediately
553 rather than trying filters in other extension languages. */
555 enum ext_lang_bt_status
556 apply_ext_lang_frame_filter (struct frame_info *frame,
557 frame_filter_flags flags,
558 enum ext_lang_frame_args args_type,
560 int frame_low, int frame_high)
563 const struct extension_language_defn *extlang;
565 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
567 enum ext_lang_bt_status status;
569 if (extlang->ops->apply_frame_filter == NULL)
571 status = extlang->ops->apply_frame_filter (extlang, frame, flags,
573 frame_low, frame_high);
574 /* We use the filters from the first extension language that has
575 applicable filters. Also, an error is reported immediately
576 rather than continue trying. */
577 if (status != EXT_LANG_BT_NO_FILTERS)
581 return EXT_LANG_BT_NO_FILTERS;
584 /* Update values held by the extension language when OBJFILE is discarded.
585 New global types must be created for every such value, which must then be
586 updated to use the new types.
587 The function typically just iterates over all appropriate values and
588 calls preserve_one_value for each one.
589 COPIED_TYPES is used to prevent cycles / duplicates and is passed to
590 preserve_one_value. */
593 preserve_ext_lang_values (struct objfile *objfile, htab_t copied_types)
596 const struct extension_language_defn *extlang;
598 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
600 if (extlang->ops->preserve_values != NULL)
601 extlang->ops->preserve_values (extlang, objfile, copied_types);
605 /* If there is a stop condition implemented in an extension language for
606 breakpoint B, return a pointer to the extension language's definition.
607 Otherwise return NULL.
608 If SKIP_LANG is not EXT_LANG_NONE, skip checking this language.
609 This is for the case where we're setting a new condition: Only one
610 condition is allowed, so when setting a condition for any particular
611 extension language, we need to check if any other extension language
612 already has a condition set. */
614 const struct extension_language_defn *
615 get_breakpoint_cond_ext_lang (struct breakpoint *b,
616 enum extension_language skip_lang)
619 const struct extension_language_defn *extlang;
621 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
623 if (extlang->language != skip_lang
624 && extlang->ops->breakpoint_has_cond != NULL
625 && extlang->ops->breakpoint_has_cond (extlang, b))
632 /* Return whether a stop condition for breakpoint B says to stop.
633 True is also returned if there is no stop condition for B. */
636 breakpoint_ext_lang_cond_says_stop (struct breakpoint *b)
639 const struct extension_language_defn *extlang;
640 enum ext_lang_bp_stop stop = EXT_LANG_BP_STOP_UNSET;
642 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
644 /* There is a rule that a breakpoint can have at most one of any of a
645 CLI or extension language condition. However, Python hacks in "finish
646 breakpoints" on top of the "stop" check, so we have to call this for
647 every language, even if we could first determine whether a "stop"
649 if (extlang->ops->breakpoint_cond_says_stop != NULL)
651 enum ext_lang_bp_stop this_stop
652 = extlang->ops->breakpoint_cond_says_stop (extlang, b);
654 if (this_stop != EXT_LANG_BP_STOP_UNSET)
656 /* Even though we have to check every extension language, only
657 one of them can return yes/no (because only one of them
658 can have a "stop" condition). */
659 gdb_assert (stop == EXT_LANG_BP_STOP_UNSET);
665 return stop == EXT_LANG_BP_STOP_NO ? 0 : 1;
668 /* ^C/SIGINT support.
669 This requires cooperation with the extension languages so the support
672 /* This flag tracks quit requests when we haven't called out to an
673 extension language. it also holds quit requests when we transition to
674 an extension language that doesn't have cooperative SIGINT handling. */
675 static int quit_flag;
677 /* The current extension language we've called out to, or
678 extension_language_gdb if there isn't one.
679 This must be set everytime we call out to an extension language, and reset
680 to the previous value when it returns. Note that the previous value may
681 be a different (or the same) extension language. */
682 static const struct extension_language_defn *active_ext_lang
683 = &extension_language_gdb;
685 /* Return the currently active extension language. */
687 const struct extension_language_defn *
688 get_active_ext_lang (void)
690 return active_ext_lang;
693 /* Install a SIGINT handler. */
696 install_sigint_handler (const struct signal_handler *handler_state)
698 gdb_assert (handler_state->handler_saved);
700 signal (SIGINT, handler_state->handler);
703 /* Install GDB's SIGINT handler, storing the previous version in *PREVIOUS.
704 As a simple optimization, if the previous version was GDB's SIGINT handler
705 then mark the previous handler as not having been saved, and thus it won't
709 install_gdb_sigint_handler (struct signal_handler *previous)
711 /* Save here to simplify comparison. */
712 sighandler_t handle_sigint_for_compare = handle_sigint;
714 previous->handler = signal (SIGINT, handle_sigint);
715 if (previous->handler != handle_sigint_for_compare)
716 previous->handler_saved = 1;
718 previous->handler_saved = 0;
721 /* Set the currently active extension language to NOW_ACTIVE.
722 The result is a pointer to a malloc'd block of memory to pass to
723 restore_active_ext_lang.
725 N.B. This function must be called every time we call out to an extension
726 language, and the result must be passed to restore_active_ext_lang
729 If there is a pending SIGINT it is "moved" to the now active extension
730 language, if it supports cooperative SIGINT handling (i.e., it provides
731 {clear,set,check}_quit_flag methods). If the extension language does not
732 support cooperative SIGINT handling, then the SIGINT is left queued and
733 we require the non-cooperative extension language to call check_quit_flag
734 at appropriate times.
735 It is important for the extension language to call check_quit_flag if it
736 installs its own SIGINT handler to prevent the situation where a SIGINT
737 is queued on entry, extension language code runs for a "long" time possibly
738 serving one or more SIGINTs, and then returns. Upon return, if
739 check_quit_flag is not called, the original SIGINT will be thrown.
740 Non-cooperative extension languages are free to install their own SIGINT
741 handler but the original must be restored upon return, either itself
742 or via restore_active_ext_lang. */
744 struct active_ext_lang_state *
745 set_active_ext_lang (const struct extension_language_defn *now_active)
747 struct active_ext_lang_state *previous
748 = XCNEW (struct active_ext_lang_state);
750 previous->ext_lang = active_ext_lang;
751 previous->sigint_handler.handler_saved = 0;
752 active_ext_lang = now_active;
754 if (target_terminal::is_ours ())
756 /* If the newly active extension language uses cooperative SIGINT
757 handling then ensure GDB's SIGINT handler is installed. */
758 if (now_active->language == EXT_LANG_GDB
759 || now_active->ops->check_quit_flag != NULL)
760 install_gdb_sigint_handler (&previous->sigint_handler);
762 /* If there's a SIGINT recorded in the cooperative extension languages,
763 move it to the new language, or save it in GDB's global flag if the
764 newly active extension language doesn't use cooperative SIGINT
766 if (check_quit_flag ())
773 /* Restore active extension language from PREVIOUS. */
776 restore_active_ext_lang (struct active_ext_lang_state *previous)
778 active_ext_lang = previous->ext_lang;
780 if (target_terminal::is_ours ())
782 /* Restore the previous SIGINT handler if one was saved. */
783 if (previous->sigint_handler.handler_saved)
784 install_sigint_handler (&previous->sigint_handler);
786 /* If there's a SIGINT recorded in the cooperative extension languages,
787 move it to the new language, or save it in GDB's global flag if the
788 newly active extension language doesn't use cooperative SIGINT
790 if (check_quit_flag ())
796 /* Set the quit flag.
797 This only sets the flag in the currently active extension language.
798 If the currently active extension language does not have cooperative
799 SIGINT handling, then GDB's global flag is set, and it is up to the
800 extension language to call check_quit_flag. The extension language
801 is free to install its own SIGINT handler, but we still need to handle
807 if (active_ext_lang->ops != NULL
808 && active_ext_lang->ops->set_quit_flag != NULL)
809 active_ext_lang->ops->set_quit_flag (active_ext_lang);
814 /* Now wake up the event loop, or any interruptible_select. Do
815 this after setting the flag, because signals on Windows
816 actually run on a separate thread, and thus otherwise the
817 main code could be woken up and find quit_flag still
819 quit_serial_event_set ();
823 /* Return true if the quit flag has been set, false otherwise.
824 Note: The flag is cleared as a side-effect.
825 The flag is checked in all extension languages that support cooperative
826 SIGINT handling, not just the current one. This simplifies transitions. */
829 check_quit_flag (void)
832 const struct extension_language_defn *extlang;
834 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
836 if (extlang->ops->check_quit_flag != NULL)
837 if (extlang->ops->check_quit_flag (extlang) != 0)
841 /* This is written in a particular way to avoid races. */
844 /* No longer need to wake up the event loop or any
845 interruptible_select. The caller handles the quit
847 quit_serial_event_clear ();
855 /* See extension.h. */
858 get_matching_xmethod_workers (struct type *type, const char *method_name,
859 std::vector<xmethod_worker_up> *workers)
862 const struct extension_language_defn *extlang;
864 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
868 /* If an extension language does not support xmethods, ignore
870 if (extlang->ops->get_matching_xmethod_workers == NULL)
873 rc = extlang->ops->get_matching_xmethod_workers (extlang,
876 if (rc == EXT_LANG_RC_ERROR)
877 error (_("Error while looking for matching xmethod workers "
878 "defined in %s."), extlang->capitalized_name);
882 /* See extension.h. */
885 xmethod_worker::get_arg_types (int *nargs)
887 type **type_array = NULL;
889 ext_lang_rc rc = do_get_arg_types (nargs, &type_array);
890 if (rc == EXT_LANG_RC_ERROR)
891 error (_("Error while looking for arg types of a xmethod worker "
892 "defined in %s."), m_extlang->capitalized_name);
897 /* See extension.h. */
900 xmethod_worker::get_result_type (value *object, value **args, int nargs)
904 ext_lang_rc rc = do_get_result_type (object, args, nargs, &result_type);
905 if (rc == EXT_LANG_RC_ERROR)
907 error (_("Error while fetching result type of an xmethod worker "
908 "defined in %s."), m_extlang->capitalized_name);
914 /* Called via an observer before gdb prints its prompt.
915 Iterate over the extension languages giving them a chance to
916 change the prompt. The first one to change the prompt wins,
917 and no further languages are tried. */
920 ext_lang_before_prompt (const char *current_gdb_prompt)
923 const struct extension_language_defn *extlang;
925 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
929 if (extlang->ops->before_prompt == NULL)
931 rc = extlang->ops->before_prompt (extlang, current_gdb_prompt);
935 case EXT_LANG_RC_ERROR:
937 case EXT_LANG_RC_NOP:
940 gdb_assert_not_reached ("bad return from before_prompt");
946 _initialize_extension (void)
948 gdb::observers::before_prompt.attach (ext_lang_before_prompt);