1 /* Interface between gdb and its extension languages.
3 Copyright (C) 2014-2021 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"
37 static script_sourcer_func source_gdb_script
;
38 static objfile_script_sourcer_func source_gdb_objfile_script
;
40 /* GDB's own scripting language.
41 This exists, in part, to support auto-loading ${prog}-gdb.gdb scripts. */
43 static const struct extension_language_script_ops
44 extension_language_gdb_script_ops
=
47 source_gdb_objfile_script
,
48 NULL
, /* objfile_script_executor */
49 auto_load_gdb_scripts_enabled
52 const struct extension_language_defn extension_language_gdb
=
58 /* We fall back to interpreting a script as a GDB script if it doesn't
59 match the other scripting languages, but for consistency's sake
60 give it a formal suffix. */
64 /* cli_control_type: This is never used: GDB's own scripting language
65 has a variety of control types (if, while, etc.). */
68 &extension_language_gdb_script_ops
,
70 /* The rest of the extension language interface isn't supported by GDB's own
71 extension/scripting language. */
75 /* NULL-terminated table of all external (non-native) extension languages.
77 The order of appearance in the table is important.
78 When multiple extension languages provide the same feature, for example
79 a pretty-printer for a particular type, which one gets used?
80 The algorithm employed here is "the first one wins". For example, in
81 the case of pretty-printers this means the first one to provide a
82 pretty-printed value is the one that is used. This algorithm is employed
85 static const std::array
<const extension_language_defn
*, 2> extension_languages
87 /* To preserve existing behaviour, python should always appear first. */
88 &extension_language_python
,
89 &extension_language_guile
,
92 /* Return a pointer to the struct extension_language_defn object of
93 extension language LANG.
94 This always returns a non-NULL pointer, even if support for the language
95 is not compiled into this copy of GDB. */
97 const struct extension_language_defn
*
98 get_ext_lang_defn (enum extension_language lang
)
100 gdb_assert (lang
!= EXT_LANG_NONE
);
102 if (lang
== EXT_LANG_GDB
)
103 return &extension_language_gdb
;
105 for (const struct extension_language_defn
*extlang
: extension_languages
)
107 if (extlang
->language
== lang
)
111 gdb_assert_not_reached ("unable to find extension_language_defn");
114 /* Return TRUE if FILE has extension EXTENSION. */
117 has_extension (const char *file
, const char *extension
)
119 int file_len
= strlen (file
);
120 int extension_len
= strlen (extension
);
122 return (file_len
> extension_len
123 && strcmp (&file
[file_len
- extension_len
], extension
) == 0);
126 /* Return the extension language of FILE, or NULL if
127 the extension language of FILE is not recognized.
128 This is done by looking at the file's suffix. */
130 const struct extension_language_defn
*
131 get_ext_lang_of_file (const char *file
)
133 if (has_extension (file
, extension_language_gdb
.suffix
))
134 return &extension_language_gdb
;
136 for (const struct extension_language_defn
*extlang
: extension_languages
)
138 if (has_extension (file
, extlang
->suffix
))
145 /* Return non-zero if support for the specified extension language
149 ext_lang_present_p (const struct extension_language_defn
*extlang
)
151 return extlang
->script_ops
!= NULL
;
154 /* Return non-zero if the specified extension language has successfully
158 ext_lang_initialized_p (const struct extension_language_defn
*extlang
)
160 if (extlang
->ops
!= NULL
)
162 /* This method is required. */
163 gdb_assert (extlang
->ops
->initialized
!= NULL
);
164 return extlang
->ops
->initialized (extlang
);
170 /* Throw an error indicating EXTLANG is not supported in this copy of GDB. */
173 throw_ext_lang_unsupported (const struct extension_language_defn
*extlang
)
175 error (_("Scripting in the \"%s\" language is not supported"
176 " in this copy of GDB."),
177 ext_lang_capitalized_name (extlang
));
180 /* Methods for GDB's own extension/scripting language. */
182 /* The extension_language_script_ops.script_sourcer "method". */
185 source_gdb_script (const struct extension_language_defn
*extlang
,
186 FILE *stream
, const char *file
)
188 script_from_file (stream
, file
);
191 /* The extension_language_script_ops.objfile_script_sourcer "method". */
194 source_gdb_objfile_script (const struct extension_language_defn
*extlang
,
195 struct objfile
*objfile
,
196 FILE *stream
, const char *file
)
198 script_from_file (stream
, file
);
201 /* Accessors for "public" attributes of struct extension_language. */
203 /* Return the "name" field of EXTLANG. */
206 ext_lang_name (const struct extension_language_defn
*extlang
)
208 return extlang
->name
;
211 /* Return the "capitalized_name" field of EXTLANG. */
214 ext_lang_capitalized_name (const struct extension_language_defn
*extlang
)
216 return extlang
->capitalized_name
;
219 /* Return the "suffix" field of EXTLANG. */
222 ext_lang_suffix (const struct extension_language_defn
*extlang
)
224 return extlang
->suffix
;
227 /* Return the "auto_load_suffix" field of EXTLANG. */
230 ext_lang_auto_load_suffix (const struct extension_language_defn
*extlang
)
232 return extlang
->auto_load_suffix
;
235 /* extension_language_script_ops wrappers. */
237 /* Return the script "sourcer" function for EXTLANG.
238 This is the function that loads and processes a script.
239 If support for this language isn't compiled in, NULL is returned. */
241 script_sourcer_func
*
242 ext_lang_script_sourcer (const struct extension_language_defn
*extlang
)
244 if (extlang
->script_ops
== NULL
)
247 /* The extension language is required to implement this function. */
248 gdb_assert (extlang
->script_ops
->script_sourcer
!= NULL
);
250 return extlang
->script_ops
->script_sourcer
;
253 /* Return the objfile script "sourcer" function for EXTLANG.
254 This is the function that loads and processes a script for a particular
256 If support for this language isn't compiled in, NULL is returned. */
258 objfile_script_sourcer_func
*
259 ext_lang_objfile_script_sourcer (const struct extension_language_defn
*extlang
)
261 if (extlang
->script_ops
== NULL
)
264 /* The extension language is required to implement this function. */
265 gdb_assert (extlang
->script_ops
->objfile_script_sourcer
!= NULL
);
267 return extlang
->script_ops
->objfile_script_sourcer
;
270 /* Return the objfile script "executor" function for EXTLANG.
271 This is the function that executes a script for a particular objfile.
272 If support for this language isn't compiled in, NULL is returned.
273 The extension language is not required to implement this function. */
275 objfile_script_executor_func
*
276 ext_lang_objfile_script_executor
277 (const struct extension_language_defn
*extlang
)
279 if (extlang
->script_ops
== NULL
)
282 return extlang
->script_ops
->objfile_script_executor
;
285 /* See extension.h. */
288 ext_lang_auto_load_enabled (const struct extension_language_defn
*extlang
)
290 if (extlang
->script_ops
== NULL
)
293 /* The extension language is required to implement this function. */
294 gdb_assert (extlang
->script_ops
->auto_load_enabled
!= NULL
);
296 return extlang
->script_ops
->auto_load_enabled (extlang
);
299 /* Functions that iterate over all extension languages.
300 These only iterate over external extension languages, not including
301 GDB's own extension/scripting language, unless otherwise indicated. */
303 /* Wrapper to call the extension_language_ops.finish_initialization "method"
304 for each compiled-in extension language. */
307 finish_ext_lang_initialization (void)
309 for (const struct extension_language_defn
*extlang
: extension_languages
)
311 if (extlang
->ops
!= nullptr
312 && extlang
->ops
->finish_initialization
!= NULL
)
313 extlang
->ops
->finish_initialization (extlang
);
317 /* Invoke the appropriate extension_language_ops.eval_from_control_command
318 method to perform CMD, which is a list of commands in an extension language.
320 This function is what implements, for example:
329 eval_ext_lang_from_control_command (struct command_line
*cmd
)
331 for (const struct extension_language_defn
*extlang
: extension_languages
)
333 if (extlang
->cli_control_type
== cmd
->control_type
)
335 if (extlang
->ops
!= NULL
336 && extlang
->ops
->eval_from_control_command
!= NULL
)
338 extlang
->ops
->eval_from_control_command (extlang
, cmd
);
341 /* The requested extension language is not supported in this GDB. */
342 throw_ext_lang_unsupported (extlang
);
346 gdb_assert_not_reached ("unknown extension language in command_line");
349 /* Search for and load scripts for OBJFILE written in extension languages.
350 This includes GDB's own scripting language.
352 This function is what implements the loading of OBJFILE-gdb.py and
356 auto_load_ext_lang_scripts_for_objfile (struct objfile
*objfile
)
358 const struct extension_language_defn
*gdb
= &extension_language_gdb
;
359 if (ext_lang_auto_load_enabled (gdb
))
360 auto_load_objfile_script (objfile
, gdb
);
362 for (const struct extension_language_defn
*extlang
: extension_languages
)
364 if (extlang
->ops
!= nullptr
365 && ext_lang_auto_load_enabled (extlang
))
366 auto_load_objfile_script (objfile
, extlang
);
370 /* Interface to type pretty-printers implemented in an extension language. */
372 /* Call this at the start when preparing to pretty-print a type.
373 The result is a pointer to an opaque object (to the caller) to be passed
374 to apply_ext_lang_type_printers and free_ext_lang_type_printers.
376 We don't know in advance which extension language will provide a
377 pretty-printer for the type, so all are initialized. */
379 ext_lang_type_printers::ext_lang_type_printers ()
381 for (const struct extension_language_defn
*extlang
: extension_languages
)
383 if (extlang
->ops
!= nullptr
384 && extlang
->ops
->start_type_printers
!= NULL
)
385 extlang
->ops
->start_type_printers (extlang
, this);
389 /* Iteratively try the type pretty-printers specified by PRINTERS
390 according to the standard search order (specified by extension_languages),
391 returning the result of the first one that succeeds.
392 If there was an error, or if no printer succeeds, then NULL is returned. */
395 apply_ext_lang_type_printers (struct ext_lang_type_printers
*printers
,
398 for (const struct extension_language_defn
*extlang
: extension_languages
)
403 if (extlang
->ops
== nullptr
404 || extlang
->ops
->apply_type_printers
== NULL
)
406 rc
= extlang
->ops
->apply_type_printers (extlang
, printers
, type
,
411 gdb_assert (result
!= NULL
);
413 case EXT_LANG_RC_ERROR
:
415 case EXT_LANG_RC_NOP
:
418 gdb_assert_not_reached ("bad return from apply_type_printers");
425 ext_lang_type_printers::~ext_lang_type_printers ()
427 for (const struct extension_language_defn
*extlang
: extension_languages
)
429 if (extlang
->ops
!= nullptr
430 && extlang
->ops
->free_type_printers
!= NULL
)
431 extlang
->ops
->free_type_printers (extlang
, this);
435 /* Try to pretty-print a value onto stdio stream STREAM according to
436 OPTIONS. VAL is the object to print. Returns non-zero if the
437 value was successfully pretty-printed.
439 Extension languages are tried in the order specified by
440 extension_languages. The first one to provide a pretty-printed
443 If an error is encountered in a pretty-printer, no further extension
445 Note: This is different than encountering a memory error trying to read a
446 value for pretty-printing. Here we're referring to, e.g., programming
447 errors that trigger an exception in the extension language. */
450 apply_ext_lang_val_pretty_printer (struct value
*val
,
451 struct ui_file
*stream
, int recurse
,
452 const struct value_print_options
*options
,
453 const struct language_defn
*language
)
455 for (const struct extension_language_defn
*extlang
: extension_languages
)
459 if (extlang
->ops
== nullptr
460 || extlang
->ops
->apply_val_pretty_printer
== NULL
)
462 rc
= extlang
->ops
->apply_val_pretty_printer (extlang
, val
, stream
,
463 recurse
, options
, language
);
468 case EXT_LANG_RC_ERROR
:
470 case EXT_LANG_RC_NOP
:
473 gdb_assert_not_reached ("bad return from apply_val_pretty_printer");
480 /* GDB access to the "frame filter" feature.
481 FRAME is the source frame to start frame-filter invocation. FLAGS is an
482 integer holding the flags for printing. The following elements of
483 the FRAME_FILTER_FLAGS enum denotes the make-up of FLAGS:
484 PRINT_LEVEL is a flag indicating whether to print the frame's
485 relative level in the output. PRINT_FRAME_INFO is a flag that
486 indicates whether this function should print the frame
487 information, PRINT_ARGS is a flag that indicates whether to print
488 frame arguments, and PRINT_LOCALS, likewise, with frame local
489 variables. ARGS_TYPE is an enumerator describing the argument
490 format, OUT is the output stream to print. FRAME_LOW is the
491 beginning of the slice of frames to print, and FRAME_HIGH is the
492 upper limit of the frames to count. Returns EXT_LANG_BT_ERROR on error,
493 or EXT_LANG_BT_COMPLETED on success.
495 Extension languages are tried in the order specified by
496 extension_languages. The first one to provide a filter "wins".
497 If there is an error (EXT_LANG_BT_ERROR) it is reported immediately
498 rather than trying filters in other extension languages. */
500 enum ext_lang_bt_status
501 apply_ext_lang_frame_filter (struct frame_info
*frame
,
502 frame_filter_flags flags
,
503 enum ext_lang_frame_args args_type
,
505 int frame_low
, int frame_high
)
507 for (const struct extension_language_defn
*extlang
: extension_languages
)
509 enum ext_lang_bt_status status
;
511 if (extlang
->ops
== nullptr
512 || extlang
->ops
->apply_frame_filter
== NULL
)
514 status
= extlang
->ops
->apply_frame_filter (extlang
, frame
, flags
,
516 frame_low
, frame_high
);
517 /* We use the filters from the first extension language that has
518 applicable filters. Also, an error is reported immediately
519 rather than continue trying. */
520 if (status
!= EXT_LANG_BT_NO_FILTERS
)
524 return EXT_LANG_BT_NO_FILTERS
;
527 /* Update values held by the extension language when OBJFILE is discarded.
528 New global types must be created for every such value, which must then be
529 updated to use the new types.
530 The function typically just iterates over all appropriate values and
531 calls preserve_one_value for each one.
532 COPIED_TYPES is used to prevent cycles / duplicates and is passed to
533 preserve_one_value. */
536 preserve_ext_lang_values (struct objfile
*objfile
, htab_t copied_types
)
538 for (const struct extension_language_defn
*extlang
: extension_languages
)
540 if (extlang
->ops
!= nullptr
541 && extlang
->ops
->preserve_values
!= NULL
)
542 extlang
->ops
->preserve_values (extlang
, objfile
, copied_types
);
546 /* If there is a stop condition implemented in an extension language for
547 breakpoint B, return a pointer to the extension language's definition.
548 Otherwise return NULL.
549 If SKIP_LANG is not EXT_LANG_NONE, skip checking this language.
550 This is for the case where we're setting a new condition: Only one
551 condition is allowed, so when setting a condition for any particular
552 extension language, we need to check if any other extension language
553 already has a condition set. */
555 const struct extension_language_defn
*
556 get_breakpoint_cond_ext_lang (struct breakpoint
*b
,
557 enum extension_language skip_lang
)
559 for (const struct extension_language_defn
*extlang
: extension_languages
)
561 if (extlang
->ops
!= nullptr
562 && extlang
->language
!= skip_lang
563 && extlang
->ops
->breakpoint_has_cond
!= NULL
564 && extlang
->ops
->breakpoint_has_cond (extlang
, b
))
571 /* Return whether a stop condition for breakpoint B says to stop.
572 True is also returned if there is no stop condition for B. */
575 breakpoint_ext_lang_cond_says_stop (struct breakpoint
*b
)
577 enum ext_lang_bp_stop stop
= EXT_LANG_BP_STOP_UNSET
;
579 for (const struct extension_language_defn
*extlang
: extension_languages
)
581 /* There is a rule that a breakpoint can have at most one of any of a
582 CLI or extension language condition. However, Python hacks in "finish
583 breakpoints" on top of the "stop" check, so we have to call this for
584 every language, even if we could first determine whether a "stop"
586 if (extlang
->ops
!= nullptr
587 && extlang
->ops
->breakpoint_cond_says_stop
!= NULL
)
589 enum ext_lang_bp_stop this_stop
590 = extlang
->ops
->breakpoint_cond_says_stop (extlang
, b
);
592 if (this_stop
!= EXT_LANG_BP_STOP_UNSET
)
594 /* Even though we have to check every extension language, only
595 one of them can return yes/no (because only one of them
596 can have a "stop" condition). */
597 gdb_assert (stop
== EXT_LANG_BP_STOP_UNSET
);
603 return stop
== EXT_LANG_BP_STOP_NO
? 0 : 1;
606 /* ^C/SIGINT support.
607 This requires cooperation with the extension languages so the support
610 /* This flag tracks quit requests when we haven't called out to an
611 extension language. it also holds quit requests when we transition to
612 an extension language that doesn't have cooperative SIGINT handling. */
613 static int quit_flag
;
615 /* The current extension language we've called out to, or
616 extension_language_gdb if there isn't one.
617 This must be set everytime we call out to an extension language, and reset
618 to the previous value when it returns. Note that the previous value may
619 be a different (or the same) extension language. */
620 static const struct extension_language_defn
*active_ext_lang
621 = &extension_language_gdb
;
623 /* Return the currently active extension language. */
625 const struct extension_language_defn
*
626 get_active_ext_lang (void)
628 return active_ext_lang
;
631 /* Install a SIGINT handler. */
634 install_sigint_handler (const struct signal_handler
*handler_state
)
636 gdb_assert (handler_state
->handler_saved
);
638 signal (SIGINT
, handler_state
->handler
);
641 /* Install GDB's SIGINT handler, storing the previous version in *PREVIOUS.
642 As a simple optimization, if the previous version was GDB's SIGINT handler
643 then mark the previous handler as not having been saved, and thus it won't
647 install_gdb_sigint_handler (struct signal_handler
*previous
)
649 /* Save here to simplify comparison. */
650 sighandler_t handle_sigint_for_compare
= handle_sigint
;
652 previous
->handler
= signal (SIGINT
, handle_sigint
);
653 if (previous
->handler
!= handle_sigint_for_compare
)
654 previous
->handler_saved
= 1;
656 previous
->handler_saved
= 0;
659 /* Set the currently active extension language to NOW_ACTIVE.
660 The result is a pointer to a malloc'd block of memory to pass to
661 restore_active_ext_lang.
663 N.B. This function must be called every time we call out to an extension
664 language, and the result must be passed to restore_active_ext_lang
667 If there is a pending SIGINT it is "moved" to the now active extension
668 language, if it supports cooperative SIGINT handling (i.e., it provides
669 {clear,set,check}_quit_flag methods). If the extension language does not
670 support cooperative SIGINT handling, then the SIGINT is left queued and
671 we require the non-cooperative extension language to call check_quit_flag
672 at appropriate times.
673 It is important for the extension language to call check_quit_flag if it
674 installs its own SIGINT handler to prevent the situation where a SIGINT
675 is queued on entry, extension language code runs for a "long" time possibly
676 serving one or more SIGINTs, and then returns. Upon return, if
677 check_quit_flag is not called, the original SIGINT will be thrown.
678 Non-cooperative extension languages are free to install their own SIGINT
679 handler but the original must be restored upon return, either itself
680 or via restore_active_ext_lang. */
682 struct active_ext_lang_state
*
683 set_active_ext_lang (const struct extension_language_defn
*now_active
)
685 struct active_ext_lang_state
*previous
686 = XCNEW (struct active_ext_lang_state
);
688 previous
->ext_lang
= active_ext_lang
;
689 previous
->sigint_handler
.handler_saved
= 0;
690 active_ext_lang
= now_active
;
692 if (target_terminal::is_ours ())
694 /* If the newly active extension language uses cooperative SIGINT
695 handling then ensure GDB's SIGINT handler is installed. */
696 if (now_active
->language
== EXT_LANG_GDB
697 || now_active
->ops
->check_quit_flag
!= NULL
)
698 install_gdb_sigint_handler (&previous
->sigint_handler
);
700 /* If there's a SIGINT recorded in the cooperative extension languages,
701 move it to the new language, or save it in GDB's global flag if the
702 newly active extension language doesn't use cooperative SIGINT
704 if (check_quit_flag ())
711 /* Restore active extension language from PREVIOUS. */
714 restore_active_ext_lang (struct active_ext_lang_state
*previous
)
716 active_ext_lang
= previous
->ext_lang
;
718 if (target_terminal::is_ours ())
720 /* Restore the previous SIGINT handler if one was saved. */
721 if (previous
->sigint_handler
.handler_saved
)
722 install_sigint_handler (&previous
->sigint_handler
);
724 /* If there's a SIGINT recorded in the cooperative extension languages,
725 move it to the new language, or save it in GDB's global flag if the
726 newly active extension language doesn't use cooperative SIGINT
728 if (check_quit_flag ())
734 /* Set the quit flag.
735 This only sets the flag in the currently active extension language.
736 If the currently active extension language does not have cooperative
737 SIGINT handling, then GDB's global flag is set, and it is up to the
738 extension language to call check_quit_flag. The extension language
739 is free to install its own SIGINT handler, but we still need to handle
745 if (active_ext_lang
->ops
!= NULL
746 && active_ext_lang
->ops
->set_quit_flag
!= NULL
)
747 active_ext_lang
->ops
->set_quit_flag (active_ext_lang
);
752 /* Now wake up the event loop, or any interruptible_select. Do
753 this after setting the flag, because signals on Windows
754 actually run on a separate thread, and thus otherwise the
755 main code could be woken up and find quit_flag still
757 quit_serial_event_set ();
761 /* Return true if the quit flag has been set, false otherwise.
762 Note: The flag is cleared as a side-effect.
763 The flag is checked in all extension languages that support cooperative
764 SIGINT handling, not just the current one. This simplifies transitions. */
767 check_quit_flag (void)
771 for (const struct extension_language_defn
*extlang
: extension_languages
)
773 if (extlang
->ops
!= nullptr
774 && extlang
->ops
->check_quit_flag
!= NULL
)
775 if (extlang
->ops
->check_quit_flag (extlang
) != 0)
779 /* This is written in a particular way to avoid races. */
782 /* No longer need to wake up the event loop or any
783 interruptible_select. The caller handles the quit
785 quit_serial_event_clear ();
793 /* See extension.h. */
796 get_matching_xmethod_workers (struct type
*type
, const char *method_name
,
797 std::vector
<xmethod_worker_up
> *workers
)
799 for (const struct extension_language_defn
*extlang
: extension_languages
)
803 /* If an extension language does not support xmethods, ignore
805 if (extlang
->ops
== nullptr
806 || extlang
->ops
->get_matching_xmethod_workers
== NULL
)
809 rc
= extlang
->ops
->get_matching_xmethod_workers (extlang
,
812 if (rc
== EXT_LANG_RC_ERROR
)
813 error (_("Error while looking for matching xmethod workers "
814 "defined in %s."), extlang
->capitalized_name
);
818 /* See extension.h. */
821 xmethod_worker::get_arg_types ()
823 std::vector
<type
*> type_array
;
825 ext_lang_rc rc
= do_get_arg_types (&type_array
);
826 if (rc
== EXT_LANG_RC_ERROR
)
827 error (_("Error while looking for arg types of a xmethod worker "
828 "defined in %s."), m_extlang
->capitalized_name
);
833 /* See extension.h. */
836 xmethod_worker::get_result_type (value
*object
, gdb::array_view
<value
*> args
)
840 ext_lang_rc rc
= do_get_result_type (object
, args
, &result_type
);
841 if (rc
== EXT_LANG_RC_ERROR
)
843 error (_("Error while fetching result type of an xmethod worker "
844 "defined in %s."), m_extlang
->capitalized_name
);
850 /* See extension.h. */
852 gdb::optional
<std::string
>
853 ext_lang_colorize (const std::string
&filename
, const std::string
&contents
)
855 gdb::optional
<std::string
> result
;
857 for (const struct extension_language_defn
*extlang
: extension_languages
)
859 if (extlang
->ops
== nullptr
860 || extlang
->ops
->colorize
== nullptr)
862 result
= extlang
->ops
->colorize (filename
, contents
);
863 if (result
.has_value ())
870 /* Called via an observer before gdb prints its prompt.
871 Iterate over the extension languages giving them a chance to
872 change the prompt. The first one to change the prompt wins,
873 and no further languages are tried. */
876 ext_lang_before_prompt (const char *current_gdb_prompt
)
878 for (const struct extension_language_defn
*extlang
: extension_languages
)
882 if (extlang
->ops
== nullptr
883 || extlang
->ops
->before_prompt
== NULL
)
885 rc
= extlang
->ops
->before_prompt (extlang
, current_gdb_prompt
);
889 case EXT_LANG_RC_ERROR
:
891 case EXT_LANG_RC_NOP
:
894 gdb_assert_not_reached ("bad return from before_prompt");
899 void _initialize_extension ();
901 _initialize_extension ()
903 gdb::observers::before_prompt
.attach (ext_lang_before_prompt
);