Import gdb-7.0
[dragonfly.git] / contrib / gdb-7 / gdb / language.c
CommitLineData
5796c8dc
SS
1/* Multiple source language support for GDB.
2
3 Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
4 2002, 2003, 2004, 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
5
6 Contributed by the Department of Computer Science at the State University
7 of New York at Buffalo.
8
9 This file is part of GDB.
10
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23
24/* This file contains functions that return things that are specific
25 to languages. Each function should examine current_language if necessary,
26 and return the appropriate result. */
27
28/* FIXME: Most of these would be better organized as macros which
29 return data out of a "language-specific" struct pointer that is set
30 whenever the working language changes. That would be a lot faster. */
31
32#include "defs.h"
33#include <ctype.h>
34#include "gdb_string.h"
35
36#include "symtab.h"
37#include "gdbtypes.h"
38#include "value.h"
39#include "gdbcmd.h"
40#include "expression.h"
41#include "language.h"
42#include "target.h"
43#include "parser-defs.h"
44#include "jv-lang.h"
45#include "demangle.h"
46#include "symfile.h"
47
48extern void _initialize_language (void);
49
50static void unk_lang_error (char *);
51
52static int unk_lang_parser (void);
53
54static void show_check (char *, int);
55
56static void set_check (char *, int);
57
58static void set_type_range_case (void);
59
60static void unk_lang_emit_char (int c, struct type *type,
61 struct ui_file *stream, int quoter);
62
63static void unk_lang_printchar (int c, struct type *type,
64 struct ui_file *stream);
65
66static void unk_lang_print_type (struct type *, char *, struct ui_file *,
67 int, int);
68
69static int unk_lang_value_print (struct value *, struct ui_file *,
70 const struct value_print_options *);
71
72static CORE_ADDR unk_lang_trampoline (struct frame_info *, CORE_ADDR pc);
73
74/* Forward declaration */
75extern const struct language_defn unknown_language_defn;
76
77/* The current (default at startup) state of type and range checking.
78 (If the modes are set to "auto", though, these are changed based
79 on the default language at startup, and then again based on the
80 language of the first source file. */
81
82enum range_mode range_mode = range_mode_auto;
83enum range_check range_check = range_check_off;
84enum type_mode type_mode = type_mode_auto;
85enum type_check type_check = type_check_off;
86enum case_mode case_mode = case_mode_auto;
87enum case_sensitivity case_sensitivity = case_sensitive_on;
88
89/* The current language and language_mode (see language.h) */
90
91const struct language_defn *current_language = &unknown_language_defn;
92enum language_mode language_mode = language_mode_auto;
93
94/* The language that the user expects to be typing in (the language
95 of main(), or the last language we notified them about, or C). */
96
97const struct language_defn *expected_language;
98
99/* The list of supported languages. The list itself is malloc'd. */
100
101static const struct language_defn **languages;
102static unsigned languages_size;
103static unsigned languages_allocsize;
104#define DEFAULT_ALLOCSIZE 4
105
106/* The current values of the "set language/type/range" enum
107 commands. */
108static const char *language;
109static const char *type;
110static const char *range;
111static const char *case_sensitive;
112
113/* Warning issued when current_language and the language of the current
114 frame do not match. */
115char lang_frame_mismatch_warn[] =
116"Warning: the current language does not match this frame.";
117\f
118/* This page contains the functions corresponding to GDB commands
119 and their helpers. */
120
121/* Show command. Display a warning if the language set
122 does not match the frame. */
123static void
124show_language_command (struct ui_file *file, int from_tty,
125 struct cmd_list_element *c, const char *value)
126{
127 enum language flang; /* The language of the current frame */
128
129 if (language_mode == language_mode_auto)
130 fprintf_filtered (gdb_stdout,
131 _("The current source language is "
132 "\"auto; currently %s\".\n"),
133 current_language->la_name);
134 else
135 fprintf_filtered (gdb_stdout, _("The current source language is \"%s\".\n"),
136 current_language->la_name);
137
138 flang = get_frame_language ();
139 if (flang != language_unknown &&
140 language_mode == language_mode_manual &&
141 current_language->la_language != flang)
142 printf_filtered ("%s\n", lang_frame_mismatch_warn);
143}
144
145/* Set command. Change the current working language. */
146static void
147set_language_command (char *ignore, int from_tty, struct cmd_list_element *c)
148{
149 int i;
150 enum language flang;
151
152 /* Search the list of languages for a match. */
153 for (i = 0; i < languages_size; i++)
154 {
155 if (strcmp (languages[i]->la_name, language) == 0)
156 {
157 /* Found it! Go into manual mode, and use this language. */
158 if (languages[i]->la_language == language_auto)
159 {
160 /* Enter auto mode. Set to the current frame's language, if
161 known, or fallback to the initial language. */
162 language_mode = language_mode_auto;
163 flang = get_frame_language ();
164 if (flang != language_unknown)
165 set_language (flang);
166 else
167 set_initial_language ();
168 expected_language = current_language;
169 return;
170 }
171 else
172 {
173 /* Enter manual mode. Set the specified language. */
174 language_mode = language_mode_manual;
175 current_language = languages[i];
176 set_type_range_case ();
177 expected_language = current_language;
178 return;
179 }
180 }
181 }
182
183 internal_error (__FILE__, __LINE__,
184 "Couldn't find language `%s' in known languages list.",
185 language);
186}
187
188/* Show command. Display a warning if the type setting does
189 not match the current language. */
190static void
191show_type_command (struct ui_file *file, int from_tty,
192 struct cmd_list_element *c, const char *value)
193{
194 if (type_mode == type_mode_auto)
195 {
196 char *tmp = NULL;
197
198 switch (type_check)
199 {
200 case type_check_on:
201 tmp = "on";
202 break;
203 case type_check_off:
204 tmp = "off";
205 break;
206 case type_check_warn:
207 tmp = "warn";
208 break;
209 default:
210 internal_error (__FILE__, __LINE__,
211 "Unrecognized type check setting.");
212 }
213
214 fprintf_filtered (gdb_stdout,
215 _("Type checking is \"auto; currently %s\".\n"),
216 tmp);
217 }
218 else
219 fprintf_filtered (gdb_stdout, _("Type checking is \"%s\".\n"),
220 value);
221
222 if (type_check != current_language->la_type_check)
223 warning (_("the current type check setting"
224 " does not match the language.\n"));
225}
226
227/* Set command. Change the setting for type checking. */
228static void
229set_type_command (char *ignore, int from_tty, struct cmd_list_element *c)
230{
231 if (strcmp (type, "on") == 0)
232 {
233 type_check = type_check_on;
234 type_mode = type_mode_manual;
235 }
236 else if (strcmp (type, "warn") == 0)
237 {
238 type_check = type_check_warn;
239 type_mode = type_mode_manual;
240 }
241 else if (strcmp (type, "off") == 0)
242 {
243 type_check = type_check_off;
244 type_mode = type_mode_manual;
245 }
246 else if (strcmp (type, "auto") == 0)
247 {
248 type_mode = type_mode_auto;
249 set_type_range_case ();
250 return;
251 }
252 else
253 internal_error (__FILE__, __LINE__,
254 _("Unrecognized type check setting: \"%s\""), type);
255
256 if (type_check != current_language->la_type_check)
257 warning (_("the current type check setting"
258 " does not match the language.\n"));
259}
260
261/* Show command. Display a warning if the range setting does
262 not match the current language. */
263static void
264show_range_command (struct ui_file *file, int from_tty,
265 struct cmd_list_element *c, const char *value)
266{
267 if (range_mode == range_mode_auto)
268 {
269 char *tmp;
270
271 switch (range_check)
272 {
273 case range_check_on:
274 tmp = "on";
275 break;
276 case range_check_off:
277 tmp = "off";
278 break;
279 case range_check_warn:
280 tmp = "warn";
281 break;
282 default:
283 internal_error (__FILE__, __LINE__,
284 "Unrecognized range check setting.");
285 }
286
287 fprintf_filtered (gdb_stdout,
288 _("Range checking is \"auto; currently %s\".\n"),
289 tmp);
290 }
291 else
292 fprintf_filtered (gdb_stdout, _("Range checking is \"%s\".\n"),
293 value);
294
295 if (range_check != current_language->la_range_check)
296 warning (_("the current range check setting "
297 "does not match the language.\n"));
298}
299
300/* Set command. Change the setting for range checking. */
301static void
302set_range_command (char *ignore, int from_tty, struct cmd_list_element *c)
303{
304 if (strcmp (range, "on") == 0)
305 {
306 range_check = range_check_on;
307 range_mode = range_mode_manual;
308 }
309 else if (strcmp (range, "warn") == 0)
310 {
311 range_check = range_check_warn;
312 range_mode = range_mode_manual;
313 }
314 else if (strcmp (range, "off") == 0)
315 {
316 range_check = range_check_off;
317 range_mode = range_mode_manual;
318 }
319 else if (strcmp (range, "auto") == 0)
320 {
321 range_mode = range_mode_auto;
322 set_type_range_case ();
323 return;
324 }
325 else
326 {
327 internal_error (__FILE__, __LINE__,
328 _("Unrecognized range check setting: \"%s\""), range);
329 }
330 if (range_check != current_language->la_range_check)
331 warning (_("the current range check setting "
332 "does not match the language.\n"));
333}
334
335/* Show command. Display a warning if the case sensitivity setting does
336 not match the current language. */
337static void
338show_case_command (struct ui_file *file, int from_tty,
339 struct cmd_list_element *c, const char *value)
340{
341 if (case_mode == case_mode_auto)
342 {
343 char *tmp = NULL;
344
345 switch (case_sensitivity)
346 {
347 case case_sensitive_on:
348 tmp = "on";
349 break;
350 case case_sensitive_off:
351 tmp = "off";
352 break;
353 default:
354 internal_error (__FILE__, __LINE__,
355 "Unrecognized case-sensitive setting.");
356 }
357
358 fprintf_filtered (gdb_stdout,
359 _("Case sensitivity in "
360 "name search is \"auto; currently %s\".\n"),
361 tmp);
362 }
363 else
364 fprintf_filtered (gdb_stdout, _("Case sensitivity in name search is \"%s\".\n"),
365 value);
366
367 if (case_sensitivity != current_language->la_case_sensitivity)
368 warning (_("the current case sensitivity setting does not match "
369 "the language.\n"));
370}
371
372/* Set command. Change the setting for case sensitivity. */
373
374static void
375set_case_command (char *ignore, int from_tty, struct cmd_list_element *c)
376{
377 if (strcmp (case_sensitive, "on") == 0)
378 {
379 case_sensitivity = case_sensitive_on;
380 case_mode = case_mode_manual;
381 }
382 else if (strcmp (case_sensitive, "off") == 0)
383 {
384 case_sensitivity = case_sensitive_off;
385 case_mode = case_mode_manual;
386 }
387 else if (strcmp (case_sensitive, "auto") == 0)
388 {
389 case_mode = case_mode_auto;
390 set_type_range_case ();
391 return;
392 }
393 else
394 {
395 internal_error (__FILE__, __LINE__,
396 "Unrecognized case-sensitive setting: \"%s\"",
397 case_sensitive);
398 }
399
400 if (case_sensitivity != current_language->la_case_sensitivity)
401 warning (_("the current case sensitivity setting does not match "
402 "the language.\n"));
403}
404
405/* Set the status of range and type checking and case sensitivity based on
406 the current modes and the current language.
407 If SHOW is non-zero, then print out the current language,
408 type and range checking status. */
409static void
410set_type_range_case (void)
411{
412 if (range_mode == range_mode_auto)
413 range_check = current_language->la_range_check;
414
415 if (type_mode == type_mode_auto)
416 type_check = current_language->la_type_check;
417
418 if (case_mode == case_mode_auto)
419 case_sensitivity = current_language->la_case_sensitivity;
420}
421
422/* Set current language to (enum language) LANG. Returns previous language. */
423
424enum language
425set_language (enum language lang)
426{
427 int i;
428 enum language prev_language;
429
430 prev_language = current_language->la_language;
431
432 for (i = 0; i < languages_size; i++)
433 {
434 if (languages[i]->la_language == lang)
435 {
436 current_language = languages[i];
437 set_type_range_case ();
438 break;
439 }
440 }
441
442 return prev_language;
443}
444\f
445
446/* Print out the current language settings: language, range and
447 type checking. If QUIETLY, print only what has changed. */
448
449void
450language_info (int quietly)
451{
452 if (quietly && expected_language == current_language)
453 return;
454
455 expected_language = current_language;
456 printf_unfiltered (_("Current language: %s\n"), language);
457 show_language_command (NULL, 1, NULL, NULL);
458
459 if (!quietly)
460 {
461 printf_unfiltered (_("Type checking: %s\n"), type);
462 show_type_command (NULL, 1, NULL, NULL);
463 printf_unfiltered (_("Range checking: %s\n"), range);
464 show_range_command (NULL, 1, NULL, NULL);
465 printf_unfiltered (_("Case sensitivity: %s\n"), case_sensitive);
466 show_case_command (NULL, 1, NULL, NULL);
467 }
468}
469\f
470/* Return the result of a binary operation. */
471
472#if 0 /* Currently unused */
473
474struct type *
475binop_result_type (struct value *v1, struct value *v2)
476{
477 int size, uns;
478 struct type *t1 = check_typedef (VALUE_TYPE (v1));
479 struct type *t2 = check_typedef (VALUE_TYPE (v2));
480
481 int l1 = TYPE_LENGTH (t1);
482 int l2 = TYPE_LENGTH (t2);
483
484 switch (current_language->la_language)
485 {
486 case language_c:
487 case language_cplus:
488 case language_objc:
489 if (TYPE_CODE (t1) == TYPE_CODE_FLT)
490 return TYPE_CODE (t2) == TYPE_CODE_FLT && l2 > l1 ?
491 VALUE_TYPE (v2) : VALUE_TYPE (v1);
492 else if (TYPE_CODE (t2) == TYPE_CODE_FLT)
493 return TYPE_CODE (t1) == TYPE_CODE_FLT && l1 > l2 ?
494 VALUE_TYPE (v1) : VALUE_TYPE (v2);
495 else if (TYPE_UNSIGNED (t1) && l1 > l2)
496 return VALUE_TYPE (v1);
497 else if (TYPE_UNSIGNED (t2) && l2 > l1)
498 return VALUE_TYPE (v2);
499 else /* Both are signed. Result is the longer type */
500 return l1 > l2 ? VALUE_TYPE (v1) : VALUE_TYPE (v2);
501 break;
502 case language_m2:
503 /* If we are doing type-checking, l1 should equal l2, so this is
504 not needed. */
505 return l1 > l2 ? VALUE_TYPE (v1) : VALUE_TYPE (v2);
506 break;
507 }
508 internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
509 return (struct type *) 0; /* For lint */
510}
511
512#endif /* 0 */
513#if 0
514/* This page contains functions that are used in type/range checking.
515 They all return zero if the type/range check fails.
516
517 It is hoped that these will make extending GDB to parse different
518 languages a little easier. These are primarily used in eval.c when
519 evaluating expressions and making sure that their types are correct.
520 Instead of having a mess of conjucted/disjuncted expressions in an "if",
521 the ideas of type can be wrapped up in the following functions.
522
523 Note that some of them are not currently dependent upon which language
524 is currently being parsed. For example, floats are the same in
525 C and Modula-2 (ie. the only floating point type has TYPE_CODE of
526 TYPE_CODE_FLT), while booleans are different. */
527
528/* Returns non-zero if its argument is a simple type. This is the same for
529 both Modula-2 and for C. In the C case, TYPE_CODE_CHAR will never occur,
530 and thus will never cause the failure of the test. */
531int
532simple_type (struct type *type)
533{
534 CHECK_TYPEDEF (type);
535 switch (TYPE_CODE (type))
536 {
537 case TYPE_CODE_INT:
538 case TYPE_CODE_CHAR:
539 case TYPE_CODE_ENUM:
540 case TYPE_CODE_FLT:
541 case TYPE_CODE_RANGE:
542 case TYPE_CODE_BOOL:
543 return 1;
544
545 default:
546 return 0;
547 }
548}
549
550/* Returns non-zero if its argument is of an ordered type.
551 An ordered type is one in which the elements can be tested for the
552 properties of "greater than", "less than", etc, or for which the
553 operations "increment" or "decrement" make sense. */
554int
555ordered_type (struct type *type)
556{
557 CHECK_TYPEDEF (type);
558 switch (TYPE_CODE (type))
559 {
560 case TYPE_CODE_INT:
561 case TYPE_CODE_CHAR:
562 case TYPE_CODE_ENUM:
563 case TYPE_CODE_FLT:
564 case TYPE_CODE_RANGE:
565 return 1;
566
567 default:
568 return 0;
569 }
570}
571
572/* Returns non-zero if the two types are the same */
573int
574same_type (struct type *arg1, struct type *arg2)
575{
576 CHECK_TYPEDEF (type);
577 if (structured_type (arg1) ? !structured_type (arg2) : structured_type (arg2))
578 /* One is structured and one isn't */
579 return 0;
580 else if (structured_type (arg1) && structured_type (arg2))
581 return arg1 == arg2;
582 else if (numeric_type (arg1) && numeric_type (arg2))
583 return (TYPE_CODE (arg2) == TYPE_CODE (arg1)) &&
584 (TYPE_UNSIGNED (arg1) == TYPE_UNSIGNED (arg2))
585 ? 1 : 0;
586 else
587 return arg1 == arg2;
588}
589
590/* Returns non-zero if the type is integral */
591int
592integral_type (struct type *type)
593{
594 CHECK_TYPEDEF (type);
595 switch (current_language->la_language)
596 {
597 case language_c:
598 case language_cplus:
599 case language_objc:
600 return (TYPE_CODE (type) != TYPE_CODE_INT) &&
601 (TYPE_CODE (type) != TYPE_CODE_ENUM) ? 0 : 1;
602 case language_m2:
603 case language_pascal:
604 return TYPE_CODE (type) != TYPE_CODE_INT ? 0 : 1;
605 default:
606 error (_("Language not supported."));
607 }
608}
609
610/* Returns non-zero if the value is numeric */
611int
612numeric_type (struct type *type)
613{
614 CHECK_TYPEDEF (type);
615 switch (TYPE_CODE (type))
616 {
617 case TYPE_CODE_INT:
618 case TYPE_CODE_FLT:
619 return 1;
620
621 default:
622 return 0;
623 }
624}
625
626/* Returns non-zero if the value is a character type */
627int
628character_type (struct type *type)
629{
630 CHECK_TYPEDEF (type);
631 switch (current_language->la_language)
632 {
633 case language_m2:
634 case language_pascal:
635 return TYPE_CODE (type) != TYPE_CODE_CHAR ? 0 : 1;
636
637 case language_c:
638 case language_cplus:
639 case language_objc:
640 return (TYPE_CODE (type) == TYPE_CODE_INT) &&
641 TYPE_LENGTH (type) == sizeof (char)
642 ? 1 : 0;
643 default:
644 return (0);
645 }
646}
647
648/* Returns non-zero if the value is a string type */
649int
650string_type (struct type *type)
651{
652 CHECK_TYPEDEF (type);
653 switch (current_language->la_language)
654 {
655 case language_m2:
656 case language_pascal:
657 return TYPE_CODE (type) != TYPE_CODE_STRING ? 0 : 1;
658
659 case language_c:
660 case language_cplus:
661 case language_objc:
662 /* C does not have distinct string type. */
663 return (0);
664 default:
665 return (0);
666 }
667}
668
669/* Returns non-zero if the value is a boolean type */
670int
671boolean_type (struct type *type)
672{
673 CHECK_TYPEDEF (type);
674 if (TYPE_CODE (type) == TYPE_CODE_BOOL)
675 return 1;
676 switch (current_language->la_language)
677 {
678 case language_c:
679 case language_cplus:
680 case language_objc:
681 /* Might be more cleanly handled by having a
682 TYPE_CODE_INT_NOT_BOOL for (the deleted) CHILL and such
683 languages, or a TYPE_CODE_INT_OR_BOOL for C. */
684 if (TYPE_CODE (type) == TYPE_CODE_INT)
685 return 1;
686 default:
687 break;
688 }
689 return 0;
690}
691
692/* Returns non-zero if the value is a floating-point type */
693int
694float_type (struct type *type)
695{
696 CHECK_TYPEDEF (type);
697 return TYPE_CODE (type) == TYPE_CODE_FLT;
698}
699
700/* Returns non-zero if the value is a pointer type */
701int
702pointer_type (struct type *type)
703{
704 return TYPE_CODE (type) == TYPE_CODE_PTR ||
705 TYPE_CODE (type) == TYPE_CODE_REF;
706}
707
708/* Returns non-zero if the value is a structured type */
709int
710structured_type (struct type *type)
711{
712 CHECK_TYPEDEF (type);
713 switch (current_language->la_language)
714 {
715 case language_c:
716 case language_cplus:
717 case language_objc:
718 return (TYPE_CODE (type) == TYPE_CODE_STRUCT) ||
719 (TYPE_CODE (type) == TYPE_CODE_UNION) ||
720 (TYPE_CODE (type) == TYPE_CODE_ARRAY);
721 case language_pascal:
722 return (TYPE_CODE(type) == TYPE_CODE_STRUCT) ||
723 (TYPE_CODE(type) == TYPE_CODE_UNION) ||
724 (TYPE_CODE(type) == TYPE_CODE_SET) ||
725 (TYPE_CODE(type) == TYPE_CODE_ARRAY);
726 case language_m2:
727 return (TYPE_CODE (type) == TYPE_CODE_STRUCT) ||
728 (TYPE_CODE (type) == TYPE_CODE_SET) ||
729 (TYPE_CODE (type) == TYPE_CODE_ARRAY);
730 default:
731 return (0);
732 }
733}
734#endif
735\f
736/* This page contains functions that return info about
737 (struct value) values used in GDB. */
738
739/* Returns non-zero if the value VAL represents a true value. */
740int
741value_true (struct value *val)
742{
743 /* It is possible that we should have some sort of error if a non-boolean
744 value is used in this context. Possibly dependent on some kind of
745 "boolean-checking" option like range checking. But it should probably
746 not depend on the language except insofar as is necessary to identify
747 a "boolean" value (i.e. in C using a float, pointer, etc., as a boolean
748 should be an error, probably). */
749 return !value_logical_not (val);
750}
751\f
752/* This page contains functions for the printing out of
753 error messages that occur during type- and range-
754 checking. */
755
756/* These are called when a language fails a type- or range-check. The
757 first argument should be a printf()-style format string, and the
758 rest of the arguments should be its arguments. If
759 [type|range]_check is [type|range]_check_on, an error is printed;
760 if [type|range]_check_warn, a warning; otherwise just the
761 message. */
762
763void
764type_error (const char *string,...)
765{
766 va_list args;
767 va_start (args, string);
768
769 switch (type_check)
770 {
771 case type_check_warn:
772 vwarning (string, args);
773 break;
774 case type_check_on:
775 verror (string, args);
776 break;
777 case type_check_off:
778 /* FIXME: cagney/2002-01-30: Should this function print anything
779 when type error is off? */
780 vfprintf_filtered (gdb_stderr, string, args);
781 fprintf_filtered (gdb_stderr, "\n");
782 break;
783 default:
784 internal_error (__FILE__, __LINE__, _("bad switch"));
785 }
786 va_end (args);
787}
788
789void
790range_error (const char *string,...)
791{
792 va_list args;
793 va_start (args, string);
794
795 switch (range_check)
796 {
797 case range_check_warn:
798 vwarning (string, args);
799 break;
800 case range_check_on:
801 verror (string, args);
802 break;
803 case range_check_off:
804 /* FIXME: cagney/2002-01-30: Should this function print anything
805 when range error is off? */
806 vfprintf_filtered (gdb_stderr, string, args);
807 fprintf_filtered (gdb_stderr, "\n");
808 break;
809 default:
810 internal_error (__FILE__, __LINE__, _("bad switch"));
811 }
812 va_end (args);
813}
814\f
815
816/* This page contains miscellaneous functions */
817
818/* Return the language enum for a given language string. */
819
820enum language
821language_enum (char *str)
822{
823 int i;
824
825 for (i = 0; i < languages_size; i++)
826 if (strcmp (languages[i]->la_name, str) == 0)
827 return languages[i]->la_language;
828
829 return language_unknown;
830}
831
832/* Return the language struct for a given language enum. */
833
834const struct language_defn *
835language_def (enum language lang)
836{
837 int i;
838
839 for (i = 0; i < languages_size; i++)
840 {
841 if (languages[i]->la_language == lang)
842 {
843 return languages[i];
844 }
845 }
846 return NULL;
847}
848
849/* Return the language as a string */
850char *
851language_str (enum language lang)
852{
853 int i;
854
855 for (i = 0; i < languages_size; i++)
856 {
857 if (languages[i]->la_language == lang)
858 {
859 return languages[i]->la_name;
860 }
861 }
862 return "Unknown";
863}
864
865static void
866set_check (char *ignore, int from_tty)
867{
868 printf_unfiltered (
869 "\"set check\" must be followed by the name of a check subcommand.\n");
870 help_list (setchecklist, "set check ", -1, gdb_stdout);
871}
872
873static void
874show_check (char *ignore, int from_tty)
875{
876 cmd_show_list (showchecklist, from_tty, "");
877}
878\f
879/* Add a language to the set of known languages. */
880
881void
882add_language (const struct language_defn *lang)
883{
884 /* For the "set language" command. */
885 static char **language_names = NULL;
886 /* For the "help set language" command. */
887 char *language_set_doc = NULL;
888
889 int i;
890 struct ui_file *tmp_stream;
891
892 if (lang->la_magic != LANG_MAGIC)
893 {
894 fprintf_unfiltered (gdb_stderr, "Magic number of %s language struct wrong\n",
895 lang->la_name);
896 internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
897 }
898
899 if (!languages)
900 {
901 languages_allocsize = DEFAULT_ALLOCSIZE;
902 languages = (const struct language_defn **) xmalloc
903 (languages_allocsize * sizeof (*languages));
904 }
905 if (languages_size >= languages_allocsize)
906 {
907 languages_allocsize *= 2;
908 languages = (const struct language_defn **) xrealloc ((char *) languages,
909 languages_allocsize * sizeof (*languages));
910 }
911 languages[languages_size++] = lang;
912
913 /* Build the language names array, to be used as enumeration in the
914 set language" enum command. */
915 language_names = xrealloc (language_names,
916 (languages_size + 1) * sizeof (const char *));
917 for (i = 0; i < languages_size; ++i)
918 language_names[i] = languages[i]->la_name;
919 language_names[i] = NULL;
920
921 /* Build the "help set language" docs. */
922 tmp_stream = mem_fileopen ();
923
924 fprintf_unfiltered (tmp_stream, _("\
925Set the current source language.\n\
926The currently understood settings are:\n\n\
927local or auto Automatic setting based on source file\n"));
928
929 for (i = 0; i < languages_size; ++i)
930 {
931 /* Already dealt with these above. */
932 if (languages[i]->la_language == language_unknown
933 || languages[i]->la_language == language_auto)
934 continue;
935
936 /* FIXME: i18n: for now assume that the human-readable name
937 is just a capitalization of the internal name. */
938 fprintf_unfiltered (tmp_stream, "%-16s Use the %c%s language\n",
939 languages[i]->la_name,
940 /* Capitalize first letter of language
941 name. */
942 toupper (languages[i]->la_name[0]),
943 languages[i]->la_name + 1);
944 }
945
946 language_set_doc = ui_file_xstrdup (tmp_stream, NULL);
947 ui_file_delete (tmp_stream);
948
949 add_setshow_enum_cmd ("language", class_support,
950 (const char **) language_names,
951 &language,
952 language_set_doc, _("\
953Show the current source language."), NULL,
954 set_language_command,
955 show_language_command,
956 &setlist, &showlist);
957
958 xfree (language_set_doc);
959}
960
961/* Iterate through all registered languages looking for and calling
962 any non-NULL struct language_defn.skip_trampoline() functions.
963 Return the result from the first that returns non-zero, or 0 if all
964 `fail'. */
965CORE_ADDR
966skip_language_trampoline (struct frame_info *frame, CORE_ADDR pc)
967{
968 int i;
969
970 for (i = 0; i < languages_size; i++)
971 {
972 if (languages[i]->skip_trampoline)
973 {
974 CORE_ADDR real_pc = (languages[i]->skip_trampoline) (frame, pc);
975 if (real_pc)
976 return real_pc;
977 }
978 }
979
980 return 0;
981}
982
983/* Return demangled language symbol, or NULL.
984 FIXME: Options are only useful for certain languages and ignored
985 by others, so it would be better to remove them here and have a
986 more flexible demangler for the languages that need it.
987 FIXME: Sometimes the demangler is invoked when we don't know the
988 language, so we can't use this everywhere. */
989char *
990language_demangle (const struct language_defn *current_language,
991 const char *mangled, int options)
992{
993 if (current_language != NULL && current_language->la_demangle)
994 return current_language->la_demangle (mangled, options);
995 return NULL;
996}
997
998/* Return class name from physname or NULL. */
999char *
1000language_class_name_from_physname (const struct language_defn *current_language,
1001 const char *physname)
1002{
1003 if (current_language != NULL && current_language->la_class_name_from_physname)
1004 return current_language->la_class_name_from_physname (physname);
1005 return NULL;
1006}
1007
1008/* Return non-zero if TYPE should be passed (and returned) by
1009 reference at the language level. */
1010int
1011language_pass_by_reference (struct type *type)
1012{
1013 return current_language->la_pass_by_reference (type);
1014}
1015
1016/* Return zero; by default, types are passed by value at the language
1017 level. The target ABI may pass or return some structs by reference
1018 independent of this. */
1019int
1020default_pass_by_reference (struct type *type)
1021{
1022 return 0;
1023}
1024
1025/* Return the default string containing the list of characters
1026 delimiting words. This is a reasonable default value that
1027 most languages should be able to use. */
1028
1029char *
1030default_word_break_characters (void)
1031{
1032 return " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,-";
1033}
1034
1035/* Print the index of array elements using the C99 syntax. */
1036
1037void
1038default_print_array_index (struct value *index_value, struct ui_file *stream,
1039 const struct value_print_options *options)
1040{
1041 fprintf_filtered (stream, "[");
1042 LA_VALUE_PRINT (index_value, stream, options);
1043 fprintf_filtered (stream, "] = ");
1044}
1045
1046void
1047default_get_string (struct value *value, gdb_byte **buffer, int *length,
1048 const char **charset)
1049{
1050 error (_("Getting a string is unsupported in this language."));
1051}
1052
1053/* Define the language that is no language. */
1054
1055static int
1056unk_lang_parser (void)
1057{
1058 return 1;
1059}
1060
1061static void
1062unk_lang_error (char *msg)
1063{
1064 error (_("Attempted to parse an expression with unknown language"));
1065}
1066
1067static void
1068unk_lang_emit_char (int c, struct type *type, struct ui_file *stream,
1069 int quoter)
1070{
1071 error (_("internal error - unimplemented function unk_lang_emit_char called."));
1072}
1073
1074static void
1075unk_lang_printchar (int c, struct type *type, struct ui_file *stream)
1076{
1077 error (_("internal error - unimplemented function unk_lang_printchar called."));
1078}
1079
1080static void
1081unk_lang_printstr (struct ui_file *stream, struct type *type,
1082 const gdb_byte *string, unsigned int length,
1083 int force_ellipses,
1084 const struct value_print_options *options)
1085{
1086 error (_("internal error - unimplemented function unk_lang_printstr called."));
1087}
1088
1089static void
1090unk_lang_print_type (struct type *type, char *varstring, struct ui_file *stream,
1091 int show, int level)
1092{
1093 error (_("internal error - unimplemented function unk_lang_print_type called."));
1094}
1095
1096static int
1097unk_lang_val_print (struct type *type, const gdb_byte *valaddr,
1098 int embedded_offset, CORE_ADDR address,
1099 struct ui_file *stream, int recurse,
1100 const struct value_print_options *options)
1101{
1102 error (_("internal error - unimplemented function unk_lang_val_print called."));
1103}
1104
1105static int
1106unk_lang_value_print (struct value *val, struct ui_file *stream,
1107 const struct value_print_options *options)
1108{
1109 error (_("internal error - unimplemented function unk_lang_value_print called."));
1110}
1111
1112static CORE_ADDR unk_lang_trampoline (struct frame_info *frame, CORE_ADDR pc)
1113{
1114 return 0;
1115}
1116
1117/* Unknown languages just use the cplus demangler. */
1118static char *unk_lang_demangle (const char *mangled, int options)
1119{
1120 return cplus_demangle (mangled, options);
1121}
1122
1123static char *unk_lang_class_name (const char *mangled)
1124{
1125 return NULL;
1126}
1127
1128static const struct op_print unk_op_print_tab[] =
1129{
1130 {NULL, OP_NULL, PREC_NULL, 0}
1131};
1132
1133static void
1134unknown_language_arch_info (struct gdbarch *gdbarch,
1135 struct language_arch_info *lai)
1136{
1137 lai->string_char_type = builtin_type (gdbarch)->builtin_char;
1138 lai->bool_type_default = builtin_type (gdbarch)->builtin_int;
1139 lai->primitive_type_vector = GDBARCH_OBSTACK_CALLOC (gdbarch, 1,
1140 struct type *);
1141}
1142
1143const struct language_defn unknown_language_defn =
1144{
1145 "unknown",
1146 language_unknown,
1147 range_check_off,
1148 type_check_off,
1149 case_sensitive_on,
1150 array_row_major,
1151 macro_expansion_no,
1152 &exp_descriptor_standard,
1153 unk_lang_parser,
1154 unk_lang_error,
1155 null_post_parser,
1156 unk_lang_printchar, /* Print character constant */
1157 unk_lang_printstr,
1158 unk_lang_emit_char,
1159 unk_lang_print_type, /* Print a type using appropriate syntax */
1160 default_print_typedef, /* Print a typedef using appropriate syntax */
1161 unk_lang_val_print, /* Print a value using appropriate syntax */
1162 unk_lang_value_print, /* Print a top-level value */
1163 unk_lang_trampoline, /* Language specific skip_trampoline */
1164 "this", /* name_of_this */
1165 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1166 basic_lookup_transparent_type,/* lookup_transparent_type */
1167 unk_lang_demangle, /* Language specific symbol demangler */
1168 unk_lang_class_name, /* Language specific class_name_from_physname */
1169 unk_op_print_tab, /* expression operators for printing */
1170 1, /* c-style arrays */
1171 0, /* String lower bound */
1172 default_word_break_characters,
1173 default_make_symbol_completion_list,
1174 unknown_language_arch_info, /* la_language_arch_info. */
1175 default_print_array_index,
1176 default_pass_by_reference,
1177 default_get_string,
1178 LANG_MAGIC
1179};
1180
1181/* These two structs define fake entries for the "local" and "auto" options. */
1182const struct language_defn auto_language_defn =
1183{
1184 "auto",
1185 language_auto,
1186 range_check_off,
1187 type_check_off,
1188 case_sensitive_on,
1189 array_row_major,
1190 macro_expansion_no,
1191 &exp_descriptor_standard,
1192 unk_lang_parser,
1193 unk_lang_error,
1194 null_post_parser,
1195 unk_lang_printchar, /* Print character constant */
1196 unk_lang_printstr,
1197 unk_lang_emit_char,
1198 unk_lang_print_type, /* Print a type using appropriate syntax */
1199 default_print_typedef, /* Print a typedef using appropriate syntax */
1200 unk_lang_val_print, /* Print a value using appropriate syntax */
1201 unk_lang_value_print, /* Print a top-level value */
1202 unk_lang_trampoline, /* Language specific skip_trampoline */
1203 "this", /* name_of_this */
1204 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1205 basic_lookup_transparent_type,/* lookup_transparent_type */
1206 unk_lang_demangle, /* Language specific symbol demangler */
1207 unk_lang_class_name, /* Language specific class_name_from_physname */
1208 unk_op_print_tab, /* expression operators for printing */
1209 1, /* c-style arrays */
1210 0, /* String lower bound */
1211 default_word_break_characters,
1212 default_make_symbol_completion_list,
1213 unknown_language_arch_info, /* la_language_arch_info. */
1214 default_print_array_index,
1215 default_pass_by_reference,
1216 default_get_string,
1217 LANG_MAGIC
1218};
1219
1220const struct language_defn local_language_defn =
1221{
1222 "local",
1223 language_auto,
1224 range_check_off,
1225 type_check_off,
1226 case_sensitive_on,
1227 array_row_major,
1228 macro_expansion_no,
1229 &exp_descriptor_standard,
1230 unk_lang_parser,
1231 unk_lang_error,
1232 null_post_parser,
1233 unk_lang_printchar, /* Print character constant */
1234 unk_lang_printstr,
1235 unk_lang_emit_char,
1236 unk_lang_print_type, /* Print a type using appropriate syntax */
1237 default_print_typedef, /* Print a typedef using appropriate syntax */
1238 unk_lang_val_print, /* Print a value using appropriate syntax */
1239 unk_lang_value_print, /* Print a top-level value */
1240 unk_lang_trampoline, /* Language specific skip_trampoline */
1241 "this", /* name_of_this */
1242 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1243 basic_lookup_transparent_type,/* lookup_transparent_type */
1244 unk_lang_demangle, /* Language specific symbol demangler */
1245 unk_lang_class_name, /* Language specific class_name_from_physname */
1246 unk_op_print_tab, /* expression operators for printing */
1247 1, /* c-style arrays */
1248 0, /* String lower bound */
1249 default_word_break_characters,
1250 default_make_symbol_completion_list,
1251 unknown_language_arch_info, /* la_language_arch_info. */
1252 default_print_array_index,
1253 default_pass_by_reference,
1254 default_get_string,
1255 LANG_MAGIC
1256};
1257\f
1258/* Per-architecture language information. */
1259
1260static struct gdbarch_data *language_gdbarch_data;
1261
1262struct language_gdbarch
1263{
1264 /* A vector of per-language per-architecture info. Indexed by "enum
1265 language". */
1266 struct language_arch_info arch_info[nr_languages];
1267};
1268
1269static void *
1270language_gdbarch_post_init (struct gdbarch *gdbarch)
1271{
1272 struct language_gdbarch *l;
1273 int i;
1274
1275 l = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct language_gdbarch);
1276 for (i = 0; i < languages_size; i++)
1277 {
1278 if (languages[i] != NULL
1279 && languages[i]->la_language_arch_info != NULL)
1280 languages[i]->la_language_arch_info
1281 (gdbarch, l->arch_info + languages[i]->la_language);
1282 }
1283 return l;
1284}
1285
1286struct type *
1287language_string_char_type (const struct language_defn *la,
1288 struct gdbarch *gdbarch)
1289{
1290 struct language_gdbarch *ld = gdbarch_data (gdbarch,
1291 language_gdbarch_data);
1292 return ld->arch_info[la->la_language].string_char_type;
1293}
1294
1295struct type *
1296language_bool_type (const struct language_defn *la,
1297 struct gdbarch *gdbarch)
1298{
1299 struct language_gdbarch *ld = gdbarch_data (gdbarch,
1300 language_gdbarch_data);
1301
1302 if (ld->arch_info[la->la_language].bool_type_symbol)
1303 {
1304 struct symbol *sym;
1305 sym = lookup_symbol (ld->arch_info[la->la_language].bool_type_symbol,
1306 NULL, VAR_DOMAIN, NULL);
1307 if (sym)
1308 {
1309 struct type *type = SYMBOL_TYPE (sym);
1310 if (type && TYPE_CODE (type) == TYPE_CODE_BOOL)
1311 return type;
1312 }
1313 }
1314
1315 return ld->arch_info[la->la_language].bool_type_default;
1316}
1317
1318struct type *
1319language_lookup_primitive_type_by_name (const struct language_defn *la,
1320 struct gdbarch *gdbarch,
1321 const char *name)
1322{
1323 struct language_gdbarch *ld = gdbarch_data (gdbarch,
1324 language_gdbarch_data);
1325 struct type *const *p;
1326 for (p = ld->arch_info[la->la_language].primitive_type_vector;
1327 (*p) != NULL;
1328 p++)
1329 {
1330 if (strcmp (TYPE_NAME (*p), name) == 0)
1331 return (*p);
1332 }
1333 return (NULL);
1334}
1335
1336/* Initialize the language routines */
1337
1338void
1339_initialize_language (void)
1340{
1341 static const char *type_or_range_names[]
1342 = { "on", "off", "warn", "auto", NULL };
1343
1344 static const char *case_sensitive_names[]
1345 = { "on", "off", "auto", NULL };
1346
1347 language_gdbarch_data
1348 = gdbarch_data_register_post_init (language_gdbarch_post_init);
1349
1350 /* GDB commands for language specific stuff */
1351
1352 add_prefix_cmd ("check", no_class, set_check,
1353 _("Set the status of the type/range checker."),
1354 &setchecklist, "set check ", 0, &setlist);
1355 add_alias_cmd ("c", "check", no_class, 1, &setlist);
1356 add_alias_cmd ("ch", "check", no_class, 1, &setlist);
1357
1358 add_prefix_cmd ("check", no_class, show_check,
1359 _("Show the status of the type/range checker."),
1360 &showchecklist, "show check ", 0, &showlist);
1361 add_alias_cmd ("c", "check", no_class, 1, &showlist);
1362 add_alias_cmd ("ch", "check", no_class, 1, &showlist);
1363
1364 add_setshow_enum_cmd ("type", class_support, type_or_range_names, &type, _("\
1365Set type checking. (on/warn/off/auto)"), _("\
1366Show type checking. (on/warn/off/auto)"), NULL,
1367 set_type_command,
1368 show_type_command,
1369 &setchecklist, &showchecklist);
1370
1371 add_setshow_enum_cmd ("range", class_support, type_or_range_names,
1372 &range, _("\
1373Set range checking. (on/warn/off/auto)"), _("\
1374Show range checking. (on/warn/off/auto)"), NULL,
1375 set_range_command,
1376 show_range_command,
1377 &setchecklist, &showchecklist);
1378
1379 add_setshow_enum_cmd ("case-sensitive", class_support, case_sensitive_names,
1380 &case_sensitive, _("\
1381Set case sensitivity in name search. (on/off/auto)"), _("\
1382Show case sensitivity in name search. (on/off/auto)"), _("\
1383For Fortran the default is off; for other languages the default is on."),
1384 set_case_command,
1385 show_case_command,
1386 &setlist, &showlist);
1387
1388 add_language (&auto_language_defn);
1389 add_language (&local_language_defn);
1390 add_language (&unknown_language_defn);
1391
1392 language = xstrdup ("auto");
1393 type = xstrdup ("auto");
1394 range = xstrdup ("auto");
1395 case_sensitive = xstrdup ("auto");
1396
1397 /* Have the above take effect */
1398 set_language (language_auto);
1399}