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 void set_range_case (void);
52 /* The current (default at startup) state of type and range checking.
53 (If the modes are set to "auto", though, these are changed based
54 on the default language at startup, and then again based on the
55 language of the first source file. */
57 enum range_mode range_mode
= range_mode_auto
;
58 enum range_check range_check
= range_check_off
;
59 enum case_mode case_mode
= case_mode_auto
;
60 enum case_sensitivity case_sensitivity
= case_sensitive_on
;
62 /* The current language and language_mode (see language.h). */
64 const struct language_defn
*current_language
= nullptr;
65 enum language_mode language_mode
= language_mode_auto
;
67 /* The language that the user expects to be typing in (the language
68 of main(), or the last language we notified them about, or C). */
70 const struct language_defn
*expected_language
;
72 /* Define the array containing all languages. */
74 const struct language_defn
*language_defn::languages
[nr_languages
];
76 /* The current values of the "set language/range/case-sensitive" enum
78 static const char *language
;
79 static const char *range
;
80 static const char *case_sensitive
;
83 const char lang_frame_mismatch_warn
[] =
84 N_("Warning: the current language does not match this frame.");
86 /* This page contains the functions corresponding to GDB commands
89 /* Show command. Display a warning if the language set
90 does not match the frame. */
92 show_language_command (struct ui_file
*file
, int from_tty
,
93 struct cmd_list_element
*c
, const char *value
)
95 enum language flang
; /* The language of the frame. */
97 if (language_mode
== language_mode_auto
)
98 fprintf_filtered (gdb_stdout
,
99 _("The current source language is "
100 "\"auto; currently %s\".\n"),
101 current_language
->la_name
);
103 fprintf_filtered (gdb_stdout
,
104 _("The current source language is \"%s\".\n"),
105 current_language
->la_name
);
107 if (has_stack_frames ())
109 struct frame_info
*frame
;
111 frame
= get_selected_frame (NULL
);
112 flang
= get_frame_language (frame
);
113 if (flang
!= language_unknown
114 && language_mode
== language_mode_manual
115 && current_language
->la_language
!= flang
)
116 printf_filtered ("%s\n", _(lang_frame_mismatch_warn
));
120 /* Set command. Change the current working language. */
122 set_language_command (const char *ignore
,
123 int from_tty
, struct cmd_list_element
*c
)
125 enum language flang
= language_unknown
;
127 /* "local" is a synonym of "auto". */
128 if (strcmp (language
, "local") == 0)
131 /* Search the list of languages for a match. */
132 for (const auto &lang
: language_defn::languages
)
134 if (strcmp (lang
->la_name
, language
) == 0)
136 /* Found it! Go into manual mode, and use this language. */
137 if (lang
->la_language
== language_auto
)
139 /* Enter auto mode. Set to the current frame's language, if
140 known, or fallback to the initial language. */
141 language_mode
= language_mode_auto
;
144 struct frame_info
*frame
;
146 frame
= get_selected_frame (NULL
);
147 flang
= get_frame_language (frame
);
149 catch (const gdb_exception_error
&ex
)
151 flang
= language_unknown
;
154 if (flang
!= language_unknown
)
155 set_language (flang
);
157 set_initial_language ();
158 expected_language
= current_language
;
163 /* Enter manual mode. Set the specified language. */
164 language_mode
= language_mode_manual
;
165 current_language
= lang
;
167 expected_language
= current_language
;
173 internal_error (__FILE__
, __LINE__
,
174 "Couldn't find language `%s' in known languages list.",
178 /* Show command. Display a warning if the range setting does
179 not match the current language. */
181 show_range_command (struct ui_file
*file
, int from_tty
,
182 struct cmd_list_element
*c
, const char *value
)
184 if (range_mode
== range_mode_auto
)
193 case range_check_off
:
196 case range_check_warn
:
200 internal_error (__FILE__
, __LINE__
,
201 "Unrecognized range check setting.");
204 fprintf_filtered (gdb_stdout
,
205 _("Range checking is \"auto; currently %s\".\n"),
209 fprintf_filtered (gdb_stdout
, _("Range checking is \"%s\".\n"),
212 if (range_check
!= current_language
->la_range_check
)
213 warning (_("the current range check setting "
214 "does not match the language.\n"));
217 /* Set command. Change the setting for range checking. */
219 set_range_command (const char *ignore
,
220 int from_tty
, struct cmd_list_element
*c
)
222 if (strcmp (range
, "on") == 0)
224 range_check
= range_check_on
;
225 range_mode
= range_mode_manual
;
227 else if (strcmp (range
, "warn") == 0)
229 range_check
= range_check_warn
;
230 range_mode
= range_mode_manual
;
232 else if (strcmp (range
, "off") == 0)
234 range_check
= range_check_off
;
235 range_mode
= range_mode_manual
;
237 else if (strcmp (range
, "auto") == 0)
239 range_mode
= range_mode_auto
;
245 internal_error (__FILE__
, __LINE__
,
246 _("Unrecognized range check setting: \"%s\""), range
);
248 if (range_check
!= current_language
->la_range_check
)
249 warning (_("the current range check setting "
250 "does not match the language.\n"));
253 /* Show command. Display a warning if the case sensitivity setting does
254 not match the current language. */
256 show_case_command (struct ui_file
*file
, int from_tty
,
257 struct cmd_list_element
*c
, const char *value
)
259 if (case_mode
== case_mode_auto
)
261 const char *tmp
= NULL
;
263 switch (case_sensitivity
)
265 case case_sensitive_on
:
268 case case_sensitive_off
:
272 internal_error (__FILE__
, __LINE__
,
273 "Unrecognized case-sensitive setting.");
276 fprintf_filtered (gdb_stdout
,
277 _("Case sensitivity in "
278 "name search is \"auto; currently %s\".\n"),
282 fprintf_filtered (gdb_stdout
,
283 _("Case sensitivity in name search is \"%s\".\n"),
286 if (case_sensitivity
!= current_language
->la_case_sensitivity
)
287 warning (_("the current case sensitivity setting does not match "
291 /* Set command. Change the setting for case sensitivity. */
294 set_case_command (const char *ignore
, int from_tty
, struct cmd_list_element
*c
)
296 if (strcmp (case_sensitive
, "on") == 0)
298 case_sensitivity
= case_sensitive_on
;
299 case_mode
= case_mode_manual
;
301 else if (strcmp (case_sensitive
, "off") == 0)
303 case_sensitivity
= case_sensitive_off
;
304 case_mode
= case_mode_manual
;
306 else if (strcmp (case_sensitive
, "auto") == 0)
308 case_mode
= case_mode_auto
;
314 internal_error (__FILE__
, __LINE__
,
315 "Unrecognized case-sensitive setting: \"%s\"",
319 if (case_sensitivity
!= current_language
->la_case_sensitivity
)
320 warning (_("the current case sensitivity setting does not match "
324 /* Set the status of range and type checking and case sensitivity based on
325 the current modes and the current language.
326 If SHOW is non-zero, then print out the current language,
327 type and range checking status. */
329 set_range_case (void)
331 if (range_mode
== range_mode_auto
)
332 range_check
= current_language
->la_range_check
;
334 if (case_mode
== case_mode_auto
)
335 case_sensitivity
= current_language
->la_case_sensitivity
;
338 /* Set current language to (enum language) LANG. Returns previous
342 set_language (enum language lang
)
344 enum language prev_language
;
346 prev_language
= current_language
->la_language
;
347 current_language
= language_def (lang
);
349 return prev_language
;
353 /* Print out the current language settings: language, range and
354 type checking. If QUIETLY, print only what has changed. */
357 language_info (int quietly
)
359 if (quietly
&& expected_language
== current_language
)
362 expected_language
= current_language
;
363 printf_unfiltered (_("Current language: %s\n"), language
);
364 show_language_command (NULL
, 1, NULL
, NULL
);
368 printf_unfiltered (_("Range checking: %s\n"), range
);
369 show_range_command (NULL
, 1, NULL
, NULL
);
370 printf_unfiltered (_("Case sensitivity: %s\n"), case_sensitive
);
371 show_case_command (NULL
, 1, NULL
, NULL
);
376 /* Returns non-zero if the value is a pointer type. */
378 pointer_type (struct type
*type
)
380 return type
->code () == TYPE_CODE_PTR
|| TYPE_IS_REFERENCE (type
);
384 /* This page contains functions that return info about
385 (struct value) values used in GDB. */
387 /* Returns non-zero if the value VAL represents a true value. */
389 value_true (struct value
*val
)
391 /* It is possible that we should have some sort of error if a non-boolean
392 value is used in this context. Possibly dependent on some kind of
393 "boolean-checking" option like range checking. But it should probably
394 not depend on the language except insofar as is necessary to identify
395 a "boolean" value (i.e. in C using a float, pointer, etc., as a boolean
396 should be an error, probably). */
397 return !value_logical_not (val
);
400 /* This page contains functions for the printing out of
401 error messages that occur during type- and range-
404 /* This is called when a language fails a range-check. The
405 first argument should be a printf()-style format string, and the
406 rest of the arguments should be its arguments. If range_check is
407 range_check_on, an error is printed; if range_check_warn, a warning;
408 otherwise just the message. */
411 range_error (const char *string
,...)
415 va_start (args
, string
);
418 case range_check_warn
:
419 vwarning (string
, args
);
422 verror (string
, args
);
424 case range_check_off
:
425 /* FIXME: cagney/2002-01-30: Should this function print anything
426 when range error is off? */
427 vfprintf_filtered (gdb_stderr
, string
, args
);
428 fprintf_filtered (gdb_stderr
, "\n");
431 internal_error (__FILE__
, __LINE__
, _("bad switch"));
437 /* This page contains miscellaneous functions. */
439 /* Return the language enum for a given language string. */
442 language_enum (const char *str
)
444 for (const auto &lang
: language_defn::languages
)
445 if (strcmp (lang
->la_name
, str
) == 0)
446 return lang
->la_language
;
448 if (strcmp (str
, "local") == 0)
449 return language_auto
;
451 return language_unknown
;
454 /* Return the language struct for a given language enum. */
456 const struct language_defn
*
457 language_def (enum language lang
)
459 const struct language_defn
*l
= language_defn::languages
[lang
];
460 gdb_assert (l
!= nullptr);
464 /* Return the language as a string. */
467 language_str (enum language lang
)
469 return language_def (lang
)->la_name
;
474 /* Build and install the "set language LANG" command. */
477 add_set_language_command ()
479 static const char **language_names
;
481 /* Build the language names array, to be used as enumeration in the
482 "set language" enum command. +1 for "local" and +1 for NULL
484 language_names
= new const char *[ARRAY_SIZE (language_defn::languages
) + 2];
486 /* Display "auto", "local" and "unknown" first, and then the rest,
488 const char **language_names_p
= language_names
;
489 *language_names_p
++ = language_def (language_auto
)->la_name
;
490 *language_names_p
++ = "local";
491 *language_names_p
++ = language_def (language_unknown
)->la_name
;
492 const char **sort_begin
= language_names_p
;
493 for (const auto &lang
: language_defn::languages
)
495 /* Already handled above. */
496 if (lang
->la_language
== language_auto
497 || lang
->la_language
== language_unknown
)
499 *language_names_p
++ = lang
->la_name
;
501 *language_names_p
= NULL
;
502 std::sort (sort_begin
, language_names_p
, compare_cstrings
);
504 /* Add the filename extensions. */
505 for (const auto &lang
: language_defn::languages
)
506 if (lang
->la_filename_extensions
!= NULL
)
508 for (size_t i
= 0; lang
->la_filename_extensions
[i
] != NULL
; ++i
)
509 add_filename_language (lang
->la_filename_extensions
[i
],
513 /* Build the "help set language" docs. */
516 doc
.printf (_("Set the current source language.\n"
517 "The currently understood settings are:\n\nlocal or "
518 "auto Automatic setting based on source file"));
520 for (const auto &lang
: language_defn::languages
)
522 /* Already dealt with these above. */
523 if (lang
->la_language
== language_unknown
524 || lang
->la_language
== language_auto
)
527 /* FIXME: i18n: for now assume that the human-readable name is
528 just a capitalization of the internal name. */
529 /* Note that we add the newline at the front, so we don't wind
530 up with a trailing newline. */
531 doc
.printf ("\n%-16s Use the %c%s language",
533 /* Capitalize first letter of language name. */
534 toupper (lang
->la_name
[0]),
538 add_setshow_enum_cmd ("language", class_support
,
542 _("Show the current source language."),
543 NULL
, set_language_command
,
544 show_language_command
,
545 &setlist
, &showlist
);
548 /* Iterate through all registered languages looking for and calling
549 any non-NULL struct language_defn.skip_trampoline() functions.
550 Return the result from the first that returns non-zero, or 0 if all
553 skip_language_trampoline (struct frame_info
*frame
, CORE_ADDR pc
)
555 for (const auto &lang
: language_defn::languages
)
557 CORE_ADDR real_pc
= lang
->skip_trampoline (frame
, pc
);
566 /* Return demangled language symbol, or NULL.
567 FIXME: Options are only useful for certain languages and ignored
568 by others, so it would be better to remove them here and have a
569 more flexible demangler for the languages that need it.
570 FIXME: Sometimes the demangler is invoked when we don't know the
571 language, so we can't use this everywhere. */
573 language_demangle (const struct language_defn
*current_language
,
574 const char *mangled
, int options
)
576 if (current_language
!= NULL
)
577 return current_language
->demangle (mangled
, options
);
581 /* Return information about whether TYPE should be passed
582 (and returned) by reference at the language level. */
584 struct language_pass_by_ref_info
585 language_pass_by_reference (struct type
*type
)
587 return current_language
->pass_by_reference_info (type
);
590 /* Return the default string containing the list of characters
591 delimiting words. This is a reasonable default value that
592 most languages should be able to use. */
595 default_word_break_characters (void)
597 return " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,-";
600 /* See language.h. */
603 language_defn::print_array_index (struct type
*index_type
, LONGEST index
,
604 struct ui_file
*stream
,
605 const value_print_options
*options
) const
607 struct value
*index_value
= value_from_longest (index_type
, index
);
609 fprintf_filtered (stream
, "[");
610 LA_VALUE_PRINT (index_value
, stream
, options
);
611 fprintf_filtered (stream
, "] = ");
614 /* See language.h. */
616 gdb::unique_xmalloc_ptr
<char>
617 language_defn::watch_location_expression (struct type
*type
,
618 CORE_ADDR addr
) const
620 /* Generates an expression that assumes a C like syntax is valid. */
621 type
= check_typedef (TYPE_TARGET_TYPE (check_typedef (type
)));
622 std::string name
= type_to_string (type
);
623 return gdb::unique_xmalloc_ptr
<char>
624 (xstrprintf ("* (%s *) %s", name
.c_str (), core_addr_to_string (addr
)));
627 /* See language.h. */
630 language_defn::value_print (struct value
*val
, struct ui_file
*stream
,
631 const struct value_print_options
*options
) const
633 return c_value_print (val
, stream
, options
);
636 /* See language.h. */
639 language_defn::parser (struct parser_state
*ps
) const
644 /* See language.h. */
647 language_defn::value_print_inner
648 (struct value
*val
, struct ui_file
*stream
, int recurse
,
649 const struct value_print_options
*options
) const
651 return c_value_print_inner (val
, stream
, recurse
, options
);
654 /* See language.h. */
657 language_defn::emitchar (int ch
, struct type
*chtype
,
658 struct ui_file
* stream
, int quoter
) const
660 c_emit_char (ch
, chtype
, stream
, quoter
);
663 /* See language.h. */
666 language_defn::printchar (int ch
, struct type
*chtype
,
667 struct ui_file
* stream
) const
669 c_printchar (ch
, chtype
, stream
);
672 /* See language.h. */
675 language_defn::printstr (struct ui_file
*stream
, struct type
*elttype
,
676 const gdb_byte
*string
, unsigned int length
,
677 const char *encoding
, int force_ellipses
,
678 const struct value_print_options
*options
) const
680 c_printstr (stream
, elttype
, string
, length
, encoding
, force_ellipses
,
684 /* See language.h. */
687 language_defn::print_typedef (struct type
*type
, struct symbol
*new_symbol
,
688 struct ui_file
*stream
) const
690 c_print_typedef (type
, new_symbol
, stream
);
693 /* See language.h. */
696 language_defn::is_string_type_p (struct type
*type
) const
698 return c_is_string_type_p (type
);
701 /* The default implementation of the get_symbol_name_matcher_inner method
702 from the language_defn class. Matches with strncmp_iw. */
705 default_symbol_name_matcher (const char *symbol_search_name
,
706 const lookup_name_info
&lookup_name
,
707 completion_match_result
*comp_match_res
)
709 gdb::string_view name
= lookup_name
.name ();
710 completion_match_for_lcd
*match_for_lcd
711 = (comp_match_res
!= NULL
? &comp_match_res
->match_for_lcd
: NULL
);
712 strncmp_iw_mode mode
= (lookup_name
.completion_mode ()
713 ? strncmp_iw_mode::NORMAL
714 : strncmp_iw_mode::MATCH_PARAMS
);
716 if (strncmp_iw_with_mode (symbol_search_name
, name
.data (), name
.size (),
717 mode
, language_minimal
, match_for_lcd
) == 0)
719 if (comp_match_res
!= NULL
)
720 comp_match_res
->set_match (symbol_search_name
);
727 /* See language.h. */
729 symbol_name_matcher_ftype
*
730 language_defn::get_symbol_name_matcher
731 (const lookup_name_info
&lookup_name
) const
733 /* If currently in Ada mode, and the lookup name is wrapped in
734 '<...>', hijack all symbol name comparisons using the Ada
735 matcher, which handles the verbatim matching. */
736 if (current_language
->la_language
== language_ada
737 && lookup_name
.ada ().verbatim_p ())
738 return current_language
->get_symbol_name_matcher_inner (lookup_name
);
740 return this->get_symbol_name_matcher_inner (lookup_name
);
743 /* See language.h. */
745 symbol_name_matcher_ftype
*
746 language_defn::get_symbol_name_matcher_inner
747 (const lookup_name_info
&lookup_name
) const
749 return default_symbol_name_matcher
;
752 /* Return true if TYPE is a string type, otherwise return false. This
753 default implementation only detects TYPE_CODE_STRING. */
756 default_is_string_type_p (struct type
*type
)
758 type
= check_typedef (type
);
759 while (type
->code () == TYPE_CODE_REF
)
761 type
= TYPE_TARGET_TYPE (type
);
762 type
= check_typedef (type
);
764 return (type
->code () == TYPE_CODE_STRING
);
767 static const struct op_print unk_op_print_tab
[] =
769 {NULL
, OP_NULL
, PREC_NULL
, 0}
773 unknown_language_arch_info (struct gdbarch
*gdbarch
,
774 struct language_arch_info
*lai
)
776 lai
->string_char_type
= builtin_type (gdbarch
)->builtin_char
;
777 lai
->bool_type_default
= builtin_type (gdbarch
)->builtin_int
;
778 lai
->primitive_type_vector
= GDBARCH_OBSTACK_CALLOC (gdbarch
, 1,
782 /* Constant data that describes the unknown language. */
784 extern const struct language_data unknown_language_data
=
794 &exp_descriptor_standard
,
795 "this", /* name_of_this */
796 true, /* store_sym_names_in_linkage_form_p */
797 unk_op_print_tab
, /* expression operators for printing */
798 1, /* c-style arrays */
799 0, /* String lower bound */
803 /* Class representing the unknown language. */
805 class unknown_language
: public language_defn
809 : language_defn (language_unknown
, unknown_language_data
)
812 /* See language.h. */
813 void language_arch_info (struct gdbarch
*gdbarch
,
814 struct language_arch_info
*lai
) const override
816 unknown_language_arch_info (gdbarch
, lai
);
819 /* See language.h. */
821 void print_type (struct type
*type
, const char *varstring
,
822 struct ui_file
*stream
, int show
, int level
,
823 const struct type_print_options
*flags
) const override
825 error (_("unimplemented unknown_language::print_type called"));
828 /* See language.h. */
830 char *demangle (const char *mangled
, int options
) const override
832 /* The unknown language just uses the C++ demangler. */
833 return gdb_demangle (mangled
, options
);
836 /* See language.h. */
838 void value_print (struct value
*val
, struct ui_file
*stream
,
839 const struct value_print_options
*options
) const override
841 error (_("unimplemented unknown_language::value_print called"));
844 /* See language.h. */
846 void value_print_inner
847 (struct value
*val
, struct ui_file
*stream
, int recurse
,
848 const struct value_print_options
*options
) const override
850 error (_("unimplemented unknown_language::value_print_inner called"));
853 /* See language.h. */
855 int parser (struct parser_state
*ps
) const override
857 /* No parsing is done, just claim success. */
861 /* See language.h. */
863 void emitchar (int ch
, struct type
*chtype
,
864 struct ui_file
*stream
, int quoter
) const override
866 error (_("unimplemented unknown_language::emitchar called"));
869 /* See language.h. */
871 void printchar (int ch
, struct type
*chtype
,
872 struct ui_file
*stream
) const override
874 error (_("unimplemented unknown_language::printchar called"));
877 /* See language.h. */
879 void printstr (struct ui_file
*stream
, struct type
*elttype
,
880 const gdb_byte
*string
, unsigned int length
,
881 const char *encoding
, int force_ellipses
,
882 const struct value_print_options
*options
) const override
884 error (_("unimplemented unknown_language::printstr called"));
887 /* See language.h. */
889 void print_typedef (struct type
*type
, struct symbol
*new_symbol
,
890 struct ui_file
*stream
) const override
892 error (_("unimplemented unknown_language::print_typedef called"));
895 /* See language.h. */
897 bool is_string_type_p (struct type
*type
) const override
899 return default_is_string_type_p (type
);
903 /* Single instance of the unknown language class. */
905 static unknown_language unknown_language_defn
;
907 /* Constant data for the fake "auto" language. */
909 extern const struct language_data auto_language_data
=
919 &exp_descriptor_standard
,
920 "this", /* name_of_this */
921 false, /* store_sym_names_in_linkage_form_p */
922 unk_op_print_tab
, /* expression operators for printing */
923 1, /* c-style arrays */
924 0, /* String lower bound */
928 /* Class representing the fake "auto" language. */
930 class auto_language
: public language_defn
934 : language_defn (language_auto
, auto_language_data
)
937 /* See language.h. */
938 void language_arch_info (struct gdbarch
*gdbarch
,
939 struct language_arch_info
*lai
) const override
941 unknown_language_arch_info (gdbarch
, lai
);
944 /* See language.h. */
946 void print_type (struct type
*type
, const char *varstring
,
947 struct ui_file
*stream
, int show
, int level
,
948 const struct type_print_options
*flags
) const override
950 error (_("unimplemented auto_language::print_type called"));
953 /* See language.h. */
955 char *demangle (const char *mangled
, int options
) const override
957 /* The auto language just uses the C++ demangler. */
958 return gdb_demangle (mangled
, options
);
961 /* See language.h. */
963 void value_print (struct value
*val
, struct ui_file
*stream
,
964 const struct value_print_options
*options
) const override
966 error (_("unimplemented auto_language::value_print called"));
969 /* See language.h. */
971 void value_print_inner
972 (struct value
*val
, struct ui_file
*stream
, int recurse
,
973 const struct value_print_options
*options
) const override
975 error (_("unimplemented auto_language::value_print_inner called"));
978 /* See language.h. */
980 int parser (struct parser_state
*ps
) const override
982 /* No parsing is done, just claim success. */
986 /* See language.h. */
988 void emitchar (int ch
, struct type
*chtype
,
989 struct ui_file
*stream
, int quoter
) const override
991 error (_("unimplemented auto_language::emitchar called"));
994 /* See language.h. */
996 void printchar (int ch
, struct type
*chtype
,
997 struct ui_file
*stream
) const override
999 error (_("unimplemented auto_language::printchar called"));
1002 /* See language.h. */
1004 void printstr (struct ui_file
*stream
, struct type
*elttype
,
1005 const gdb_byte
*string
, unsigned int length
,
1006 const char *encoding
, int force_ellipses
,
1007 const struct value_print_options
*options
) const override
1009 error (_("unimplemented auto_language::printstr called"));
1012 /* See language.h. */
1014 void print_typedef (struct type
*type
, struct symbol
*new_symbol
,
1015 struct ui_file
*stream
) const override
1017 error (_("unimplemented auto_language::print_typedef called"));
1020 /* See language.h. */
1022 bool is_string_type_p (struct type
*type
) const override
1024 return default_is_string_type_p (type
);
1028 /* Single instance of the fake "auto" language. */
1030 static auto_language auto_language_defn
;
1033 /* Per-architecture language information. */
1035 static struct gdbarch_data
*language_gdbarch_data
;
1037 struct language_gdbarch
1039 /* A vector of per-language per-architecture info. Indexed by "enum
1041 struct language_arch_info arch_info
[nr_languages
];
1045 language_gdbarch_post_init (struct gdbarch
*gdbarch
)
1047 struct language_gdbarch
*l
;
1049 l
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct language_gdbarch
);
1050 for (const auto &lang
: language_defn::languages
)
1052 gdb_assert (lang
!= nullptr);
1053 lang
->language_arch_info (gdbarch
,
1054 l
->arch_info
+ lang
->la_language
);
1061 language_string_char_type (const struct language_defn
*la
,
1062 struct gdbarch
*gdbarch
)
1064 struct language_gdbarch
*ld
1065 = (struct language_gdbarch
*) gdbarch_data (gdbarch
, language_gdbarch_data
);
1067 return ld
->arch_info
[la
->la_language
].string_char_type
;
1071 language_bool_type (const struct language_defn
*la
,
1072 struct gdbarch
*gdbarch
)
1074 struct language_gdbarch
*ld
1075 = (struct language_gdbarch
*) gdbarch_data (gdbarch
, language_gdbarch_data
);
1077 if (ld
->arch_info
[la
->la_language
].bool_type_symbol
)
1081 sym
= lookup_symbol (ld
->arch_info
[la
->la_language
].bool_type_symbol
,
1082 NULL
, VAR_DOMAIN
, NULL
).symbol
;
1085 struct type
*type
= SYMBOL_TYPE (sym
);
1087 if (type
&& type
->code () == TYPE_CODE_BOOL
)
1092 return ld
->arch_info
[la
->la_language
].bool_type_default
;
1095 /* Helper function for primitive type lookup. */
1097 static struct type
**
1098 language_lookup_primitive_type_1 (const struct language_arch_info
*lai
,
1103 for (p
= lai
->primitive_type_vector
; (*p
) != NULL
; p
++)
1105 if (strcmp ((*p
)->name (), name
) == 0)
1111 /* See language.h. */
1114 language_lookup_primitive_type (const struct language_defn
*la
,
1115 struct gdbarch
*gdbarch
,
1118 struct language_gdbarch
*ld
=
1119 (struct language_gdbarch
*) gdbarch_data (gdbarch
, language_gdbarch_data
);
1120 struct type
**typep
;
1122 typep
= language_lookup_primitive_type_1 (&ld
->arch_info
[la
->la_language
],
1129 /* Helper function for type lookup as a symbol.
1130 Create the symbol corresponding to type TYPE in language LANG. */
1132 static struct symbol
*
1133 language_alloc_type_symbol (enum language lang
, struct type
*type
)
1135 struct symbol
*symbol
;
1136 struct gdbarch
*gdbarch
;
1138 gdb_assert (!TYPE_OBJFILE_OWNED (type
));
1140 gdbarch
= TYPE_OWNER (type
).gdbarch
;
1141 symbol
= new (gdbarch_obstack (gdbarch
)) struct symbol ();
1143 symbol
->m_name
= type
->name ();
1144 symbol
->set_language (lang
, nullptr);
1145 symbol
->owner
.arch
= gdbarch
;
1146 SYMBOL_OBJFILE_OWNED (symbol
) = 0;
1147 SYMBOL_SECTION (symbol
) = 0;
1148 SYMBOL_TYPE (symbol
) = type
;
1149 SYMBOL_DOMAIN (symbol
) = VAR_DOMAIN
;
1150 SYMBOL_ACLASS_INDEX (symbol
) = LOC_TYPEDEF
;
1155 /* Initialize the primitive type symbols of language LD.
1156 The primitive type vector must have already been initialized. */
1159 language_init_primitive_type_symbols (struct language_arch_info
*lai
,
1160 const struct language_defn
*la
,
1161 struct gdbarch
*gdbarch
)
1165 gdb_assert (lai
->primitive_type_vector
!= NULL
);
1167 for (n
= 0; lai
->primitive_type_vector
[n
] != NULL
; ++n
)
1170 lai
->primitive_type_symbols
1171 = GDBARCH_OBSTACK_CALLOC (gdbarch
, n
+ 1, struct symbol
*);
1173 for (n
= 0; lai
->primitive_type_vector
[n
] != NULL
; ++n
)
1175 lai
->primitive_type_symbols
[n
]
1176 = language_alloc_type_symbol (la
->la_language
,
1177 lai
->primitive_type_vector
[n
]);
1180 /* Note: The result of symbol lookup is normally a symbol *and* the block
1181 it was found in. Builtin types don't live in blocks. We *could* give
1182 them one, but there is no current need so to keep things simple symbol
1183 lookup is extended to allow for BLOCK_FOUND to be NULL. */
1186 /* See language.h. */
1189 language_lookup_primitive_type_as_symbol (const struct language_defn
*la
,
1190 struct gdbarch
*gdbarch
,
1193 struct language_gdbarch
*ld
1194 = (struct language_gdbarch
*) gdbarch_data (gdbarch
, language_gdbarch_data
);
1195 struct language_arch_info
*lai
= &ld
->arch_info
[la
->la_language
];
1196 struct type
**typep
;
1199 if (symbol_lookup_debug
)
1201 fprintf_unfiltered (gdb_stdlog
,
1202 "language_lookup_primitive_type_as_symbol"
1204 la
->la_name
, host_address_to_string (gdbarch
), name
);
1207 typep
= language_lookup_primitive_type_1 (lai
, name
);
1210 if (symbol_lookup_debug
)
1211 fprintf_unfiltered (gdb_stdlog
, " = NULL\n");
1215 /* The set of symbols is lazily initialized. */
1216 if (lai
->primitive_type_symbols
== NULL
)
1217 language_init_primitive_type_symbols (lai
, la
, gdbarch
);
1219 sym
= lai
->primitive_type_symbols
[typep
- lai
->primitive_type_vector
];
1221 if (symbol_lookup_debug
)
1222 fprintf_unfiltered (gdb_stdlog
, " = %s\n", host_address_to_string (sym
));
1226 /* Initialize the language routines. */
1228 void _initialize_language ();
1230 _initialize_language ()
1232 static const char *const type_or_range_names
[]
1233 = { "on", "off", "warn", "auto", NULL
};
1235 static const char *const case_sensitive_names
[]
1236 = { "on", "off", "auto", NULL
};
1238 language_gdbarch_data
1239 = gdbarch_data_register_post_init (language_gdbarch_post_init
);
1241 /* GDB commands for language specific stuff. */
1243 add_basic_prefix_cmd ("check", no_class
,
1244 _("Set the status of the type/range checker."),
1245 &setchecklist
, "set check ", 0, &setlist
);
1246 add_alias_cmd ("c", "check", no_class
, 1, &setlist
);
1247 add_alias_cmd ("ch", "check", no_class
, 1, &setlist
);
1249 add_show_prefix_cmd ("check", no_class
,
1250 _("Show the status of the type/range checker."),
1251 &showchecklist
, "show check ", 0, &showlist
);
1252 add_alias_cmd ("c", "check", no_class
, 1, &showlist
);
1253 add_alias_cmd ("ch", "check", no_class
, 1, &showlist
);
1255 add_setshow_enum_cmd ("range", class_support
, type_or_range_names
,
1257 _("Set range checking (on/warn/off/auto)."),
1258 _("Show range checking (on/warn/off/auto)."),
1259 NULL
, set_range_command
,
1261 &setchecklist
, &showchecklist
);
1263 add_setshow_enum_cmd ("case-sensitive", class_support
, case_sensitive_names
,
1264 &case_sensitive
, _("\
1265 Set case sensitivity in name search (on/off/auto)."), _("\
1266 Show case sensitivity in name search (on/off/auto)."), _("\
1267 For Fortran the default is off; for other languages the default is on."),
1270 &setlist
, &showlist
);
1272 /* In order to call SET_LANGUAGE (below) we need to make sure that
1273 CURRENT_LANGUAGE is not NULL. So first set the language to unknown,
1274 then we can change the language to 'auto'. */
1275 current_language
= language_def (language_unknown
);
1277 add_set_language_command ();
1281 case_sensitive
= "auto";
1283 /* Have the above take effect. */
1284 set_language (language_auto
);