1 /* Interface between gdb and its extension languages.
3 Copyright (C) 2014-2015 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. */
25 #include "auto-load.h"
26 #include "breakpoint.h"
27 #include "event-top.h"
28 #include "extension.h"
29 #include "extension-priv.h"
31 #include "cli/cli-script.h"
33 /* Iterate over all external extension languages, regardless of whether the
34 support has been compiled in or not.
35 This does not include GDB's own scripting language. */
37 #define ALL_EXTENSION_LANGUAGES(i, extlang) \
38 for (/*int*/ i = 0, extlang = extension_languages[0]; \
40 extlang = extension_languages[++i])
42 /* Iterate over all external extension languages that are supported.
43 This does not include GDB's own scripting language. */
45 #define ALL_ENABLED_EXTENSION_LANGUAGES(i, extlang) \
46 for (/*int*/ i = 0, extlang = extension_languages[0]; \
48 extlang = extension_languages[++i]) \
49 if (extlang->ops != NULL)
51 static script_sourcer_func source_gdb_script;
52 static objfile_script_sourcer_func source_gdb_objfile_script;
54 /* GDB's own scripting language.
55 This exists, in part, to support auto-loading ${prog}-gdb.gdb scripts. */
57 static const struct extension_language_script_ops
58 extension_language_gdb_script_ops =
61 source_gdb_objfile_script,
62 NULL, /* objfile_script_executor */
63 auto_load_gdb_scripts_enabled
66 const struct extension_language_defn extension_language_gdb =
72 /* We fall back to interpreting a script as a GDB script if it doesn't
73 match the other scripting languages, but for consistency's sake
74 give it a formal suffix. */
78 /* cli_control_type: This is never used: GDB's own scripting language
79 has a variety of control types (if, while, etc.). */
82 &extension_language_gdb_script_ops,
84 /* The rest of the extension language interface isn't supported by GDB's own
85 extension/scripting language. */
89 /* NULL-terminated table of all external (non-native) extension languages.
91 The order of appearance in the table is important.
92 When multiple extension languages provide the same feature, for example
93 a pretty-printer for a particular type, which one gets used?
94 The algorithm employed here is "the first one wins". For example, in
95 the case of pretty-printers this means the first one to provide a
96 pretty-printed value is the one that is used. This algorithm is employed
99 static const struct extension_language_defn * const extension_languages[] =
101 /* To preserve existing behaviour, python should always appear first. */
105 /* Return a pointer to the struct extension_language_defn object of
106 extension language LANG.
107 This always returns a non-NULL pointer, even if support for the language
108 is not compiled into this copy of GDB. */
110 const struct extension_language_defn *
111 get_ext_lang_defn (enum extension_language lang)
114 const struct extension_language_defn *extlang;
116 gdb_assert (lang != EXT_LANG_NONE);
118 if (lang == EXT_LANG_GDB)
119 return &extension_language_gdb;
121 ALL_EXTENSION_LANGUAGES (i, extlang)
123 if (extlang->language == lang)
127 gdb_assert_not_reached ("unable to find extension_language_defn");
130 /* Return TRUE if FILE has extension EXTENSION. */
133 has_extension (const char *file, const char *extension)
135 int file_len = strlen (file);
136 int extension_len = strlen (extension);
138 return (file_len > extension_len
139 && strcmp (&file[file_len - extension_len], extension) == 0);
142 /* Return the extension language of FILE, or NULL if
143 the extension language of FILE is not recognized.
144 This is done by looking at the file's suffix. */
146 const struct extension_language_defn *
147 get_ext_lang_of_file (const char *file)
150 const struct extension_language_defn *extlang;
152 ALL_EXTENSION_LANGUAGES (i, extlang)
154 if (has_extension (file, extlang->suffix))
161 /* Return non-zero if support for the specified extension language
165 ext_lang_present_p (const struct extension_language_defn *extlang)
167 return extlang->script_ops != NULL;
170 /* Return non-zero if the specified extension language has successfully
174 ext_lang_initialized_p (const struct extension_language_defn *extlang)
176 if (extlang->ops != NULL)
178 /* This method is required. */
179 gdb_assert (extlang->ops->initialized != NULL);
180 return extlang->ops->initialized (extlang);
186 /* Throw an error indicating EXTLANG is not supported in this copy of GDB. */
189 throw_ext_lang_unsupported (const struct extension_language_defn *extlang)
191 error (_("Scripting in the \"%s\" language is not supported"
192 " in this copy of GDB."),
193 ext_lang_capitalized_name (extlang));
196 /* Methods for GDB's own extension/scripting language. */
198 /* The extension_language_script_ops.script_sourcer "method". */
201 source_gdb_script (const struct extension_language_defn *extlang,
202 FILE *stream, const char *file)
204 script_from_file (stream, file);
207 /* The extension_language_script_ops.objfile_script_sourcer "method". */
210 source_gdb_objfile_script (const struct extension_language_defn *extlang,
211 struct objfile *objfile,
212 FILE *stream, const char *file)
214 script_from_file (stream, file);
217 /* Accessors for "public" attributes of struct extension_language. */
219 /* Return the "name" field of EXTLANG. */
222 ext_lang_name (const struct extension_language_defn *extlang)
224 return extlang->name;
227 /* Return the "capitalized_name" field of EXTLANG. */
230 ext_lang_capitalized_name (const struct extension_language_defn *extlang)
232 return extlang->capitalized_name;
235 /* Return the "suffix" field of EXTLANG. */
238 ext_lang_suffix (const struct extension_language_defn *extlang)
240 return extlang->suffix;
243 /* Return the "auto_load_suffix" field of EXTLANG. */
246 ext_lang_auto_load_suffix (const struct extension_language_defn *extlang)
248 return extlang->auto_load_suffix;
251 /* extension_language_script_ops wrappers. */
253 /* Return the script "sourcer" function for EXTLANG.
254 This is the function that loads and processes a script.
255 If support for this language isn't compiled in, NULL is returned. */
257 script_sourcer_func *
258 ext_lang_script_sourcer (const struct extension_language_defn *extlang)
260 if (extlang->script_ops == NULL)
263 /* The extension language is required to implement this function. */
264 gdb_assert (extlang->script_ops->script_sourcer != NULL);
266 return extlang->script_ops->script_sourcer;
269 /* Return the objfile script "sourcer" function for EXTLANG.
270 This is the function that loads and processes a script for a particular
272 If support for this language isn't compiled in, NULL is returned. */
274 objfile_script_sourcer_func *
275 ext_lang_objfile_script_sourcer (const struct extension_language_defn *extlang)
277 if (extlang->script_ops == NULL)
280 /* The extension language is required to implement this function. */
281 gdb_assert (extlang->script_ops->objfile_script_sourcer != NULL);
283 return extlang->script_ops->objfile_script_sourcer;
286 /* Return the objfile script "executor" function for EXTLANG.
287 This is the function that executes a script for a particular objfile.
288 If support for this language isn't compiled in, NULL is returned.
289 The extension language is not required to implement this function. */
291 objfile_script_executor_func *
292 ext_lang_objfile_script_executor
293 (const struct extension_language_defn *extlang)
295 if (extlang->script_ops == NULL)
298 return extlang->script_ops->objfile_script_executor;
301 /* Return non-zero if auto-loading of EXTLANG scripts is enabled.
302 Zero is returned if support for this language isn't compiled in. */
305 ext_lang_auto_load_enabled (const struct extension_language_defn *extlang)
307 if (extlang->script_ops == NULL)
310 /* The extension language is required to implement this function. */
311 gdb_assert (extlang->script_ops->auto_load_enabled != NULL);
313 return extlang->script_ops->auto_load_enabled (extlang);
316 /* Functions that iterate over all extension languages.
317 These only iterate over external extension languages, not including
318 GDB's own extension/scripting language, unless otherwise indicated. */
320 /* Wrapper to call the extension_language_ops.finish_initialization "method"
321 for each compiled-in extension language. */
324 finish_ext_lang_initialization (void)
327 const struct extension_language_defn *extlang;
329 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
331 if (extlang->ops->finish_initialization != NULL)
332 extlang->ops->finish_initialization (extlang);
336 /* Invoke the appropriate extension_language_ops.eval_from_control_command
337 method to perform CMD, which is a list of commands in an extension language.
339 This function is what implements, for example:
348 eval_ext_lang_from_control_command (struct command_line *cmd)
351 const struct extension_language_defn *extlang;
353 ALL_EXTENSION_LANGUAGES (i, extlang)
355 if (extlang->cli_control_type == cmd->control_type)
357 if (extlang->ops != NULL
358 && extlang->ops->eval_from_control_command != NULL)
360 extlang->ops->eval_from_control_command (extlang, cmd);
363 /* The requested extension language is not supported in this GDB. */
364 throw_ext_lang_unsupported (extlang);
368 gdb_assert_not_reached ("unknown extension language in command_line");
371 /* Search for and load scripts for OBJFILE written in extension languages.
372 This includes GDB's own scripting language.
374 This function is what implements the loading of OBJFILE-gdb.py and
378 auto_load_ext_lang_scripts_for_objfile (struct objfile *objfile)
381 const struct extension_language_defn *extlang;
383 extlang = &extension_language_gdb;
384 if (ext_lang_auto_load_enabled (extlang))
385 auto_load_objfile_script (objfile, extlang);
387 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
389 if (ext_lang_auto_load_enabled (extlang))
390 auto_load_objfile_script (objfile, extlang);
394 /* Interface to type pretty-printers implemented in an extension language. */
396 /* Call this at the start when preparing to pretty-print a type.
397 The result is a pointer to an opaque object (to the caller) to be passed
398 to apply_ext_lang_type_printers and free_ext_lang_type_printers.
400 We don't know in advance which extension language will provide a
401 pretty-printer for the type, so all are initialized. */
403 struct ext_lang_type_printers *
404 start_ext_lang_type_printers (void)
406 struct ext_lang_type_printers *printers
407 = XCNEW (struct ext_lang_type_printers);
409 const struct extension_language_defn *extlang;
411 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
413 if (extlang->ops->start_type_printers != NULL)
414 extlang->ops->start_type_printers (extlang, printers);
420 /* Iteratively try the type pretty-printers specified by PRINTERS
421 according to the standard search order (specified by extension_languages),
422 returning the result of the first one that succeeds.
423 If there was an error, or if no printer succeeds, then NULL is returned. */
426 apply_ext_lang_type_printers (struct ext_lang_type_printers *printers,
430 const struct extension_language_defn *extlang;
432 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
437 if (extlang->ops->apply_type_printers == NULL)
439 rc = extlang->ops->apply_type_printers (extlang, printers, type,
444 gdb_assert (result != NULL);
446 case EXT_LANG_RC_ERROR:
448 case EXT_LANG_RC_NOP:
451 gdb_assert_not_reached ("bad return from apply_type_printers");
458 /* Call this after pretty-printing a type to release all memory held
462 free_ext_lang_type_printers (struct ext_lang_type_printers *printers)
465 const struct extension_language_defn *extlang;
467 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
469 if (extlang->ops->free_type_printers != NULL)
470 extlang->ops->free_type_printers (extlang, printers);
476 /* Try to pretty-print a value of type TYPE located at VALADDR
477 + EMBEDDED_OFFSET, which came from the inferior at address ADDRESS
478 + EMBEDDED_OFFSET, onto stdio stream STREAM according to OPTIONS.
479 VAL is the whole object that came from ADDRESS. VALADDR must point to
480 the head of VAL's contents buffer.
481 Returns non-zero if the value was successfully pretty-printed.
483 Extension languages are tried in the order specified by
484 extension_languages. The first one to provide a pretty-printed
487 If an error is encountered in a pretty-printer, no further extension
489 Note: This is different than encountering a memory error trying to read a
490 value for pretty-printing. Here we're referring to, e.g., programming
491 errors that trigger an exception in the extension language. */
494 apply_ext_lang_val_pretty_printer (struct type *type, const gdb_byte *valaddr,
495 int embedded_offset, CORE_ADDR address,
496 struct ui_file *stream, int recurse,
497 const struct value *val,
498 const struct value_print_options *options,
499 const struct language_defn *language)
502 const struct extension_language_defn *extlang;
504 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
508 if (extlang->ops->apply_val_pretty_printer == NULL)
510 rc = extlang->ops->apply_val_pretty_printer (extlang, type, valaddr,
511 embedded_offset, address,
512 stream, recurse, val,
518 case EXT_LANG_RC_ERROR:
520 case EXT_LANG_RC_NOP:
523 gdb_assert_not_reached ("bad return from apply_val_pretty_printer");
530 /* GDB access to the "frame filter" feature.
531 FRAME is the source frame to start frame-filter invocation. FLAGS is an
532 integer holding the flags for printing. The following elements of
533 the FRAME_FILTER_FLAGS enum denotes the make-up of FLAGS:
534 PRINT_LEVEL is a flag indicating whether to print the frame's
535 relative level in the output. PRINT_FRAME_INFO is a flag that
536 indicates whether this function should print the frame
537 information, PRINT_ARGS is a flag that indicates whether to print
538 frame arguments, and PRINT_LOCALS, likewise, with frame local
539 variables. ARGS_TYPE is an enumerator describing the argument
540 format, OUT is the output stream to print. FRAME_LOW is the
541 beginning of the slice of frames to print, and FRAME_HIGH is the
542 upper limit of the frames to count. Returns EXT_LANG_BT_ERROR on error,
543 or EXT_LANG_BT_COMPLETED on success.
545 Extension languages are tried in the order specified by
546 extension_languages. The first one to provide a filter "wins".
547 If there is an error (EXT_LANG_BT_ERROR) it is reported immediately
548 rather than trying filters in other extension languages. */
550 enum ext_lang_bt_status
551 apply_ext_lang_frame_filter (struct frame_info *frame, int flags,
552 enum ext_lang_frame_args args_type,
554 int frame_low, int frame_high)
557 const struct extension_language_defn *extlang;
559 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
561 enum ext_lang_bt_status status;
563 if (extlang->ops->apply_frame_filter == NULL)
565 status = extlang->ops->apply_frame_filter (extlang, frame, flags,
567 frame_low, frame_high);
568 /* We use the filters from the first extension language that has
569 applicable filters. Also, an error is reported immediately
570 rather than continue trying. */
571 if (status != EXT_LANG_BT_NO_FILTERS)
575 return EXT_LANG_BT_NO_FILTERS;
578 /* Update values held by the extension language when OBJFILE is discarded.
579 New global types must be created for every such value, which must then be
580 updated to use the new types.
581 The function typically just iterates over all appropriate values and
582 calls preserve_one_value for each one.
583 COPIED_TYPES is used to prevent cycles / duplicates and is passed to
584 preserve_one_value. */
587 preserve_ext_lang_values (struct objfile *objfile, htab_t copied_types)
590 const struct extension_language_defn *extlang;
592 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
594 if (extlang->ops->preserve_values != NULL)
595 extlang->ops->preserve_values (extlang, objfile, copied_types);
599 /* If there is a stop condition implemented in an extension language for
600 breakpoint B, return a pointer to the extension language's definition.
601 Otherwise return NULL.
602 If SKIP_LANG is not EXT_LANG_NONE, skip checking this language.
603 This is for the case where we're setting a new condition: Only one
604 condition is allowed, so when setting a condition for any particular
605 extension language, we need to check if any other extension language
606 already has a condition set. */
608 const struct extension_language_defn *
609 get_breakpoint_cond_ext_lang (struct breakpoint *b,
610 enum extension_language skip_lang)
613 const struct extension_language_defn *extlang;
615 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
617 if (extlang->language != skip_lang
618 && extlang->ops->breakpoint_has_cond != NULL
619 && extlang->ops->breakpoint_has_cond (extlang, b))
626 /* Return whether a stop condition for breakpoint B says to stop.
627 True is also returned if there is no stop condition for B. */
630 breakpoint_ext_lang_cond_says_stop (struct breakpoint *b)
633 const struct extension_language_defn *extlang;
634 enum ext_lang_bp_stop stop = EXT_LANG_BP_STOP_UNSET;
636 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
638 /* There is a rule that a breakpoint can have at most one of any of a
639 CLI or extension language condition. However, Python hacks in "finish
640 breakpoints" on top of the "stop" check, so we have to call this for
641 every language, even if we could first determine whether a "stop"
643 if (extlang->ops->breakpoint_cond_says_stop != NULL)
645 enum ext_lang_bp_stop this_stop
646 = extlang->ops->breakpoint_cond_says_stop (extlang, b);
648 if (this_stop != EXT_LANG_BP_STOP_UNSET)
650 /* Even though we have to check every extension language, only
651 one of them can return yes/no (because only one of them
652 can have a "stop" condition). */
653 gdb_assert (stop == EXT_LANG_BP_STOP_UNSET);
659 return stop == EXT_LANG_BP_STOP_NO ? 0 : 1;
662 /* ^C/SIGINT support.
663 This requires cooperation with the extension languages so the support
666 /* This flag tracks quit requests when we haven't called out to an
667 extension language. it also holds quit requests when we transition to
668 an extension language that doesn't have cooperative SIGINT handling. */
669 static int quit_flag;
671 /* The current extension language we've called out to, or
672 extension_language_gdb if there isn't one.
673 This must be set everytime we call out to an extension language, and reset
674 to the previous value when it returns. Note that the previous value may
675 be a different (or the same) extension language. */
676 static const struct extension_language_defn *active_ext_lang
677 = &extension_language_gdb;
679 /* Return the currently active extension language. */
681 const struct extension_language_defn *
682 get_active_ext_lang (void)
684 return active_ext_lang;
687 /* Install a SIGINT handler. */
690 install_sigint_handler (const struct signal_handler *handler_state)
692 gdb_assert (handler_state->handler_saved);
694 signal (SIGINT, handler_state->handler);
697 /* Install GDB's SIGINT handler, storing the previous version in *PREVIOUS.
698 As a simple optimization, if the previous version was GDB's SIGINT handler
699 then mark the previous handler as not having been saved, and thus it won't
703 install_gdb_sigint_handler (struct signal_handler *previous)
705 /* Save here to simplify comparison. */
706 RETSIGTYPE (*handle_sigint_for_compare) () = handle_sigint;
708 previous->handler = signal (SIGINT, handle_sigint);
709 if (previous->handler != handle_sigint_for_compare)
710 previous->handler_saved = 1;
712 previous->handler_saved = 0;
715 /* Set the currently active extension language to NOW_ACTIVE.
716 The result is a pointer to a malloc'd block of memory to pass to
717 restore_active_ext_lang.
719 N.B. This function must be called every time we call out to an extension
720 language, and the result must be passed to restore_active_ext_lang
723 If there is a pending SIGINT it is "moved" to the now active extension
724 language, if it supports cooperative SIGINT handling (i.e., it provides
725 {clear,set,check}_quit_flag methods). If the extension language does not
726 support cooperative SIGINT handling, then the SIGINT is left queued and
727 we require the non-cooperative extension language to call check_quit_flag
728 at appropriate times.
729 It is important for the extension language to call check_quit_flag if it
730 installs its own SIGINT handler to prevent the situation where a SIGINT
731 is queued on entry, extension language code runs for a "long" time possibly
732 serving one or more SIGINTs, and then returns. Upon return, if
733 check_quit_flag is not called, the original SIGINT will be thrown.
734 Non-cooperative extension languages are free to install their own SIGINT
735 handler but the original must be restored upon return, either itself
736 or via restore_active_ext_lang. */
738 struct active_ext_lang_state *
739 set_active_ext_lang (const struct extension_language_defn *now_active)
741 struct active_ext_lang_state *previous
742 = XCNEW (struct active_ext_lang_state);
744 previous->ext_lang = active_ext_lang;
745 active_ext_lang = now_active;
747 /* If the newly active extension language uses cooperative SIGINT handling
748 then ensure GDB's SIGINT handler is installed. */
749 if (now_active->language == EXT_LANG_GDB
750 || now_active->ops->check_quit_flag != NULL)
751 install_gdb_sigint_handler (&previous->sigint_handler);
753 /* If there's a SIGINT recorded in the cooperative extension languages,
754 move it to the new language, or save it in GDB's global flag if the newly
755 active extension language doesn't use cooperative SIGINT handling. */
756 if (check_quit_flag ())
762 /* Restore active extension language from PREVIOUS. */
765 restore_active_ext_lang (struct active_ext_lang_state *previous)
767 const struct extension_language_defn *current = active_ext_lang;
769 active_ext_lang = previous->ext_lang;
771 /* Restore the previous SIGINT handler if one was saved. */
772 if (previous->sigint_handler.handler_saved)
773 install_sigint_handler (&previous->sigint_handler);
775 /* If there's a SIGINT recorded in the cooperative extension languages,
776 move it to the new language, or save it in GDB's global flag if the newly
777 active extension language doesn't use cooperative SIGINT handling. */
778 if (check_quit_flag ())
784 /* Clear the quit flag.
785 The flag is cleared in all extension languages,
786 not just the currently active one. */
789 clear_quit_flag (void)
792 const struct extension_language_defn *extlang;
794 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
796 if (extlang->ops->clear_quit_flag != NULL)
797 extlang->ops->clear_quit_flag (extlang);
803 /* Set the quit flag.
804 This only sets the flag in the currently active extension language.
805 If the currently active extension language does not have cooperative
806 SIGINT handling, then GDB's global flag is set, and it is up to the
807 extension language to call check_quit_flag. The extension language
808 is free to install its own SIGINT handler, but we still need to handle
814 if (active_ext_lang->ops != NULL
815 && active_ext_lang->ops->set_quit_flag != NULL)
816 active_ext_lang->ops->set_quit_flag (active_ext_lang);
821 /* Return true if the quit flag has been set, false otherwise.
822 Note: The flag is cleared as a side-effect.
823 The flag is checked in all extension languages that support cooperative
824 SIGINT handling, not just the current one. This simplifies transitions. */
827 check_quit_flag (void)
830 const struct extension_language_defn *extlang;
832 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
834 if (extlang->ops->check_quit_flag != NULL)
835 if (extlang->ops->check_quit_flag (extlang) != 0)
839 /* This is written in a particular way to avoid races. */
849 /* xmethod support. */
851 /* The xmethod API routines do not have "ext_lang" in the name because
852 the name "xmethod" implies that this routine deals with extension
853 languages. Plus some of the methods take a xmethod_foo * "self/this"
854 arg, not an extension_language_defn * arg. */
856 /* Returns a new xmethod_worker with EXTLANG and DATA. Space for the
857 result must be freed with free_xmethod_worker. */
859 struct xmethod_worker *
860 new_xmethod_worker (const struct extension_language_defn *extlang, void *data)
862 struct xmethod_worker *worker = XCNEW (struct xmethod_worker);
864 worker->extlang = extlang;
866 worker->value = NULL;
871 /* Clones WORKER and returns a new but identical worker.
872 The function get_matching_xmethod_workers (see below), returns a
873 vector of matching workers. If a particular worker is selected by GDB
874 to invoke a method, then this function can help in cloning the
875 selected worker and freeing up the vector via a cleanup.
877 Space for the result must be freed with free_xmethod_worker. */
879 struct xmethod_worker *
880 clone_xmethod_worker (struct xmethod_worker *worker)
882 struct xmethod_worker *new_worker;
883 const struct extension_language_defn *extlang = worker->extlang;
885 gdb_assert (extlang->ops->clone_xmethod_worker_data != NULL);
887 new_worker = new_xmethod_worker
889 extlang->ops->clone_xmethod_worker_data (extlang, worker->data));
894 /* If a method with name METHOD_NAME is to be invoked on an object of type
895 TYPE, then all entension languages are searched for implementations of
896 methods with name METHOD. All matches found are returned as a vector
897 of 'xmethod_worker_ptr' objects. If no matching methods are
898 found, NULL is returned. */
900 VEC (xmethod_worker_ptr) *
901 get_matching_xmethod_workers (struct type *type, const char *method_name)
903 VEC (xmethod_worker_ptr) *workers = NULL;
905 const struct extension_language_defn *extlang;
907 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
909 VEC (xmethod_worker_ptr) *lang_workers, *new_vec;
912 /* If an extension language does not support xmethods, ignore
914 if (extlang->ops->get_matching_xmethod_workers == NULL)
917 rc = extlang->ops->get_matching_xmethod_workers (extlang,
920 if (rc == EXT_LANG_RC_ERROR)
922 free_xmethod_worker_vec (workers);
923 error (_("Error while looking for matching xmethod workers "
924 "defined in %s."), extlang->capitalized_name);
927 new_vec = VEC_merge (xmethod_worker_ptr, workers, lang_workers);
928 /* Free only the vectors and not the elements as NEW_VEC still
930 VEC_free (xmethod_worker_ptr, workers);
931 VEC_free (xmethod_worker_ptr, lang_workers);
938 /* Return the arg types of the xmethod encapsulated in WORKER.
939 An array of arg types is returned. The length of the array is returned in
940 NARGS. The type of the 'this' object is returned as the first element of
944 get_xmethod_arg_types (struct xmethod_worker *worker, int *nargs)
947 struct type **type_array = NULL;
948 const struct extension_language_defn *extlang = worker->extlang;
950 gdb_assert (extlang->ops->get_xmethod_arg_types != NULL);
952 rc = extlang->ops->get_xmethod_arg_types (extlang, worker, nargs,
954 if (rc == EXT_LANG_RC_ERROR)
956 error (_("Error while looking for arg types of a xmethod worker "
957 "defined in %s."), extlang->capitalized_name);
963 /* Return the type of the result of the xmethod encapsulated in WORKER.
964 OBJECT, ARGS, NARGS are the same as for invoke_xmethod. */
967 get_xmethod_result_type (struct xmethod_worker *worker,
968 struct value *object, struct value **args, int nargs)
971 struct type *result_type;
972 const struct extension_language_defn *extlang = worker->extlang;
974 gdb_assert (extlang->ops->get_xmethod_arg_types != NULL);
976 rc = extlang->ops->get_xmethod_result_type (extlang, worker,
979 if (rc == EXT_LANG_RC_ERROR)
981 error (_("Error while fetching result type of an xmethod worker "
982 "defined in %s."), extlang->capitalized_name);
988 /* Invokes the xmethod encapsulated in WORKER and returns the result.
989 The method is invoked on OBJ with arguments in the ARGS array. NARGS is
990 the length of the this array. */
993 invoke_xmethod (struct xmethod_worker *worker, struct value *obj,
994 struct value **args, int nargs)
996 gdb_assert (worker->extlang->ops->invoke_xmethod != NULL);
998 return worker->extlang->ops->invoke_xmethod (worker->extlang, worker,
1002 /* Frees the xmethod worker WORKER. */
1005 free_xmethod_worker (struct xmethod_worker *worker)
1007 gdb_assert (worker->extlang->ops->free_xmethod_worker_data != NULL);
1008 worker->extlang->ops->free_xmethod_worker_data (worker->extlang,
1013 /* Frees a vector of xmethod_workers VEC. */
1016 free_xmethod_worker_vec (void *vec)
1019 struct xmethod_worker *worker;
1020 VEC (xmethod_worker_ptr) *v = (VEC (xmethod_worker_ptr) *) vec;
1022 for (i = 0; VEC_iterate (xmethod_worker_ptr, v, i, worker); i++)
1023 free_xmethod_worker (worker);
1025 VEC_free (xmethod_worker_ptr, v);
1028 /* Called via an observer before gdb prints its prompt.
1029 Iterate over the extension languages giving them a chance to
1030 change the prompt. The first one to change the prompt wins,
1031 and no further languages are tried. */
1034 ext_lang_before_prompt (const char *current_gdb_prompt)
1037 const struct extension_language_defn *extlang;
1039 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
1041 enum ext_lang_rc rc;
1043 if (extlang->ops->before_prompt == NULL)
1045 rc = extlang->ops->before_prompt (extlang, current_gdb_prompt);
1048 case EXT_LANG_RC_OK:
1049 case EXT_LANG_RC_ERROR:
1051 case EXT_LANG_RC_NOP:
1054 gdb_assert_not_reached ("bad return from before_prompt");
1059 extern initialize_file_ftype _initialize_extension;
1062 _initialize_extension (void)
1064 observer_attach_before_prompt (ext_lang_before_prompt);