1 /* Multiple source language support for GDB.
3 Copyright (C) 1991-2020 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"
50 static int unk_lang_parser (struct parser_state
*);
52 static void set_range_case (void);
54 static void unk_lang_emit_char (int c
, struct type
*type
,
55 struct ui_file
*stream
, int quoter
);
57 static void unk_lang_printchar (int c
, struct type
*type
,
58 struct ui_file
*stream
);
60 static void unk_lang_value_print (struct value
*, struct ui_file
*,
61 const struct value_print_options
*);
63 static CORE_ADDR
unk_lang_trampoline (struct frame_info
*, CORE_ADDR pc
);
65 /* Forward declaration */
66 extern const struct language_defn unknown_language_defn
;
68 /* The current (default at startup) state of type and range checking.
69 (If the modes are set to "auto", though, these are changed based
70 on the default language at startup, and then again based on the
71 language of the first source file. */
73 enum range_mode range_mode
= range_mode_auto
;
74 enum range_check range_check
= range_check_off
;
75 enum case_mode case_mode
= case_mode_auto
;
76 enum case_sensitivity case_sensitivity
= case_sensitive_on
;
78 /* The current language and language_mode (see language.h). */
80 const struct language_defn
*current_language
= &unknown_language_defn
;
81 enum language_mode language_mode
= language_mode_auto
;
83 /* The language that the user expects to be typing in (the language
84 of main(), or the last language we notified them about, or C). */
86 const struct language_defn
*expected_language
;
88 /* The list of supported languages. Keep this in the same order as
89 the 'enum language' values. */
91 static const struct language_defn
*languages
[] = {
92 &unknown_language_defn
,
102 &pascal_language_defn
,
103 &opencl_language_defn
,
105 &minimal_language_defn
,
109 /* The current values of the "set language/range/case-sensitive" enum
111 static const char *language
;
112 static const char *range
;
113 static const char *case_sensitive
;
115 /* See language.h. */
116 const char lang_frame_mismatch_warn
[] =
117 N_("Warning: the current language does not match this frame.");
119 /* This page contains the functions corresponding to GDB commands
120 and their helpers. */
122 /* Show command. Display a warning if the language set
123 does not match the frame. */
125 show_language_command (struct ui_file
*file
, int from_tty
,
126 struct cmd_list_element
*c
, const char *value
)
128 enum language flang
; /* The language of the frame. */
130 if (language_mode
== language_mode_auto
)
131 fprintf_filtered (gdb_stdout
,
132 _("The current source language is "
133 "\"auto; currently %s\".\n"),
134 current_language
->la_name
);
136 fprintf_filtered (gdb_stdout
,
137 _("The current source language is \"%s\".\n"),
138 current_language
->la_name
);
140 if (has_stack_frames ())
142 struct frame_info
*frame
;
144 frame
= get_selected_frame (NULL
);
145 flang
= get_frame_language (frame
);
146 if (flang
!= language_unknown
147 && language_mode
== language_mode_manual
148 && current_language
->la_language
!= flang
)
149 printf_filtered ("%s\n", _(lang_frame_mismatch_warn
));
153 /* Set command. Change the current working language. */
155 set_language_command (const char *ignore
,
156 int from_tty
, struct cmd_list_element
*c
)
158 enum language flang
= language_unknown
;
160 /* "local" is a synonym of "auto". */
161 if (strcmp (language
, "local") == 0)
164 /* Search the list of languages for a match. */
165 for (const auto &lang
: languages
)
167 if (strcmp (lang
->la_name
, language
) == 0)
169 /* Found it! Go into manual mode, and use this language. */
170 if (lang
->la_language
== language_auto
)
172 /* Enter auto mode. Set to the current frame's language, if
173 known, or fallback to the initial language. */
174 language_mode
= language_mode_auto
;
177 struct frame_info
*frame
;
179 frame
= get_selected_frame (NULL
);
180 flang
= get_frame_language (frame
);
182 catch (const gdb_exception_error
&ex
)
184 flang
= language_unknown
;
187 if (flang
!= language_unknown
)
188 set_language (flang
);
190 set_initial_language ();
191 expected_language
= current_language
;
196 /* Enter manual mode. Set the specified language. */
197 language_mode
= language_mode_manual
;
198 current_language
= lang
;
200 expected_language
= current_language
;
206 internal_error (__FILE__
, __LINE__
,
207 "Couldn't find language `%s' in known languages list.",
211 /* Show command. Display a warning if the range setting does
212 not match the current language. */
214 show_range_command (struct ui_file
*file
, int from_tty
,
215 struct cmd_list_element
*c
, const char *value
)
217 if (range_mode
== range_mode_auto
)
226 case range_check_off
:
229 case range_check_warn
:
233 internal_error (__FILE__
, __LINE__
,
234 "Unrecognized range check setting.");
237 fprintf_filtered (gdb_stdout
,
238 _("Range checking is \"auto; currently %s\".\n"),
242 fprintf_filtered (gdb_stdout
, _("Range checking is \"%s\".\n"),
245 if (range_check
!= current_language
->la_range_check
)
246 warning (_("the current range check setting "
247 "does not match the language.\n"));
250 /* Set command. Change the setting for range checking. */
252 set_range_command (const char *ignore
,
253 int from_tty
, struct cmd_list_element
*c
)
255 if (strcmp (range
, "on") == 0)
257 range_check
= range_check_on
;
258 range_mode
= range_mode_manual
;
260 else if (strcmp (range
, "warn") == 0)
262 range_check
= range_check_warn
;
263 range_mode
= range_mode_manual
;
265 else if (strcmp (range
, "off") == 0)
267 range_check
= range_check_off
;
268 range_mode
= range_mode_manual
;
270 else if (strcmp (range
, "auto") == 0)
272 range_mode
= range_mode_auto
;
278 internal_error (__FILE__
, __LINE__
,
279 _("Unrecognized range check setting: \"%s\""), range
);
281 if (range_check
!= current_language
->la_range_check
)
282 warning (_("the current range check setting "
283 "does not match the language.\n"));
286 /* Show command. Display a warning if the case sensitivity setting does
287 not match the current language. */
289 show_case_command (struct ui_file
*file
, int from_tty
,
290 struct cmd_list_element
*c
, const char *value
)
292 if (case_mode
== case_mode_auto
)
294 const char *tmp
= NULL
;
296 switch (case_sensitivity
)
298 case case_sensitive_on
:
301 case case_sensitive_off
:
305 internal_error (__FILE__
, __LINE__
,
306 "Unrecognized case-sensitive setting.");
309 fprintf_filtered (gdb_stdout
,
310 _("Case sensitivity in "
311 "name search is \"auto; currently %s\".\n"),
315 fprintf_filtered (gdb_stdout
,
316 _("Case sensitivity in name search is \"%s\".\n"),
319 if (case_sensitivity
!= current_language
->la_case_sensitivity
)
320 warning (_("the current case sensitivity setting does not match "
324 /* Set command. Change the setting for case sensitivity. */
327 set_case_command (const char *ignore
, int from_tty
, struct cmd_list_element
*c
)
329 if (strcmp (case_sensitive
, "on") == 0)
331 case_sensitivity
= case_sensitive_on
;
332 case_mode
= case_mode_manual
;
334 else if (strcmp (case_sensitive
, "off") == 0)
336 case_sensitivity
= case_sensitive_off
;
337 case_mode
= case_mode_manual
;
339 else if (strcmp (case_sensitive
, "auto") == 0)
341 case_mode
= case_mode_auto
;
347 internal_error (__FILE__
, __LINE__
,
348 "Unrecognized case-sensitive setting: \"%s\"",
352 if (case_sensitivity
!= current_language
->la_case_sensitivity
)
353 warning (_("the current case sensitivity setting does not match "
357 /* Set the status of range and type checking and case sensitivity based on
358 the current modes and the current language.
359 If SHOW is non-zero, then print out the current language,
360 type and range checking status. */
362 set_range_case (void)
364 if (range_mode
== range_mode_auto
)
365 range_check
= current_language
->la_range_check
;
367 if (case_mode
== case_mode_auto
)
368 case_sensitivity
= current_language
->la_case_sensitivity
;
371 /* Set current language to (enum language) LANG. Returns previous
375 set_language (enum language lang
)
377 enum language prev_language
;
379 prev_language
= current_language
->la_language
;
380 current_language
= languages
[lang
];
382 return prev_language
;
386 /* Print out the current language settings: language, range and
387 type checking. If QUIETLY, print only what has changed. */
390 language_info (int quietly
)
392 if (quietly
&& expected_language
== current_language
)
395 expected_language
= current_language
;
396 printf_unfiltered (_("Current language: %s\n"), language
);
397 show_language_command (NULL
, 1, NULL
, NULL
);
401 printf_unfiltered (_("Range checking: %s\n"), range
);
402 show_range_command (NULL
, 1, NULL
, NULL
);
403 printf_unfiltered (_("Case sensitivity: %s\n"), case_sensitive
);
404 show_case_command (NULL
, 1, NULL
, NULL
);
409 /* Returns non-zero if the value is a pointer type. */
411 pointer_type (struct type
*type
)
413 return type
->code () == TYPE_CODE_PTR
|| TYPE_IS_REFERENCE (type
);
417 /* This page contains functions that return info about
418 (struct value) values used in GDB. */
420 /* Returns non-zero if the value VAL represents a true value. */
422 value_true (struct value
*val
)
424 /* It is possible that we should have some sort of error if a non-boolean
425 value is used in this context. Possibly dependent on some kind of
426 "boolean-checking" option like range checking. But it should probably
427 not depend on the language except insofar as is necessary to identify
428 a "boolean" value (i.e. in C using a float, pointer, etc., as a boolean
429 should be an error, probably). */
430 return !value_logical_not (val
);
433 /* This page contains functions for the printing out of
434 error messages that occur during type- and range-
437 /* This is called when a language fails a range-check. The
438 first argument should be a printf()-style format string, and the
439 rest of the arguments should be its arguments. If range_check is
440 range_check_on, an error is printed; if range_check_warn, a warning;
441 otherwise just the message. */
444 range_error (const char *string
,...)
448 va_start (args
, string
);
451 case range_check_warn
:
452 vwarning (string
, args
);
455 verror (string
, args
);
457 case range_check_off
:
458 /* FIXME: cagney/2002-01-30: Should this function print anything
459 when range error is off? */
460 vfprintf_filtered (gdb_stderr
, string
, args
);
461 fprintf_filtered (gdb_stderr
, "\n");
464 internal_error (__FILE__
, __LINE__
, _("bad switch"));
470 /* This page contains miscellaneous functions. */
472 /* Return the language enum for a given language string. */
475 language_enum (const char *str
)
477 for (const auto &lang
: languages
)
478 if (strcmp (lang
->la_name
, str
) == 0)
479 return lang
->la_language
;
481 if (strcmp (str
, "local") == 0)
482 return language_auto
;
484 return language_unknown
;
487 /* Return the language struct for a given language enum. */
489 const struct language_defn
*
490 language_def (enum language lang
)
492 return languages
[lang
];
495 /* Return the language as a string. */
498 language_str (enum language lang
)
500 return languages
[lang
]->la_name
;
505 /* Build and install the "set language LANG" command. */
508 add_set_language_command ()
510 static const char **language_names
;
512 /* Build the language names array, to be used as enumeration in the
513 "set language" enum command. +1 for "local" and +1 for NULL
515 language_names
= new const char *[ARRAY_SIZE (languages
) + 2];
517 /* Display "auto", "local" and "unknown" first, and then the rest,
519 const char **language_names_p
= language_names
;
520 *language_names_p
++ = auto_language_defn
.la_name
;
521 *language_names_p
++ = "local";
522 *language_names_p
++ = unknown_language_defn
.la_name
;
523 const char **sort_begin
= language_names_p
;
524 for (const auto &lang
: languages
)
526 /* Already handled above. */
527 if (lang
->la_language
== language_auto
528 || lang
->la_language
== language_unknown
)
530 *language_names_p
++ = lang
->la_name
;
532 *language_names_p
= NULL
;
533 std::sort (sort_begin
, language_names_p
, compare_cstrings
);
535 /* Add the filename extensions. */
536 for (const auto &lang
: languages
)
537 if (lang
->la_filename_extensions
!= NULL
)
539 for (size_t i
= 0; lang
->la_filename_extensions
[i
] != NULL
; ++i
)
540 add_filename_language (lang
->la_filename_extensions
[i
],
544 /* Build the "help set language" docs. */
547 doc
.printf (_("Set the current source language.\n"
548 "The currently understood settings are:\n\nlocal or "
549 "auto Automatic setting based on source file"));
551 for (const auto &lang
: languages
)
553 /* Already dealt with these above. */
554 if (lang
->la_language
== language_unknown
555 || lang
->la_language
== language_auto
)
558 /* FIXME: i18n: for now assume that the human-readable name is
559 just a capitalization of the internal name. */
560 /* Note that we add the newline at the front, so we don't wind
561 up with a trailing newline. */
562 doc
.printf ("\n%-16s Use the %c%s language",
564 /* Capitalize first letter of language name. */
565 toupper (lang
->la_name
[0]),
569 add_setshow_enum_cmd ("language", class_support
,
573 _("Show the current source language."),
574 NULL
, set_language_command
,
575 show_language_command
,
576 &setlist
, &showlist
);
579 /* Iterate through all registered languages looking for and calling
580 any non-NULL struct language_defn.skip_trampoline() functions.
581 Return the result from the first that returns non-zero, or 0 if all
584 skip_language_trampoline (struct frame_info
*frame
, CORE_ADDR pc
)
586 for (const auto &lang
: languages
)
588 if (lang
->skip_trampoline
!= NULL
)
590 CORE_ADDR real_pc
= lang
->skip_trampoline (frame
, pc
);
600 /* Return demangled language symbol, or NULL.
601 FIXME: Options are only useful for certain languages and ignored
602 by others, so it would be better to remove them here and have a
603 more flexible demangler for the languages that need it.
604 FIXME: Sometimes the demangler is invoked when we don't know the
605 language, so we can't use this everywhere. */
607 language_demangle (const struct language_defn
*current_language
,
608 const char *mangled
, int options
)
610 if (current_language
!= NULL
&& current_language
->la_demangle
)
611 return current_language
->la_demangle (mangled
, options
);
615 /* See language.h. */
618 language_sniff_from_mangled_name (const struct language_defn
*lang
,
619 const char *mangled
, char **demangled
)
621 gdb_assert (lang
!= NULL
);
623 if (lang
->la_sniff_from_mangled_name
== NULL
)
629 return lang
->la_sniff_from_mangled_name (mangled
, demangled
);
632 /* Return class name from physname or NULL. */
634 language_class_name_from_physname (const struct language_defn
*lang
,
635 const char *physname
)
637 if (lang
!= NULL
&& lang
->la_class_name_from_physname
)
638 return lang
->la_class_name_from_physname (physname
);
642 /* Return information about whether TYPE should be passed
643 (and returned) by reference at the language level. */
645 struct language_pass_by_ref_info
646 language_pass_by_reference (struct type
*type
)
648 return current_language
->la_pass_by_reference (type
);
651 /* Return a default struct that provides pass-by-reference information
652 about the given TYPE. Languages should update the default values
655 struct language_pass_by_ref_info
656 default_pass_by_reference (struct type
*type
)
661 /* Return the default string containing the list of characters
662 delimiting words. This is a reasonable default value that
663 most languages should be able to use. */
666 default_word_break_characters (void)
668 return " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,-";
671 /* Print the index of array elements using the C99 syntax. */
674 default_print_array_index (struct type
*index_type
, LONGEST index
,
675 struct ui_file
*stream
,
676 const struct value_print_options
*options
)
678 struct value
*index_value
= value_from_longest (index_type
, index
);
680 fprintf_filtered (stream
, "[");
681 LA_VALUE_PRINT (index_value
, stream
, options
);
682 fprintf_filtered (stream
, "] = ");
685 /* See language.h. */
688 default_symbol_name_matcher (const char *symbol_search_name
,
689 const lookup_name_info
&lookup_name
,
690 completion_match_result
*comp_match_res
)
692 gdb::string_view name
= lookup_name
.name ();
693 completion_match_for_lcd
*match_for_lcd
694 = (comp_match_res
!= NULL
? &comp_match_res
->match_for_lcd
: NULL
);
695 strncmp_iw_mode mode
= (lookup_name
.completion_mode ()
696 ? strncmp_iw_mode::NORMAL
697 : strncmp_iw_mode::MATCH_PARAMS
);
699 if (strncmp_iw_with_mode (symbol_search_name
, name
.data (), name
.size (),
700 mode
, language_minimal
, match_for_lcd
) == 0)
702 if (comp_match_res
!= NULL
)
703 comp_match_res
->set_match (symbol_search_name
);
710 /* See language.h. */
713 default_is_string_type_p (struct type
*type
)
715 type
= check_typedef (type
);
716 while (type
->code () == TYPE_CODE_REF
)
718 type
= TYPE_TARGET_TYPE (type
);
719 type
= check_typedef (type
);
721 return (type
->code () == TYPE_CODE_STRING
);
724 /* See language.h. */
726 symbol_name_matcher_ftype
*
727 get_symbol_name_matcher (const language_defn
*lang
,
728 const lookup_name_info
&lookup_name
)
730 /* If currently in Ada mode, and the lookup name is wrapped in
731 '<...>', hijack all symbol name comparisons using the Ada
732 matcher, which handles the verbatim matching. */
733 if (current_language
->la_language
== language_ada
734 && lookup_name
.ada ().verbatim_p ())
735 return current_language
->la_get_symbol_name_matcher (lookup_name
);
737 if (lang
->la_get_symbol_name_matcher
!= nullptr)
738 return lang
->la_get_symbol_name_matcher (lookup_name
);
739 return default_symbol_name_matcher
;
742 /* Define the language that is no language. */
745 unk_lang_parser (struct parser_state
*ps
)
751 unk_lang_emit_char (int c
, struct type
*type
, struct ui_file
*stream
,
754 error (_("internal error - unimplemented "
755 "function unk_lang_emit_char called."));
759 unk_lang_printchar (int c
, struct type
*type
, struct ui_file
*stream
)
761 error (_("internal error - unimplemented "
762 "function unk_lang_printchar called."));
766 unk_lang_printstr (struct ui_file
*stream
, struct type
*type
,
767 const gdb_byte
*string
, unsigned int length
,
768 const char *encoding
, int force_ellipses
,
769 const struct value_print_options
*options
)
771 error (_("internal error - unimplemented "
772 "function unk_lang_printstr called."));
776 unk_lang_print_type (struct type
*type
, const char *varstring
,
777 struct ui_file
*stream
, int show
, int level
,
778 const struct type_print_options
*flags
)
780 error (_("internal error - unimplemented "
781 "function unk_lang_print_type called."));
785 unk_lang_value_print_inner (struct value
*val
,
786 struct ui_file
*stream
, int recurse
,
787 const struct value_print_options
*options
)
789 error (_("internal error - unimplemented "
790 "function unk_lang_value_print_inner called."));
794 unk_lang_value_print (struct value
*val
, struct ui_file
*stream
,
795 const struct value_print_options
*options
)
797 error (_("internal error - unimplemented "
798 "function unk_lang_value_print called."));
801 static CORE_ADDR
unk_lang_trampoline (struct frame_info
*frame
, CORE_ADDR pc
)
806 /* Unknown languages just use the cplus demangler. */
807 static char *unk_lang_demangle (const char *mangled
, int options
)
809 return gdb_demangle (mangled
, options
);
812 static char *unk_lang_class_name (const char *mangled
)
817 static const struct op_print unk_op_print_tab
[] =
819 {NULL
, OP_NULL
, PREC_NULL
, 0}
823 unknown_language_arch_info (struct gdbarch
*gdbarch
,
824 struct language_arch_info
*lai
)
826 lai
->string_char_type
= builtin_type (gdbarch
)->builtin_char
;
827 lai
->bool_type_default
= builtin_type (gdbarch
)->builtin_int
;
828 lai
->primitive_type_vector
= GDBARCH_OBSTACK_CALLOC (gdbarch
, 1,
832 const struct language_defn unknown_language_defn
=
842 &exp_descriptor_standard
,
845 unk_lang_printchar
, /* Print character constant */
848 unk_lang_print_type
, /* Print a type using appropriate syntax */
849 default_print_typedef
, /* Print a typedef using appropriate syntax */
850 unk_lang_value_print_inner
, /* la_value_print_inner */
851 unk_lang_value_print
, /* Print a top-level value */
852 default_read_var_value
, /* la_read_var_value */
853 unk_lang_trampoline
, /* Language specific skip_trampoline */
854 "this", /* name_of_this */
855 true, /* store_sym_names_in_linkage_form_p */
856 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
857 basic_lookup_transparent_type
,/* lookup_transparent_type */
858 unk_lang_demangle
, /* Language specific symbol demangler */
860 unk_lang_class_name
, /* Language specific
861 class_name_from_physname */
862 unk_op_print_tab
, /* expression operators for printing */
863 1, /* c-style arrays */
864 0, /* String lower bound */
865 default_word_break_characters
,
866 default_collect_symbol_completion_matches
,
867 unknown_language_arch_info
, /* la_language_arch_info. */
868 default_print_array_index
,
869 default_pass_by_reference
,
870 c_watch_location_expression
,
871 NULL
, /* la_get_symbol_name_matcher */
872 iterate_over_symbols
,
873 default_search_name_hash
,
877 default_is_string_type_p
,
878 "{...}" /* la_struct_too_deep_ellipsis */
881 /* These two structs define fake entries for the "local" and "auto"
883 const struct language_defn auto_language_defn
=
893 &exp_descriptor_standard
,
896 unk_lang_printchar
, /* Print character constant */
899 unk_lang_print_type
, /* Print a type using appropriate syntax */
900 default_print_typedef
, /* Print a typedef using appropriate syntax */
901 unk_lang_value_print_inner
, /* la_value_print_inner */
902 unk_lang_value_print
, /* Print a top-level value */
903 default_read_var_value
, /* la_read_var_value */
904 unk_lang_trampoline
, /* Language specific skip_trampoline */
905 "this", /* name_of_this */
906 false, /* store_sym_names_in_linkage_form_p */
907 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
908 basic_lookup_transparent_type
,/* lookup_transparent_type */
909 unk_lang_demangle
, /* Language specific symbol demangler */
911 unk_lang_class_name
, /* Language specific
912 class_name_from_physname */
913 unk_op_print_tab
, /* expression operators for printing */
914 1, /* c-style arrays */
915 0, /* String lower bound */
916 default_word_break_characters
,
917 default_collect_symbol_completion_matches
,
918 unknown_language_arch_info
, /* la_language_arch_info. */
919 default_print_array_index
,
920 default_pass_by_reference
,
921 c_watch_location_expression
,
922 NULL
, /* la_get_symbol_name_matcher */
923 iterate_over_symbols
,
924 default_search_name_hash
,
928 default_is_string_type_p
,
929 "{...}" /* la_struct_too_deep_ellipsis */
933 /* Per-architecture language information. */
935 static struct gdbarch_data
*language_gdbarch_data
;
937 struct language_gdbarch
939 /* A vector of per-language per-architecture info. Indexed by "enum
941 struct language_arch_info arch_info
[nr_languages
];
945 language_gdbarch_post_init (struct gdbarch
*gdbarch
)
947 struct language_gdbarch
*l
;
949 l
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct language_gdbarch
);
950 for (const auto &lang
: languages
)
951 if (lang
!= NULL
&& lang
->la_language_arch_info
!= NULL
)
953 lang
->la_language_arch_info (gdbarch
,
954 l
->arch_info
+ lang
->la_language
);
961 language_string_char_type (const struct language_defn
*la
,
962 struct gdbarch
*gdbarch
)
964 struct language_gdbarch
*ld
965 = (struct language_gdbarch
*) gdbarch_data (gdbarch
, language_gdbarch_data
);
967 return ld
->arch_info
[la
->la_language
].string_char_type
;
971 language_bool_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
);
977 if (ld
->arch_info
[la
->la_language
].bool_type_symbol
)
981 sym
= lookup_symbol (ld
->arch_info
[la
->la_language
].bool_type_symbol
,
982 NULL
, VAR_DOMAIN
, NULL
).symbol
;
985 struct type
*type
= SYMBOL_TYPE (sym
);
987 if (type
&& type
->code () == TYPE_CODE_BOOL
)
992 return ld
->arch_info
[la
->la_language
].bool_type_default
;
995 /* Helper function for primitive type lookup. */
997 static struct type
**
998 language_lookup_primitive_type_1 (const struct language_arch_info
*lai
,
1003 for (p
= lai
->primitive_type_vector
; (*p
) != NULL
; p
++)
1005 if (strcmp ((*p
)->name (), name
) == 0)
1011 /* See language.h. */
1014 language_lookup_primitive_type (const struct language_defn
*la
,
1015 struct gdbarch
*gdbarch
,
1018 struct language_gdbarch
*ld
=
1019 (struct language_gdbarch
*) gdbarch_data (gdbarch
, language_gdbarch_data
);
1020 struct type
**typep
;
1022 typep
= language_lookup_primitive_type_1 (&ld
->arch_info
[la
->la_language
],
1029 /* Helper function for type lookup as a symbol.
1030 Create the symbol corresponding to type TYPE in language LANG. */
1032 static struct symbol
*
1033 language_alloc_type_symbol (enum language lang
, struct type
*type
)
1035 struct symbol
*symbol
;
1036 struct gdbarch
*gdbarch
;
1038 gdb_assert (!TYPE_OBJFILE_OWNED (type
));
1040 gdbarch
= TYPE_OWNER (type
).gdbarch
;
1041 symbol
= new (gdbarch_obstack (gdbarch
)) struct symbol ();
1043 symbol
->m_name
= type
->name ();
1044 symbol
->set_language (lang
, nullptr);
1045 symbol
->owner
.arch
= gdbarch
;
1046 SYMBOL_OBJFILE_OWNED (symbol
) = 0;
1047 SYMBOL_SECTION (symbol
) = 0;
1048 SYMBOL_TYPE (symbol
) = type
;
1049 SYMBOL_DOMAIN (symbol
) = VAR_DOMAIN
;
1050 SYMBOL_ACLASS_INDEX (symbol
) = LOC_TYPEDEF
;
1055 /* Initialize the primitive type symbols of language LD.
1056 The primitive type vector must have already been initialized. */
1059 language_init_primitive_type_symbols (struct language_arch_info
*lai
,
1060 const struct language_defn
*la
,
1061 struct gdbarch
*gdbarch
)
1065 gdb_assert (lai
->primitive_type_vector
!= NULL
);
1067 for (n
= 0; lai
->primitive_type_vector
[n
] != NULL
; ++n
)
1070 lai
->primitive_type_symbols
1071 = GDBARCH_OBSTACK_CALLOC (gdbarch
, n
+ 1, struct symbol
*);
1073 for (n
= 0; lai
->primitive_type_vector
[n
] != NULL
; ++n
)
1075 lai
->primitive_type_symbols
[n
]
1076 = language_alloc_type_symbol (la
->la_language
,
1077 lai
->primitive_type_vector
[n
]);
1080 /* Note: The result of symbol lookup is normally a symbol *and* the block
1081 it was found in. Builtin types don't live in blocks. We *could* give
1082 them one, but there is no current need so to keep things simple symbol
1083 lookup is extended to allow for BLOCK_FOUND to be NULL. */
1086 /* See language.h. */
1089 language_lookup_primitive_type_as_symbol (const struct language_defn
*la
,
1090 struct gdbarch
*gdbarch
,
1093 struct language_gdbarch
*ld
1094 = (struct language_gdbarch
*) gdbarch_data (gdbarch
, language_gdbarch_data
);
1095 struct language_arch_info
*lai
= &ld
->arch_info
[la
->la_language
];
1096 struct type
**typep
;
1099 if (symbol_lookup_debug
)
1101 fprintf_unfiltered (gdb_stdlog
,
1102 "language_lookup_primitive_type_as_symbol"
1104 la
->la_name
, host_address_to_string (gdbarch
), name
);
1107 typep
= language_lookup_primitive_type_1 (lai
, name
);
1110 if (symbol_lookup_debug
)
1111 fprintf_unfiltered (gdb_stdlog
, " = NULL\n");
1115 /* The set of symbols is lazily initialized. */
1116 if (lai
->primitive_type_symbols
== NULL
)
1117 language_init_primitive_type_symbols (lai
, la
, gdbarch
);
1119 sym
= lai
->primitive_type_symbols
[typep
- lai
->primitive_type_vector
];
1121 if (symbol_lookup_debug
)
1122 fprintf_unfiltered (gdb_stdlog
, " = %s\n", host_address_to_string (sym
));
1126 /* Initialize the language routines. */
1128 void _initialize_language ();
1130 _initialize_language ()
1132 static const char *const type_or_range_names
[]
1133 = { "on", "off", "warn", "auto", NULL
};
1135 static const char *const case_sensitive_names
[]
1136 = { "on", "off", "auto", NULL
};
1138 language_gdbarch_data
1139 = gdbarch_data_register_post_init (language_gdbarch_post_init
);
1141 /* GDB commands for language specific stuff. */
1143 add_basic_prefix_cmd ("check", no_class
,
1144 _("Set the status of the type/range checker."),
1145 &setchecklist
, "set check ", 0, &setlist
);
1146 add_alias_cmd ("c", "check", no_class
, 1, &setlist
);
1147 add_alias_cmd ("ch", "check", no_class
, 1, &setlist
);
1149 add_show_prefix_cmd ("check", no_class
,
1150 _("Show the status of the type/range checker."),
1151 &showchecklist
, "show check ", 0, &showlist
);
1152 add_alias_cmd ("c", "check", no_class
, 1, &showlist
);
1153 add_alias_cmd ("ch", "check", no_class
, 1, &showlist
);
1155 add_setshow_enum_cmd ("range", class_support
, type_or_range_names
,
1157 _("Set range checking (on/warn/off/auto)."),
1158 _("Show range checking (on/warn/off/auto)."),
1159 NULL
, set_range_command
,
1161 &setchecklist
, &showchecklist
);
1163 add_setshow_enum_cmd ("case-sensitive", class_support
, case_sensitive_names
,
1164 &case_sensitive
, _("\
1165 Set case sensitivity in name search (on/off/auto)."), _("\
1166 Show case sensitivity in name search (on/off/auto)."), _("\
1167 For Fortran the default is off; for other languages the default is on."),
1170 &setlist
, &showlist
);
1172 add_set_language_command ();
1176 case_sensitive
= "auto";
1178 /* Have the above take effect. */
1179 set_language (language_auto
);