1 /* Multiple source language support for GDB.
3 Copyright (C) 1991-2021 Free Software Foundation, Inc.
5 Contributed by the Department of Computer Science at the State University
6 of New York at Buffalo.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 /* This file contains functions that return things that are specific
24 to languages. Each function should examine current_language if necessary,
25 and return the appropriate result. */
27 /* FIXME: Most of these would be better organized as macros which
28 return data out of a "language-specific" struct pointer that is set
29 whenever the working language changes. That would be a lot faster. */
37 #include "expression.h"
41 #include "parser-defs.h"
44 #include "cp-support.h"
49 #include "compile/compile-internal.h"
51 static void set_range_case (void);
54 range_mode_auto: range_check set automatically to default of language.
55 range_mode_manual: range_check set manually by user. */
59 range_mode_auto
, range_mode_manual
63 case_mode_auto: case_sensitivity set upon selection of scope.
64 case_mode_manual: case_sensitivity set only by user. */
68 case_mode_auto
, case_mode_manual
71 /* The current (default at startup) state of type and range checking.
72 (If the modes are set to "auto", though, these are changed based
73 on the default language at startup, and then again based on the
74 language of the first source file. */
76 static enum range_mode range_mode
= range_mode_auto
;
77 enum range_check range_check
= range_check_off
;
78 static enum case_mode case_mode
= case_mode_auto
;
79 enum case_sensitivity case_sensitivity
= case_sensitive_on
;
81 /* The current language and language_mode (see language.h). */
83 const struct language_defn
*current_language
= nullptr;
84 enum language_mode language_mode
= language_mode_auto
;
86 /* The language that the user expects to be typing in (the language
87 of main(), or the last language we notified them about, or C). */
89 const struct language_defn
*expected_language
;
91 /* Define the array containing all languages. */
93 const struct language_defn
*language_defn::languages
[nr_languages
];
95 /* The current values of the "set language/range/case-sensitive" enum
97 static const char *language
;
98 static const char *range
;
99 static const char *case_sensitive
;
101 /* See language.h. */
102 const char lang_frame_mismatch_warn
[] =
103 N_("Warning: the current language does not match this frame.");
105 /* This page contains the functions corresponding to GDB commands
106 and their helpers. */
108 /* Show command. Display a warning if the language set
109 does not match the frame. */
111 show_language_command (struct ui_file
*file
, int from_tty
,
112 struct cmd_list_element
*c
, const char *value
)
114 enum language flang
; /* The language of the frame. */
116 if (language_mode
== language_mode_auto
)
117 fprintf_filtered (gdb_stdout
,
118 _("The current source language is "
119 "\"auto; currently %s\".\n"),
120 current_language
->name ());
122 fprintf_filtered (gdb_stdout
,
123 _("The current source language is \"%s\".\n"),
124 current_language
->name ());
126 if (has_stack_frames ())
128 struct frame_info
*frame
;
130 frame
= get_selected_frame (NULL
);
131 flang
= get_frame_language (frame
);
132 if (flang
!= language_unknown
133 && language_mode
== language_mode_manual
134 && current_language
->la_language
!= flang
)
135 printf_filtered ("%s\n", _(lang_frame_mismatch_warn
));
139 /* Set command. Change the current working language. */
141 set_language_command (const char *ignore
,
142 int from_tty
, struct cmd_list_element
*c
)
144 enum language flang
= language_unknown
;
146 /* "local" is a synonym of "auto". */
147 if (strcmp (language
, "local") == 0)
150 /* Search the list of languages for a match. */
151 for (const auto &lang
: language_defn::languages
)
153 if (strcmp (lang
->name (), language
) == 0)
155 /* Found it! Go into manual mode, and use this language. */
156 if (lang
->la_language
== language_auto
)
158 /* Enter auto mode. Set to the current frame's language, if
159 known, or fallback to the initial language. */
160 language_mode
= language_mode_auto
;
163 struct frame_info
*frame
;
165 frame
= get_selected_frame (NULL
);
166 flang
= get_frame_language (frame
);
168 catch (const gdb_exception_error
&ex
)
170 flang
= language_unknown
;
173 if (flang
!= language_unknown
)
174 set_language (flang
);
176 set_initial_language ();
177 expected_language
= current_language
;
182 /* Enter manual mode. Set the specified language. */
183 language_mode
= language_mode_manual
;
184 current_language
= lang
;
186 expected_language
= current_language
;
192 internal_error (__FILE__
, __LINE__
,
193 "Couldn't find language `%s' in known languages list.",
197 /* Show command. Display a warning if the range setting does
198 not match the current language. */
200 show_range_command (struct ui_file
*file
, int from_tty
,
201 struct cmd_list_element
*c
, const char *value
)
203 if (range_mode
== range_mode_auto
)
212 case range_check_off
:
215 case range_check_warn
:
219 internal_error (__FILE__
, __LINE__
,
220 "Unrecognized range check setting.");
223 fprintf_filtered (gdb_stdout
,
224 _("Range checking is \"auto; currently %s\".\n"),
228 fprintf_filtered (gdb_stdout
, _("Range checking is \"%s\".\n"),
231 if (range_check
== range_check_warn
232 || ((range_check
== range_check_on
)
233 != current_language
->range_checking_on_by_default ()))
234 warning (_("the current range check setting "
235 "does not match the language.\n"));
238 /* Set command. Change the setting for range checking. */
240 set_range_command (const char *ignore
,
241 int from_tty
, struct cmd_list_element
*c
)
243 if (strcmp (range
, "on") == 0)
245 range_check
= range_check_on
;
246 range_mode
= range_mode_manual
;
248 else if (strcmp (range
, "warn") == 0)
250 range_check
= range_check_warn
;
251 range_mode
= range_mode_manual
;
253 else if (strcmp (range
, "off") == 0)
255 range_check
= range_check_off
;
256 range_mode
= range_mode_manual
;
258 else if (strcmp (range
, "auto") == 0)
260 range_mode
= range_mode_auto
;
266 internal_error (__FILE__
, __LINE__
,
267 _("Unrecognized range check setting: \"%s\""), range
);
269 if (range_check
== range_check_warn
270 || ((range_check
== range_check_on
)
271 != current_language
->range_checking_on_by_default ()))
272 warning (_("the current range check setting "
273 "does not match the language.\n"));
276 /* Show command. Display a warning if the case sensitivity setting does
277 not match the current language. */
279 show_case_command (struct ui_file
*file
, int from_tty
,
280 struct cmd_list_element
*c
, const char *value
)
282 if (case_mode
== case_mode_auto
)
284 const char *tmp
= NULL
;
286 switch (case_sensitivity
)
288 case case_sensitive_on
:
291 case case_sensitive_off
:
295 internal_error (__FILE__
, __LINE__
,
296 "Unrecognized case-sensitive setting.");
299 fprintf_filtered (gdb_stdout
,
300 _("Case sensitivity in "
301 "name search is \"auto; currently %s\".\n"),
305 fprintf_filtered (gdb_stdout
,
306 _("Case sensitivity in name search is \"%s\".\n"),
309 if (case_sensitivity
!= current_language
->case_sensitivity ())
310 warning (_("the current case sensitivity setting does not match "
314 /* Set command. Change the setting for case sensitivity. */
317 set_case_command (const char *ignore
, int from_tty
, struct cmd_list_element
*c
)
319 if (strcmp (case_sensitive
, "on") == 0)
321 case_sensitivity
= case_sensitive_on
;
322 case_mode
= case_mode_manual
;
324 else if (strcmp (case_sensitive
, "off") == 0)
326 case_sensitivity
= case_sensitive_off
;
327 case_mode
= case_mode_manual
;
329 else if (strcmp (case_sensitive
, "auto") == 0)
331 case_mode
= case_mode_auto
;
337 internal_error (__FILE__
, __LINE__
,
338 "Unrecognized case-sensitive setting: \"%s\"",
342 if (case_sensitivity
!= current_language
->case_sensitivity ())
343 warning (_("the current case sensitivity setting does not match "
347 /* Set the status of range and type checking and case sensitivity based on
348 the current modes and the current language.
349 If SHOW is non-zero, then print out the current language,
350 type and range checking status. */
352 set_range_case (void)
354 if (range_mode
== range_mode_auto
)
355 range_check
= (current_language
->range_checking_on_by_default ()
356 ? range_check_on
: range_check_off
);
358 if (case_mode
== case_mode_auto
)
359 case_sensitivity
= current_language
->case_sensitivity ();
362 /* Set current language to (enum language) LANG. Returns previous
366 set_language (enum language lang
)
368 enum language prev_language
;
370 prev_language
= current_language
->la_language
;
371 current_language
= language_def (lang
);
373 return prev_language
;
377 /* Print out the current language settings: language, range and
378 type checking. If QUIETLY, print only what has changed. */
381 language_info (int quietly
)
383 if (quietly
&& expected_language
== current_language
)
386 expected_language
= current_language
;
387 printf_unfiltered (_("Current language: %s\n"), language
);
388 show_language_command (NULL
, 1, NULL
, NULL
);
392 printf_unfiltered (_("Range checking: %s\n"), range
);
393 show_range_command (NULL
, 1, NULL
, NULL
);
394 printf_unfiltered (_("Case sensitivity: %s\n"), case_sensitive
);
395 show_case_command (NULL
, 1, NULL
, NULL
);
400 /* Returns non-zero if the value is a pointer type. */
402 pointer_type (struct type
*type
)
404 return type
->code () == TYPE_CODE_PTR
|| TYPE_IS_REFERENCE (type
);
408 /* This page contains functions that return info about
409 (struct value) values used in GDB. */
411 /* Returns non-zero if the value VAL represents a true value. */
413 value_true (struct value
*val
)
415 /* It is possible that we should have some sort of error if a non-boolean
416 value is used in this context. Possibly dependent on some kind of
417 "boolean-checking" option like range checking. But it should probably
418 not depend on the language except insofar as is necessary to identify
419 a "boolean" value (i.e. in C using a float, pointer, etc., as a boolean
420 should be an error, probably). */
421 return !value_logical_not (val
);
424 /* This page contains functions for the printing out of
425 error messages that occur during type- and range-
428 /* This is called when a language fails a range-check. The
429 first argument should be a printf()-style format string, and the
430 rest of the arguments should be its arguments. If range_check is
431 range_check_on, an error is printed; if range_check_warn, a warning;
432 otherwise just the message. */
435 range_error (const char *string
,...)
439 va_start (args
, string
);
442 case range_check_warn
:
443 vwarning (string
, args
);
446 verror (string
, args
);
448 case range_check_off
:
449 /* FIXME: cagney/2002-01-30: Should this function print anything
450 when range error is off? */
451 vfprintf_filtered (gdb_stderr
, string
, args
);
452 fprintf_filtered (gdb_stderr
, "\n");
455 internal_error (__FILE__
, __LINE__
, _("bad switch"));
461 /* This page contains miscellaneous functions. */
463 /* Return the language enum for a given language string. */
466 language_enum (const char *str
)
468 for (const auto &lang
: language_defn::languages
)
469 if (strcmp (lang
->name (), str
) == 0)
470 return lang
->la_language
;
472 if (strcmp (str
, "local") == 0)
473 return language_auto
;
475 return language_unknown
;
478 /* Return the language struct for a given language enum. */
480 const struct language_defn
*
481 language_def (enum language lang
)
483 const struct language_defn
*l
= language_defn::languages
[lang
];
484 gdb_assert (l
!= nullptr);
488 /* Return the language as a string. */
491 language_str (enum language lang
)
493 return language_def (lang
)->name ();
498 /* Build and install the "set language LANG" command. */
501 add_set_language_command ()
503 static const char **language_names
;
505 /* Build the language names array, to be used as enumeration in the
506 "set language" enum command. +1 for "local" and +1 for NULL
508 language_names
= new const char *[ARRAY_SIZE (language_defn::languages
) + 2];
510 /* Display "auto", "local" and "unknown" first, and then the rest,
512 const char **language_names_p
= language_names
;
513 *language_names_p
++ = language_def (language_auto
)->name ();
514 *language_names_p
++ = "local";
515 *language_names_p
++ = language_def (language_unknown
)->name ();
516 const char **sort_begin
= language_names_p
;
517 for (const auto &lang
: language_defn::languages
)
519 /* Already handled above. */
520 if (lang
->la_language
== language_auto
521 || lang
->la_language
== language_unknown
)
523 *language_names_p
++ = lang
->name ();
525 *language_names_p
= NULL
;
526 std::sort (sort_begin
, language_names_p
, compare_cstrings
);
528 /* Add the filename extensions. */
529 for (const auto &lang
: language_defn::languages
)
530 for (const char * const &ext
: lang
->filename_extensions ())
531 add_filename_language (ext
, lang
->la_language
);
533 /* Build the "help set language" docs. */
536 doc
.printf (_("Set the current source language.\n"
537 "The currently understood settings are:\n\nlocal or "
538 "auto Automatic setting based on source file"));
540 for (const auto &lang
: language_defn::languages
)
542 /* Already dealt with these above. */
543 if (lang
->la_language
== language_unknown
544 || lang
->la_language
== language_auto
)
547 /* Note that we add the newline at the front, so we don't wind
548 up with a trailing newline. */
549 doc
.printf ("\n%-16s Use the %s language",
551 lang
->natural_name ());
554 add_setshow_enum_cmd ("language", class_support
,
558 _("Show the current source language."),
559 NULL
, set_language_command
,
560 show_language_command
,
561 &setlist
, &showlist
);
564 /* Iterate through all registered languages looking for and calling
565 any non-NULL struct language_defn.skip_trampoline() functions.
566 Return the result from the first that returns non-zero, or 0 if all
569 skip_language_trampoline (struct frame_info
*frame
, CORE_ADDR pc
)
571 for (const auto &lang
: language_defn::languages
)
573 CORE_ADDR real_pc
= lang
->skip_trampoline (frame
, pc
);
582 /* Return demangled language symbol, or NULL.
583 FIXME: Options are only useful for certain languages and ignored
584 by others, so it would be better to remove them here and have a
585 more flexible demangler for the languages that need it.
586 FIXME: Sometimes the demangler is invoked when we don't know the
587 language, so we can't use this everywhere. */
589 language_demangle (const struct language_defn
*current_language
,
590 const char *mangled
, int options
)
592 if (current_language
!= NULL
)
593 return current_language
->demangle_symbol (mangled
, options
);
597 /* Return information about whether TYPE should be passed
598 (and returned) by reference at the language level. */
600 struct language_pass_by_ref_info
601 language_pass_by_reference (struct type
*type
)
603 return current_language
->pass_by_reference_info (type
);
606 /* Return the default string containing the list of characters
607 delimiting words. This is a reasonable default value that
608 most languages should be able to use. */
611 default_word_break_characters (void)
613 return " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,-";
616 /* See language.h. */
619 language_defn::print_array_index (struct type
*index_type
, LONGEST index
,
620 struct ui_file
*stream
,
621 const value_print_options
*options
) const
623 struct value
*index_value
= value_from_longest (index_type
, index
);
625 fprintf_filtered (stream
, "[");
626 value_print (index_value
, stream
, options
);
627 fprintf_filtered (stream
, "] = ");
630 /* See language.h. */
632 gdb::unique_xmalloc_ptr
<char>
633 language_defn::watch_location_expression (struct type
*type
,
634 CORE_ADDR addr
) const
636 /* Generates an expression that assumes a C like syntax is valid. */
637 type
= check_typedef (TYPE_TARGET_TYPE (check_typedef (type
)));
638 std::string name
= type_to_string (type
);
639 return gdb::unique_xmalloc_ptr
<char>
640 (xstrprintf ("* (%s *) %s", name
.c_str (), core_addr_to_string (addr
)));
643 /* See language.h. */
646 language_defn::value_print (struct value
*val
, struct ui_file
*stream
,
647 const struct value_print_options
*options
) const
649 return c_value_print (val
, stream
, options
);
652 /* See language.h. */
655 language_defn::parser (struct parser_state
*ps
) const
660 /* See language.h. */
663 language_defn::value_print_inner
664 (struct value
*val
, struct ui_file
*stream
, int recurse
,
665 const struct value_print_options
*options
) const
667 return c_value_print_inner (val
, stream
, recurse
, options
);
670 /* See language.h. */
673 language_defn::emitchar (int ch
, struct type
*chtype
,
674 struct ui_file
* stream
, int quoter
) const
676 c_emit_char (ch
, chtype
, stream
, quoter
);
679 /* See language.h. */
682 language_defn::printstr (struct ui_file
*stream
, struct type
*elttype
,
683 const gdb_byte
*string
, unsigned int length
,
684 const char *encoding
, int force_ellipses
,
685 const struct value_print_options
*options
) const
687 c_printstr (stream
, elttype
, string
, length
, encoding
, force_ellipses
,
691 /* See language.h. */
694 language_defn::print_typedef (struct type
*type
, struct symbol
*new_symbol
,
695 struct ui_file
*stream
) const
697 c_print_typedef (type
, new_symbol
, stream
);
700 /* See language.h. */
703 language_defn::is_string_type_p (struct type
*type
) const
705 return c_is_string_type_p (type
);
708 /* See language.h. */
710 std::unique_ptr
<compile_instance
>
711 language_defn::get_compile_instance () const
716 /* The default implementation of the get_symbol_name_matcher_inner method
717 from the language_defn class. Matches with strncmp_iw. */
720 default_symbol_name_matcher (const char *symbol_search_name
,
721 const lookup_name_info
&lookup_name
,
722 completion_match_result
*comp_match_res
)
724 gdb::string_view name
= lookup_name
.name ();
725 completion_match_for_lcd
*match_for_lcd
726 = (comp_match_res
!= NULL
? &comp_match_res
->match_for_lcd
: NULL
);
727 strncmp_iw_mode mode
= (lookup_name
.completion_mode ()
728 ? strncmp_iw_mode::NORMAL
729 : strncmp_iw_mode::MATCH_PARAMS
);
731 if (strncmp_iw_with_mode (symbol_search_name
, name
.data (), name
.size (),
732 mode
, language_minimal
, match_for_lcd
) == 0)
734 if (comp_match_res
!= NULL
)
735 comp_match_res
->set_match (symbol_search_name
);
742 /* See language.h. */
744 symbol_name_matcher_ftype
*
745 language_defn::get_symbol_name_matcher
746 (const lookup_name_info
&lookup_name
) const
748 /* If currently in Ada mode, and the lookup name is wrapped in
749 '<...>', hijack all symbol name comparisons using the Ada
750 matcher, which handles the verbatim matching. */
751 if (current_language
->la_language
== language_ada
752 && lookup_name
.ada ().verbatim_p ())
753 return current_language
->get_symbol_name_matcher_inner (lookup_name
);
755 return this->get_symbol_name_matcher_inner (lookup_name
);
758 /* See language.h. */
760 symbol_name_matcher_ftype
*
761 language_defn::get_symbol_name_matcher_inner
762 (const lookup_name_info
&lookup_name
) const
764 return default_symbol_name_matcher
;
767 /* See language.h. */
769 const struct lang_varobj_ops
*
770 language_defn::varobj_ops () const
772 /* The ops for the C language are suitable for the vast majority of the
773 supported languages. */
774 return &c_varobj_ops
;
777 /* Parent class for both the "auto" and "unknown" languages. These two
778 pseudo-languages are very similar so merging their implementations like
781 class auto_or_unknown_language
: public language_defn
784 auto_or_unknown_language (enum language lang
)
785 : language_defn (lang
)
788 /* See language.h. */
789 void language_arch_info (struct gdbarch
*gdbarch
,
790 struct language_arch_info
*lai
) const override
792 lai
->set_string_char_type (builtin_type (gdbarch
)->builtin_char
);
793 lai
->set_bool_type (builtin_type (gdbarch
)->builtin_int
);
796 /* See language.h. */
798 void print_type (struct type
*type
, const char *varstring
,
799 struct ui_file
*stream
, int show
, int level
,
800 const struct type_print_options
*flags
) const override
802 error (_("type printing not implemented for language \"%s\""),
806 /* See language.h. */
808 char *demangle_symbol (const char *mangled
, int options
) const override
810 /* The auto language just uses the C++ demangler. */
811 return gdb_demangle (mangled
, options
);
814 /* See language.h. */
816 void value_print (struct value
*val
, struct ui_file
*stream
,
817 const struct value_print_options
*options
) const override
819 error (_("value printing not implemented for language \"%s\""),
823 /* See language.h. */
825 void value_print_inner
826 (struct value
*val
, struct ui_file
*stream
, int recurse
,
827 const struct value_print_options
*options
) const override
829 error (_("inner value printing not implemented for language \"%s\""),
833 /* See language.h. */
835 int parser (struct parser_state
*ps
) const override
837 /* No parsing is done, just claim success. */
841 /* See language.h. */
843 void emitchar (int ch
, struct type
*chtype
,
844 struct ui_file
*stream
, int quoter
) const override
846 error (_("emit character not implemented for language \"%s\""),
850 /* See language.h. */
852 void printchar (int ch
, struct type
*chtype
,
853 struct ui_file
*stream
) const override
855 error (_("print character not implemented for language \"%s\""),
859 /* See language.h. */
861 void printstr (struct ui_file
*stream
, struct type
*elttype
,
862 const gdb_byte
*string
, unsigned int length
,
863 const char *encoding
, int force_ellipses
,
864 const struct value_print_options
*options
) const override
866 error (_("print string not implemented for language \"%s\""),
870 /* See language.h. */
872 void print_typedef (struct type
*type
, struct symbol
*new_symbol
,
873 struct ui_file
*stream
) const override
875 error (_("print typedef not implemented for language \"%s\""),
879 /* See language.h. */
881 bool is_string_type_p (struct type
*type
) const override
883 type
= check_typedef (type
);
884 while (type
->code () == TYPE_CODE_REF
)
886 type
= TYPE_TARGET_TYPE (type
);
887 type
= check_typedef (type
);
889 return (type
->code () == TYPE_CODE_STRING
);
892 /* See language.h. */
894 const char *name_of_this () const override
898 /* Class representing the fake "auto" language. */
900 class auto_language
: public auto_or_unknown_language
904 : auto_or_unknown_language (language_auto
)
907 /* See language.h. */
909 const char *name () const override
912 /* See language.h. */
914 const char *natural_name () const override
918 /* Single instance of the fake "auto" language. */
920 static auto_language auto_language_defn
;
922 /* Class representing the unknown language. */
924 class unknown_language
: public auto_or_unknown_language
928 : auto_or_unknown_language (language_unknown
)
931 /* See language.h. */
933 const char *name () const override
934 { return "unknown"; }
936 /* See language.h. */
938 const char *natural_name () const override
939 { return "Unknown"; }
941 /* See language.h. */
943 bool store_sym_names_in_linkage_form_p () const override
947 /* Single instance of the unknown language class. */
949 static unknown_language unknown_language_defn
;
952 /* Per-architecture language information. */
954 static struct gdbarch_data
*language_gdbarch_data
;
956 struct language_gdbarch
958 /* A vector of per-language per-architecture info. Indexed by "enum
960 struct language_arch_info arch_info
[nr_languages
];
964 language_gdbarch_post_init (struct gdbarch
*gdbarch
)
966 struct language_gdbarch
*l
967 = obstack_new
<struct language_gdbarch
> (gdbarch_obstack (gdbarch
));
968 for (const auto &lang
: language_defn::languages
)
970 gdb_assert (lang
!= nullptr);
971 lang
->language_arch_info (gdbarch
, &l
->arch_info
[lang
->la_language
]);
977 /* See language.h. */
980 language_string_char_type (const struct language_defn
*la
,
981 struct gdbarch
*gdbarch
)
983 struct language_gdbarch
*ld
984 = (struct language_gdbarch
*) gdbarch_data (gdbarch
, language_gdbarch_data
);
985 return ld
->arch_info
[la
->la_language
].string_char_type ();
988 /* See language.h. */
991 language_bool_type (const struct language_defn
*la
,
992 struct gdbarch
*gdbarch
)
994 struct language_gdbarch
*ld
995 = (struct language_gdbarch
*) gdbarch_data (gdbarch
, language_gdbarch_data
);
996 return ld
->arch_info
[la
->la_language
].bool_type ();
999 /* See language.h. */
1002 language_arch_info::bool_type () const
1004 if (m_bool_type_name
!= nullptr)
1008 sym
= lookup_symbol (m_bool_type_name
, NULL
, VAR_DOMAIN
, NULL
).symbol
;
1011 struct type
*type
= SYMBOL_TYPE (sym
);
1012 if (type
!= nullptr && type
->code () == TYPE_CODE_BOOL
)
1017 return m_bool_type_default
;
1020 /* See language.h. */
1023 language_arch_info::type_and_symbol::alloc_type_symbol
1024 (enum language lang
, struct type
*type
)
1026 struct symbol
*symbol
;
1027 struct gdbarch
*gdbarch
;
1028 gdb_assert (!type
->is_objfile_owned ());
1029 gdbarch
= type
->arch_owner ();
1030 symbol
= new (gdbarch_obstack (gdbarch
)) struct symbol ();
1031 symbol
->m_name
= type
->name ();
1032 symbol
->set_language (lang
, nullptr);
1033 symbol
->owner
.arch
= gdbarch
;
1034 SYMBOL_OBJFILE_OWNED (symbol
) = 0;
1035 symbol
->set_section_index (0);
1036 SYMBOL_TYPE (symbol
) = type
;
1037 SYMBOL_DOMAIN (symbol
) = VAR_DOMAIN
;
1038 SYMBOL_ACLASS_INDEX (symbol
) = LOC_TYPEDEF
;
1042 /* See language.h. */
1044 language_arch_info::type_and_symbol
*
1045 language_arch_info::lookup_primitive_type_and_symbol (const char *name
)
1047 for (struct type_and_symbol
&tas
: primitive_types_and_symbols
)
1049 if (strcmp (tas
.type ()->name (), name
) == 0)
1056 /* See language.h. */
1059 language_arch_info::lookup_primitive_type (const char *name
)
1061 type_and_symbol
*tas
= lookup_primitive_type_and_symbol (name
);
1063 return tas
->type ();
1067 /* See language.h. */
1070 language_arch_info::lookup_primitive_type
1071 (gdb::function_view
<bool (struct type
*)> filter
)
1073 for (struct type_and_symbol
&tas
: primitive_types_and_symbols
)
1075 if (filter (tas
.type ()))
1082 /* See language.h. */
1085 language_arch_info::lookup_primitive_type_as_symbol (const char *name
,
1088 type_and_symbol
*tas
= lookup_primitive_type_and_symbol (name
);
1090 return tas
->symbol (lang
);
1094 /* Helper for the language_lookup_primitive_type overloads to forward
1095 to the corresponding language's lookup_primitive_type overload. */
1097 template<typename T
>
1098 static struct type
*
1099 language_lookup_primitive_type_1 (const struct language_defn
*la
,
1100 struct gdbarch
*gdbarch
,
1103 struct language_gdbarch
*ld
=
1104 (struct language_gdbarch
*) gdbarch_data (gdbarch
, language_gdbarch_data
);
1105 return ld
->arch_info
[la
->la_language
].lookup_primitive_type (arg
);
1108 /* See language.h. */
1111 language_lookup_primitive_type (const struct language_defn
*la
,
1112 struct gdbarch
*gdbarch
,
1115 return language_lookup_primitive_type_1 (la
, gdbarch
, name
);
1118 /* See language.h. */
1121 language_lookup_primitive_type (const struct language_defn
*la
,
1122 struct gdbarch
*gdbarch
,
1123 gdb::function_view
<bool (struct type
*)> filter
)
1125 return language_lookup_primitive_type_1 (la
, gdbarch
, filter
);
1128 /* See language.h. */
1131 language_lookup_primitive_type_as_symbol (const struct language_defn
*la
,
1132 struct gdbarch
*gdbarch
,
1135 struct language_gdbarch
*ld
1136 = (struct language_gdbarch
*) gdbarch_data (gdbarch
, language_gdbarch_data
);
1137 struct language_arch_info
*lai
= &ld
->arch_info
[la
->la_language
];
1139 if (symbol_lookup_debug
)
1140 fprintf_unfiltered (gdb_stdlog
,
1141 "language_lookup_primitive_type_as_symbol"
1143 la
->name (), host_address_to_string (gdbarch
), name
);
1146 = lai
->lookup_primitive_type_as_symbol (name
, la
->la_language
);
1148 if (symbol_lookup_debug
)
1149 fprintf_unfiltered (gdb_stdlog
, " = %s\n", host_address_to_string (sym
));
1151 /* Note: The result of symbol lookup is normally a symbol *and* the block
1152 it was found in. Builtin types don't live in blocks. We *could* give
1153 them one, but there is no current need so to keep things simple symbol
1154 lookup is extended to allow for BLOCK_FOUND to be NULL. */
1159 /* Initialize the language routines. */
1161 void _initialize_language ();
1163 _initialize_language ()
1165 static const char *const type_or_range_names
[]
1166 = { "on", "off", "warn", "auto", NULL
};
1168 static const char *const case_sensitive_names
[]
1169 = { "on", "off", "auto", NULL
};
1171 language_gdbarch_data
1172 = gdbarch_data_register_post_init (language_gdbarch_post_init
);
1174 /* GDB commands for language specific stuff. */
1176 add_basic_prefix_cmd ("check", no_class
,
1177 _("Set the status of the type/range checker."),
1178 &setchecklist
, "set check ", 0, &setlist
);
1179 add_alias_cmd ("c", "check", no_class
, 1, &setlist
);
1180 add_alias_cmd ("ch", "check", no_class
, 1, &setlist
);
1182 add_show_prefix_cmd ("check", no_class
,
1183 _("Show the status of the type/range checker."),
1184 &showchecklist
, "show check ", 0, &showlist
);
1185 add_alias_cmd ("c", "check", no_class
, 1, &showlist
);
1186 add_alias_cmd ("ch", "check", no_class
, 1, &showlist
);
1188 add_setshow_enum_cmd ("range", class_support
, type_or_range_names
,
1190 _("Set range checking (on/warn/off/auto)."),
1191 _("Show range checking (on/warn/off/auto)."),
1192 NULL
, set_range_command
,
1194 &setchecklist
, &showchecklist
);
1196 add_setshow_enum_cmd ("case-sensitive", class_support
, case_sensitive_names
,
1197 &case_sensitive
, _("\
1198 Set case sensitivity in name search (on/off/auto)."), _("\
1199 Show case sensitivity in name search (on/off/auto)."), _("\
1200 For Fortran the default is off; for other languages the default is on."),
1203 &setlist
, &showlist
);
1205 /* In order to call SET_LANGUAGE (below) we need to make sure that
1206 CURRENT_LANGUAGE is not NULL. So first set the language to unknown,
1207 then we can change the language to 'auto'. */
1208 current_language
= language_def (language_unknown
);
1210 add_set_language_command ();
1214 case_sensitive
= "auto";
1216 /* Have the above take effect. */
1217 set_language (language_auto
);