Automatic date update in version.in
[external/binutils.git] / gdb / extension.c
1 /* Interface between gdb and its extension languages.
2
3    Copyright (C) 2014-2019 Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
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.
11
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.
16
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/>.  */
19
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.  */
22
23 #include "defs.h"
24 #include <signal.h>
25 #include "target.h"
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"
35
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.  */
39
40 #define ALL_EXTENSION_LANGUAGES(i, extlang) \
41   for (/*int*/ i = 0, extlang = extension_languages[0]; \
42        extlang != NULL; \
43        extlang = extension_languages[++i])
44
45 /* Iterate over all external extension languages that are supported.
46    This does not include GDB's own scripting language.  */
47
48 #define ALL_ENABLED_EXTENSION_LANGUAGES(i, extlang) \
49   for (/*int*/ i = 0, extlang = extension_languages[0]; \
50        extlang != NULL; \
51        extlang = extension_languages[++i]) \
52     if (extlang->ops != NULL)
53
54 static script_sourcer_func source_gdb_script;
55 static objfile_script_sourcer_func source_gdb_objfile_script;
56
57 /* GDB's own scripting language.
58    This exists, in part, to support auto-loading ${prog}-gdb.gdb scripts.  */
59
60 static const struct extension_language_script_ops
61   extension_language_gdb_script_ops =
62 {
63   source_gdb_script,
64   source_gdb_objfile_script,
65   NULL, /* objfile_script_executor */
66   auto_load_gdb_scripts_enabled
67 };
68
69 const struct extension_language_defn extension_language_gdb =
70 {
71   EXT_LANG_GDB,
72   "gdb",
73   "GDB",
74
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.  */
78   ".gdb",
79   "-gdb.gdb",
80
81   /* cli_control_type: This is never used: GDB's own scripting language
82      has a variety of control types (if, while, etc.).  */
83   commands_control,
84
85   &extension_language_gdb_script_ops,
86
87   /* The rest of the extension language interface isn't supported by GDB's own
88      extension/scripting language.  */
89   NULL
90 };
91
92 /* NULL-terminated table of all external (non-native) extension languages.
93
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
100    throughout.  */
101
102 static const struct extension_language_defn * const extension_languages[] =
103 {
104   /* To preserve existing behaviour, python should always appear first.  */
105   &extension_language_python,
106   &extension_language_guile,
107   NULL
108 };
109
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.  */
114
115 const struct extension_language_defn *
116 get_ext_lang_defn (enum extension_language lang)
117 {
118   int i;
119   const struct extension_language_defn *extlang;
120
121   gdb_assert (lang != EXT_LANG_NONE);
122
123   if (lang == EXT_LANG_GDB)
124     return &extension_language_gdb;
125
126   ALL_EXTENSION_LANGUAGES (i, extlang)
127     {
128       if (extlang->language == lang)
129         return extlang;
130     }
131
132   gdb_assert_not_reached ("unable to find extension_language_defn");
133 }
134
135 /* Return TRUE if FILE has extension EXTENSION.  */
136
137 static int
138 has_extension (const char *file, const char *extension)
139 {
140   int file_len = strlen (file);
141   int extension_len = strlen (extension);
142
143   return (file_len > extension_len
144           && strcmp (&file[file_len - extension_len], extension) == 0);
145 }
146
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.  */
150
151 const struct extension_language_defn *
152 get_ext_lang_of_file (const char *file)
153 {
154   int i;
155   const struct extension_language_defn *extlang;
156
157   ALL_EXTENSION_LANGUAGES (i, extlang)
158     {
159       if (has_extension (file, extlang->suffix))
160         return extlang;
161     }
162
163   return NULL;
164 }
165
166 /* Return non-zero if support for the specified extension language
167    is compiled in.  */
168
169 int
170 ext_lang_present_p (const struct extension_language_defn *extlang)
171 {
172   return extlang->script_ops != NULL;
173 }
174
175 /* Return non-zero if the specified extension language has successfully
176    initialized.  */
177
178 int
179 ext_lang_initialized_p (const struct extension_language_defn *extlang)
180 {
181   if (extlang->ops != NULL)
182     {
183       /* This method is required.  */
184       gdb_assert (extlang->ops->initialized != NULL);
185       return extlang->ops->initialized (extlang);
186     }
187
188   return 0;
189 }
190
191 /* Throw an error indicating EXTLANG is not supported in this copy of GDB.  */
192
193 void
194 throw_ext_lang_unsupported (const struct extension_language_defn *extlang)
195 {
196   error (_("Scripting in the \"%s\" language is not supported"
197            " in this copy of GDB."),
198          ext_lang_capitalized_name (extlang));
199 }
200 \f
201 /* Methods for GDB's own extension/scripting language.  */
202
203 /* The extension_language_script_ops.script_sourcer "method".  */
204
205 static void
206 source_gdb_script (const struct extension_language_defn *extlang,
207                    FILE *stream, const char *file)
208 {
209   script_from_file (stream, file);
210 }
211
212 /* The extension_language_script_ops.objfile_script_sourcer "method".  */
213
214 static void
215 source_gdb_objfile_script (const struct extension_language_defn *extlang,
216                            struct objfile *objfile,
217                            FILE *stream, const char *file)
218 {
219   script_from_file (stream, file);
220 }
221 \f
222 /* Accessors for "public" attributes of struct extension_language.  */
223
224 /* Return the "name" field of EXTLANG.  */
225
226 const char *
227 ext_lang_name (const struct extension_language_defn *extlang)
228 {
229   return extlang->name;
230 }
231
232 /* Return the "capitalized_name" field of EXTLANG.  */
233
234 const char *
235 ext_lang_capitalized_name (const struct extension_language_defn *extlang)
236 {
237   return extlang->capitalized_name;
238 }
239
240 /* Return the "suffix" field of EXTLANG.  */
241
242 const char *
243 ext_lang_suffix (const struct extension_language_defn *extlang)
244 {
245   return extlang->suffix;
246 }
247
248 /* Return the "auto_load_suffix" field of EXTLANG.  */
249
250 const char *
251 ext_lang_auto_load_suffix (const struct extension_language_defn *extlang)
252 {
253   return extlang->auto_load_suffix;
254 }
255 \f
256 /* extension_language_script_ops wrappers.  */
257
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.  */
261
262 script_sourcer_func *
263 ext_lang_script_sourcer (const struct extension_language_defn *extlang)
264 {
265   if (extlang->script_ops == NULL)
266     return NULL;
267
268   /* The extension language is required to implement this function.  */
269   gdb_assert (extlang->script_ops->script_sourcer != NULL);
270
271   return extlang->script_ops->script_sourcer;
272 }
273
274 /* Return the objfile script "sourcer" function for EXTLANG.
275    This is the function that loads and processes a script for a particular
276    objfile.
277    If support for this language isn't compiled in, NULL is returned.  */
278
279 objfile_script_sourcer_func *
280 ext_lang_objfile_script_sourcer (const struct extension_language_defn *extlang)
281 {
282   if (extlang->script_ops == NULL)
283     return NULL;
284
285   /* The extension language is required to implement this function.  */
286   gdb_assert (extlang->script_ops->objfile_script_sourcer != NULL);
287
288   return extlang->script_ops->objfile_script_sourcer;
289 }
290
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.  */
295
296 objfile_script_executor_func *
297 ext_lang_objfile_script_executor
298   (const struct extension_language_defn *extlang)
299 {
300   if (extlang->script_ops == NULL)
301     return NULL;
302
303   return extlang->script_ops->objfile_script_executor;
304 }
305
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.  */
308
309 int
310 ext_lang_auto_load_enabled (const struct extension_language_defn *extlang)
311 {
312   if (extlang->script_ops == NULL)
313     return 0;
314
315   /* The extension language is required to implement this function.  */
316   gdb_assert (extlang->script_ops->auto_load_enabled != NULL);
317
318   return extlang->script_ops->auto_load_enabled (extlang);
319 }
320 \f
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.  */
324
325 /* Wrapper to call the extension_language_ops.finish_initialization "method"
326    for each compiled-in extension language.  */
327
328 void
329 finish_ext_lang_initialization (void)
330 {
331   int i;
332   const struct extension_language_defn *extlang;
333
334   ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
335     {
336       if (extlang->ops->finish_initialization != NULL)
337         extlang->ops->finish_initialization (extlang);
338     }
339 }
340
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.
343
344    This function is what implements, for example:
345
346    python
347    print 42
348    end
349
350    in a GDB script.  */
351
352 void
353 eval_ext_lang_from_control_command (struct command_line *cmd)
354 {
355   int i;
356   const struct extension_language_defn *extlang;
357
358   ALL_EXTENSION_LANGUAGES (i, extlang)
359     {
360       if (extlang->cli_control_type == cmd->control_type)
361         {
362           if (extlang->ops != NULL
363               && extlang->ops->eval_from_control_command != NULL)
364             {
365               extlang->ops->eval_from_control_command (extlang, cmd);
366               return;
367             }
368           /* The requested extension language is not supported in this GDB.  */
369           throw_ext_lang_unsupported (extlang);
370         }
371     }
372
373   gdb_assert_not_reached ("unknown extension language in command_line");
374 }
375
376 /* Search for and load scripts for OBJFILE written in extension languages.
377    This includes GDB's own scripting language.
378
379    This function is what implements the loading of OBJFILE-gdb.py and
380    OBJFILE-gdb.gdb.  */
381
382 void
383 auto_load_ext_lang_scripts_for_objfile (struct objfile *objfile)
384 {
385   int i;
386   const struct extension_language_defn *extlang;
387
388   extlang = &extension_language_gdb;
389   if (ext_lang_auto_load_enabled (extlang))
390     auto_load_objfile_script (objfile, extlang);
391
392   ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
393     {
394       if (ext_lang_auto_load_enabled (extlang))
395         auto_load_objfile_script (objfile, extlang);
396     }
397 }
398 \f
399 /* Interface to type pretty-printers implemented in an extension language.  */
400
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.
404
405    We don't know in advance which extension language will provide a
406    pretty-printer for the type, so all are initialized.  */
407
408 ext_lang_type_printers::ext_lang_type_printers ()
409 {
410   int i;
411   const struct extension_language_defn *extlang;
412
413   ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
414     {
415       if (extlang->ops->start_type_printers != NULL)
416         extlang->ops->start_type_printers (extlang, this);
417     }
418 }
419
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.  */
424
425 char *
426 apply_ext_lang_type_printers (struct ext_lang_type_printers *printers,
427                               struct type *type)
428 {
429   int i;
430   const struct extension_language_defn *extlang;
431
432   ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
433     {
434       char *result = NULL;
435       enum ext_lang_rc rc;
436
437       if (extlang->ops->apply_type_printers == NULL)
438         continue;
439       rc = extlang->ops->apply_type_printers (extlang, printers, type,
440                                               &result);
441       switch (rc)
442         {
443         case EXT_LANG_RC_OK:
444           gdb_assert (result != NULL);
445           return result;
446         case EXT_LANG_RC_ERROR:
447           return NULL;
448         case EXT_LANG_RC_NOP:
449           break;
450         default:
451           gdb_assert_not_reached ("bad return from apply_type_printers");
452         }
453     }
454
455   return NULL;
456 }
457
458 ext_lang_type_printers::~ext_lang_type_printers ()
459 {
460   int i;
461   const struct extension_language_defn *extlang;
462
463   ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
464     {
465       if (extlang->ops->free_type_printers != NULL)
466         extlang->ops->free_type_printers (extlang, this);
467     }
468 }
469 \f
470 /* Try to pretty-print a value of type TYPE located at VAL's contents
471    buffer + EMBEDDED_OFFSET, which came from the inferior at address
472    ADDRESS + EMBEDDED_OFFSET, onto stdio stream STREAM according to
473    OPTIONS.
474    VAL is the whole object that came from ADDRESS.
475    Returns non-zero if the value was successfully pretty-printed.
476
477    Extension languages are tried in the order specified by
478    extension_languages.  The first one to provide a pretty-printed
479    value "wins".
480
481    If an error is encountered in a pretty-printer, no further extension
482    languages are tried.
483    Note: This is different than encountering a memory error trying to read a
484    value for pretty-printing.  Here we're referring to, e.g., programming
485    errors that trigger an exception in the extension language.  */
486
487 int
488 apply_ext_lang_val_pretty_printer (struct type *type,
489                                    LONGEST embedded_offset, CORE_ADDR address,
490                                    struct ui_file *stream, int recurse,
491                                    struct value *val,
492                                    const struct value_print_options *options,
493                                    const struct language_defn *language)
494 {
495   int i;
496   const struct extension_language_defn *extlang;
497
498   ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
499     {
500       enum ext_lang_rc rc;
501
502       if (extlang->ops->apply_val_pretty_printer == NULL)
503         continue;
504       rc = extlang->ops->apply_val_pretty_printer (extlang, type,
505                                                    embedded_offset, address,
506                                                    stream, recurse, val,
507                                                    options, language);
508       switch (rc)
509         {
510         case EXT_LANG_RC_OK:
511           return 1;
512         case EXT_LANG_RC_ERROR:
513           return 0;
514         case EXT_LANG_RC_NOP:
515           break;
516         default:
517           gdb_assert_not_reached ("bad return from apply_val_pretty_printer");
518         }
519     }
520
521   return 0;
522 }
523
524 /* GDB access to the "frame filter" feature.
525    FRAME is the source frame to start frame-filter invocation.  FLAGS is an
526    integer holding the flags for printing.  The following elements of
527    the FRAME_FILTER_FLAGS enum denotes the make-up of FLAGS:
528    PRINT_LEVEL is a flag indicating whether to print the frame's
529    relative level in the output.  PRINT_FRAME_INFO is a flag that
530    indicates whether this function should print the frame
531    information, PRINT_ARGS is a flag that indicates whether to print
532    frame arguments, and PRINT_LOCALS, likewise, with frame local
533    variables.  ARGS_TYPE is an enumerator describing the argument
534    format, OUT is the output stream to print.  FRAME_LOW is the
535    beginning of the slice of frames to print, and FRAME_HIGH is the
536    upper limit of the frames to count.  Returns EXT_LANG_BT_ERROR on error,
537    or EXT_LANG_BT_COMPLETED on success.
538
539    Extension languages are tried in the order specified by
540    extension_languages.  The first one to provide a filter "wins".
541    If there is an error (EXT_LANG_BT_ERROR) it is reported immediately
542    rather than trying filters in other extension languages.  */
543
544 enum ext_lang_bt_status
545 apply_ext_lang_frame_filter (struct frame_info *frame,
546                              frame_filter_flags flags,
547                              enum ext_lang_frame_args args_type,
548                              struct ui_out *out,
549                              int frame_low, int frame_high)
550 {
551   int i;
552   const struct extension_language_defn *extlang;
553
554   ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
555     {
556       enum ext_lang_bt_status status;
557
558       if (extlang->ops->apply_frame_filter == NULL)
559         continue;
560       status = extlang->ops->apply_frame_filter (extlang, frame, flags,
561                                                args_type, out,
562                                                frame_low, frame_high);
563       /* We use the filters from the first extension language that has
564          applicable filters.  Also, an error is reported immediately
565          rather than continue trying.  */
566       if (status != EXT_LANG_BT_NO_FILTERS)
567         return status;
568     }
569
570   return EXT_LANG_BT_NO_FILTERS;
571 }
572
573 /* Update values held by the extension language when OBJFILE is discarded.
574    New global types must be created for every such value, which must then be
575    updated to use the new types.
576    The function typically just iterates over all appropriate values and
577    calls preserve_one_value for each one.
578    COPIED_TYPES is used to prevent cycles / duplicates and is passed to
579    preserve_one_value.  */
580
581 void
582 preserve_ext_lang_values (struct objfile *objfile, htab_t copied_types)
583 {
584   int i;
585   const struct extension_language_defn *extlang;
586
587   ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
588     {
589       if (extlang->ops->preserve_values != NULL)
590         extlang->ops->preserve_values (extlang, objfile, copied_types);
591     }
592 }
593
594 /* If there is a stop condition implemented in an extension language for
595    breakpoint B, return a pointer to the extension language's definition.
596    Otherwise return NULL.
597    If SKIP_LANG is not EXT_LANG_NONE, skip checking this language.
598    This is for the case where we're setting a new condition: Only one
599    condition is allowed, so when setting a condition for any particular
600    extension language, we need to check if any other extension language
601    already has a condition set.  */
602
603 const struct extension_language_defn *
604 get_breakpoint_cond_ext_lang (struct breakpoint *b,
605                               enum extension_language skip_lang)
606 {
607   int i;
608   const struct extension_language_defn *extlang;
609
610   ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
611     {
612       if (extlang->language != skip_lang
613           && extlang->ops->breakpoint_has_cond != NULL
614           && extlang->ops->breakpoint_has_cond (extlang, b))
615         return extlang;
616     }
617
618   return NULL;
619 }
620
621 /* Return whether a stop condition for breakpoint B says to stop.
622    True is also returned if there is no stop condition for B.  */
623
624 int
625 breakpoint_ext_lang_cond_says_stop (struct breakpoint *b)
626 {
627   int i;
628   const struct extension_language_defn *extlang;
629   enum ext_lang_bp_stop stop = EXT_LANG_BP_STOP_UNSET;
630
631   ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
632     {
633       /* There is a rule that a breakpoint can have at most one of any of a
634          CLI or extension language condition.  However, Python hacks in "finish
635          breakpoints" on top of the "stop" check, so we have to call this for
636          every language, even if we could first determine whether a "stop"
637          method exists.  */
638       if (extlang->ops->breakpoint_cond_says_stop != NULL)
639         {
640           enum ext_lang_bp_stop this_stop
641             = extlang->ops->breakpoint_cond_says_stop (extlang, b);
642
643           if (this_stop != EXT_LANG_BP_STOP_UNSET)
644             {
645               /* Even though we have to check every extension language, only
646                  one of them can return yes/no (because only one of them
647                  can have a "stop" condition).  */
648               gdb_assert (stop == EXT_LANG_BP_STOP_UNSET);
649               stop = this_stop;
650             }
651         }
652     }
653
654   return stop == EXT_LANG_BP_STOP_NO ? 0 : 1;
655 }
656 \f
657 /* ^C/SIGINT support.
658    This requires cooperation with the extension languages so the support
659    is defined here.  */
660
661 /* This flag tracks quit requests when we haven't called out to an
662    extension language.  it also holds quit requests when we transition to
663    an extension language that doesn't have cooperative SIGINT handling.  */
664 static int quit_flag;
665
666 /* The current extension language we've called out to, or
667    extension_language_gdb if there isn't one.
668    This must be set everytime we call out to an extension language, and reset
669    to the previous value when it returns.  Note that the previous value may
670    be a different (or the same) extension language.  */
671 static const struct extension_language_defn *active_ext_lang
672   = &extension_language_gdb;
673
674 /* Return the currently active extension language.  */
675
676 const struct extension_language_defn *
677 get_active_ext_lang (void)
678 {
679   return active_ext_lang;
680 }
681
682 /* Install a SIGINT handler.  */
683
684 static void
685 install_sigint_handler (const struct signal_handler *handler_state)
686 {
687   gdb_assert (handler_state->handler_saved);
688
689   signal (SIGINT, handler_state->handler);
690 }
691
692 /* Install GDB's SIGINT handler, storing the previous version in *PREVIOUS.
693    As a simple optimization, if the previous version was GDB's SIGINT handler
694    then mark the previous handler as not having been saved, and thus it won't
695    be restored.  */
696
697 static void
698 install_gdb_sigint_handler (struct signal_handler *previous)
699 {
700   /* Save here to simplify comparison.  */
701   sighandler_t handle_sigint_for_compare = handle_sigint;
702
703   previous->handler = signal (SIGINT, handle_sigint);
704   if (previous->handler != handle_sigint_for_compare)
705     previous->handler_saved = 1;
706   else
707     previous->handler_saved = 0;
708 }
709
710 /* Set the currently active extension language to NOW_ACTIVE.
711    The result is a pointer to a malloc'd block of memory to pass to
712    restore_active_ext_lang.
713
714    N.B. This function must be called every time we call out to an extension
715    language, and the result must be passed to restore_active_ext_lang
716    afterwards.
717
718    If there is a pending SIGINT it is "moved" to the now active extension
719    language, if it supports cooperative SIGINT handling (i.e., it provides
720    {clear,set,check}_quit_flag methods).  If the extension language does not
721    support cooperative SIGINT handling, then the SIGINT is left queued and
722    we require the non-cooperative extension language to call check_quit_flag
723    at appropriate times.
724    It is important for the extension language to call check_quit_flag if it
725    installs its own SIGINT handler to prevent the situation where a SIGINT
726    is queued on entry, extension language code runs for a "long" time possibly
727    serving one or more SIGINTs, and then returns.  Upon return, if
728    check_quit_flag is not called, the original SIGINT will be thrown.
729    Non-cooperative extension languages are free to install their own SIGINT
730    handler but the original must be restored upon return, either itself
731    or via restore_active_ext_lang.  */
732
733 struct active_ext_lang_state *
734 set_active_ext_lang (const struct extension_language_defn *now_active)
735 {
736   struct active_ext_lang_state *previous
737     = XCNEW (struct active_ext_lang_state);
738
739   previous->ext_lang = active_ext_lang;
740   previous->sigint_handler.handler_saved = 0;
741   active_ext_lang = now_active;
742
743   if (target_terminal::is_ours ())
744     {
745       /* If the newly active extension language uses cooperative SIGINT
746          handling then ensure GDB's SIGINT handler is installed.  */
747       if (now_active->language == EXT_LANG_GDB
748           || now_active->ops->check_quit_flag != NULL)
749         install_gdb_sigint_handler (&previous->sigint_handler);
750
751       /* If there's a SIGINT recorded in the cooperative extension languages,
752          move it to the new language, or save it in GDB's global flag if the
753          newly active extension language doesn't use cooperative SIGINT
754          handling.  */
755       if (check_quit_flag ())
756         set_quit_flag ();
757     }
758
759   return previous;
760 }
761
762 /* Restore active extension language from PREVIOUS.  */
763
764 void
765 restore_active_ext_lang (struct active_ext_lang_state *previous)
766 {
767   active_ext_lang = previous->ext_lang;
768
769   if (target_terminal::is_ours ())
770     {
771       /* Restore the previous SIGINT handler if one was saved.  */
772       if (previous->sigint_handler.handler_saved)
773         install_sigint_handler (&previous->sigint_handler);
774
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
777          newly active extension language doesn't use cooperative SIGINT
778          handling.  */
779       if (check_quit_flag ())
780         set_quit_flag ();
781     }
782   xfree (previous);
783 }
784
785 /* Set the quit flag.
786    This only sets the flag in the currently active extension language.
787    If the currently active extension language does not have cooperative
788    SIGINT handling, then GDB's global flag is set, and it is up to the
789    extension language to call check_quit_flag.  The extension language
790    is free to install its own SIGINT handler, but we still need to handle
791    the transition.  */
792
793 void
794 set_quit_flag (void)
795 {
796   if (active_ext_lang->ops != NULL
797       && active_ext_lang->ops->set_quit_flag != NULL)
798     active_ext_lang->ops->set_quit_flag (active_ext_lang);
799   else
800     {
801       quit_flag = 1;
802
803       /* Now wake up the event loop, or any interruptible_select.  Do
804          this after setting the flag, because signals on Windows
805          actually run on a separate thread, and thus otherwise the
806          main code could be woken up and find quit_flag still
807          clear.  */
808       quit_serial_event_set ();
809     }
810 }
811
812 /* Return true if the quit flag has been set, false otherwise.
813    Note: The flag is cleared as a side-effect.
814    The flag is checked in all extension languages that support cooperative
815    SIGINT handling, not just the current one.  This simplifies transitions.  */
816
817 int
818 check_quit_flag (void)
819 {
820   int i, result = 0;
821   const struct extension_language_defn *extlang;
822
823   ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
824     {
825       if (extlang->ops->check_quit_flag != NULL)
826         if (extlang->ops->check_quit_flag (extlang) != 0)
827           result = 1;
828     }
829
830   /* This is written in a particular way to avoid races.  */
831   if (quit_flag)
832     {
833       /* No longer need to wake up the event loop or any
834          interruptible_select.  The caller handles the quit
835          request.  */
836       quit_serial_event_clear ();
837       quit_flag = 0;
838       result = 1;
839     }
840
841   return result;
842 }
843
844 /* See extension.h.  */
845
846 void
847 get_matching_xmethod_workers (struct type *type, const char *method_name,
848                               std::vector<xmethod_worker_up> *workers)
849 {
850   int i;
851   const struct extension_language_defn *extlang;
852
853   ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
854     {
855       enum ext_lang_rc rc;
856
857       /* If an extension language does not support xmethods, ignore
858          it.  */
859       if (extlang->ops->get_matching_xmethod_workers == NULL)
860         continue;
861
862       rc = extlang->ops->get_matching_xmethod_workers (extlang,
863                                                        type, method_name,
864                                                        workers);
865       if (rc == EXT_LANG_RC_ERROR)
866         error (_("Error while looking for matching xmethod workers "
867                  "defined in %s."), extlang->capitalized_name);
868     }
869 }
870
871 /* See extension.h.  */
872
873 std::vector<type *>
874 xmethod_worker::get_arg_types ()
875 {
876   std::vector<type *> type_array;
877
878   ext_lang_rc rc = do_get_arg_types (&type_array);
879   if (rc == EXT_LANG_RC_ERROR)
880     error (_("Error while looking for arg types of a xmethod worker "
881              "defined in %s."), m_extlang->capitalized_name);
882
883   return type_array;
884 }
885
886 /* See extension.h.  */
887
888 struct type *
889 xmethod_worker::get_result_type (value *object, gdb::array_view<value *> args)
890 {
891   type *result_type;
892
893   ext_lang_rc rc = do_get_result_type (object, args, &result_type);
894   if (rc == EXT_LANG_RC_ERROR)
895     {
896       error (_("Error while fetching result type of an xmethod worker "
897                "defined in %s."), m_extlang->capitalized_name);
898     }
899
900   return result_type;
901 }
902
903 /* Called via an observer before gdb prints its prompt.
904    Iterate over the extension languages giving them a chance to
905    change the prompt.  The first one to change the prompt wins,
906    and no further languages are tried.  */
907
908 static void
909 ext_lang_before_prompt (const char *current_gdb_prompt)
910 {
911   int i;
912   const struct extension_language_defn *extlang;
913
914   ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
915     {
916       enum ext_lang_rc rc;
917
918       if (extlang->ops->before_prompt == NULL)
919         continue;
920       rc = extlang->ops->before_prompt (extlang, current_gdb_prompt);
921       switch (rc)
922         {
923         case EXT_LANG_RC_OK:
924         case EXT_LANG_RC_ERROR:
925           return;
926         case EXT_LANG_RC_NOP:
927           break;
928         default:
929           gdb_assert_not_reached ("bad return from before_prompt");
930         }
931     }
932 }
933
934 void
935 _initialize_extension (void)
936 {
937   gdb::observers::before_prompt.attach (ext_lang_before_prompt);
938 }