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