gdb/extension.c

   1 /* Interface between gdb and its extension languages.
   2
   3    Copyright (C) 2014-2018 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 "observer.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 struct ext_lang_type_printers *
 409 start_ext_lang_type_printers (void)
 410 {
 411   struct ext_lang_type_printers *printers
 412     = XCNEW (struct ext_lang_type_printers);
 413   int i;
 414   const struct extension_language_defn *extlang;
 415
 416   ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
 417     {
 418       if (extlang->ops->start_type_printers != NULL)
 419         extlang->ops->start_type_printers (extlang, printers);
 420     }
 421
 422   return printers;
 423 }
 424
 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.  */
 429
 430 char *
 431 apply_ext_lang_type_printers (struct ext_lang_type_printers *printers,
 432                               struct type *type)
 433 {
 434   int i;
 435   const struct extension_language_defn *extlang;
 436
 437   ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
 438     {
 439       char *result = NULL;
 440       enum ext_lang_rc rc;
 441
 442       if (extlang->ops->apply_type_printers == NULL)
 443         continue;
 444       rc = extlang->ops->apply_type_printers (extlang, printers, type,
 445                                               &result);
 446       switch (rc)
 447         {
 448         case EXT_LANG_RC_OK:
 449           gdb_assert (result != NULL);
 450           return result;
 451         case EXT_LANG_RC_ERROR:
 452           return NULL;
 453         case EXT_LANG_RC_NOP:
 454           break;
 455         default:
 456           gdb_assert_not_reached ("bad return from apply_type_printers");
 457         }
 458     }
 459
 460   return NULL;
 461 }
 462
 463 /* Call this after pretty-printing a type to release all memory held
 464    by PRINTERS.  */
 465
 466 void
 467 free_ext_lang_type_printers (struct ext_lang_type_printers *printers)
 468 {
 469   int i;
 470   const struct extension_language_defn *extlang;
 471
 472   ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
 473     {
 474       if (extlang->ops->free_type_printers != NULL)
 475         extlang->ops->free_type_printers (extlang, printers);
 476     }
 477
 478   xfree (printers);
 479 }
 480 \f
 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
 484    OPTIONS.
 485    VAL is the whole object that came from ADDRESS.
 486    Returns non-zero if the value was successfully pretty-printed.
 487
 488    Extension languages are tried in the order specified by
 489    extension_languages.  The first one to provide a pretty-printed
 490    value "wins".
 491
 492    If an error is encountered in a pretty-printer, no further extension
 493    languages are tried.
 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.  */
 497
 498 int
 499 apply_ext_lang_val_pretty_printer (struct type *type,
 500                                    LONGEST embedded_offset, CORE_ADDR address,
 501                                    struct ui_file *stream, int recurse,
 502                                    struct value *val,
 503                                    const struct value_print_options *options,
 504                                    const struct language_defn *language)
 505 {
 506   int i;
 507   const struct extension_language_defn *extlang;
 508
 509   ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
 510     {
 511       enum ext_lang_rc rc;
 512
 513       if (extlang->ops->apply_val_pretty_printer == NULL)
 514         continue;
 515       rc = extlang->ops->apply_val_pretty_printer (extlang, type,
 516                                                    embedded_offset, address,
 517                                                    stream, recurse, val,
 518                                                    options, language);
 519       switch (rc)
 520         {
 521         case EXT_LANG_RC_OK:
 522           return 1;
 523         case EXT_LANG_RC_ERROR:
 524           return 0;
 525         case EXT_LANG_RC_NOP:
 526           break;
 527         default:
 528           gdb_assert_not_reached ("bad return from apply_val_pretty_printer");
 529         }
 530     }
 531
 532   return 0;
 533 }
 534
 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.
 549
 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.  */
 554
 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,
 559                              struct ui_out *out,
 560                              int frame_low, int frame_high)
 561 {
 562   int i;
 563   const struct extension_language_defn *extlang;
 564
 565   ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
 566     {
 567       enum ext_lang_bt_status status;
 568
 569       if (extlang->ops->apply_frame_filter == NULL)
 570         continue;
 571       status = extlang->ops->apply_frame_filter (extlang, frame, flags,
 572                                                args_type, out,
 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)
 578         return status;
 579     }
 580
 581   return EXT_LANG_BT_NO_FILTERS;
 582 }
 583
 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.  */
 591
 592 void
 593 preserve_ext_lang_values (struct objfile *objfile, htab_t copied_types)
 594 {
 595   int i;
 596   const struct extension_language_defn *extlang;
 597
 598   ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
 599     {
 600       if (extlang->ops->preserve_values != NULL)
 601         extlang->ops->preserve_values (extlang, objfile, copied_types);
 602     }
 603 }
 604
 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.  */
 613
 614 const struct extension_language_defn *
 615 get_breakpoint_cond_ext_lang (struct breakpoint *b,
 616                               enum extension_language skip_lang)
 617 {
 618   int i;
 619   const struct extension_language_defn *extlang;
 620
 621   ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
 622     {
 623       if (extlang->language != skip_lang
 624           && extlang->ops->breakpoint_has_cond != NULL
 625           && extlang->ops->breakpoint_has_cond (extlang, b))
 626         return extlang;
 627     }
 628
 629   return NULL;
 630 }
 631
 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.  */
 634
 635 int
 636 breakpoint_ext_lang_cond_says_stop (struct breakpoint *b)
 637 {
 638   int i;
 639   const struct extension_language_defn *extlang;
 640   enum ext_lang_bp_stop stop = EXT_LANG_BP_STOP_UNSET;
 641
 642   ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
 643     {
 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"
 648          method exists.  */
 649       if (extlang->ops->breakpoint_cond_says_stop != NULL)
 650         {
 651           enum ext_lang_bp_stop this_stop
 652             = extlang->ops->breakpoint_cond_says_stop (extlang, b);
 653
 654           if (this_stop != EXT_LANG_BP_STOP_UNSET)
 655             {
 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);
 660               stop = this_stop;
 661             }
 662         }
 663     }
 664
 665   return stop == EXT_LANG_BP_STOP_NO ? 0 : 1;
 666 }
 667 \f
 668 /* ^C/SIGINT support.
 669    This requires cooperation with the extension languages so the support
 670    is defined here.  */
 671
 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;
 676
 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;
 684
 685 /* Return the currently active extension language.  */
 686
 687 const struct extension_language_defn *
 688 get_active_ext_lang (void)
 689 {
 690   return active_ext_lang;
 691 }
 692
 693 /* Install a SIGINT handler.  */
 694
 695 static void
 696 install_sigint_handler (const struct signal_handler *handler_state)
 697 {
 698   gdb_assert (handler_state->handler_saved);
 699
 700   signal (SIGINT, handler_state->handler);
 701 }
 702
 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
 706    be restored.  */
 707
 708 static void
 709 install_gdb_sigint_handler (struct signal_handler *previous)
 710 {
 711   /* Save here to simplify comparison.  */
 712   sighandler_t handle_sigint_for_compare = handle_sigint;
 713
 714   previous->handler = signal (SIGINT, handle_sigint);
 715   if (previous->handler != handle_sigint_for_compare)
 716     previous->handler_saved = 1;
 717   else
 718     previous->handler_saved = 0;
 719 }
 720
 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.
 724
 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
 727    afterwards.
 728
 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.  */
 743
 744 struct active_ext_lang_state *
 745 set_active_ext_lang (const struct extension_language_defn *now_active)
 746 {
 747   struct active_ext_lang_state *previous
 748     = XCNEW (struct active_ext_lang_state);
 749
 750   previous->ext_lang = active_ext_lang;
 751   previous->sigint_handler.handler_saved = 0;
 752   active_ext_lang = now_active;
 753
 754   if (target_terminal::is_ours ())
 755     {
 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);
 761
 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
 765          handling.  */
 766       if (check_quit_flag ())
 767         set_quit_flag ();
 768     }
 769
 770   return previous;
 771 }
 772
 773 /* Restore active extension language from PREVIOUS.  */
 774
 775 void
 776 restore_active_ext_lang (struct active_ext_lang_state *previous)
 777 {
 778   active_ext_lang = previous->ext_lang;
 779
 780   if (target_terminal::is_ours ())
 781     {
 782       /* Restore the previous SIGINT handler if one was saved.  */
 783       if (previous->sigint_handler.handler_saved)
 784         install_sigint_handler (&previous->sigint_handler);
 785
 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
 789          handling.  */
 790       if (check_quit_flag ())
 791         set_quit_flag ();
 792     }
 793   xfree (previous);
 794 }
 795
 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
 802    the transition.  */
 803
 804 void
 805 set_quit_flag (void)
 806 {
 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);
 810   else
 811     {
 812       quit_flag = 1;
 813
 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
 818          clear.  */
 819       quit_serial_event_set ();
 820     }
 821 }
 822
 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.  */
 827
 828 int
 829 check_quit_flag (void)
 830 {
 831   int i, result = 0;
 832   const struct extension_language_defn *extlang;
 833
 834   ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
 835     {
 836       if (extlang->ops->check_quit_flag != NULL)
 837         if (extlang->ops->check_quit_flag (extlang) != 0)
 838           result = 1;
 839     }
 840
 841   /* This is written in a particular way to avoid races.  */
 842   if (quit_flag)
 843     {
 844       /* No longer need to wake up the event loop or any
 845          interruptible_select.  The caller handles the quit
 846          request.  */
 847       quit_serial_event_clear ();
 848       quit_flag = 0;
 849       result = 1;
 850     }
 851
 852   return result;
 853 }
 854
 855 /* See extension.h.  */
 856
 857 void
 858 get_matching_xmethod_workers (struct type *type, const char *method_name,
 859                               std::vector<xmethod_worker_up> *workers)
 860 {
 861   int i;
 862   const struct extension_language_defn *extlang;
 863
 864   ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
 865     {
 866       enum ext_lang_rc rc;
 867
 868       /* If an extension language does not support xmethods, ignore
 869          it.  */
 870       if (extlang->ops->get_matching_xmethod_workers == NULL)
 871         continue;
 872
 873       rc = extlang->ops->get_matching_xmethod_workers (extlang,
 874                                                        type, method_name,
 875                                                        workers);
 876       if (rc == EXT_LANG_RC_ERROR)
 877         error (_("Error while looking for matching xmethod workers "
 878                  "defined in %s."), extlang->capitalized_name);
 879     }
 880 }
 881
 882 /* See extension.h.  */
 883
 884 type **
 885 xmethod_worker::get_arg_types (int *nargs)
 886 {
 887   type **type_array = NULL;
 888
 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);
 893
 894   return type_array;
 895 }
 896
 897 /* See extension.h.  */
 898
 899 struct type *
 900 xmethod_worker::get_result_type (value *object, value **args, int nargs)
 901 {
 902   type *result_type;
 903
 904   ext_lang_rc rc = do_get_result_type (object, args, nargs, &result_type);
 905   if (rc == EXT_LANG_RC_ERROR)
 906     {
 907       error (_("Error while fetching result type of an xmethod worker "
 908                "defined in %s."), m_extlang->capitalized_name);
 909     }
 910
 911   return result_type;
 912 }
 913
 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.  */
 918
 919 static void
 920 ext_lang_before_prompt (const char *current_gdb_prompt)
 921 {
 922   int i;
 923   const struct extension_language_defn *extlang;
 924
 925   ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
 926     {
 927       enum ext_lang_rc rc;
 928
 929       if (extlang->ops->before_prompt == NULL)
 930         continue;
 931       rc = extlang->ops->before_prompt (extlang, current_gdb_prompt);
 932       switch (rc)
 933         {
 934         case EXT_LANG_RC_OK:
 935         case EXT_LANG_RC_ERROR:
 936           return;
 937         case EXT_LANG_RC_NOP:
 938           break;
 939         default:
 940           gdb_assert_not_reached ("bad return from before_prompt");
 941         }
 942     }
 943 }
 944
 945 void
 946 _initialize_extension (void)
 947 {
 948   observer_attach_before_prompt (ext_lang_before_prompt);
 949 }