1 /* Multiple source language support for GDB.
3 Copyright (C) 1991-2018 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 static int unk_lang_parser (struct parser_state
*);
51 static void set_range_case (void);
53 static void unk_lang_emit_char (int c
, struct type
*type
,
54 struct ui_file
*stream
, int quoter
);
56 static void unk_lang_printchar (int c
, struct type
*type
,
57 struct ui_file
*stream
);
59 static void unk_lang_value_print (struct value
*, struct ui_file
*,
60 const struct value_print_options
*);
62 static CORE_ADDR
unk_lang_trampoline (struct frame_info
*, CORE_ADDR pc
);
64 /* Forward declaration */
65 extern const struct language_defn unknown_language_defn
;
67 /* The current (default at startup) state of type and range checking.
68 (If the modes are set to "auto", though, these are changed based
69 on the default language at startup, and then again based on the
70 language of the first source file. */
72 enum range_mode range_mode
= range_mode_auto
;
73 enum range_check range_check
= range_check_off
;
74 enum case_mode case_mode
= case_mode_auto
;
75 enum case_sensitivity case_sensitivity
= case_sensitive_on
;
77 /* The current language and language_mode (see language.h). */
79 const struct language_defn
*current_language
= &unknown_language_defn
;
80 enum language_mode language_mode
= language_mode_auto
;
82 /* The language that the user expects to be typing in (the language
83 of main(), or the last language we notified them about, or C). */
85 const struct language_defn
*expected_language
;
87 /* The list of supported languages. Keep this in the same order as
88 the 'enum language' values. */
90 static const struct language_defn
*languages
[] = {
91 &unknown_language_defn
,
101 &pascal_language_defn
,
102 &opencl_language_defn
,
104 &minimal_language_defn
,
108 /* The current values of the "set language/type/range" enum
110 static const char *language
;
111 static const char *type
;
112 static const char *range
;
113 static const char *case_sensitive
;
115 /* Warning issued when current_language and the language of the current
116 frame do not match. */
117 char lang_frame_mismatch_warn
[] =
118 "Warning: the current language does not match this frame.";
120 /* This page contains the functions corresponding to GDB commands
121 and their helpers. */
123 /* Show command. Display a warning if the language set
124 does not match the frame. */
126 show_language_command (struct ui_file
*file
, int from_tty
,
127 struct cmd_list_element
*c
, const char *value
)
129 enum language flang
; /* The language of the frame. */
131 if (language_mode
== language_mode_auto
)
132 fprintf_filtered (gdb_stdout
,
133 _("The current source language is "
134 "\"auto; currently %s\".\n"),
135 current_language
->la_name
);
137 fprintf_filtered (gdb_stdout
,
138 _("The current source language is \"%s\".\n"),
139 current_language
->la_name
);
141 if (has_stack_frames ())
143 struct frame_info
*frame
;
145 frame
= get_selected_frame (NULL
);
146 flang
= get_frame_language (frame
);
147 if (flang
!= language_unknown
148 && language_mode
== language_mode_manual
149 && current_language
->la_language
!= flang
)
150 printf_filtered ("%s\n", lang_frame_mismatch_warn
);
154 /* Set command. Change the current working language. */
156 set_language_command (const char *ignore
,
157 int from_tty
, struct cmd_list_element
*c
)
159 enum language flang
= language_unknown
;
161 /* "local" is a synonym of "auto". */
162 if (strcmp (language
, "local") == 0)
165 /* Search the list of languages for a match. */
166 for (const auto &lang
: languages
)
168 if (strcmp (lang
->la_name
, language
) == 0)
170 /* Found it! Go into manual mode, and use this language. */
171 if (lang
->la_language
== language_auto
)
173 /* Enter auto mode. Set to the current frame's language, if
174 known, or fallback to the initial language. */
175 language_mode
= language_mode_auto
;
178 struct frame_info
*frame
;
180 frame
= get_selected_frame (NULL
);
181 flang
= get_frame_language (frame
);
183 CATCH (ex
, RETURN_MASK_ERROR
)
185 flang
= language_unknown
;
189 if (flang
!= language_unknown
)
190 set_language (flang
);
192 set_initial_language ();
193 expected_language
= current_language
;
198 /* Enter manual mode. Set the specified language. */
199 language_mode
= language_mode_manual
;
200 current_language
= lang
;
202 expected_language
= current_language
;
208 internal_error (__FILE__
, __LINE__
,
209 "Couldn't find language `%s' in known languages list.",
213 /* Show command. Display a warning if the range setting does
214 not match the current language. */
216 show_range_command (struct ui_file
*file
, int from_tty
,
217 struct cmd_list_element
*c
, const char *value
)
219 if (range_mode
== range_mode_auto
)
228 case range_check_off
:
231 case range_check_warn
:
235 internal_error (__FILE__
, __LINE__
,
236 "Unrecognized range check setting.");
239 fprintf_filtered (gdb_stdout
,
240 _("Range checking is \"auto; currently %s\".\n"),
244 fprintf_filtered (gdb_stdout
, _("Range checking is \"%s\".\n"),
247 if (range_check
!= current_language
->la_range_check
)
248 warning (_("the current range check setting "
249 "does not match the language.\n"));
252 /* Set command. Change the setting for range checking. */
254 set_range_command (const char *ignore
,
255 int from_tty
, struct cmd_list_element
*c
)
257 if (strcmp (range
, "on") == 0)
259 range_check
= range_check_on
;
260 range_mode
= range_mode_manual
;
262 else if (strcmp (range
, "warn") == 0)
264 range_check
= range_check_warn
;
265 range_mode
= range_mode_manual
;
267 else if (strcmp (range
, "off") == 0)
269 range_check
= range_check_off
;
270 range_mode
= range_mode_manual
;
272 else if (strcmp (range
, "auto") == 0)
274 range_mode
= range_mode_auto
;
280 internal_error (__FILE__
, __LINE__
,
281 _("Unrecognized range check setting: \"%s\""), range
);
283 if (range_check
!= current_language
->la_range_check
)
284 warning (_("the current range check setting "
285 "does not match the language.\n"));
288 /* Show command. Display a warning if the case sensitivity setting does
289 not match the current language. */
291 show_case_command (struct ui_file
*file
, int from_tty
,
292 struct cmd_list_element
*c
, const char *value
)
294 if (case_mode
== case_mode_auto
)
296 const char *tmp
= NULL
;
298 switch (case_sensitivity
)
300 case case_sensitive_on
:
303 case case_sensitive_off
:
307 internal_error (__FILE__
, __LINE__
,
308 "Unrecognized case-sensitive setting.");
311 fprintf_filtered (gdb_stdout
,
312 _("Case sensitivity in "
313 "name search is \"auto; currently %s\".\n"),
317 fprintf_filtered (gdb_stdout
,
318 _("Case sensitivity in name search is \"%s\".\n"),
321 if (case_sensitivity
!= current_language
->la_case_sensitivity
)
322 warning (_("the current case sensitivity setting does not match "
326 /* Set command. Change the setting for case sensitivity. */
329 set_case_command (const char *ignore
, int from_tty
, struct cmd_list_element
*c
)
331 if (strcmp (case_sensitive
, "on") == 0)
333 case_sensitivity
= case_sensitive_on
;
334 case_mode
= case_mode_manual
;
336 else if (strcmp (case_sensitive
, "off") == 0)
338 case_sensitivity
= case_sensitive_off
;
339 case_mode
= case_mode_manual
;
341 else if (strcmp (case_sensitive
, "auto") == 0)
343 case_mode
= case_mode_auto
;
349 internal_error (__FILE__
, __LINE__
,
350 "Unrecognized case-sensitive setting: \"%s\"",
354 if (case_sensitivity
!= current_language
->la_case_sensitivity
)
355 warning (_("the current case sensitivity setting does not match "
359 /* Set the status of range and type checking and case sensitivity based on
360 the current modes and the current language.
361 If SHOW is non-zero, then print out the current language,
362 type and range checking status. */
364 set_range_case (void)
366 if (range_mode
== range_mode_auto
)
367 range_check
= current_language
->la_range_check
;
369 if (case_mode
== case_mode_auto
)
370 case_sensitivity
= current_language
->la_case_sensitivity
;
373 /* Set current language to (enum language) LANG. Returns previous
377 set_language (enum language lang
)
379 enum language prev_language
;
381 prev_language
= current_language
->la_language
;
382 current_language
= languages
[lang
];
384 return prev_language
;
388 /* Print out the current language settings: language, range and
389 type checking. If QUIETLY, print only what has changed. */
392 language_info (int quietly
)
394 if (quietly
&& expected_language
== current_language
)
397 expected_language
= current_language
;
398 printf_unfiltered (_("Current language: %s\n"), language
);
399 show_language_command (NULL
, 1, NULL
, NULL
);
403 printf_unfiltered (_("Range checking: %s\n"), range
);
404 show_range_command (NULL
, 1, NULL
, NULL
);
405 printf_unfiltered (_("Case sensitivity: %s\n"), case_sensitive
);
406 show_case_command (NULL
, 1, NULL
, NULL
);
411 /* Returns non-zero if the value is a pointer type. */
413 pointer_type (struct type
*type
)
415 return TYPE_CODE (type
) == TYPE_CODE_PTR
|| TYPE_IS_REFERENCE (type
);
419 /* This page contains functions that return info about
420 (struct value) values used in GDB. */
422 /* Returns non-zero if the value VAL represents a true value. */
424 value_true (struct value
*val
)
426 /* It is possible that we should have some sort of error if a non-boolean
427 value is used in this context. Possibly dependent on some kind of
428 "boolean-checking" option like range checking. But it should probably
429 not depend on the language except insofar as is necessary to identify
430 a "boolean" value (i.e. in C using a float, pointer, etc., as a boolean
431 should be an error, probably). */
432 return !value_logical_not (val
);
435 /* This page contains functions for the printing out of
436 error messages that occur during type- and range-
439 /* This is called when a language fails a range-check. The
440 first argument should be a printf()-style format string, and the
441 rest of the arguments should be its arguments. If range_check is
442 range_check_on, an error is printed; if range_check_warn, a warning;
443 otherwise just the message. */
446 range_error (const char *string
,...)
450 va_start (args
, string
);
453 case range_check_warn
:
454 vwarning (string
, args
);
457 verror (string
, args
);
459 case range_check_off
:
460 /* FIXME: cagney/2002-01-30: Should this function print anything
461 when range error is off? */
462 vfprintf_filtered (gdb_stderr
, string
, args
);
463 fprintf_filtered (gdb_stderr
, "\n");
466 internal_error (__FILE__
, __LINE__
, _("bad switch"));
472 /* This page contains miscellaneous functions. */
474 /* Return the language enum for a given language string. */
477 language_enum (const char *str
)
479 for (const auto &lang
: languages
)
480 if (strcmp (lang
->la_name
, str
) == 0)
481 return lang
->la_language
;
483 if (strcmp (str
, "local") == 0)
484 return language_auto
;
486 return language_unknown
;
489 /* Return the language struct for a given language enum. */
491 const struct language_defn
*
492 language_def (enum language lang
)
494 return languages
[lang
];
497 /* Return the language as a string. */
500 language_str (enum language lang
)
502 return languages
[lang
]->la_name
;
506 set_check (const char *ignore
, int from_tty
)
509 "\"set check\" must be followed by the name of a check subcommand.\n");
510 help_list (setchecklist
, "set check ", all_commands
, gdb_stdout
);
514 show_check (const char *ignore
, int from_tty
)
516 cmd_show_list (showchecklist
, from_tty
, "");
520 /* Build and install the "set language LANG" command. */
523 add_set_language_command ()
525 static const char **language_names
;
527 /* Build the language names array, to be used as enumeration in the
528 "set language" enum command. +1 for "local" and +1 for NULL
530 language_names
= new const char *[ARRAY_SIZE (languages
) + 2];
532 /* Display "auto", "local" and "unknown" first, and then the rest,
534 const char **language_names_p
= language_names
;
535 *language_names_p
++ = auto_language_defn
.la_name
;
536 *language_names_p
++ = "local";
537 *language_names_p
++ = unknown_language_defn
.la_name
;
538 const char **sort_begin
= language_names_p
;
539 for (const auto &lang
: languages
)
541 /* Already handled above. */
542 if (lang
->la_language
== language_auto
543 || lang
->la_language
== language_unknown
)
545 *language_names_p
++ = lang
->la_name
;
547 *language_names_p
= NULL
;
548 std::sort (sort_begin
, language_names_p
, compare_cstrings
);
550 /* Add the filename extensions. */
551 for (const auto &lang
: languages
)
552 if (lang
->la_filename_extensions
!= NULL
)
554 for (size_t i
= 0; lang
->la_filename_extensions
[i
] != NULL
; ++i
)
555 add_filename_language (lang
->la_filename_extensions
[i
],
559 /* Build the "help set language" docs. */
562 doc
.printf (_("Set the current source language.\n"
563 "The currently understood settings are:\n\nlocal or "
564 "auto Automatic setting based on source file\n"));
566 for (const auto &lang
: languages
)
568 /* Already dealt with these above. */
569 if (lang
->la_language
== language_unknown
570 || lang
->la_language
== language_auto
)
573 /* FIXME: i18n: for now assume that the human-readable name is
574 just a capitalization of the internal name. */
575 doc
.printf ("%-16s Use the %c%s language\n",
577 /* Capitalize first letter of language name. */
578 toupper (lang
->la_name
[0]),
582 add_setshow_enum_cmd ("language", class_support
,
586 _("Show the current source language."),
587 NULL
, set_language_command
,
588 show_language_command
,
589 &setlist
, &showlist
);
592 /* Iterate through all registered languages looking for and calling
593 any non-NULL struct language_defn.skip_trampoline() functions.
594 Return the result from the first that returns non-zero, or 0 if all
597 skip_language_trampoline (struct frame_info
*frame
, CORE_ADDR pc
)
599 for (const auto &lang
: languages
)
601 if (lang
->skip_trampoline
!= NULL
)
603 CORE_ADDR real_pc
= lang
->skip_trampoline (frame
, pc
);
613 /* Return demangled language symbol, or NULL.
614 FIXME: Options are only useful for certain languages and ignored
615 by others, so it would be better to remove them here and have a
616 more flexible demangler for the languages that need it.
617 FIXME: Sometimes the demangler is invoked when we don't know the
618 language, so we can't use this everywhere. */
620 language_demangle (const struct language_defn
*current_language
,
621 const char *mangled
, int options
)
623 if (current_language
!= NULL
&& current_language
->la_demangle
)
624 return current_language
->la_demangle (mangled
, options
);
628 /* See langauge.h. */
631 language_sniff_from_mangled_name (const struct language_defn
*lang
,
632 const char *mangled
, char **demangled
)
634 gdb_assert (lang
!= NULL
);
636 if (lang
->la_sniff_from_mangled_name
== NULL
)
642 return lang
->la_sniff_from_mangled_name (mangled
, demangled
);
645 /* Return class name from physname or NULL. */
647 language_class_name_from_physname (const struct language_defn
*lang
,
648 const char *physname
)
650 if (lang
!= NULL
&& lang
->la_class_name_from_physname
)
651 return lang
->la_class_name_from_physname (physname
);
655 /* Return non-zero if TYPE should be passed (and returned) by
656 reference at the language level. */
658 language_pass_by_reference (struct type
*type
)
660 return current_language
->la_pass_by_reference (type
);
663 /* Return zero; by default, types are passed by value at the language
664 level. The target ABI may pass or return some structs by reference
665 independent of this. */
667 default_pass_by_reference (struct type
*type
)
672 /* Return the default string containing the list of characters
673 delimiting words. This is a reasonable default value that
674 most languages should be able to use. */
677 default_word_break_characters (void)
679 return " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,-";
682 /* Print the index of array elements using the C99 syntax. */
685 default_print_array_index (struct value
*index_value
, struct ui_file
*stream
,
686 const struct value_print_options
*options
)
688 fprintf_filtered (stream
, "[");
689 LA_VALUE_PRINT (index_value
, stream
, options
);
690 fprintf_filtered (stream
, "] = ");
694 default_get_string (struct value
*value
,
695 gdb::unique_xmalloc_ptr
<gdb_byte
> *buffer
,
696 int *length
, struct type
**char_type
, const char **charset
)
698 error (_("Getting a string is unsupported in this language."));
701 /* See language.h. */
704 default_symbol_name_matcher (const char *symbol_search_name
,
705 const lookup_name_info
&lookup_name
,
706 completion_match_result
*comp_match_res
)
708 const std::string
&name
= lookup_name
.name ();
709 completion_match_for_lcd
*match_for_lcd
710 = (comp_match_res
!= NULL
? &comp_match_res
->match_for_lcd
: NULL
);
711 strncmp_iw_mode mode
= (lookup_name
.completion_mode ()
712 ? strncmp_iw_mode::NORMAL
713 : strncmp_iw_mode::MATCH_PARAMS
);
715 if (strncmp_iw_with_mode (symbol_search_name
, name
.c_str (), name
.size (),
716 mode
, language_minimal
, match_for_lcd
) == 0)
718 if (comp_match_res
!= NULL
)
719 comp_match_res
->set_match (symbol_search_name
);
726 /* See language.h. */
728 symbol_name_matcher_ftype
*
729 get_symbol_name_matcher (const language_defn
*lang
,
730 const lookup_name_info
&lookup_name
)
732 /* If currently in Ada mode, and the lookup name is wrapped in
733 '<...>', hijack all symbol name comparisons using the Ada
734 matcher, which handles the verbatim matching. */
735 if (current_language
->la_language
== language_ada
736 && lookup_name
.ada ().verbatim_p ())
737 return current_language
->la_get_symbol_name_matcher (lookup_name
);
739 if (lang
->la_get_symbol_name_matcher
!= nullptr)
740 return lang
->la_get_symbol_name_matcher (lookup_name
);
741 return default_symbol_name_matcher
;
744 /* Define the language that is no language. */
747 unk_lang_parser (struct parser_state
*ps
)
753 unk_lang_emit_char (int c
, struct type
*type
, struct ui_file
*stream
,
756 error (_("internal error - unimplemented "
757 "function unk_lang_emit_char called."));
761 unk_lang_printchar (int c
, struct type
*type
, struct ui_file
*stream
)
763 error (_("internal error - unimplemented "
764 "function unk_lang_printchar called."));
768 unk_lang_printstr (struct ui_file
*stream
, struct type
*type
,
769 const gdb_byte
*string
, unsigned int length
,
770 const char *encoding
, int force_ellipses
,
771 const struct value_print_options
*options
)
773 error (_("internal error - unimplemented "
774 "function unk_lang_printstr called."));
778 unk_lang_print_type (struct type
*type
, const char *varstring
,
779 struct ui_file
*stream
, int show
, int level
,
780 const struct type_print_options
*flags
)
782 error (_("internal error - unimplemented "
783 "function unk_lang_print_type called."));
787 unk_lang_val_print (struct type
*type
,
788 int embedded_offset
, CORE_ADDR address
,
789 struct ui_file
*stream
, int recurse
,
791 const struct value_print_options
*options
)
793 error (_("internal error - unimplemented "
794 "function unk_lang_val_print called."));
798 unk_lang_value_print (struct value
*val
, struct ui_file
*stream
,
799 const struct value_print_options
*options
)
801 error (_("internal error - unimplemented "
802 "function unk_lang_value_print called."));
805 static CORE_ADDR
unk_lang_trampoline (struct frame_info
*frame
, CORE_ADDR pc
)
810 /* Unknown languages just use the cplus demangler. */
811 static char *unk_lang_demangle (const char *mangled
, int options
)
813 return gdb_demangle (mangled
, options
);
816 static char *unk_lang_class_name (const char *mangled
)
821 static const struct op_print unk_op_print_tab
[] =
823 {NULL
, OP_NULL
, PREC_NULL
, 0}
827 unknown_language_arch_info (struct gdbarch
*gdbarch
,
828 struct language_arch_info
*lai
)
830 lai
->string_char_type
= builtin_type (gdbarch
)->builtin_char
;
831 lai
->bool_type_default
= builtin_type (gdbarch
)->builtin_int
;
832 lai
->primitive_type_vector
= GDBARCH_OBSTACK_CALLOC (gdbarch
, 1,
836 const struct language_defn unknown_language_defn
=
846 &exp_descriptor_standard
,
849 unk_lang_printchar
, /* Print character constant */
852 unk_lang_print_type
, /* Print a type using appropriate syntax */
853 default_print_typedef
, /* Print a typedef using appropriate syntax */
854 unk_lang_val_print
, /* Print a value using appropriate syntax */
855 unk_lang_value_print
, /* Print a top-level value */
856 default_read_var_value
, /* la_read_var_value */
857 unk_lang_trampoline
, /* Language specific skip_trampoline */
858 "this", /* name_of_this */
859 true, /* store_sym_names_in_linkage_form_p */
860 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
861 basic_lookup_transparent_type
,/* lookup_transparent_type */
862 unk_lang_demangle
, /* Language specific symbol demangler */
864 unk_lang_class_name
, /* Language specific
865 class_name_from_physname */
866 unk_op_print_tab
, /* expression operators for printing */
867 1, /* c-style arrays */
868 0, /* String lower bound */
869 default_word_break_characters
,
870 default_collect_symbol_completion_matches
,
871 unknown_language_arch_info
, /* la_language_arch_info. */
872 default_print_array_index
,
873 default_pass_by_reference
,
875 c_watch_location_expression
,
876 NULL
, /* la_get_symbol_name_matcher */
877 iterate_over_symbols
,
878 default_search_name_hash
,
885 /* These two structs define fake entries for the "local" and "auto"
887 const struct language_defn auto_language_defn
=
897 &exp_descriptor_standard
,
900 unk_lang_printchar
, /* Print character constant */
903 unk_lang_print_type
, /* Print a type using appropriate syntax */
904 default_print_typedef
, /* Print a typedef using appropriate syntax */
905 unk_lang_val_print
, /* Print a value using appropriate syntax */
906 unk_lang_value_print
, /* Print a top-level value */
907 default_read_var_value
, /* la_read_var_value */
908 unk_lang_trampoline
, /* Language specific skip_trampoline */
909 "this", /* name_of_this */
910 false, /* store_sym_names_in_linkage_form_p */
911 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
912 basic_lookup_transparent_type
,/* lookup_transparent_type */
913 unk_lang_demangle
, /* Language specific symbol demangler */
915 unk_lang_class_name
, /* Language specific
916 class_name_from_physname */
917 unk_op_print_tab
, /* expression operators for printing */
918 1, /* c-style arrays */
919 0, /* String lower bound */
920 default_word_break_characters
,
921 default_collect_symbol_completion_matches
,
922 unknown_language_arch_info
, /* la_language_arch_info. */
923 default_print_array_index
,
924 default_pass_by_reference
,
926 c_watch_location_expression
,
927 NULL
, /* la_get_symbol_name_matcher */
928 iterate_over_symbols
,
929 default_search_name_hash
,
937 /* Per-architecture language information. */
939 static struct gdbarch_data
*language_gdbarch_data
;
941 struct language_gdbarch
943 /* A vector of per-language per-architecture info. Indexed by "enum
945 struct language_arch_info arch_info
[nr_languages
];
949 language_gdbarch_post_init (struct gdbarch
*gdbarch
)
951 struct language_gdbarch
*l
;
953 l
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct language_gdbarch
);
954 for (const auto &lang
: languages
)
955 if (lang
!= NULL
&& lang
->la_language_arch_info
!= NULL
)
957 lang
->la_language_arch_info (gdbarch
,
958 l
->arch_info
+ lang
->la_language
);
965 language_string_char_type (const struct language_defn
*la
,
966 struct gdbarch
*gdbarch
)
968 struct language_gdbarch
*ld
969 = (struct language_gdbarch
*) gdbarch_data (gdbarch
, language_gdbarch_data
);
971 return ld
->arch_info
[la
->la_language
].string_char_type
;
975 language_bool_type (const struct language_defn
*la
,
976 struct gdbarch
*gdbarch
)
978 struct language_gdbarch
*ld
979 = (struct language_gdbarch
*) gdbarch_data (gdbarch
, language_gdbarch_data
);
981 if (ld
->arch_info
[la
->la_language
].bool_type_symbol
)
985 sym
= lookup_symbol (ld
->arch_info
[la
->la_language
].bool_type_symbol
,
986 NULL
, VAR_DOMAIN
, NULL
).symbol
;
989 struct type
*type
= SYMBOL_TYPE (sym
);
991 if (type
&& TYPE_CODE (type
) == TYPE_CODE_BOOL
)
996 return ld
->arch_info
[la
->la_language
].bool_type_default
;
999 /* Helper function for primitive type lookup. */
1001 static struct type
**
1002 language_lookup_primitive_type_1 (const struct language_arch_info
*lai
,
1007 for (p
= lai
->primitive_type_vector
; (*p
) != NULL
; p
++)
1009 if (strcmp (TYPE_NAME (*p
), name
) == 0)
1015 /* See language.h. */
1018 language_lookup_primitive_type (const struct language_defn
*la
,
1019 struct gdbarch
*gdbarch
,
1022 struct language_gdbarch
*ld
=
1023 (struct language_gdbarch
*) gdbarch_data (gdbarch
, language_gdbarch_data
);
1024 struct type
**typep
;
1026 typep
= language_lookup_primitive_type_1 (&ld
->arch_info
[la
->la_language
],
1033 /* Helper function for type lookup as a symbol.
1034 Create the symbol corresponding to type TYPE in language LANG. */
1036 static struct symbol
*
1037 language_alloc_type_symbol (enum language lang
, struct type
*type
)
1039 struct symbol
*symbol
;
1040 struct gdbarch
*gdbarch
;
1042 gdb_assert (!TYPE_OBJFILE_OWNED (type
));
1044 gdbarch
= TYPE_OWNER (type
).gdbarch
;
1045 symbol
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct symbol
);
1047 symbol
->ginfo
.name
= TYPE_NAME (type
);
1048 symbol
->ginfo
.language
= lang
;
1049 symbol
->owner
.arch
= gdbarch
;
1050 SYMBOL_OBJFILE_OWNED (symbol
) = 0;
1051 SYMBOL_TYPE (symbol
) = type
;
1052 SYMBOL_DOMAIN (symbol
) = VAR_DOMAIN
;
1053 SYMBOL_ACLASS_INDEX (symbol
) = LOC_TYPEDEF
;
1058 /* Initialize the primitive type symbols of language LD.
1059 The primitive type vector must have already been initialized. */
1062 language_init_primitive_type_symbols (struct language_arch_info
*lai
,
1063 const struct language_defn
*la
,
1064 struct gdbarch
*gdbarch
)
1068 gdb_assert (lai
->primitive_type_vector
!= NULL
);
1070 for (n
= 0; lai
->primitive_type_vector
[n
] != NULL
; ++n
)
1073 lai
->primitive_type_symbols
1074 = GDBARCH_OBSTACK_CALLOC (gdbarch
, n
+ 1, struct symbol
*);
1076 for (n
= 0; lai
->primitive_type_vector
[n
] != NULL
; ++n
)
1078 lai
->primitive_type_symbols
[n
]
1079 = language_alloc_type_symbol (la
->la_language
,
1080 lai
->primitive_type_vector
[n
]);
1083 /* Note: The result of symbol lookup is normally a symbol *and* the block
1084 it was found in. Builtin types don't live in blocks. We *could* give
1085 them one, but there is no current need so to keep things simple symbol
1086 lookup is extended to allow for BLOCK_FOUND to be NULL. */
1089 /* See language.h. */
1092 language_lookup_primitive_type_as_symbol (const struct language_defn
*la
,
1093 struct gdbarch
*gdbarch
,
1096 struct language_gdbarch
*ld
1097 = (struct language_gdbarch
*) gdbarch_data (gdbarch
, language_gdbarch_data
);
1098 struct language_arch_info
*lai
= &ld
->arch_info
[la
->la_language
];
1099 struct type
**typep
;
1102 if (symbol_lookup_debug
)
1104 fprintf_unfiltered (gdb_stdlog
,
1105 "language_lookup_primitive_type_as_symbol"
1107 la
->la_name
, host_address_to_string (gdbarch
), name
);
1110 typep
= language_lookup_primitive_type_1 (lai
, name
);
1113 if (symbol_lookup_debug
)
1114 fprintf_unfiltered (gdb_stdlog
, " = NULL\n");
1118 /* The set of symbols is lazily initialized. */
1119 if (lai
->primitive_type_symbols
== NULL
)
1120 language_init_primitive_type_symbols (lai
, la
, gdbarch
);
1122 sym
= lai
->primitive_type_symbols
[typep
- lai
->primitive_type_vector
];
1124 if (symbol_lookup_debug
)
1125 fprintf_unfiltered (gdb_stdlog
, " = %s\n", host_address_to_string (sym
));
1129 /* Initialize the language routines. */
1132 _initialize_language (void)
1134 static const char *const type_or_range_names
[]
1135 = { "on", "off", "warn", "auto", NULL
};
1137 static const char *const case_sensitive_names
[]
1138 = { "on", "off", "auto", NULL
};
1140 language_gdbarch_data
1141 = gdbarch_data_register_post_init (language_gdbarch_post_init
);
1143 /* GDB commands for language specific stuff. */
1145 add_prefix_cmd ("check", no_class
, set_check
,
1146 _("Set the status of the type/range checker."),
1147 &setchecklist
, "set check ", 0, &setlist
);
1148 add_alias_cmd ("c", "check", no_class
, 1, &setlist
);
1149 add_alias_cmd ("ch", "check", no_class
, 1, &setlist
);
1151 add_prefix_cmd ("check", no_class
, show_check
,
1152 _("Show the status of the type/range checker."),
1153 &showchecklist
, "show check ", 0, &showlist
);
1154 add_alias_cmd ("c", "check", no_class
, 1, &showlist
);
1155 add_alias_cmd ("ch", "check", no_class
, 1, &showlist
);
1157 add_setshow_enum_cmd ("range", class_support
, type_or_range_names
,
1159 _("Set range checking. (on/warn/off/auto)"),
1160 _("Show range checking. (on/warn/off/auto)"),
1161 NULL
, set_range_command
,
1163 &setchecklist
, &showchecklist
);
1165 add_setshow_enum_cmd ("case-sensitive", class_support
, case_sensitive_names
,
1166 &case_sensitive
, _("\
1167 Set case sensitivity in name search. (on/off/auto)"), _("\
1168 Show case sensitivity in name search. (on/off/auto)"), _("\
1169 For Fortran the default is off; for other languages the default is on."),
1172 &setlist
, &showlist
);
1174 add_set_language_command ();
1176 language
= xstrdup ("auto");
1177 type
= xstrdup ("auto");
1178 range
= xstrdup ("auto");
1179 case_sensitive
= xstrdup ("auto");
1181 /* Have the above take effect. */
1182 set_language (language_auto
);