GDB (xrefs)

/tmp/gdb-8.1/gdb/extension.c
Go to the documentation of this file.
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
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
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
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
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
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
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, int flags,
557 enum ext_lang_frame_args args_type,
558 struct ui_out *out,
559 int frame_low, int frame_high)
560 {
561 int i;
562 const struct extension_language_defn *extlang;
563
564 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
565 {
566 enum ext_lang_bt_status status;
567
568 if (extlang->ops->apply_frame_filter == NULL)
569 continue;
570 status = extlang->ops->apply_frame_filter (extlang, frame, flags,
571 args_type, out,
572 frame_low, frame_high);
573 /* We use the filters from the first extension language that has
574 applicable filters. Also, an error is reported immediately
575 rather than continue trying. */
576 if (status != EXT_LANG_BT_NO_FILTERS)
577 return status;
578 }
579
580 return EXT_LANG_BT_NO_FILTERS;
581 }
582
583 /* Update values held by the extension language when OBJFILE is discarded.
584 New global types must be created for every such value, which must then be
585 updated to use the new types.
586 The function typically just iterates over all appropriate values and
587 calls preserve_one_value for each one.
588 COPIED_TYPES is used to prevent cycles / duplicates and is passed to
589 preserve_one_value. */
590
591 void
592 preserve_ext_lang_values (struct objfile *objfile, htab_t copied_types)
593 {
594 int i;
595 const struct extension_language_defn *extlang;
596
597 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
598 {
599 if (extlang->ops->preserve_values != NULL)
600 extlang->ops->preserve_values (extlang, objfile, copied_types);
601 }
602 }
603
604 /* If there is a stop condition implemented in an extension language for
605 breakpoint B, return a pointer to the extension language's definition.
606 Otherwise return NULL.
607 If SKIP_LANG is not EXT_LANG_NONE, skip checking this language.
608 This is for the case where we're setting a new condition: Only one
609 condition is allowed, so when setting a condition for any particular
610 extension language, we need to check if any other extension language
611 already has a condition set. */
612
613 const struct extension_language_defn *
614 get_breakpoint_cond_ext_lang (struct breakpoint *b,
615 enum extension_language skip_lang)
616 {
617 int i;
618 const struct extension_language_defn *extlang;
619
620 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
621 {
622 if (extlang->language != skip_lang
623 && extlang->ops->breakpoint_has_cond != NULL
624 && extlang->ops->breakpoint_has_cond (extlang, b))
625 return extlang;
626 }
627
628 return NULL;
629 }
630
631 /* Return whether a stop condition for breakpoint B says to stop.
632 True is also returned if there is no stop condition for B. */
633
634 int
635 breakpoint_ext_lang_cond_says_stop (struct breakpoint *b)
636 {
637 int i;
638 const struct extension_language_defn *extlang;
639 enum ext_lang_bp_stop stop = EXT_LANG_BP_STOP_UNSET;
640
641 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
642 {
643 /* There is a rule that a breakpoint can have at most one of any of a
644 CLI or extension language condition. However, Python hacks in "finish
645 breakpoints" on top of the "stop" check, so we have to call this for
646 every language, even if we could first determine whether a "stop"
647 method exists. */
648 if (extlang->ops->breakpoint_cond_says_stop != NULL)
649 {
650 enum ext_lang_bp_stop this_stop
651 = extlang->ops->breakpoint_cond_says_stop (extlang, b);
652
653 if (this_stop != EXT_LANG_BP_STOP_UNSET)
654 {
655 /* Even though we have to check every extension language, only
656 one of them can return yes/no (because only one of them
657 can have a "stop" condition). */
658 gdb_assert (stop == EXT_LANG_BP_STOP_UNSET);
659 stop = this_stop;
660 }
661 }
662 }
663
664 return stop == EXT_LANG_BP_STOP_NO ? 0 : 1;
665 }
666
667 /* ^C/SIGINT support.
668 This requires cooperation with the extension languages so the support
669 is defined here. */
670
671 /* This flag tracks quit requests when we haven't called out to an
672 extension language. it also holds quit requests when we transition to
673 an extension language that doesn't have cooperative SIGINT handling. */
674 static int quit_flag;
675
676 /* The current extension language we've called out to, or
677 extension_language_gdb if there isn't one.
678 This must be set everytime we call out to an extension language, and reset
679 to the previous value when it returns. Note that the previous value may
680 be a different (or the same) extension language. */
681 static const struct extension_language_defn *active_ext_lang
682 = &extension_language_gdb;
683
684 /* Return the currently active extension language. */
685
686 const struct extension_language_defn *
687 get_active_ext_lang (void)
688 {
689 return active_ext_lang;
690 }
691
692 /* Install a SIGINT handler. */
693
694 static void
695 install_sigint_handler (const struct signal_handler *handler_state)
696 {
697 gdb_assert (handler_state->handler_saved);
698
699 signal (SIGINT, handler_state->handler);
700 }
701
702 /* Install GDB's SIGINT handler, storing the previous version in *PREVIOUS.
703 As a simple optimization, if the previous version was GDB's SIGINT handler
704 then mark the previous handler as not having been saved, and thus it won't
705 be restored. */
706
707 static void
708 install_gdb_sigint_handler (struct signal_handler *previous)
709 {
710 /* Save here to simplify comparison. */
711 sighandler_t handle_sigint_for_compare = handle_sigint;
712
713 previous->handler = signal (SIGINT, handle_sigint);
714 if (previous->handler != handle_sigint_for_compare)
715 previous->handler_saved = 1;
716 else
717 previous->handler_saved = 0;
718 }
719
720 /* Set the currently active extension language to NOW_ACTIVE.
721 The result is a pointer to a malloc'd block of memory to pass to
722 restore_active_ext_lang.
723
724 N.B. This function must be called every time we call out to an extension
725 language, and the result must be passed to restore_active_ext_lang
726 afterwards.
727
728 If there is a pending SIGINT it is "moved" to the now active extension
729 language, if it supports cooperative SIGINT handling (i.e., it provides
730 {clear,set,check}_quit_flag methods). If the extension language does not
731 support cooperative SIGINT handling, then the SIGINT is left queued and
732 we require the non-cooperative extension language to call check_quit_flag
733 at appropriate times.
734 It is important for the extension language to call check_quit_flag if it
735 installs its own SIGINT handler to prevent the situation where a SIGINT
736 is queued on entry, extension language code runs for a "long" time possibly
737 serving one or more SIGINTs, and then returns. Upon return, if
738 check_quit_flag is not called, the original SIGINT will be thrown.
739 Non-cooperative extension languages are free to install their own SIGINT
740 handler but the original must be restored upon return, either itself
741 or via restore_active_ext_lang. */
742
743 struct active_ext_lang_state *
744 set_active_ext_lang (const struct extension_language_defn *now_active)
745 {
746 struct active_ext_lang_state *previous
747 = XCNEW (struct active_ext_lang_state);
748
749 previous->ext_lang = active_ext_lang;
750 previous->sigint_handler.handler_saved = 0;
751 active_ext_lang = now_active;
752
753 if (target_terminal::is_ours ())
754 {
755 /* If the newly active extension language uses cooperative SIGINT
756 handling then ensure GDB's SIGINT handler is installed. */
757 if (now_active->language == EXT_LANG_GDB
758 || now_active->ops->check_quit_flag != NULL)
759 install_gdb_sigint_handler (&previous->sigint_handler);
760
761 /* If there's a SIGINT recorded in the cooperative extension languages,
762 move it to the new language, or save it in GDB's global flag if the
763 newly active extension language doesn't use cooperative SIGINT
764 handling. */
765 if (check_quit_flag ())
766 set_quit_flag ();
767 }
768
769 return previous;
770 }
771
772 /* Restore active extension language from PREVIOUS. */
773
774 void
775 restore_active_ext_lang (struct active_ext_lang_state *previous)
776 {
777 active_ext_lang = previous->ext_lang;
778
779 if (target_terminal::is_ours ())
780 {
781 /* Restore the previous SIGINT handler if one was saved. */
782 if (previous->sigint_handler.handler_saved)
783 install_sigint_handler (&previous->sigint_handler);
784
785 /* If there's a SIGINT recorded in the cooperative extension languages,
786 move it to the new language, or save it in GDB's global flag if the
787 newly active extension language doesn't use cooperative SIGINT
788 handling. */
789 if (check_quit_flag ())
790 set_quit_flag ();
791 }
792 xfree (previous);
793 }
794
795 /* Set the quit flag.
796 This only sets the flag in the currently active extension language.
797 If the currently active extension language does not have cooperative
798 SIGINT handling, then GDB's global flag is set, and it is up to the
799 extension language to call check_quit_flag. The extension language
800 is free to install its own SIGINT handler, but we still need to handle
801 the transition. */
802
803 void
804 set_quit_flag (void)
805 {
806 if (active_ext_lang->ops != NULL
807 && active_ext_lang->ops->set_quit_flag != NULL)
808 active_ext_lang->ops->set_quit_flag (active_ext_lang);
809 else
810 {
811 quit_flag = 1;
812
813 /* Now wake up the event loop, or any interruptible_select. Do
814 this after setting the flag, because signals on Windows
815 actually run on a separate thread, and thus otherwise the
816 main code could be woken up and find quit_flag still
817 clear. */
818 quit_serial_event_set ();
819 }
820 }
821
822 /* Return true if the quit flag has been set, false otherwise.
823 Note: The flag is cleared as a side-effect.
824 The flag is checked in all extension languages that support cooperative
825 SIGINT handling, not just the current one. This simplifies transitions. */
826
827 int
828 check_quit_flag (void)
829 {
830 int i, result = 0;
831 const struct extension_language_defn *extlang;
832
833 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
834 {
835 if (extlang->ops->check_quit_flag != NULL)
836 if (extlang->ops->check_quit_flag (extlang) != 0)
837 result = 1;
838 }
839
840 /* This is written in a particular way to avoid races. */
841 if (quit_flag)
842 {
843 /* No longer need to wake up the event loop or any
844 interruptible_select. The caller handles the quit
845 request. */
846 quit_serial_event_clear ();
847 quit_flag = 0;
848 result = 1;
849 }
850
851 return result;
852 }
853
854 /* xmethod support. */
855
856 /* The xmethod API routines do not have "ext_lang" in the name because
857 the name "xmethod" implies that this routine deals with extension
858 languages. Plus some of the methods take a xmethod_foo * "self/this"
859 arg, not an extension_language_defn * arg. */
860
861 /* Returns a new xmethod_worker with EXTLANG and DATA. Space for the
862 result must be freed with free_xmethod_worker. */
863
864 struct xmethod_worker *
865 new_xmethod_worker (const struct extension_language_defn *extlang, void *data)
866 {
867 struct xmethod_worker *worker = XCNEW (struct xmethod_worker);
868
869 worker->extlang = extlang;
870 worker->data = data;
871 worker->value = NULL;
872
873 return worker;
874 }
875
876 /* Clones WORKER and returns a new but identical worker.
877 The function get_matching_xmethod_workers (see below), returns a
878 vector of matching workers. If a particular worker is selected by GDB
879 to invoke a method, then this function can help in cloning the
880 selected worker and freeing up the vector via a cleanup.
881
882 Space for the result must be freed with free_xmethod_worker. */
883
884 struct xmethod_worker *
885 clone_xmethod_worker (struct xmethod_worker *worker)
886 {
887 struct xmethod_worker *new_worker;
888 const struct extension_language_defn *extlang = worker->extlang;
889
890 gdb_assert (extlang->ops->clone_xmethod_worker_data != NULL);
891
892 new_worker = new_xmethod_worker
893 (extlang,
894 extlang->ops->clone_xmethod_worker_data (extlang, worker->data));
895
896 return new_worker;
897 }
898
899 /* If a method with name METHOD_NAME is to be invoked on an object of type
900 TYPE, then all entension languages are searched for implementations of
901 methods with name METHOD. All matches found are returned as a vector
902 of 'xmethod_worker_ptr' objects. If no matching methods are
903 found, NULL is returned. */
904
905 VEC (xmethod_worker_ptr) *
906 get_matching_xmethod_workers (struct type *type, const char *method_name)
907 {
908 VEC (xmethod_worker_ptr) *workers = NULL;
909 int i;
910 const struct extension_language_defn *extlang;
911
912 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
913 {
914 VEC (xmethod_worker_ptr) *lang_workers, *new_vec;
915 enum ext_lang_rc rc;
916
917 /* If an extension language does not support xmethods, ignore
918 it. */
919 if (extlang->ops->get_matching_xmethod_workers == NULL)
920 continue;
921
922 rc = extlang->ops->get_matching_xmethod_workers (extlang,
923 type, method_name,
924 &lang_workers);
925 if (rc == EXT_LANG_RC_ERROR)
926 {
927 free_xmethod_worker_vec (workers);
928 error (_("Error while looking for matching xmethod workers "
929 "defined in %s."), extlang->capitalized_name);
930 }
931
932 new_vec = VEC_merge (xmethod_worker_ptr, workers, lang_workers);
933 /* Free only the vectors and not the elements as NEW_VEC still
934 contains them. */
935 VEC_free (xmethod_worker_ptr, workers);
936 VEC_free (xmethod_worker_ptr, lang_workers);
937 workers = new_vec;
938 }
939
940 return workers;
941 }
942
943 /* Return the arg types of the xmethod encapsulated in WORKER.
944 An array of arg types is returned. The length of the array is returned in
945 NARGS. The type of the 'this' object is returned as the first element of
946 array. */
947
948 struct type **
949 get_xmethod_arg_types (struct xmethod_worker *worker, int *nargs)
950 {
951 enum ext_lang_rc rc;
952 struct type **type_array = NULL;
953 const struct extension_language_defn *extlang = worker->extlang;
954
955 gdb_assert (extlang->ops->get_xmethod_arg_types != NULL);
956
957 rc = extlang->ops->get_xmethod_arg_types (extlang, worker, nargs,
958 &type_array);
959 if (rc == EXT_LANG_RC_ERROR)
960 {
961 error (_("Error while looking for arg types of a xmethod worker "
962 "defined in %s."), extlang->capitalized_name);
963 }
964
965 return type_array;
966 }
967
968 /* Return the type of the result of the xmethod encapsulated in WORKER.
969 OBJECT, ARGS, NARGS are the same as for invoke_xmethod. */
970
971 struct type *
972 get_xmethod_result_type (struct xmethod_worker *worker,
973 struct value *object, struct value **args, int nargs)
974 {
975 enum ext_lang_rc rc;
976 struct type *result_type;
977 const struct extension_language_defn *extlang = worker->extlang;
978
979 gdb_assert (extlang->ops->get_xmethod_arg_types != NULL);
980
981 rc = extlang->ops->get_xmethod_result_type (extlang, worker,
982 object, args, nargs,
983 &result_type);
984 if (rc == EXT_LANG_RC_ERROR)
985 {
986 error (_("Error while fetching result type of an xmethod worker "
987 "defined in %s."), extlang->capitalized_name);
988 }
989
990 return result_type;
991 }
992
993 /* Invokes the xmethod encapsulated in WORKER and returns the result.
994 The method is invoked on OBJ with arguments in the ARGS array. NARGS is
995 the length of the this array. */
996
997 struct value *
998 invoke_xmethod (struct xmethod_worker *worker, struct value *obj,
999 struct value **args, int nargs)
1000 {
1001 gdb_assert (worker->extlang->ops->invoke_xmethod != NULL);
1002
1003 return worker->extlang->ops->invoke_xmethod (worker->extlang, worker,
1004 obj, args, nargs);
1005 }
1006
1007 /* Frees the xmethod worker WORKER. */
1008
1009 void
1010 free_xmethod_worker (struct xmethod_worker *worker)
1011 {
1012 gdb_assert (worker->extlang->ops->free_xmethod_worker_data != NULL);
1013 worker->extlang->ops->free_xmethod_worker_data (worker->extlang,
1014 worker->data);
1015 xfree (worker);
1016 }
1017
1018 /* Frees a vector of xmethod_workers VEC. */
1019
1020 void
1021 free_xmethod_worker_vec (void *vec)
1022 {
1023 int i;
1024 struct xmethod_worker *worker;
1025 VEC (xmethod_worker_ptr) *v = (VEC (xmethod_worker_ptr) *) vec;
1026
1027 for (i = 0; VEC_iterate (xmethod_worker_ptr, v, i, worker); i++)
1028 free_xmethod_worker (worker);
1029
1030 VEC_free (xmethod_worker_ptr, v);
1031 }
1032
1033 /* Called via an observer before gdb prints its prompt.
1034 Iterate over the extension languages giving them a chance to
1035 change the prompt. The first one to change the prompt wins,
1036 and no further languages are tried. */
1037
1038 static void
1039 ext_lang_before_prompt (const char *current_gdb_prompt)
1040 {
1041 int i;
1042 const struct extension_language_defn *extlang;
1043
1044 ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang)
1045 {
1046 enum ext_lang_rc rc;
1047
1048 if (extlang->ops->before_prompt == NULL)
1049 continue;
1050 rc = extlang->ops->before_prompt (extlang, current_gdb_prompt);
1051 switch (rc)
1052 {
1053 case EXT_LANG_RC_OK:
1054 case EXT_LANG_RC_ERROR:
1055 return;
1056 case EXT_LANG_RC_NOP:
1057 break;
1058 default:
1059 gdb_assert_not_reached ("bad return from before_prompt");
1060 }
1061 }
1062 }
1063
1064 void
1065 _initialize_extension (void)
1066 {
1067 observer_attach_before_prompt (ext_lang_before_prompt);
1068 }
command_line
Definition: cli-script.h:51
check_quit_flag
int check_quit_flag(void)
Definition: extension.c:828
VEC_merge
#define VEC_merge(T, V1, V2)
Definition: vec.h:229
extension_languages
static const struct extension_language_defn *const extension_languages[]
Definition: extension.c:102
xmethod_worker
Definition: extension.h:151
extension_language_defn::capitalized_name
const char * capitalized_name
Definition: extension-priv.h:63
set_quit_flag
void set_quit_flag(void)
Definition: extension.c:804
observer_attach_before_prompt
struct observer * observer_attach_before_prompt(observer_before_prompt_ftype *f)
extension_language_script_ops::objfile_script_sourcer
objfile_script_sourcer_func * objfile_script_sourcer
Definition: extension-priv.h:106
install_gdb_sigint_handler
static void install_gdb_sigint_handler(struct signal_handler *previous)
Definition: extension.c:708
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
extension_language_gdb
const struct extension_language_defn extension_language_gdb
Definition: extension.c:69
ext_lang_bp_stop
ext_lang_bp_stop
Definition: extension.h:129
xfree
void xfree(void *)
restore_active_ext_lang
void restore_active_ext_lang(struct active_ext_lang_state *previous)
Definition: extension.c:775
xmethod_worker::extlang
const struct extension_language_defn * extlang
Definition: extension.h:154
finish_ext_lang_initialization
void finish_ext_lang_initialization(void)
Definition: extension.c:329
ext_lang_rc
ext_lang_rc
Definition: extension-priv.h:30
start_ext_lang_type_printers
struct ext_lang_type_printers * start_ext_lang_type_printers(void)
Definition: extension.c:409
extension_language_ops::eval_from_control_command
void(* eval_from_control_command)(const struct extension_language_defn *, struct command_line *)
Definition: extension-priv.h:146
invoke_xmethod
struct value * invoke_xmethod(struct xmethod_worker *worker, struct value *obj, struct value **args, int nargs)
Definition: extension.c:998
extension_language_ops::breakpoint_cond_says_stop
enum ext_lang_bp_stop(* breakpoint_cond_says_stop)(const struct extension_language_defn *, struct breakpoint *)
Definition: extension-priv.h:234
objfile_script_executor_func
void objfile_script_executor_func(const struct extension_language_defn *, struct objfile *, const char *name, const char *script)
Definition: extension.h:54
active_ext_lang
static const struct extension_language_defn * active_ext_lang
Definition: extension.c:682
frame_info
Definition: frame.c:85
extension_language_defn::suffix
const char * suffix
Definition: extension-priv.h:66
get_ext_lang_of_file
const struct extension_language_defn * get_ext_lang_of_file(const char *file)
Definition: extension.c:152
extension_language_defn::name
const char * name
Definition: extension-priv.h:59
ALL_EXTENSION_LANGUAGES
#define ALL_EXTENSION_LANGUAGES(i, extlang)
Definition: extension.c:40
extension_language_ops::before_prompt
enum ext_lang_rc(* before_prompt)(const struct extension_language_defn *, const char *current_gdb_prompt)
Definition: extension-priv.h:261
_
#define _(String)
Definition: gdb_locale.h:35
EXT_LANG_GDB
Definition: extension.h:62
ui_file
Definition: ui-file.h:26
ext_lang_name
const char * ext_lang_name(const struct extension_language_defn *extlang)
Definition: extension.c:227
extension_language_python
const struct extension_language_defn extension_language_python
Definition: python.c:68
defs.h
quit_flag
static int quit_flag
Definition: extension.c:674
signal_handler::handler_saved
int handler_saved
Definition: extension-priv.h:328
ext_lang_bt_status
ext_lang_bt_status
Definition: extension.h:69
extension_language_defn::ops
const struct extension_language_ops * ops
Definition: extension-priv.h:86
language_defn
Definition: language.h:132
observer.h
extension_language_defn::cli_control_type
enum command_control_type cli_control_type
Definition: extension-priv.h:76
flags
mach_port_t kern_return_t mach_port_t msgports mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition: gnu-nat.c:1891
auto_load_objfile_script
void auto_load_objfile_script(struct objfile *objfile, const struct extension_language_defn *language)
Definition: auto-load.c:879
extension_language_ops::get_xmethod_result_type
enum ext_lang_rc(* get_xmethod_result_type)(const struct extension_language_defn *extlang, struct xmethod_worker *worker, struct value *object, struct value **args, int nargs, struct type **result_type)
Definition: extension-priv.h:307
source_gdb_objfile_script
static objfile_script_sourcer_func source_gdb_objfile_script
Definition: extension.c:55
extension_language
extension_language
Definition: extension.h:59
extension_language_ops::apply_type_printers
enum ext_lang_rc(* apply_type_printers)(const struct extension_language_defn *, const struct ext_lang_type_printers *, struct type *, char **prettied_type)
Definition: extension-priv.h:166
VEC_iterate
#define VEC_iterate(T, V, I, P)
Definition: vec.h:181
extension_language_script_ops::script_sourcer
script_sourcer_func * script_sourcer
Definition: extension-priv.h:101
free_xmethod_worker
void free_xmethod_worker(struct xmethod_worker *worker)
Definition: extension.c:1010
signal_handler
Definition: extension-priv.h:325
value_print_options
Definition: valprint.h:25
extension_language_ops::clone_xmethod_worker_data
void *(* clone_xmethod_worker_data)(const struct extension_language_defn *extlang, void *data)
Definition: extension-priv.h:274
objfile_script_sourcer_func
void objfile_script_sourcer_func(const struct extension_language_defn *, struct objfile *, FILE *stream, const char *filename)
Definition: extension.h:48
ext_lang_script_sourcer
script_sourcer_func * ext_lang_script_sourcer(const struct extension_language_defn *extlang)
Definition: extension.c:263
eval_ext_lang_from_control_command
void eval_ext_lang_from_control_command(struct command_line *cmd)
Definition: extension.c:353
source_gdb_script
static script_sourcer_func source_gdb_script
Definition: extension.c:54
preserve_ext_lang_values
void preserve_ext_lang_values(struct objfile *objfile, htab_t copied_types)
Definition: extension.c:592
extension_language_ops::get_matching_xmethod_workers
enum ext_lang_rc(* get_matching_xmethod_workers)(const struct extension_language_defn *extlang, struct type *obj_type, const char *method_name, xmethod_worker_vec **dm_vec)
Definition: extension-priv.h:285
target_terminal::is_ours
static bool is_ours()
Definition: target.h:136
ext_lang_before_prompt
static void ext_lang_before_prompt(const char *current_gdb_prompt)
Definition: extension.c:1039
ext_lang_frame_args
ext_lang_frame_args
Definition: extension.h:108
gdb_assert_not_reached
#define gdb_assert_not_reached(message)
Definition: gdb_assert.h:55
get_active_ext_lang
const struct extension_language_defn * get_active_ext_lang(void)
Definition: extension.c:687
extension_language_defn::script_ops
const struct extension_language_script_ops * script_ops
Definition: extension-priv.h:80
extension_language_defn::language
enum extension_language language
Definition: extension-priv.h:56
breakpoint
Definition: breakpoint.h:684
cli-script.h
extension_language_ops::invoke_xmethod
struct value *(* invoke_xmethod)(const struct extension_language_defn *extlang, struct xmethod_worker *worker, struct value *object, struct value **args, int nargs)
Definition: extension-priv.h:316
get_xmethod_result_type
struct type * get_xmethod_result_type(struct xmethod_worker *worker, struct value *object, struct value **args, int nargs)
Definition: extension.c:972
type
Definition: gdbtypes.h:749
EXT_LANG_NONE
Definition: extension.h:61
script_sourcer_func
void script_sourcer_func(const struct extension_language_defn *, FILE *stream, const char *filename)
Definition: extension.h:41
free_ext_lang_type_printers
void free_ext_lang_type_printers(struct ext_lang_type_printers *printers)
Definition: extension.c:467
extension_language_ops::get_xmethod_arg_types
enum ext_lang_rc(* get_xmethod_arg_types)(const struct extension_language_defn *extlang, struct xmethod_worker *worker, int *nargs, struct type ***arg_types)
Definition: extension-priv.h:295
commands_control
Definition: cli-script.h:40
status
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
Definition: gnu-nat.c:1822
free_xmethod_worker_vec
void free_xmethod_worker_vec(void *vec)
Definition: extension.c:1021
new_xmethod_worker
struct xmethod_worker * new_xmethod_worker(const struct extension_language_defn *extlang, void *data)
Definition: extension.c:865
python.h
VEC
VEC(xmethod_worker_ptr)
Definition: extension.c:905
extension_language_ops::initialized
int(* initialized)(const struct extension_language_defn *)
Definition: extension-priv.h:139
active_ext_lang_state::sigint_handler
struct signal_handler sigint_handler
Definition: extension-priv.h:343
extension_language_ops::apply_val_pretty_printer
enum ext_lang_rc(* apply_val_pretty_printer)(const struct extension_language_defn *, struct type *type, LONGEST embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, struct value *val, const struct value_print_options *options, const struct language_defn *language)
Definition: extension-priv.h:183
breakpoint.h
extension_language_defn
Definition: extension-priv.h:53
extension_language_defn::auto_load_suffix
const char * auto_load_suffix
Definition: extension-priv.h:70
script_from_file
void script_from_file(FILE *stream, const char *file)
Definition: cli-script.c:1578
breakpoint_ext_lang_cond_says_stop
int breakpoint_ext_lang_cond_says_stop(struct breakpoint *b)
Definition: extension.c:635
extension_language_script_ops
Definition: extension-priv.h:96
extension_language_ops::free_xmethod_worker_data
void(* free_xmethod_worker_data)(const struct extension_language_defn *extlang, void *data)
Definition: extension-priv.h:278
extension.h
set_active_ext_lang
struct active_ext_lang_state * set_active_ext_lang(const struct extension_language_defn *now_active)
Definition: extension.c:744
get_ext_lang_defn
const struct extension_language_defn * get_ext_lang_defn(enum extension_language lang)
Definition: extension.c:116
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
active_ext_lang_state::ext_lang
const struct extension_language_defn * ext_lang
Definition: extension-priv.h:340
value
Definition: value.c:169
has_extension
static int has_extension(const char *file, const char *extension)
Definition: extension.c:138
ui_out
Definition: ui-out.h:77
extension_language_script_ops::objfile_script_executor
objfile_script_executor_func * objfile_script_executor
Definition: extension-priv.h:111
objfile
Definition: objfiles.h:286
ext_lang_type_printers
Definition: extension.h:143
event-top.h
extension_language_gdb_script_ops
static const struct extension_language_script_ops extension_language_gdb_script_ops
Definition: extension.c:61
extension_language_ops::check_quit_flag
int(* check_quit_flag)(const struct extension_language_defn *)
Definition: extension-priv.h:252
command_line::control_type
enum command_control_type control_type
Definition: cli-script.h:55
xmethod_worker::value
struct value * value
Definition: extension.h:161
get_breakpoint_cond_ext_lang
const struct extension_language_defn * get_breakpoint_cond_ext_lang(struct breakpoint *b, enum extension_language skip_lang)
Definition: extension.c:614
extension_language_ops::free_type_printers
void(* free_type_printers)(const struct extension_language_defn *, struct ext_lang_type_printers *)
Definition: extension-priv.h:172
get_matching_xmethod_workers
xmethod_worker_vec * get_matching_xmethod_workers(struct type *, const char *)
extension_language_ops::apply_frame_filter
enum ext_lang_bt_status(* apply_frame_filter)(const struct extension_language_defn *, struct frame_info *frame, int flags, enum ext_lang_frame_args args_type, struct ui_out *out, int frame_low, int frame_high)
Definition: extension-priv.h:205
guile.h
ext_lang_capitalized_name
const char * ext_lang_capitalized_name(const struct extension_language_defn *extlang)
Definition: extension.c:235
throw_ext_lang_unsupported
void throw_ext_lang_unsupported(const struct extension_language_defn *extlang)
Definition: extension.c:194
XCNEW
#define XCNEW(T)
Definition: poison.h:121
extension_language_ops::finish_initialization
void(* finish_initialization)(const struct extension_language_defn *)
Definition: extension-priv.h:135
apply_ext_lang_type_printers
char * apply_ext_lang_type_printers(struct ext_lang_type_printers *printers, struct type *type)
Definition: extension.c:431
quit_serial_event_clear
void quit_serial_event_clear(void)
Definition: event-top.c:933
ext_lang_suffix
const char * ext_lang_suffix(const struct extension_language_defn *extlang)
Definition: extension.c:243
apply_ext_lang_frame_filter
enum ext_lang_bt_status apply_ext_lang_frame_filter(struct frame_info *frame, int flags, enum ext_lang_frame_args args_type, struct ui_out *out, int frame_low, int frame_high)
Definition: extension.c:556
signal_handler::handler
sighandler_t handler
Definition: extension-priv.h:331
auto_load_gdb_scripts_enabled
int auto_load_gdb_scripts_enabled(const struct extension_language_defn *extlang)
Definition: auto-load.c:97
ext_lang_auto_load_suffix
const char * ext_lang_auto_load_suffix(const struct extension_language_defn *extlang)
Definition: extension.c:251
ALL_ENABLED_EXTENSION_LANGUAGES
#define ALL_ENABLED_EXTENSION_LANGUAGES(i, extlang)
Definition: extension.c:48
VEC_free
#define VEC_free(T, V)
Definition: vec.h:196
target.h
extension-priv.h
EXT_LANG_BP_STOP_UNSET
Definition: extension.h:132
auto-load.h
language
language
Definition: defs.h:203
_initialize_extension
void _initialize_extension(void)
Definition: extension.c:1065
extension_language_script_ops::auto_load_enabled
int(* auto_load_enabled)(const struct extension_language_defn *)
Definition: extension-priv.h:115
EXT_LANG_RC_NOP
Definition: extension-priv.h:36
xmethod_worker::data
void * data
Definition: extension.h:157
auto_load_ext_lang_scripts_for_objfile
void auto_load_ext_lang_scripts_for_objfile(struct objfile *objfile)
Definition: extension.c:383
handle_sigint
void handle_sigint(int sig)
Definition: event-top.c:967
get_xmethod_arg_types
struct type ** get_xmethod_arg_types(struct xmethod_worker *worker, int *nargs)
Definition: extension.c:949
ext_lang_auto_load_enabled
int ext_lang_auto_load_enabled(const struct extension_language_defn *extlang)
Definition: extension.c:310
install_sigint_handler
static void install_sigint_handler(const struct signal_handler *handler_state)
Definition: extension.c:695
ext_lang_objfile_script_executor
objfile_script_executor_func * ext_lang_objfile_script_executor(const struct extension_language_defn *extlang)
Definition: extension.c:298
EXT_LANG_RC_OK
Definition: extension-priv.h:33
quit_serial_event_set
void quit_serial_event_set(void)
Definition: event-top.c:925
EXT_LANG_BT_NO_FILTERS
Definition: extension.h:85
extension_language_ops::breakpoint_has_cond
int(* breakpoint_has_cond)(const struct extension_language_defn *, struct breakpoint *)
Definition: extension-priv.h:222
ext_lang_objfile_script_sourcer
objfile_script_sourcer_func * ext_lang_objfile_script_sourcer(const struct extension_language_defn *extlang)
Definition: extension.c:280
clone_xmethod_worker
struct xmethod_worker * clone_xmethod_worker(struct xmethod_worker *worker)
Definition: extension.c:885
extension_language_guile
const struct extension_language_defn extension_language_guile
active_ext_lang_state
Definition: extension-priv.h:337
extension_language_ops::start_type_printers
void(* start_type_printers)(const struct extension_language_defn *, struct ext_lang_type_printers *)
Definition: extension-priv.h:155
EXT_LANG_BP_STOP_NO
Definition: extension.h:135
extension_language_ops::set_quit_flag
void(* set_quit_flag)(const struct extension_language_defn *)
Definition: extension-priv.h:248
extension_language_ops::preserve_values
void(* preserve_values)(const struct extension_language_defn *, struct objfile *objfile, htab_t copied_types)
Definition: extension-priv.h:216
error
void error(const char *fmt,...)
Definition: errors.c:38
ext_lang_present_p
int ext_lang_present_p(const struct extension_language_defn *extlang)
Definition: extension.c:170
ext_lang_initialized_p
int ext_lang_initialized_p(const struct extension_language_defn *extlang)
Definition: extension.c:179
EXT_LANG_RC_ERROR
Definition: extension-priv.h:45
LONGEST
long long LONGEST
Definition: common-types.h:52
apply_ext_lang_val_pretty_printer
int apply_ext_lang_val_pretty_printer(struct type *type, LONGEST embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, struct value *val, const struct value_print_options *options, const struct language_defn *language)
Definition: extension.c:499