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 /* See language.h. */
382 if (expected_language
== current_language
)
385 expected_language
= current_language
;
386 printf_unfiltered (_("Current language: %s\n"), language
);
387 show_language_command (NULL
, 1, NULL
, NULL
);
391 /* Returns non-zero if the value is a pointer type. */
393 pointer_type (struct type
*type
)
395 return type
->code () == TYPE_CODE_PTR
|| TYPE_IS_REFERENCE (type
);
399 /* This page contains functions that return info about
400 (struct value) values used in GDB. */
402 /* Returns non-zero if the value VAL represents a true value. */
404 value_true (struct value
*val
)
406 /* It is possible that we should have some sort of error if a non-boolean
407 value is used in this context. Possibly dependent on some kind of
408 "boolean-checking" option like range checking. But it should probably
409 not depend on the language except insofar as is necessary to identify
410 a "boolean" value (i.e. in C using a float, pointer, etc., as a boolean
411 should be an error, probably). */
412 return !value_logical_not (val
);
415 /* This page contains functions for the printing out of
416 error messages that occur during type- and range-
419 /* This is called when a language fails a range-check. The
420 first argument should be a printf()-style format string, and the
421 rest of the arguments should be its arguments. If range_check is
422 range_check_on, an error is printed; if range_check_warn, a warning;
423 otherwise just the message. */
426 range_error (const char *string
,...)
430 va_start (args
, string
);
433 case range_check_warn
:
434 vwarning (string
, args
);
437 verror (string
, args
);
439 case range_check_off
:
440 /* FIXME: cagney/2002-01-30: Should this function print anything
441 when range error is off? */
442 vfprintf_filtered (gdb_stderr
, string
, args
);
443 fprintf_filtered (gdb_stderr
, "\n");
446 internal_error (__FILE__
, __LINE__
, _("bad switch"));
452 /* This page contains miscellaneous functions. */
454 /* Return the language enum for a given language string. */
457 language_enum (const char *str
)
459 for (const auto &lang
: language_defn::languages
)
460 if (strcmp (lang
->name (), str
) == 0)
461 return lang
->la_language
;
463 if (strcmp (str
, "local") == 0)
464 return language_auto
;
466 return language_unknown
;
469 /* Return the language struct for a given language enum. */
471 const struct language_defn
*
472 language_def (enum language lang
)
474 const struct language_defn
*l
= language_defn::languages
[lang
];
475 gdb_assert (l
!= nullptr);
479 /* Return the language as a string. */
482 language_str (enum language lang
)
484 return language_def (lang
)->name ();
489 /* Build and install the "set language LANG" command. */
492 add_set_language_command ()
494 static const char **language_names
;
496 /* Build the language names array, to be used as enumeration in the
497 "set language" enum command. +1 for "local" and +1 for NULL
499 language_names
= new const char *[ARRAY_SIZE (language_defn::languages
) + 2];
501 /* Display "auto", "local" and "unknown" first, and then the rest,
503 const char **language_names_p
= language_names
;
504 *language_names_p
++ = language_def (language_auto
)->name ();
505 *language_names_p
++ = "local";
506 *language_names_p
++ = language_def (language_unknown
)->name ();
507 const char **sort_begin
= language_names_p
;
508 for (const auto &lang
: language_defn::languages
)
510 /* Already handled above. */
511 if (lang
->la_language
== language_auto
512 || lang
->la_language
== language_unknown
)
514 *language_names_p
++ = lang
->name ();
516 *language_names_p
= NULL
;
517 std::sort (sort_begin
, language_names_p
, compare_cstrings
);
519 /* Add the filename extensions. */
520 for (const auto &lang
: language_defn::languages
)
521 for (const char * const &ext
: lang
->filename_extensions ())
522 add_filename_language (ext
, lang
->la_language
);
524 /* Build the "help set language" docs. */
527 doc
.printf (_("Set the current source language.\n"
528 "The currently understood settings are:\n\nlocal or "
529 "auto Automatic setting based on source file"));
531 for (const auto &lang
: language_defn::languages
)
533 /* Already dealt with these above. */
534 if (lang
->la_language
== language_unknown
535 || lang
->la_language
== language_auto
)
538 /* Note that we add the newline at the front, so we don't wind
539 up with a trailing newline. */
540 doc
.printf ("\n%-16s Use the %s language",
542 lang
->natural_name ());
545 add_setshow_enum_cmd ("language", class_support
,
549 _("Show the current source language."),
550 NULL
, set_language_command
,
551 show_language_command
,
552 &setlist
, &showlist
);
555 /* Iterate through all registered languages looking for and calling
556 any non-NULL struct language_defn.skip_trampoline() functions.
557 Return the result from the first that returns non-zero, or 0 if all
560 skip_language_trampoline (struct frame_info
*frame
, CORE_ADDR pc
)
562 for (const auto &lang
: language_defn::languages
)
564 CORE_ADDR real_pc
= lang
->skip_trampoline (frame
, pc
);
573 /* Return demangled language symbol, or NULL.
574 FIXME: Options are only useful for certain languages and ignored
575 by others, so it would be better to remove them here and have a
576 more flexible demangler for the languages that need it.
577 FIXME: Sometimes the demangler is invoked when we don't know the
578 language, so we can't use this everywhere. */
580 language_demangle (const struct language_defn
*current_language
,
581 const char *mangled
, int options
)
583 if (current_language
!= NULL
)
584 return current_language
->demangle_symbol (mangled
, options
);
588 /* Return information about whether TYPE should be passed
589 (and returned) by reference at the language level. */
591 struct language_pass_by_ref_info
592 language_pass_by_reference (struct type
*type
)
594 return current_language
->pass_by_reference_info (type
);
597 /* Return the default string containing the list of characters
598 delimiting words. This is a reasonable default value that
599 most languages should be able to use. */
602 default_word_break_characters (void)
604 return " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,-";
607 /* See language.h. */
610 language_defn::print_array_index (struct type
*index_type
, LONGEST index
,
611 struct ui_file
*stream
,
612 const value_print_options
*options
) const
614 struct value
*index_value
= value_from_longest (index_type
, index
);
616 fprintf_filtered (stream
, "[");
617 value_print (index_value
, stream
, options
);
618 fprintf_filtered (stream
, "] = ");
621 /* See language.h. */
623 gdb::unique_xmalloc_ptr
<char>
624 language_defn::watch_location_expression (struct type
*type
,
625 CORE_ADDR addr
) const
627 /* Generates an expression that assumes a C like syntax is valid. */
628 type
= check_typedef (TYPE_TARGET_TYPE (check_typedef (type
)));
629 std::string name
= type_to_string (type
);
630 return gdb::unique_xmalloc_ptr
<char>
631 (xstrprintf ("* (%s *) %s", name
.c_str (), core_addr_to_string (addr
)));
634 /* See language.h. */
637 language_defn::value_print (struct value
*val
, struct ui_file
*stream
,
638 const struct value_print_options
*options
) const
640 return c_value_print (val
, stream
, options
);
643 /* See language.h. */
646 language_defn::parser (struct parser_state
*ps
) const
651 /* See language.h. */
654 language_defn::value_print_inner
655 (struct value
*val
, struct ui_file
*stream
, int recurse
,
656 const struct value_print_options
*options
) const
658 return c_value_print_inner (val
, stream
, recurse
, options
);
661 /* See language.h. */
664 language_defn::emitchar (int ch
, struct type
*chtype
,
665 struct ui_file
* stream
, int quoter
) const
667 c_emit_char (ch
, chtype
, stream
, quoter
);
670 /* See language.h. */
673 language_defn::printstr (struct ui_file
*stream
, struct type
*elttype
,
674 const gdb_byte
*string
, unsigned int length
,
675 const char *encoding
, int force_ellipses
,
676 const struct value_print_options
*options
) const
678 c_printstr (stream
, elttype
, string
, length
, encoding
, force_ellipses
,
682 /* See language.h. */
685 language_defn::print_typedef (struct type
*type
, struct symbol
*new_symbol
,
686 struct ui_file
*stream
) const
688 c_print_typedef (type
, new_symbol
, stream
);
691 /* See language.h. */
694 language_defn::is_string_type_p (struct type
*type
) const
696 return c_is_string_type_p (type
);
699 /* See language.h. */
701 std::unique_ptr
<compile_instance
>
702 language_defn::get_compile_instance () const
707 /* The default implementation of the get_symbol_name_matcher_inner method
708 from the language_defn class. Matches with strncmp_iw. */
711 default_symbol_name_matcher (const char *symbol_search_name
,
712 const lookup_name_info
&lookup_name
,
713 completion_match_result
*comp_match_res
)
715 gdb::string_view name
= lookup_name
.name ();
716 completion_match_for_lcd
*match_for_lcd
717 = (comp_match_res
!= NULL
? &comp_match_res
->match_for_lcd
: NULL
);
718 strncmp_iw_mode mode
= (lookup_name
.completion_mode ()
719 ? strncmp_iw_mode::NORMAL
720 : strncmp_iw_mode::MATCH_PARAMS
);
722 if (strncmp_iw_with_mode (symbol_search_name
, name
.data (), name
.size (),
723 mode
, language_minimal
, match_for_lcd
) == 0)
725 if (comp_match_res
!= NULL
)
726 comp_match_res
->set_match (symbol_search_name
);
733 /* See language.h. */
735 symbol_name_matcher_ftype
*
736 language_defn::get_symbol_name_matcher
737 (const lookup_name_info
&lookup_name
) const
739 /* If currently in Ada mode, and the lookup name is wrapped in
740 '<...>', hijack all symbol name comparisons using the Ada
741 matcher, which handles the verbatim matching. */
742 if (current_language
->la_language
== language_ada
743 && lookup_name
.ada ().verbatim_p ())
744 return current_language
->get_symbol_name_matcher_inner (lookup_name
);
746 return this->get_symbol_name_matcher_inner (lookup_name
);
749 /* See language.h. */
751 symbol_name_matcher_ftype
*
752 language_defn::get_symbol_name_matcher_inner
753 (const lookup_name_info
&lookup_name
) const
755 return default_symbol_name_matcher
;
758 /* See language.h. */
760 const struct lang_varobj_ops
*
761 language_defn::varobj_ops () const
763 /* The ops for the C language are suitable for the vast majority of the
764 supported languages. */
765 return &c_varobj_ops
;
768 /* Parent class for both the "auto" and "unknown" languages. These two
769 pseudo-languages are very similar so merging their implementations like
772 class auto_or_unknown_language
: public language_defn
775 auto_or_unknown_language (enum language lang
)
776 : language_defn (lang
)
779 /* See language.h. */
780 void language_arch_info (struct gdbarch
*gdbarch
,
781 struct language_arch_info
*lai
) const override
783 lai
->set_string_char_type (builtin_type (gdbarch
)->builtin_char
);
784 lai
->set_bool_type (builtin_type (gdbarch
)->builtin_int
);
787 /* See language.h. */
789 void print_type (struct type
*type
, const char *varstring
,
790 struct ui_file
*stream
, int show
, int level
,
791 const struct type_print_options
*flags
) const override
793 error (_("type printing not implemented for language \"%s\""),
797 /* See language.h. */
799 char *demangle_symbol (const char *mangled
, int options
) const override
801 /* The auto language just uses the C++ demangler. */
802 return gdb_demangle (mangled
, options
);
805 /* See language.h. */
807 void value_print (struct value
*val
, struct ui_file
*stream
,
808 const struct value_print_options
*options
) const override
810 error (_("value printing not implemented for language \"%s\""),
814 /* See language.h. */
816 void value_print_inner
817 (struct value
*val
, struct ui_file
*stream
, int recurse
,
818 const struct value_print_options
*options
) const override
820 error (_("inner value printing not implemented for language \"%s\""),
824 /* See language.h. */
826 int parser (struct parser_state
*ps
) const override
828 /* No parsing is done, just claim success. */
832 /* See language.h. */
834 void emitchar (int ch
, struct type
*chtype
,
835 struct ui_file
*stream
, int quoter
) const override
837 error (_("emit character not implemented for language \"%s\""),
841 /* See language.h. */
843 void printchar (int ch
, struct type
*chtype
,
844 struct ui_file
*stream
) const override
846 error (_("print character not implemented for language \"%s\""),
850 /* See language.h. */
852 void printstr (struct ui_file
*stream
, struct type
*elttype
,
853 const gdb_byte
*string
, unsigned int length
,
854 const char *encoding
, int force_ellipses
,
855 const struct value_print_options
*options
) const override
857 error (_("print string not implemented for language \"%s\""),
861 /* See language.h. */
863 void print_typedef (struct type
*type
, struct symbol
*new_symbol
,
864 struct ui_file
*stream
) const override
866 error (_("print typedef not implemented for language \"%s\""),
870 /* See language.h. */
872 bool is_string_type_p (struct type
*type
) const override
874 type
= check_typedef (type
);
875 while (type
->code () == TYPE_CODE_REF
)
877 type
= TYPE_TARGET_TYPE (type
);
878 type
= check_typedef (type
);
880 return (type
->code () == TYPE_CODE_STRING
);
883 /* See language.h. */
885 const char *name_of_this () const override
889 /* Class representing the fake "auto" language. */
891 class auto_language
: public auto_or_unknown_language
895 : auto_or_unknown_language (language_auto
)
898 /* See language.h. */
900 const char *name () const override
903 /* See language.h. */
905 const char *natural_name () const override
909 /* Single instance of the fake "auto" language. */
911 static auto_language auto_language_defn
;
913 /* Class representing the unknown language. */
915 class unknown_language
: public auto_or_unknown_language
919 : auto_or_unknown_language (language_unknown
)
922 /* See language.h. */
924 const char *name () const override
925 { return "unknown"; }
927 /* See language.h. */
929 const char *natural_name () const override
930 { return "Unknown"; }
932 /* See language.h. */
934 bool store_sym_names_in_linkage_form_p () const override
938 /* Single instance of the unknown language class. */
940 static unknown_language unknown_language_defn
;
943 /* Per-architecture language information. */
945 static struct gdbarch_data
*language_gdbarch_data
;
947 struct language_gdbarch
949 /* A vector of per-language per-architecture info. Indexed by "enum
951 struct language_arch_info arch_info
[nr_languages
];
955 language_gdbarch_post_init (struct gdbarch
*gdbarch
)
957 struct language_gdbarch
*l
958 = obstack_new
<struct language_gdbarch
> (gdbarch_obstack (gdbarch
));
959 for (const auto &lang
: language_defn::languages
)
961 gdb_assert (lang
!= nullptr);
962 lang
->language_arch_info (gdbarch
, &l
->arch_info
[lang
->la_language
]);
968 /* See language.h. */
971 language_string_char_type (const struct language_defn
*la
,
972 struct gdbarch
*gdbarch
)
974 struct language_gdbarch
*ld
975 = (struct language_gdbarch
*) gdbarch_data (gdbarch
, language_gdbarch_data
);
976 return ld
->arch_info
[la
->la_language
].string_char_type ();
979 /* See language.h. */
982 language_bool_type (const struct language_defn
*la
,
983 struct gdbarch
*gdbarch
)
985 struct language_gdbarch
*ld
986 = (struct language_gdbarch
*) gdbarch_data (gdbarch
, language_gdbarch_data
);
987 return ld
->arch_info
[la
->la_language
].bool_type ();
990 /* See language.h. */
993 language_arch_info::bool_type () const
995 if (m_bool_type_name
!= nullptr)
999 sym
= lookup_symbol (m_bool_type_name
, NULL
, VAR_DOMAIN
, NULL
).symbol
;
1002 struct type
*type
= SYMBOL_TYPE (sym
);
1003 if (type
!= nullptr && type
->code () == TYPE_CODE_BOOL
)
1008 return m_bool_type_default
;
1011 /* See language.h. */
1014 language_arch_info::type_and_symbol::alloc_type_symbol
1015 (enum language lang
, struct type
*type
)
1017 struct symbol
*symbol
;
1018 struct gdbarch
*gdbarch
;
1019 gdb_assert (!type
->is_objfile_owned ());
1020 gdbarch
= type
->arch_owner ();
1021 symbol
= new (gdbarch_obstack (gdbarch
)) struct symbol ();
1022 symbol
->m_name
= type
->name ();
1023 symbol
->set_language (lang
, nullptr);
1024 symbol
->owner
.arch
= gdbarch
;
1025 SYMBOL_OBJFILE_OWNED (symbol
) = 0;
1026 symbol
->set_section_index (0);
1027 SYMBOL_TYPE (symbol
) = type
;
1028 SYMBOL_DOMAIN (symbol
) = VAR_DOMAIN
;
1029 SYMBOL_ACLASS_INDEX (symbol
) = LOC_TYPEDEF
;
1033 /* See language.h. */
1035 language_arch_info::type_and_symbol
*
1036 language_arch_info::lookup_primitive_type_and_symbol (const char *name
)
1038 for (struct type_and_symbol
&tas
: primitive_types_and_symbols
)
1040 if (strcmp (tas
.type ()->name (), name
) == 0)
1047 /* See language.h. */
1050 language_arch_info::lookup_primitive_type (const char *name
)
1052 type_and_symbol
*tas
= lookup_primitive_type_and_symbol (name
);
1054 return tas
->type ();
1058 /* See language.h. */
1061 language_arch_info::lookup_primitive_type
1062 (gdb::function_view
<bool (struct type
*)> filter
)
1064 for (struct type_and_symbol
&tas
: primitive_types_and_symbols
)
1066 if (filter (tas
.type ()))
1073 /* See language.h. */
1076 language_arch_info::lookup_primitive_type_as_symbol (const char *name
,
1079 type_and_symbol
*tas
= lookup_primitive_type_and_symbol (name
);
1081 return tas
->symbol (lang
);
1085 /* Helper for the language_lookup_primitive_type overloads to forward
1086 to the corresponding language's lookup_primitive_type overload. */
1088 template<typename T
>
1089 static struct type
*
1090 language_lookup_primitive_type_1 (const struct language_defn
*la
,
1091 struct gdbarch
*gdbarch
,
1094 struct language_gdbarch
*ld
=
1095 (struct language_gdbarch
*) gdbarch_data (gdbarch
, language_gdbarch_data
);
1096 return ld
->arch_info
[la
->la_language
].lookup_primitive_type (arg
);
1099 /* See language.h. */
1102 language_lookup_primitive_type (const struct language_defn
*la
,
1103 struct gdbarch
*gdbarch
,
1106 return language_lookup_primitive_type_1 (la
, gdbarch
, name
);
1109 /* See language.h. */
1112 language_lookup_primitive_type (const struct language_defn
*la
,
1113 struct gdbarch
*gdbarch
,
1114 gdb::function_view
<bool (struct type
*)> filter
)
1116 return language_lookup_primitive_type_1 (la
, gdbarch
, filter
);
1119 /* See language.h. */
1122 language_lookup_primitive_type_as_symbol (const struct language_defn
*la
,
1123 struct gdbarch
*gdbarch
,
1126 struct language_gdbarch
*ld
1127 = (struct language_gdbarch
*) gdbarch_data (gdbarch
, language_gdbarch_data
);
1128 struct language_arch_info
*lai
= &ld
->arch_info
[la
->la_language
];
1130 if (symbol_lookup_debug
)
1131 fprintf_unfiltered (gdb_stdlog
,
1132 "language_lookup_primitive_type_as_symbol"
1134 la
->name (), host_address_to_string (gdbarch
), name
);
1137 = lai
->lookup_primitive_type_as_symbol (name
, la
->la_language
);
1139 if (symbol_lookup_debug
)
1140 fprintf_unfiltered (gdb_stdlog
, " = %s\n", host_address_to_string (sym
));
1142 /* Note: The result of symbol lookup is normally a symbol *and* the block
1143 it was found in. Builtin types don't live in blocks. We *could* give
1144 them one, but there is no current need so to keep things simple symbol
1145 lookup is extended to allow for BLOCK_FOUND to be NULL. */
1150 /* Initialize the language routines. */
1152 void _initialize_language ();
1154 _initialize_language ()
1156 static const char *const type_or_range_names
[]
1157 = { "on", "off", "warn", "auto", NULL
};
1159 static const char *const case_sensitive_names
[]
1160 = { "on", "off", "auto", NULL
};
1162 language_gdbarch_data
1163 = gdbarch_data_register_post_init (language_gdbarch_post_init
);
1165 /* GDB commands for language specific stuff. */
1167 add_basic_prefix_cmd ("check", no_class
,
1168 _("Set the status of the type/range checker."),
1169 &setchecklist
, "set check ", 0, &setlist
);
1170 add_alias_cmd ("c", "check", no_class
, 1, &setlist
);
1171 add_alias_cmd ("ch", "check", no_class
, 1, &setlist
);
1173 add_show_prefix_cmd ("check", no_class
,
1174 _("Show the status of the type/range checker."),
1175 &showchecklist
, "show check ", 0, &showlist
);
1176 add_alias_cmd ("c", "check", no_class
, 1, &showlist
);
1177 add_alias_cmd ("ch", "check", no_class
, 1, &showlist
);
1179 add_setshow_enum_cmd ("range", class_support
, type_or_range_names
,
1181 _("Set range checking (on/warn/off/auto)."),
1182 _("Show range checking (on/warn/off/auto)."),
1183 NULL
, set_range_command
,
1185 &setchecklist
, &showchecklist
);
1187 add_setshow_enum_cmd ("case-sensitive", class_support
, case_sensitive_names
,
1188 &case_sensitive
, _("\
1189 Set case sensitivity in name search (on/off/auto)."), _("\
1190 Show case sensitivity in name search (on/off/auto)."), _("\
1191 For Fortran the default is off; for other languages the default is on."),
1194 &setlist
, &showlist
);
1196 /* In order to call SET_LANGUAGE (below) we need to make sure that
1197 CURRENT_LANGUAGE is not NULL. So first set the language to unknown,
1198 then we can change the language to 'auto'. */
1199 current_language
= language_def (language_unknown
);
1201 add_set_language_command ();
1205 case_sensitive
= "auto";
1207 /* Have the above take effect. */
1208 set_language (language_auto
);