]> Git Repo - binutils.git/blob - gdb/language.c
Unify gdb printf functions
[binutils.git] / gdb / language.c
1 /* Multiple source language support for GDB.
2
3    Copyright (C) 1991-2022 Free Software Foundation, Inc.
4
5    Contributed by the Department of Computer Science at the State University
6    of New York at Buffalo.
7
8    This file is part of GDB.
9
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.
14
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.
19
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/>.  */
22
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.  */
26
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.  */
30
31 #include "defs.h"
32 #include <ctype.h>
33 #include "symtab.h"
34 #include "gdbtypes.h"
35 #include "value.h"
36 #include "gdbcmd.h"
37 #include "expression.h"
38 #include "language.h"
39 #include "varobj.h"
40 #include "target.h"
41 #include "parser-defs.h"
42 #include "demangle.h"
43 #include "symfile.h"
44 #include "cp-support.h"
45 #include "frame.h"
46 #include "c-lang.h"
47 #include <algorithm>
48 #include "gdbarch.h"
49 #include "compile/compile-internal.h"
50
51 static void set_range_case (void);
52
53 /* range_mode ==
54    range_mode_auto:   range_check set automatically to default of language.
55    range_mode_manual: range_check set manually by user.  */
56
57 enum range_mode
58   {
59     range_mode_auto, range_mode_manual
60   };
61
62 /* case_mode ==
63    case_mode_auto:   case_sensitivity set upon selection of scope.
64    case_mode_manual: case_sensitivity set only by user.  */
65
66 enum case_mode
67   {
68     case_mode_auto, case_mode_manual
69   };
70
71 /* The current (default at startup) state of type and range checking.
72    (If the modes are set to "auto", though, these are changed based
73    on the default language at startup, and then again based on the
74    language of the first source file.  */
75
76 static enum range_mode range_mode = range_mode_auto;
77 enum range_check range_check = range_check_off;
78 static enum case_mode case_mode = case_mode_auto;
79 enum case_sensitivity case_sensitivity = case_sensitive_on;
80
81 /* The current language and language_mode (see language.h).  */
82
83 const struct language_defn *current_language = nullptr;
84 enum language_mode language_mode = language_mode_auto;
85
86 /* The language that the user expects to be typing in (the language
87    of main(), or the last language we notified them about, or C).  */
88
89 const struct language_defn *expected_language;
90
91 /* Define the array containing all languages.  */
92
93 const struct language_defn *language_defn::languages[nr_languages];
94
95 /* The current values of the "set language/range/case-sensitive" enum
96    commands.  */
97 static const char *language;
98 static const char *range;
99 static const char *case_sensitive;
100
101 /* See language.h.  */
102 const char lang_frame_mismatch_warn[] =
103 N_("Warning: the current language does not match this frame.");
104 \f
105 /* This page contains the functions corresponding to GDB commands
106    and their helpers.  */
107
108 /* Show command.  Display a warning if the language set
109    does not match the frame.  */
110 static void
111 show_language_command (struct ui_file *file, int from_tty,
112                        struct cmd_list_element *c, const char *value)
113 {
114   enum language flang;          /* The language of the frame.  */
115
116   if (language_mode == language_mode_auto)
117     gdb_printf (file,
118                 _("The current source language is "
119                   "\"auto; currently %s\".\n"),
120                 current_language->name ());
121   else
122     gdb_printf (file,
123                 _("The current source language is \"%s\".\n"),
124                 current_language->name ());
125
126   if (has_stack_frames ())
127     {
128       struct frame_info *frame;
129
130       frame = get_selected_frame (NULL);
131       flang = get_frame_language (frame);
132       if (flang != language_unknown
133           && language_mode == language_mode_manual
134           && current_language->la_language != flang)
135         gdb_printf (file, "%s\n", _(lang_frame_mismatch_warn));
136     }
137 }
138
139 /* Set command.  Change the current working language.  */
140 static void
141 set_language_command (const char *ignore,
142                       int from_tty, struct cmd_list_element *c)
143 {
144   enum language flang = language_unknown;
145
146   /* "local" is a synonym of "auto".  */
147   if (strcmp (language, "local") == 0)
148     language = "auto";
149
150   /* Search the list of languages for a match.  */
151   for (const auto &lang : language_defn::languages)
152     {
153       if (strcmp (lang->name (), language) == 0)
154         {
155           /* Found it!  Go into manual mode, and use this language.  */
156           if (lang->la_language == language_auto)
157             {
158               /* Enter auto mode.  Set to the current frame's language, if
159                  known, or fallback to the initial language.  */
160               language_mode = language_mode_auto;
161               try
162                 {
163                   struct frame_info *frame;
164
165                   frame = get_selected_frame (NULL);
166                   flang = get_frame_language (frame);
167                 }
168               catch (const gdb_exception_error &ex)
169                 {
170                   flang = language_unknown;
171                 }
172
173               if (flang != language_unknown)
174                 set_language (flang);
175               else
176                 set_initial_language ();
177               expected_language = current_language;
178               return;
179             }
180           else
181             {
182               /* Enter manual mode.  Set the specified language.  */
183               language_mode = language_mode_manual;
184               current_language = lang;
185               set_range_case ();
186               expected_language = current_language;
187               return;
188             }
189         }
190     }
191
192   internal_error (__FILE__, __LINE__,
193                   "Couldn't find language `%s' in known languages list.",
194                   language);
195 }
196
197 /* Show command.  Display a warning if the range setting does
198    not match the current language.  */
199 static void
200 show_range_command (struct ui_file *file, int from_tty,
201                     struct cmd_list_element *c, const char *value)
202 {
203   if (range_mode == range_mode_auto)
204     {
205       const char *tmp;
206
207       switch (range_check)
208         {
209         case range_check_on:
210           tmp = "on";
211           break;
212         case range_check_off:
213           tmp = "off";
214           break;
215         case range_check_warn:
216           tmp = "warn";
217           break;
218         default:
219           internal_error (__FILE__, __LINE__,
220                           "Unrecognized range check setting.");
221         }
222
223       gdb_printf (file,
224                   _("Range checking is \"auto; currently %s\".\n"),
225                   tmp);
226     }
227   else
228     gdb_printf (file, _("Range checking is \"%s\".\n"),
229                 value);
230
231   if (range_check == range_check_warn
232       || ((range_check == range_check_on)
233           != current_language->range_checking_on_by_default ()))
234     warning (_("the current range check setting "
235                "does not match the language.\n"));
236 }
237
238 /* Set command.  Change the setting for range checking.  */
239 static void
240 set_range_command (const char *ignore,
241                    int from_tty, struct cmd_list_element *c)
242 {
243   if (strcmp (range, "on") == 0)
244     {
245       range_check = range_check_on;
246       range_mode = range_mode_manual;
247     }
248   else if (strcmp (range, "warn") == 0)
249     {
250       range_check = range_check_warn;
251       range_mode = range_mode_manual;
252     }
253   else if (strcmp (range, "off") == 0)
254     {
255       range_check = range_check_off;
256       range_mode = range_mode_manual;
257     }
258   else if (strcmp (range, "auto") == 0)
259     {
260       range_mode = range_mode_auto;
261       set_range_case ();
262       return;
263     }
264   else
265     {
266       internal_error (__FILE__, __LINE__,
267                       _("Unrecognized range check setting: \"%s\""), range);
268     }
269   if (range_check == range_check_warn
270       || ((range_check == range_check_on)
271           != current_language->range_checking_on_by_default ()))
272     warning (_("the current range check setting "
273                "does not match the language.\n"));
274 }
275
276 /* Show command.  Display a warning if the case sensitivity setting does
277    not match the current language.  */
278 static void
279 show_case_command (struct ui_file *file, int from_tty,
280                    struct cmd_list_element *c, const char *value)
281 {
282   if (case_mode == case_mode_auto)
283     {
284       const char *tmp = NULL;
285
286       switch (case_sensitivity)
287         {
288         case case_sensitive_on:
289           tmp = "on";
290           break;
291         case case_sensitive_off:
292           tmp = "off";
293           break;
294         default:
295           internal_error (__FILE__, __LINE__,
296                           "Unrecognized case-sensitive setting.");
297         }
298
299       gdb_printf (file,
300                   _("Case sensitivity in "
301                     "name search is \"auto; currently %s\".\n"),
302                   tmp);
303     }
304   else
305     gdb_printf (file,
306                 _("Case sensitivity in name search is \"%s\".\n"),
307                 value);
308
309   if (case_sensitivity != current_language->case_sensitivity ())
310     warning (_("the current case sensitivity setting does not match "
311                "the language.\n"));
312 }
313
314 /* Set command.  Change the setting for case sensitivity.  */
315
316 static void
317 set_case_command (const char *ignore, int from_tty, struct cmd_list_element *c)
318 {
319    if (strcmp (case_sensitive, "on") == 0)
320      {
321        case_sensitivity = case_sensitive_on;
322        case_mode = case_mode_manual;
323      }
324    else if (strcmp (case_sensitive, "off") == 0)
325      {
326        case_sensitivity = case_sensitive_off;
327        case_mode = case_mode_manual;
328      }
329    else if (strcmp (case_sensitive, "auto") == 0)
330      {
331        case_mode = case_mode_auto;
332        set_range_case ();
333        return;
334      }
335    else
336      {
337        internal_error (__FILE__, __LINE__,
338                        "Unrecognized case-sensitive setting: \"%s\"",
339                        case_sensitive);
340      }
341
342    if (case_sensitivity != current_language->case_sensitivity ())
343      warning (_("the current case sensitivity setting does not match "
344                 "the language.\n"));
345 }
346
347 /* Set the status of range and type checking and case sensitivity based on
348    the current modes and the current language.
349    If SHOW is non-zero, then print out the current language,
350    type and range checking status.  */
351 static void
352 set_range_case (void)
353 {
354   if (range_mode == range_mode_auto)
355     range_check = (current_language->range_checking_on_by_default ()
356                    ? range_check_on : range_check_off);
357
358   if (case_mode == case_mode_auto)
359     case_sensitivity = current_language->case_sensitivity ();
360 }
361
362 /* Set current language to (enum language) LANG.  Returns previous
363    language.  */
364
365 enum language
366 set_language (enum language lang)
367 {
368   enum language prev_language;
369
370   prev_language = current_language->la_language;
371   current_language = language_def (lang);
372   set_range_case ();
373   return prev_language;
374 }
375 \f
376
377 /* See language.h.  */
378
379 void
380 language_info ()
381 {
382   if (expected_language == current_language)
383     return;
384
385   expected_language = current_language;
386   gdb_printf (_("Current language:  %s\n"), language);
387   show_language_command (gdb_stdout, 1, NULL, NULL);
388 }
389 \f
390 /* This page contains functions for the printing out of
391    error messages that occur during type- and range-
392    checking.  */
393
394 /* This is called when a language fails a range-check.  The
395    first argument should be a printf()-style format string, and the
396    rest of the arguments should be its arguments.  If range_check is
397    range_check_on, an error is printed;  if range_check_warn, a warning;
398    otherwise just the message.  */
399
400 void
401 range_error (const char *string,...)
402 {
403   va_list args;
404
405   va_start (args, string);
406   switch (range_check)
407     {
408     case range_check_warn:
409       vwarning (string, args);
410       break;
411     case range_check_on:
412       verror (string, args);
413       break;
414     case range_check_off:
415       /* FIXME: cagney/2002-01-30: Should this function print anything
416          when range error is off?  */
417       gdb_vprintf (gdb_stderr, string, args);
418       gdb_printf (gdb_stderr, "\n");
419       break;
420     default:
421       internal_error (__FILE__, __LINE__, _("bad switch"));
422     }
423   va_end (args);
424 }
425 \f
426
427 /* This page contains miscellaneous functions.  */
428
429 /* Return the language enum for a given language string.  */
430
431 enum language
432 language_enum (const char *str)
433 {
434   for (const auto &lang : language_defn::languages)
435     if (strcmp (lang->name (), str) == 0)
436       return lang->la_language;
437
438   if (strcmp (str, "local") == 0)
439     return language_auto;
440
441   return language_unknown;
442 }
443
444 /* Return the language struct for a given language enum.  */
445
446 const struct language_defn *
447 language_def (enum language lang)
448 {
449   const struct language_defn *l = language_defn::languages[lang];
450   gdb_assert (l != nullptr);
451   return l;
452 }
453
454 /* Return the language as a string.  */
455
456 const char *
457 language_str (enum language lang)
458 {
459   return language_def (lang)->name ();
460 }
461
462 \f
463
464 /* Build and install the "set language LANG" command.  */
465
466 static void
467 add_set_language_command ()
468 {
469   static const char **language_names;
470
471   /* Build the language names array, to be used as enumeration in the
472      "set language" enum command.  +1 for "local" and +1 for NULL
473      termination.  */
474   language_names = new const char *[ARRAY_SIZE (language_defn::languages) + 2];
475
476   /* Display "auto", "local" and "unknown" first, and then the rest,
477      alpha sorted.  */
478   const char **language_names_p = language_names;
479   language = language_def (language_auto)->name ();
480   *language_names_p++ = language;
481   *language_names_p++ = "local";
482   *language_names_p++ = language_def (language_unknown)->name ();
483   const char **sort_begin = language_names_p;
484   for (const auto &lang : language_defn::languages)
485     {
486       /* Already handled above.  */
487       if (lang->la_language == language_auto
488           || lang->la_language == language_unknown)
489         continue;
490       *language_names_p++ = lang->name ();
491     }
492   *language_names_p = NULL;
493   std::sort (sort_begin, language_names_p, compare_cstrings);
494
495   /* Add the filename extensions.  */
496   for (const auto &lang : language_defn::languages)
497     for (const char * const &ext : lang->filename_extensions ())
498       add_filename_language (ext, lang->la_language);
499
500   /* Build the "help set language" docs.  */
501   string_file doc;
502
503   doc.printf (_("Set the current source language.\n"
504                 "The currently understood settings are:\n\nlocal or "
505                 "auto    Automatic setting based on source file"));
506
507   for (const auto &lang : language_defn::languages)
508     {
509       /* Already dealt with these above.  */
510       if (lang->la_language == language_unknown
511           || lang->la_language == language_auto)
512         continue;
513
514       /* Note that we add the newline at the front, so we don't wind
515          up with a trailing newline.  */
516       doc.printf ("\n%-16s Use the %s language",
517                   lang->name (),
518                   lang->natural_name ());
519     }
520
521   add_setshow_enum_cmd ("language", class_support,
522                         language_names,
523                         &language,
524                         doc.c_str (),
525                         _("Show the current source language."),
526                         NULL, set_language_command,
527                         show_language_command,
528                         &setlist, &showlist);
529 }
530
531 /* Iterate through all registered languages looking for and calling
532    any non-NULL struct language_defn.skip_trampoline() functions.
533    Return the result from the first that returns non-zero, or 0 if all
534    `fail'.  */
535 CORE_ADDR 
536 skip_language_trampoline (struct frame_info *frame, CORE_ADDR pc)
537 {
538   for (const auto &lang : language_defn::languages)
539     {
540       CORE_ADDR real_pc = lang->skip_trampoline (frame, pc);
541
542       if (real_pc != 0)
543         return real_pc;
544     }
545
546   return 0;
547 }
548
549 /* Return demangled language symbol, or NULL.
550    FIXME: Options are only useful for certain languages and ignored
551    by others, so it would be better to remove them here and have a
552    more flexible demangler for the languages that need it.
553    FIXME: Sometimes the demangler is invoked when we don't know the
554    language, so we can't use this everywhere.  */
555 gdb::unique_xmalloc_ptr<char>
556 language_demangle (const struct language_defn *current_language, 
557                                 const char *mangled, int options)
558 {
559   if (current_language != NULL)
560     return current_language->demangle_symbol (mangled, options);
561   return NULL;
562 }
563
564 /* Return information about whether TYPE should be passed
565    (and returned) by reference at the language level.  */
566
567 struct language_pass_by_ref_info
568 language_pass_by_reference (struct type *type)
569 {
570   return current_language->pass_by_reference_info (type);
571 }
572
573 /* Return the default string containing the list of characters
574    delimiting words.  This is a reasonable default value that
575    most languages should be able to use.  */
576
577 const char *
578 default_word_break_characters (void)
579 {
580   return " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,-";
581 }
582
583 /* See language.h.  */
584
585 void
586 language_defn::print_array_index (struct type *index_type, LONGEST index,
587                                   struct ui_file *stream,
588                                   const value_print_options *options) const
589 {
590   struct value *index_value = value_from_longest (index_type, index);
591
592   gdb_printf (stream, "[");
593   value_print (index_value, stream, options);
594   gdb_printf (stream, "] = ");
595 }
596
597 /* See language.h.  */
598
599 gdb::unique_xmalloc_ptr<char>
600 language_defn::watch_location_expression (struct type *type,
601                                           CORE_ADDR addr) const
602 {
603   /* Generates an expression that assumes a C like syntax is valid.  */
604   type = check_typedef (TYPE_TARGET_TYPE (check_typedef (type)));
605   std::string name = type_to_string (type);
606   return xstrprintf ("* (%s *) %s", name.c_str (), core_addr_to_string (addr));
607 }
608
609 /* See language.h.  */
610
611 void
612 language_defn::value_print (struct value *val, struct ui_file *stream,
613                const struct value_print_options *options) const
614 {
615   return c_value_print (val, stream, options);
616 }
617
618 /* See language.h.  */
619
620 int
621 language_defn::parser (struct parser_state *ps) const
622 {
623   return c_parse (ps);
624 }
625
626 /* See language.h.  */
627
628 void
629 language_defn::value_print_inner
630         (struct value *val, struct ui_file *stream, int recurse,
631          const struct value_print_options *options) const
632 {
633   return c_value_print_inner (val, stream, recurse, options);
634 }
635
636 /* See language.h.  */
637
638 void
639 language_defn::emitchar (int ch, struct type *chtype,
640                          struct ui_file * stream, int quoter) const
641 {
642   c_emit_char (ch, chtype, stream, quoter);
643 }
644
645 /* See language.h.  */
646
647 void
648 language_defn::printstr (struct ui_file *stream, struct type *elttype,
649                          const gdb_byte *string, unsigned int length,
650                          const char *encoding, int force_ellipses,
651                          const struct value_print_options *options) const
652 {
653   c_printstr (stream, elttype, string, length, encoding, force_ellipses,
654               options);
655 }
656
657 /* See language.h.  */
658
659 void
660 language_defn::print_typedef (struct type *type, struct symbol *new_symbol,
661                               struct ui_file *stream) const
662 {
663   c_print_typedef (type, new_symbol, stream);
664 }
665
666 /* See language.h.  */
667
668 bool
669 language_defn::is_string_type_p (struct type *type) const
670 {
671   return c_is_string_type_p (type);
672 }
673
674 /* See language.h.  */
675
676 std::unique_ptr<compile_instance>
677 language_defn::get_compile_instance () const
678 {
679   return {};
680 }
681
682 /* The default implementation of the get_symbol_name_matcher_inner method
683    from the language_defn class.  Matches with strncmp_iw.  */
684
685 static bool
686 default_symbol_name_matcher (const char *symbol_search_name,
687                              const lookup_name_info &lookup_name,
688                              completion_match_result *comp_match_res)
689 {
690   gdb::string_view name = lookup_name.name ();
691   completion_match_for_lcd *match_for_lcd
692     = (comp_match_res != NULL ? &comp_match_res->match_for_lcd : NULL);
693   strncmp_iw_mode mode = (lookup_name.completion_mode ()
694                           ? strncmp_iw_mode::NORMAL
695                           : strncmp_iw_mode::MATCH_PARAMS);
696
697   if (strncmp_iw_with_mode (symbol_search_name, name.data (), name.size (),
698                             mode, language_minimal, match_for_lcd) == 0)
699     {
700       if (comp_match_res != NULL)
701         comp_match_res->set_match (symbol_search_name);
702       return true;
703     }
704   else
705     return false;
706 }
707
708 /* See language.h.  */
709
710 symbol_name_matcher_ftype *
711 language_defn::get_symbol_name_matcher
712         (const lookup_name_info &lookup_name) const
713 {
714   /* If currently in Ada mode, and the lookup name is wrapped in
715      '<...>', hijack all symbol name comparisons using the Ada
716      matcher, which handles the verbatim matching.  */
717   if (current_language->la_language == language_ada
718       && lookup_name.ada ().verbatim_p ())
719     return current_language->get_symbol_name_matcher_inner (lookup_name);
720
721   return this->get_symbol_name_matcher_inner (lookup_name);
722 }
723
724 /* See language.h.  */
725
726 symbol_name_matcher_ftype *
727 language_defn::get_symbol_name_matcher_inner
728         (const lookup_name_info &lookup_name) const
729 {
730   return default_symbol_name_matcher;
731 }
732
733 /* See language.h.  */
734
735 const struct lang_varobj_ops *
736 language_defn::varobj_ops () const
737 {
738   /* The ops for the C language are suitable for the vast majority of the
739      supported languages.  */
740   return &c_varobj_ops;
741 }
742
743 /* Parent class for both the "auto" and "unknown" languages.  These two
744    pseudo-languages are very similar so merging their implementations like
745    this makes sense.  */
746
747 class auto_or_unknown_language : public language_defn
748 {
749 public:
750   auto_or_unknown_language (enum language lang)
751     : language_defn (lang)
752   { /* Nothing.  */ }
753
754   /* See language.h.  */
755   void language_arch_info (struct gdbarch *gdbarch,
756                            struct language_arch_info *lai) const override
757   {
758     lai->set_string_char_type (builtin_type (gdbarch)->builtin_char);
759     lai->set_bool_type (builtin_type (gdbarch)->builtin_int);
760   }
761
762   /* See language.h.  */
763
764   void print_type (struct type *type, const char *varstring,
765                    struct ui_file *stream, int show, int level,
766                    const struct type_print_options *flags) const override
767   {
768     error (_("type printing not implemented for language \"%s\""),
769            natural_name ());
770   }
771
772   /* See language.h.  */
773
774   gdb::unique_xmalloc_ptr<char> demangle_symbol (const char *mangled,
775                                                  int options) const override
776   {
777     /* The auto language just uses the C++ demangler.  */
778     return gdb_demangle (mangled, options);
779   }
780
781   /* See language.h.  */
782
783   void value_print (struct value *val, struct ui_file *stream,
784                     const struct value_print_options *options) const override
785   {
786     error (_("value printing not implemented for language \"%s\""),
787            natural_name ());
788   }
789
790   /* See language.h.  */
791
792   void value_print_inner
793         (struct value *val, struct ui_file *stream, int recurse,
794          const struct value_print_options *options) const override
795   {
796     error (_("inner value printing not implemented for language \"%s\""),
797            natural_name ());
798   }
799
800   /* See language.h.  */
801
802   int parser (struct parser_state *ps) const override
803   {
804     error (_("expression parsing not implemented for language \"%s\""),
805            natural_name ());
806   }
807
808   /* See language.h.  */
809
810   void emitchar (int ch, struct type *chtype,
811                  struct ui_file *stream, int quoter) const override
812   {
813     error (_("emit character not implemented for language \"%s\""),
814            natural_name ());
815   }
816
817   /* See language.h.  */
818
819   void printchar (int ch, struct type *chtype,
820                   struct ui_file *stream) const override
821   {
822     error (_("print character not implemented for language \"%s\""),
823            natural_name ());
824   }
825
826   /* See language.h.  */
827
828   void printstr (struct ui_file *stream, struct type *elttype,
829                  const gdb_byte *string, unsigned int length,
830                  const char *encoding, int force_ellipses,
831                  const struct value_print_options *options) const override
832   {
833     error (_("print string not implemented for language \"%s\""),
834            natural_name ());
835   }
836
837   /* See language.h.  */
838
839   void print_typedef (struct type *type, struct symbol *new_symbol,
840                       struct ui_file *stream) const override
841   {
842     error (_("print typedef not implemented for language \"%s\""),
843            natural_name ());
844   }
845
846   /* See language.h.  */
847
848   bool is_string_type_p (struct type *type) const override
849   {
850     type = check_typedef (type);
851     while (type->code () == TYPE_CODE_REF)
852       {
853         type = TYPE_TARGET_TYPE (type);
854         type = check_typedef (type);
855       }
856     return (type->code () == TYPE_CODE_STRING);
857   }
858
859   /* See language.h.  */
860
861   const char *name_of_this () const override
862   { return "this"; }
863 };
864
865 /* Class representing the fake "auto" language.  */
866
867 class auto_language : public auto_or_unknown_language
868 {
869 public:
870   auto_language ()
871     : auto_or_unknown_language (language_auto)
872   { /* Nothing.  */ }
873
874   /* See language.h.  */
875
876   const char *name () const override
877   { return "auto"; }
878
879   /* See language.h.  */
880
881   const char *natural_name () const override
882   { return "Auto"; }
883 };
884
885 /* Single instance of the fake "auto" language.  */
886
887 static auto_language auto_language_defn;
888
889 /* Class representing the unknown language.  */
890
891 class unknown_language : public auto_or_unknown_language
892 {
893 public:
894   unknown_language ()
895     : auto_or_unknown_language (language_unknown)
896   { /* Nothing.  */ }
897
898   /* See language.h.  */
899
900   const char *name () const override
901   { return "unknown"; }
902
903   /* See language.h.  */
904
905   const char *natural_name () const override
906   { return "Unknown"; }
907
908   /* See language.h.  */
909
910   bool store_sym_names_in_linkage_form_p () const override
911   { return true; }
912 };
913
914 /* Single instance of the unknown language class.  */
915
916 static unknown_language unknown_language_defn;
917
918 \f
919 /* Per-architecture language information.  */
920
921 static struct gdbarch_data *language_gdbarch_data;
922
923 struct language_gdbarch
924 {
925   /* A vector of per-language per-architecture info.  Indexed by "enum
926      language".  */
927   struct language_arch_info arch_info[nr_languages];
928 };
929
930 static void *
931 language_gdbarch_post_init (struct gdbarch *gdbarch)
932 {
933   struct language_gdbarch *l
934     = obstack_new<struct language_gdbarch> (gdbarch_obstack (gdbarch));
935   for (const auto &lang : language_defn::languages)
936     {
937       gdb_assert (lang != nullptr);
938       lang->language_arch_info (gdbarch, &l->arch_info[lang->la_language]);
939     }
940
941   return l;
942 }
943
944 /* See language.h.  */
945
946 struct type *
947 language_string_char_type (const struct language_defn *la,
948                            struct gdbarch *gdbarch)
949 {
950   struct language_gdbarch *ld
951     = (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
952   return ld->arch_info[la->la_language].string_char_type ();
953 }
954
955 /* See language.h.  */
956
957 struct type *
958 language_bool_type (const struct language_defn *la,
959                     struct gdbarch *gdbarch)
960 {
961   struct language_gdbarch *ld
962     = (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
963   return ld->arch_info[la->la_language].bool_type ();
964 }
965
966 /* See language.h.  */
967
968 struct type *
969 language_arch_info::bool_type () const
970 {
971   if (m_bool_type_name != nullptr)
972     {
973       struct symbol *sym;
974
975       sym = lookup_symbol (m_bool_type_name, NULL, VAR_DOMAIN, NULL).symbol;
976       if (sym != nullptr)
977         {
978           struct type *type = sym->type ();
979           if (type != nullptr && type->code () == TYPE_CODE_BOOL)
980             return type;
981         }
982     }
983
984   return m_bool_type_default;
985 }
986
987 /* See language.h.  */
988
989 struct symbol *
990 language_arch_info::type_and_symbol::alloc_type_symbol
991         (enum language lang, struct type *type)
992 {
993   struct symbol *symbol;
994   struct gdbarch *gdbarch;
995   gdb_assert (!type->is_objfile_owned ());
996   gdbarch = type->arch_owner ();
997   symbol = new (gdbarch_obstack (gdbarch)) struct symbol ();
998   symbol->m_name = type->name ();
999   symbol->set_language (lang, nullptr);
1000   symbol->owner.arch = gdbarch;
1001   symbol->set_is_objfile_owned (0);
1002   symbol->set_section_index (0);
1003   symbol->set_type (type);
1004   symbol->set_domain (VAR_DOMAIN);
1005   symbol->set_aclass_index (LOC_TYPEDEF);
1006   return symbol;
1007 }
1008
1009 /* See language.h.  */
1010
1011 language_arch_info::type_and_symbol *
1012 language_arch_info::lookup_primitive_type_and_symbol (const char *name)
1013 {
1014   for (struct type_and_symbol &tas : primitive_types_and_symbols)
1015     {
1016       if (strcmp (tas.type ()->name (), name) == 0)
1017         return &tas;
1018     }
1019
1020   return nullptr;
1021 }
1022
1023 /* See language.h.  */
1024
1025 struct type *
1026 language_arch_info::lookup_primitive_type (const char *name)
1027 {
1028   type_and_symbol *tas = lookup_primitive_type_and_symbol (name);
1029   if (tas != nullptr)
1030     return tas->type ();
1031   return nullptr;
1032 }
1033
1034 /* See language.h.  */
1035
1036 struct type *
1037 language_arch_info::lookup_primitive_type
1038   (gdb::function_view<bool (struct type *)> filter)
1039 {
1040   for (struct type_and_symbol &tas : primitive_types_and_symbols)
1041     {
1042       if (filter (tas.type ()))
1043         return tas.type ();
1044     }
1045
1046   return nullptr;
1047 }
1048
1049 /* See language.h.  */
1050
1051 struct symbol *
1052 language_arch_info::lookup_primitive_type_as_symbol (const char *name,
1053                                                      enum language lang)
1054 {
1055   type_and_symbol *tas = lookup_primitive_type_and_symbol (name);
1056   if (tas != nullptr)
1057     return tas->symbol (lang);
1058   return nullptr;
1059 }
1060
1061 /* Helper for the language_lookup_primitive_type overloads to forward
1062    to the corresponding language's lookup_primitive_type overload.  */
1063
1064 template<typename T>
1065 static struct type *
1066 language_lookup_primitive_type_1 (const struct language_defn *la,
1067                                   struct gdbarch *gdbarch,
1068                                   T arg)
1069 {
1070   struct language_gdbarch *ld =
1071     (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
1072   return ld->arch_info[la->la_language].lookup_primitive_type (arg);
1073 }
1074
1075 /* See language.h.  */
1076
1077 struct type *
1078 language_lookup_primitive_type (const struct language_defn *la,
1079                                 struct gdbarch *gdbarch,
1080                                 const char *name)
1081 {
1082   return language_lookup_primitive_type_1 (la, gdbarch, name);
1083 }
1084
1085 /* See language.h.  */
1086
1087 struct type *
1088 language_lookup_primitive_type (const struct language_defn *la,
1089                                 struct gdbarch *gdbarch,
1090                                 gdb::function_view<bool (struct type *)> filter)
1091 {
1092   return language_lookup_primitive_type_1 (la, gdbarch, filter);
1093 }
1094
1095 /* See language.h.  */
1096
1097 struct symbol *
1098 language_lookup_primitive_type_as_symbol (const struct language_defn *la,
1099                                           struct gdbarch *gdbarch,
1100                                           const char *name)
1101 {
1102   struct language_gdbarch *ld
1103     = (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
1104   struct language_arch_info *lai = &ld->arch_info[la->la_language];
1105
1106   if (symbol_lookup_debug)
1107     gdb_printf (gdb_stdlog,
1108                 "language_lookup_primitive_type_as_symbol"
1109                 " (%s, %s, %s)",
1110                 la->name (), host_address_to_string (gdbarch), name);
1111
1112   struct symbol *sym
1113     = lai->lookup_primitive_type_as_symbol (name, la->la_language);
1114
1115   if (symbol_lookup_debug)
1116     gdb_printf (gdb_stdlog, " = %s\n", host_address_to_string (sym));
1117
1118   /* Note: The result of symbol lookup is normally a symbol *and* the block
1119      it was found in.  Builtin types don't live in blocks.  We *could* give
1120      them one, but there is no current need so to keep things simple symbol
1121      lookup is extended to allow for BLOCK_FOUND to be NULL.  */
1122
1123   return sym;
1124 }
1125
1126 /* Initialize the language routines.  */
1127
1128 void _initialize_language ();
1129 void
1130 _initialize_language ()
1131 {
1132   static const char *const type_or_range_names[]
1133     = { "on", "off", "warn", "auto", NULL };
1134
1135   static const char *const case_sensitive_names[]
1136     = { "on", "off", "auto", NULL };
1137
1138   language_gdbarch_data
1139     = gdbarch_data_register_post_init (language_gdbarch_post_init);
1140
1141   /* GDB commands for language specific stuff.  */
1142
1143   set_show_commands setshow_check_cmds
1144     = add_setshow_prefix_cmd ("check", no_class,
1145                               _("Set the status of the type/range checker."),
1146                               _("Show the status of the type/range checker."),
1147                               &setchecklist, &showchecklist,
1148                               &setlist, &showlist);
1149   add_alias_cmd ("c", setshow_check_cmds.set, no_class, 1, &setlist);
1150   add_alias_cmd ("ch", setshow_check_cmds.set, no_class, 1, &setlist);
1151   add_alias_cmd ("c", setshow_check_cmds.show, no_class, 1, &showlist);
1152   add_alias_cmd ("ch", setshow_check_cmds.show, no_class, 1, &showlist);
1153
1154   range = type_or_range_names[3];
1155   gdb_assert (strcmp (range, "auto") == 0);
1156   add_setshow_enum_cmd ("range", class_support, type_or_range_names,
1157                         &range,
1158                         _("Set range checking (on/warn/off/auto)."),
1159                         _("Show range checking (on/warn/off/auto)."),
1160                         NULL, set_range_command,
1161                         show_range_command,
1162                         &setchecklist, &showchecklist);
1163
1164   case_sensitive = case_sensitive_names[2];
1165   gdb_assert (strcmp (case_sensitive, "auto") == 0);
1166   add_setshow_enum_cmd ("case-sensitive", class_support, case_sensitive_names,
1167                         &case_sensitive, _("\
1168 Set case sensitivity in name search (on/off/auto)."), _("\
1169 Show case sensitivity in name search (on/off/auto)."), _("\
1170 For Fortran the default is off; for other languages the default is on."),
1171                         set_case_command,
1172                         show_case_command,
1173                         &setlist, &showlist);
1174
1175   /* In order to call SET_LANGUAGE (below) we need to make sure that
1176      CURRENT_LANGUAGE is not NULL.  So first set the language to unknown,
1177      then we can change the language to 'auto'.  */
1178   current_language = language_def (language_unknown);
1179
1180   add_set_language_command ();
1181
1182   /* Have the above take effect.  */
1183   set_language (language_auto);
1184 }
This page took 0.09499 seconds and 4 git commands to generate.