gdb/extension.c

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