PR c++/11990:
[deliverable/binutils-gdb.git] / gdb / language.c
1 /* Multiple source language support for GDB.
2
3 Copyright (C) 1991-2013 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 "gdb_string.h"
34
35 #include "symtab.h"
36 #include "gdbtypes.h"
37 #include "value.h"
38 #include "gdbcmd.h"
39 #include "expression.h"
40 #include "language.h"
41 #include "target.h"
42 #include "parser-defs.h"
43 #include "jv-lang.h"
44 #include "demangle.h"
45 #include "symfile.h"
46 #include "cp-support.h"
47
48 extern void _initialize_language (void);
49
50 static void unk_lang_error (char *);
51
52 static int unk_lang_parser (void);
53
54 static void show_check (char *, int);
55
56 static void set_check (char *, int);
57
58 static void set_range_case (void);
59
60 static void unk_lang_emit_char (int c, struct type *type,
61 struct ui_file *stream, int quoter);
62
63 static void unk_lang_printchar (int c, struct type *type,
64 struct ui_file *stream);
65
66 static void unk_lang_value_print (struct value *, struct ui_file *,
67 const struct value_print_options *);
68
69 static CORE_ADDR unk_lang_trampoline (struct frame_info *, CORE_ADDR pc);
70
71 /* Forward declaration */
72 extern const struct language_defn unknown_language_defn;
73
74 /* The current (default at startup) state of type and range checking.
75 (If the modes are set to "auto", though, these are changed based
76 on the default language at startup, and then again based on the
77 language of the first source file. */
78
79 enum range_mode range_mode = range_mode_auto;
80 enum range_check range_check = range_check_off;
81 enum case_mode case_mode = case_mode_auto;
82 enum case_sensitivity case_sensitivity = case_sensitive_on;
83
84 /* The current language and language_mode (see language.h). */
85
86 const struct language_defn *current_language = &unknown_language_defn;
87 enum language_mode language_mode = language_mode_auto;
88
89 /* The language that the user expects to be typing in (the language
90 of main(), or the last language we notified them about, or C). */
91
92 const struct language_defn *expected_language;
93
94 /* The list of supported languages. The list itself is malloc'd. */
95
96 static const struct language_defn **languages;
97 static unsigned languages_size;
98 static unsigned languages_allocsize;
99 #define DEFAULT_ALLOCSIZE 4
100
101 /* The current values of the "set language/type/range" enum
102 commands. */
103 static const char *language;
104 static const char *type;
105 static const char *range;
106 static const char *case_sensitive;
107
108 /* Warning issued when current_language and the language of the current
109 frame do not match. */
110 char lang_frame_mismatch_warn[] =
111 "Warning: the current language does not match this frame.";
112 \f
113 /* This page contains the functions corresponding to GDB commands
114 and their helpers. */
115
116 /* Show command. Display a warning if the language set
117 does not match the frame. */
118 static void
119 show_language_command (struct ui_file *file, int from_tty,
120 struct cmd_list_element *c, const char *value)
121 {
122 enum language flang; /* The language of the current frame. */
123
124 if (language_mode == language_mode_auto)
125 fprintf_filtered (gdb_stdout,
126 _("The current source language is "
127 "\"auto; currently %s\".\n"),
128 current_language->la_name);
129 else
130 fprintf_filtered (gdb_stdout,
131 _("The current source language is \"%s\".\n"),
132 current_language->la_name);
133
134 flang = get_frame_language ();
135 if (flang != language_unknown &&
136 language_mode == language_mode_manual &&
137 current_language->la_language != flang)
138 printf_filtered ("%s\n", lang_frame_mismatch_warn);
139 }
140
141 /* Set command. Change the current working language. */
142 static void
143 set_language_command (char *ignore, int from_tty, struct cmd_list_element *c)
144 {
145 int i;
146 enum language flang;
147
148 /* Search the list of languages for a match. */
149 for (i = 0; i < languages_size; i++)
150 {
151 if (strcmp (languages[i]->la_name, language) == 0)
152 {
153 /* Found it! Go into manual mode, and use this language. */
154 if (languages[i]->la_language == language_auto)
155 {
156 /* Enter auto mode. Set to the current frame's language, if
157 known, or fallback to the initial language. */
158 language_mode = language_mode_auto;
159 flang = get_frame_language ();
160 if (flang != language_unknown)
161 set_language (flang);
162 else
163 set_initial_language ();
164 expected_language = current_language;
165 return;
166 }
167 else
168 {
169 /* Enter manual mode. Set the specified language. */
170 language_mode = language_mode_manual;
171 current_language = languages[i];
172 set_range_case ();
173 expected_language = current_language;
174 return;
175 }
176 }
177 }
178
179 internal_error (__FILE__, __LINE__,
180 "Couldn't find language `%s' in known languages list.",
181 language);
182 }
183
184 /* Show command. Display a warning if the range setting does
185 not match the current language. */
186 static void
187 show_range_command (struct ui_file *file, int from_tty,
188 struct cmd_list_element *c, const char *value)
189 {
190 if (range_mode == range_mode_auto)
191 {
192 char *tmp;
193
194 switch (range_check)
195 {
196 case range_check_on:
197 tmp = "on";
198 break;
199 case range_check_off:
200 tmp = "off";
201 break;
202 case range_check_warn:
203 tmp = "warn";
204 break;
205 default:
206 internal_error (__FILE__, __LINE__,
207 "Unrecognized range check setting.");
208 }
209
210 fprintf_filtered (gdb_stdout,
211 _("Range checking is \"auto; currently %s\".\n"),
212 tmp);
213 }
214 else
215 fprintf_filtered (gdb_stdout, _("Range checking is \"%s\".\n"),
216 value);
217
218 if (range_check != current_language->la_range_check)
219 warning (_("the current range check setting "
220 "does not match the language.\n"));
221 }
222
223 /* Set command. Change the setting for range checking. */
224 static void
225 set_range_command (char *ignore, int from_tty, struct cmd_list_element *c)
226 {
227 if (strcmp (range, "on") == 0)
228 {
229 range_check = range_check_on;
230 range_mode = range_mode_manual;
231 }
232 else if (strcmp (range, "warn") == 0)
233 {
234 range_check = range_check_warn;
235 range_mode = range_mode_manual;
236 }
237 else if (strcmp (range, "off") == 0)
238 {
239 range_check = range_check_off;
240 range_mode = range_mode_manual;
241 }
242 else if (strcmp (range, "auto") == 0)
243 {
244 range_mode = range_mode_auto;
245 set_range_case ();
246 return;
247 }
248 else
249 {
250 internal_error (__FILE__, __LINE__,
251 _("Unrecognized range check setting: \"%s\""), range);
252 }
253 if (range_check != current_language->la_range_check)
254 warning (_("the current range check setting "
255 "does not match the language.\n"));
256 }
257
258 /* Show command. Display a warning if the case sensitivity setting does
259 not match the current language. */
260 static void
261 show_case_command (struct ui_file *file, int from_tty,
262 struct cmd_list_element *c, const char *value)
263 {
264 if (case_mode == case_mode_auto)
265 {
266 char *tmp = NULL;
267
268 switch (case_sensitivity)
269 {
270 case case_sensitive_on:
271 tmp = "on";
272 break;
273 case case_sensitive_off:
274 tmp = "off";
275 break;
276 default:
277 internal_error (__FILE__, __LINE__,
278 "Unrecognized case-sensitive setting.");
279 }
280
281 fprintf_filtered (gdb_stdout,
282 _("Case sensitivity in "
283 "name search is \"auto; currently %s\".\n"),
284 tmp);
285 }
286 else
287 fprintf_filtered (gdb_stdout,
288 _("Case sensitivity in name search is \"%s\".\n"),
289 value);
290
291 if (case_sensitivity != current_language->la_case_sensitivity)
292 warning (_("the current case sensitivity setting does not match "
293 "the language.\n"));
294 }
295
296 /* Set command. Change the setting for case sensitivity. */
297
298 static void
299 set_case_command (char *ignore, int from_tty, struct cmd_list_element *c)
300 {
301 if (strcmp (case_sensitive, "on") == 0)
302 {
303 case_sensitivity = case_sensitive_on;
304 case_mode = case_mode_manual;
305 }
306 else if (strcmp (case_sensitive, "off") == 0)
307 {
308 case_sensitivity = case_sensitive_off;
309 case_mode = case_mode_manual;
310 }
311 else if (strcmp (case_sensitive, "auto") == 0)
312 {
313 case_mode = case_mode_auto;
314 set_range_case ();
315 return;
316 }
317 else
318 {
319 internal_error (__FILE__, __LINE__,
320 "Unrecognized case-sensitive setting: \"%s\"",
321 case_sensitive);
322 }
323
324 if (case_sensitivity != current_language->la_case_sensitivity)
325 warning (_("the current case sensitivity setting does not match "
326 "the language.\n"));
327 }
328
329 /* Set the status of range and type checking and case sensitivity based on
330 the current modes and the current language.
331 If SHOW is non-zero, then print out the current language,
332 type and range checking status. */
333 static void
334 set_range_case (void)
335 {
336 if (range_mode == range_mode_auto)
337 range_check = current_language->la_range_check;
338
339 if (case_mode == case_mode_auto)
340 case_sensitivity = current_language->la_case_sensitivity;
341 }
342
343 /* Set current language to (enum language) LANG. Returns previous
344 language. */
345
346 enum language
347 set_language (enum language lang)
348 {
349 int i;
350 enum language prev_language;
351
352 prev_language = current_language->la_language;
353
354 for (i = 0; i < languages_size; i++)
355 {
356 if (languages[i]->la_language == lang)
357 {
358 current_language = languages[i];
359 set_range_case ();
360 break;
361 }
362 }
363
364 return prev_language;
365 }
366 \f
367
368 /* Print out the current language settings: language, range and
369 type checking. If QUIETLY, print only what has changed. */
370
371 void
372 language_info (int quietly)
373 {
374 if (quietly && expected_language == current_language)
375 return;
376
377 expected_language = current_language;
378 printf_unfiltered (_("Current language: %s\n"), language);
379 show_language_command (NULL, 1, NULL, NULL);
380
381 if (!quietly)
382 {
383 printf_unfiltered (_("Range checking: %s\n"), range);
384 show_range_command (NULL, 1, NULL, NULL);
385 printf_unfiltered (_("Case sensitivity: %s\n"), case_sensitive);
386 show_case_command (NULL, 1, NULL, NULL);
387 }
388 }
389 \f
390
391 /* Returns non-zero if the value is a pointer type. */
392 int
393 pointer_type (struct type *type)
394 {
395 return TYPE_CODE (type) == TYPE_CODE_PTR ||
396 TYPE_CODE (type) == TYPE_CODE_REF;
397 }
398
399 \f
400 /* This page contains functions that return info about
401 (struct value) values used in GDB. */
402
403 /* Returns non-zero if the value VAL represents a true value. */
404 int
405 value_true (struct value *val)
406 {
407 /* It is possible that we should have some sort of error if a non-boolean
408 value is used in this context. Possibly dependent on some kind of
409 "boolean-checking" option like range checking. But it should probably
410 not depend on the language except insofar as is necessary to identify
411 a "boolean" value (i.e. in C using a float, pointer, etc., as a boolean
412 should be an error, probably). */
413 return !value_logical_not (val);
414 }
415 \f
416 /* This page contains functions for the printing out of
417 error messages that occur during type- and range-
418 checking. */
419
420 /* This is called when a language fails a range-check. The
421 first argument should be a printf()-style format string, and the
422 rest of the arguments should be its arguments. If range_check is
423 range_check_on, an error is printed; if range_check_warn, a warning;
424 otherwise just the message. */
425
426 void
427 range_error (const char *string,...)
428 {
429 va_list args;
430
431 va_start (args, string);
432 switch (range_check)
433 {
434 case range_check_warn:
435 vwarning (string, args);
436 break;
437 case range_check_on:
438 verror (string, args);
439 break;
440 case range_check_off:
441 /* FIXME: cagney/2002-01-30: Should this function print anything
442 when range error is off? */
443 vfprintf_filtered (gdb_stderr, string, args);
444 fprintf_filtered (gdb_stderr, "\n");
445 break;
446 default:
447 internal_error (__FILE__, __LINE__, _("bad switch"));
448 }
449 va_end (args);
450 }
451 \f
452
453 /* This page contains miscellaneous functions. */
454
455 /* Return the language enum for a given language string. */
456
457 enum language
458 language_enum (char *str)
459 {
460 int i;
461
462 for (i = 0; i < languages_size; i++)
463 if (strcmp (languages[i]->la_name, str) == 0)
464 return languages[i]->la_language;
465
466 return language_unknown;
467 }
468
469 /* Return the language struct for a given language enum. */
470
471 const struct language_defn *
472 language_def (enum language lang)
473 {
474 int i;
475
476 for (i = 0; i < languages_size; i++)
477 {
478 if (languages[i]->la_language == lang)
479 {
480 return languages[i];
481 }
482 }
483 return NULL;
484 }
485
486 /* Return the language as a string. */
487 char *
488 language_str (enum language lang)
489 {
490 int i;
491
492 for (i = 0; i < languages_size; i++)
493 {
494 if (languages[i]->la_language == lang)
495 {
496 return languages[i]->la_name;
497 }
498 }
499 return "Unknown";
500 }
501
502 static void
503 set_check (char *ignore, int from_tty)
504 {
505 printf_unfiltered (
506 "\"set check\" must be followed by the name of a check subcommand.\n");
507 help_list (setchecklist, "set check ", -1, gdb_stdout);
508 }
509
510 static void
511 show_check (char *ignore, int from_tty)
512 {
513 cmd_show_list (showchecklist, from_tty, "");
514 }
515 \f
516 /* Add a language to the set of known languages. */
517
518 void
519 add_language (const struct language_defn *lang)
520 {
521 /* For the "set language" command. */
522 static char **language_names = NULL;
523 /* For the "help set language" command. */
524 char *language_set_doc = NULL;
525
526 int i;
527 struct ui_file *tmp_stream;
528
529 if (lang->la_magic != LANG_MAGIC)
530 {
531 fprintf_unfiltered (gdb_stderr,
532 "Magic number of %s language struct wrong\n",
533 lang->la_name);
534 internal_error (__FILE__, __LINE__,
535 _("failed internal consistency check"));
536 }
537
538 if (!languages)
539 {
540 languages_allocsize = DEFAULT_ALLOCSIZE;
541 languages = (const struct language_defn **) xmalloc
542 (languages_allocsize * sizeof (*languages));
543 }
544 if (languages_size >= languages_allocsize)
545 {
546 languages_allocsize *= 2;
547 languages = (const struct language_defn **) xrealloc ((char *) languages,
548 languages_allocsize * sizeof (*languages));
549 }
550 languages[languages_size++] = lang;
551
552 /* Build the language names array, to be used as enumeration in the
553 set language" enum command. */
554 language_names = xrealloc (language_names,
555 (languages_size + 1) * sizeof (const char *));
556 for (i = 0; i < languages_size; ++i)
557 language_names[i] = languages[i]->la_name;
558 language_names[i] = NULL;
559
560 /* Build the "help set language" docs. */
561 tmp_stream = mem_fileopen ();
562
563 fprintf_unfiltered (tmp_stream,
564 _("Set the current source language.\n"
565 "The currently understood settings are:\n\nlocal or "
566 "auto Automatic setting based on source file\n"));
567
568 for (i = 0; i < languages_size; ++i)
569 {
570 /* Already dealt with these above. */
571 if (languages[i]->la_language == language_unknown
572 || languages[i]->la_language == language_auto)
573 continue;
574
575 /* FIXME: i18n: for now assume that the human-readable name
576 is just a capitalization of the internal name. */
577 fprintf_unfiltered (tmp_stream, "%-16s Use the %c%s language\n",
578 languages[i]->la_name,
579 /* Capitalize first letter of language
580 name. */
581 toupper (languages[i]->la_name[0]),
582 languages[i]->la_name + 1);
583 }
584
585 language_set_doc = ui_file_xstrdup (tmp_stream, NULL);
586 ui_file_delete (tmp_stream);
587
588 add_setshow_enum_cmd ("language", class_support,
589 (const char **) language_names,
590 &language,
591 language_set_doc,
592 _("Show the current source language."),
593 NULL, set_language_command,
594 show_language_command,
595 &setlist, &showlist);
596
597 xfree (language_set_doc);
598 }
599
600 /* Iterate through all registered languages looking for and calling
601 any non-NULL struct language_defn.skip_trampoline() functions.
602 Return the result from the first that returns non-zero, or 0 if all
603 `fail'. */
604 CORE_ADDR
605 skip_language_trampoline (struct frame_info *frame, CORE_ADDR pc)
606 {
607 int i;
608
609 for (i = 0; i < languages_size; i++)
610 {
611 if (languages[i]->skip_trampoline)
612 {
613 CORE_ADDR real_pc = (languages[i]->skip_trampoline) (frame, pc);
614
615 if (real_pc)
616 return real_pc;
617 }
618 }
619
620 return 0;
621 }
622
623 /* Return demangled language symbol, or NULL.
624 FIXME: Options are only useful for certain languages and ignored
625 by others, so it would be better to remove them here and have a
626 more flexible demangler for the languages that need it.
627 FIXME: Sometimes the demangler is invoked when we don't know the
628 language, so we can't use this everywhere. */
629 char *
630 language_demangle (const struct language_defn *current_language,
631 const char *mangled, int options)
632 {
633 if (current_language != NULL && current_language->la_demangle)
634 return current_language->la_demangle (mangled, options);
635 return NULL;
636 }
637
638 /* Return class name from physname or NULL. */
639 char *
640 language_class_name_from_physname (const struct language_defn *lang,
641 const char *physname)
642 {
643 if (lang != NULL && lang->la_class_name_from_physname)
644 return lang->la_class_name_from_physname (physname);
645 return NULL;
646 }
647
648 /* Return non-zero if TYPE should be passed (and returned) by
649 reference at the language level. */
650 int
651 language_pass_by_reference (struct type *type)
652 {
653 return current_language->la_pass_by_reference (type);
654 }
655
656 /* Return zero; by default, types are passed by value at the language
657 level. The target ABI may pass or return some structs by reference
658 independent of this. */
659 int
660 default_pass_by_reference (struct type *type)
661 {
662 return 0;
663 }
664
665 /* Return the default string containing the list of characters
666 delimiting words. This is a reasonable default value that
667 most languages should be able to use. */
668
669 char *
670 default_word_break_characters (void)
671 {
672 return " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,-";
673 }
674
675 /* Print the index of array elements using the C99 syntax. */
676
677 void
678 default_print_array_index (struct value *index_value, struct ui_file *stream,
679 const struct value_print_options *options)
680 {
681 fprintf_filtered (stream, "[");
682 LA_VALUE_PRINT (index_value, stream, options);
683 fprintf_filtered (stream, "] = ");
684 }
685
686 void
687 default_get_string (struct value *value, gdb_byte **buffer, int *length,
688 struct type **char_type, const char **charset)
689 {
690 error (_("Getting a string is unsupported in this language."));
691 }
692
693 /* Define the language that is no language. */
694
695 static int
696 unk_lang_parser (void)
697 {
698 return 1;
699 }
700
701 static void
702 unk_lang_error (char *msg)
703 {
704 error (_("Attempted to parse an expression with unknown language"));
705 }
706
707 static void
708 unk_lang_emit_char (int c, struct type *type, struct ui_file *stream,
709 int quoter)
710 {
711 error (_("internal error - unimplemented "
712 "function unk_lang_emit_char called."));
713 }
714
715 static void
716 unk_lang_printchar (int c, struct type *type, struct ui_file *stream)
717 {
718 error (_("internal error - unimplemented "
719 "function unk_lang_printchar called."));
720 }
721
722 static void
723 unk_lang_printstr (struct ui_file *stream, struct type *type,
724 const gdb_byte *string, unsigned int length,
725 const char *encoding, int force_ellipses,
726 const struct value_print_options *options)
727 {
728 error (_("internal error - unimplemented "
729 "function unk_lang_printstr called."));
730 }
731
732 static void
733 unk_lang_print_type (struct type *type, const char *varstring,
734 struct ui_file *stream, int show, int level,
735 const struct type_print_options *flags)
736 {
737 error (_("internal error - unimplemented "
738 "function unk_lang_print_type called."));
739 }
740
741 static void
742 unk_lang_val_print (struct type *type, const gdb_byte *valaddr,
743 int embedded_offset, CORE_ADDR address,
744 struct ui_file *stream, int recurse,
745 const struct value *val,
746 const struct value_print_options *options)
747 {
748 error (_("internal error - unimplemented "
749 "function unk_lang_val_print called."));
750 }
751
752 static void
753 unk_lang_value_print (struct value *val, struct ui_file *stream,
754 const struct value_print_options *options)
755 {
756 error (_("internal error - unimplemented "
757 "function unk_lang_value_print called."));
758 }
759
760 static CORE_ADDR unk_lang_trampoline (struct frame_info *frame, CORE_ADDR pc)
761 {
762 return 0;
763 }
764
765 /* Unknown languages just use the cplus demangler. */
766 static char *unk_lang_demangle (const char *mangled, int options)
767 {
768 return gdb_demangle (mangled, options);
769 }
770
771 static char *unk_lang_class_name (const char *mangled)
772 {
773 return NULL;
774 }
775
776 static const struct op_print unk_op_print_tab[] =
777 {
778 {NULL, OP_NULL, PREC_NULL, 0}
779 };
780
781 static void
782 unknown_language_arch_info (struct gdbarch *gdbarch,
783 struct language_arch_info *lai)
784 {
785 lai->string_char_type = builtin_type (gdbarch)->builtin_char;
786 lai->bool_type_default = builtin_type (gdbarch)->builtin_int;
787 lai->primitive_type_vector = GDBARCH_OBSTACK_CALLOC (gdbarch, 1,
788 struct type *);
789 }
790
791 const struct language_defn unknown_language_defn =
792 {
793 "unknown",
794 language_unknown,
795 range_check_off,
796 case_sensitive_on,
797 array_row_major,
798 macro_expansion_no,
799 &exp_descriptor_standard,
800 unk_lang_parser,
801 unk_lang_error,
802 null_post_parser,
803 unk_lang_printchar, /* Print character constant */
804 unk_lang_printstr,
805 unk_lang_emit_char,
806 unk_lang_print_type, /* Print a type using appropriate syntax */
807 default_print_typedef, /* Print a typedef using appropriate syntax */
808 unk_lang_val_print, /* Print a value using appropriate syntax */
809 unk_lang_value_print, /* Print a top-level value */
810 default_read_var_value, /* la_read_var_value */
811 unk_lang_trampoline, /* Language specific skip_trampoline */
812 "this", /* name_of_this */
813 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
814 basic_lookup_transparent_type,/* lookup_transparent_type */
815 unk_lang_demangle, /* Language specific symbol demangler */
816 unk_lang_class_name, /* Language specific
817 class_name_from_physname */
818 unk_op_print_tab, /* expression operators for printing */
819 1, /* c-style arrays */
820 0, /* String lower bound */
821 default_word_break_characters,
822 default_make_symbol_completion_list,
823 unknown_language_arch_info, /* la_language_arch_info. */
824 default_print_array_index,
825 default_pass_by_reference,
826 default_get_string,
827 NULL, /* la_get_symbol_name_cmp */
828 iterate_over_symbols,
829 LANG_MAGIC
830 };
831
832 /* These two structs define fake entries for the "local" and "auto"
833 options. */
834 const struct language_defn auto_language_defn =
835 {
836 "auto",
837 language_auto,
838 range_check_off,
839 case_sensitive_on,
840 array_row_major,
841 macro_expansion_no,
842 &exp_descriptor_standard,
843 unk_lang_parser,
844 unk_lang_error,
845 null_post_parser,
846 unk_lang_printchar, /* Print character constant */
847 unk_lang_printstr,
848 unk_lang_emit_char,
849 unk_lang_print_type, /* Print a type using appropriate syntax */
850 default_print_typedef, /* Print a typedef using appropriate syntax */
851 unk_lang_val_print, /* Print a value using appropriate syntax */
852 unk_lang_value_print, /* Print a top-level value */
853 default_read_var_value, /* la_read_var_value */
854 unk_lang_trampoline, /* Language specific skip_trampoline */
855 "this", /* name_of_this */
856 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
857 basic_lookup_transparent_type,/* lookup_transparent_type */
858 unk_lang_demangle, /* Language specific symbol demangler */
859 unk_lang_class_name, /* Language specific
860 class_name_from_physname */
861 unk_op_print_tab, /* expression operators for printing */
862 1, /* c-style arrays */
863 0, /* String lower bound */
864 default_word_break_characters,
865 default_make_symbol_completion_list,
866 unknown_language_arch_info, /* la_language_arch_info. */
867 default_print_array_index,
868 default_pass_by_reference,
869 default_get_string,
870 NULL, /* la_get_symbol_name_cmp */
871 iterate_over_symbols,
872 LANG_MAGIC
873 };
874
875 const struct language_defn local_language_defn =
876 {
877 "local",
878 language_auto,
879 range_check_off,
880 case_sensitive_on,
881 array_row_major,
882 macro_expansion_no,
883 &exp_descriptor_standard,
884 unk_lang_parser,
885 unk_lang_error,
886 null_post_parser,
887 unk_lang_printchar, /* Print character constant */
888 unk_lang_printstr,
889 unk_lang_emit_char,
890 unk_lang_print_type, /* Print a type using appropriate syntax */
891 default_print_typedef, /* Print a typedef using appropriate syntax */
892 unk_lang_val_print, /* Print a value using appropriate syntax */
893 unk_lang_value_print, /* Print a top-level value */
894 default_read_var_value, /* la_read_var_value */
895 unk_lang_trampoline, /* Language specific skip_trampoline */
896 "this", /* name_of_this */
897 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
898 basic_lookup_transparent_type,/* lookup_transparent_type */
899 unk_lang_demangle, /* Language specific symbol demangler */
900 unk_lang_class_name, /* Language specific
901 class_name_from_physname */
902 unk_op_print_tab, /* expression operators for printing */
903 1, /* c-style arrays */
904 0, /* String lower bound */
905 default_word_break_characters,
906 default_make_symbol_completion_list,
907 unknown_language_arch_info, /* la_language_arch_info. */
908 default_print_array_index,
909 default_pass_by_reference,
910 default_get_string,
911 NULL, /* la_get_symbol_name_cmp */
912 iterate_over_symbols,
913 LANG_MAGIC
914 };
915 \f
916 /* Per-architecture language information. */
917
918 static struct gdbarch_data *language_gdbarch_data;
919
920 struct language_gdbarch
921 {
922 /* A vector of per-language per-architecture info. Indexed by "enum
923 language". */
924 struct language_arch_info arch_info[nr_languages];
925 };
926
927 static void *
928 language_gdbarch_post_init (struct gdbarch *gdbarch)
929 {
930 struct language_gdbarch *l;
931 int i;
932
933 l = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct language_gdbarch);
934 for (i = 0; i < languages_size; i++)
935 {
936 if (languages[i] != NULL
937 && languages[i]->la_language_arch_info != NULL)
938 languages[i]->la_language_arch_info
939 (gdbarch, l->arch_info + languages[i]->la_language);
940 }
941 return l;
942 }
943
944 struct type *
945 language_string_char_type (const struct language_defn *la,
946 struct gdbarch *gdbarch)
947 {
948 struct language_gdbarch *ld = gdbarch_data (gdbarch,
949 language_gdbarch_data);
950
951 return ld->arch_info[la->la_language].string_char_type;
952 }
953
954 struct type *
955 language_bool_type (const struct language_defn *la,
956 struct gdbarch *gdbarch)
957 {
958 struct language_gdbarch *ld = gdbarch_data (gdbarch,
959 language_gdbarch_data);
960
961 if (ld->arch_info[la->la_language].bool_type_symbol)
962 {
963 struct symbol *sym;
964
965 sym = lookup_symbol (ld->arch_info[la->la_language].bool_type_symbol,
966 NULL, VAR_DOMAIN, NULL);
967 if (sym)
968 {
969 struct type *type = SYMBOL_TYPE (sym);
970
971 if (type && TYPE_CODE (type) == TYPE_CODE_BOOL)
972 return type;
973 }
974 }
975
976 return ld->arch_info[la->la_language].bool_type_default;
977 }
978
979 struct type *
980 language_lookup_primitive_type_by_name (const struct language_defn *la,
981 struct gdbarch *gdbarch,
982 const char *name)
983 {
984 struct language_gdbarch *ld = gdbarch_data (gdbarch,
985 language_gdbarch_data);
986 struct type *const *p;
987
988 for (p = ld->arch_info[la->la_language].primitive_type_vector;
989 (*p) != NULL;
990 p++)
991 {
992 if (strcmp (TYPE_NAME (*p), name) == 0)
993 return (*p);
994 }
995 return (NULL);
996 }
997
998 /* Initialize the language routines. */
999
1000 void
1001 _initialize_language (void)
1002 {
1003 static const char *const type_or_range_names[]
1004 = { "on", "off", "warn", "auto", NULL };
1005
1006 static const char *const case_sensitive_names[]
1007 = { "on", "off", "auto", NULL };
1008
1009 language_gdbarch_data
1010 = gdbarch_data_register_post_init (language_gdbarch_post_init);
1011
1012 /* GDB commands for language specific stuff. */
1013
1014 add_prefix_cmd ("check", no_class, set_check,
1015 _("Set the status of the type/range checker."),
1016 &setchecklist, "set check ", 0, &setlist);
1017 add_alias_cmd ("c", "check", no_class, 1, &setlist);
1018 add_alias_cmd ("ch", "check", no_class, 1, &setlist);
1019
1020 add_prefix_cmd ("check", no_class, show_check,
1021 _("Show the status of the type/range checker."),
1022 &showchecklist, "show check ", 0, &showlist);
1023 add_alias_cmd ("c", "check", no_class, 1, &showlist);
1024 add_alias_cmd ("ch", "check", no_class, 1, &showlist);
1025
1026 add_setshow_enum_cmd ("range", class_support, type_or_range_names,
1027 &range,
1028 _("Set range checking. (on/warn/off/auto)"),
1029 _("Show range checking. (on/warn/off/auto)"),
1030 NULL, set_range_command,
1031 show_range_command,
1032 &setchecklist, &showchecklist);
1033
1034 add_setshow_enum_cmd ("case-sensitive", class_support, case_sensitive_names,
1035 &case_sensitive, _("\
1036 Set case sensitivity in name search. (on/off/auto)"), _("\
1037 Show case sensitivity in name search. (on/off/auto)"), _("\
1038 For Fortran the default is off; for other languages the default is on."),
1039 set_case_command,
1040 show_case_command,
1041 &setlist, &showlist);
1042
1043 add_language (&auto_language_defn);
1044 add_language (&local_language_defn);
1045 add_language (&unknown_language_defn);
1046
1047 language = xstrdup ("auto");
1048 type = xstrdup ("auto");
1049 range = xstrdup ("auto");
1050 case_sensitive = xstrdup ("auto");
1051
1052 /* Have the above take effect. */
1053 set_language (language_auto);
1054 }
This page took 0.059646 seconds and 5 git commands to generate.