gdb vendor branch: Bring in additional source files
[dragonfly.git] / contrib / gdb-7 / gdb / language.c
CommitLineData
5796c8dc
SS
1/* Multiple source language support for GDB.
2
a45ae5f8
JM
3 Copyright (C) 1991-1996, 1998-2005, 2007-2012 Free Software
4 Foundation, Inc.
5796c8dc
SS
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,
c50c785c 26 and return the appropriate result. */
5796c8dc
SS
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
cf7f2e2d 66static void unk_lang_print_type (struct type *, const char *, struct ui_file *,
5796c8dc
SS
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
c50c785c 89/* The current language and language_mode (see language.h). */
5796c8dc
SS
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
c50c785c 114 frame do not match. */
5796c8dc
SS
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
c50c785c 119 and their helpers. */
5796c8dc
SS
120
121/* Show command. Display a warning if the language set
c50c785c 122 does not match the frame. */
5796c8dc
SS
123static void
124show_language_command (struct ui_file *file, int from_tty,
125 struct cmd_list_element *c, const char *value)
126{
c50c785c 127 enum language flang; /* The language of the current frame. */
5796c8dc
SS
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
c50c785c
JM
135 fprintf_filtered (gdb_stdout,
136 _("The current source language is \"%s\".\n"),
5796c8dc
SS
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
c50c785c 146/* Set command. Change the current working language. */
5796c8dc
SS
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
c50c785c 190 not match the current language. */
5796c8dc
SS
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
c50c785c 228/* Set command. Change the setting for type checking. */
5796c8dc
SS
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
c50c785c 263 not match the current language. */
5796c8dc
SS
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
c50c785c 301/* Set command. Change the setting for range checking. */
5796c8dc
SS
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
c50c785c 337 not match the current language. */
5796c8dc
SS
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
c50c785c
JM
365 fprintf_filtered (gdb_stdout,
366 _("Case sensitivity in name search is \"%s\".\n"),
5796c8dc
SS
367 value);
368
369 if (case_sensitivity != current_language->la_case_sensitivity)
370 warning (_("the current case sensitivity setting does not match "
371 "the language.\n"));
372}
373
374/* Set command. Change the setting for case sensitivity. */
375
376static void
377set_case_command (char *ignore, int from_tty, struct cmd_list_element *c)
378{
379 if (strcmp (case_sensitive, "on") == 0)
380 {
381 case_sensitivity = case_sensitive_on;
382 case_mode = case_mode_manual;
383 }
384 else if (strcmp (case_sensitive, "off") == 0)
385 {
386 case_sensitivity = case_sensitive_off;
387 case_mode = case_mode_manual;
388 }
389 else if (strcmp (case_sensitive, "auto") == 0)
390 {
391 case_mode = case_mode_auto;
392 set_type_range_case ();
393 return;
394 }
395 else
396 {
397 internal_error (__FILE__, __LINE__,
398 "Unrecognized case-sensitive setting: \"%s\"",
399 case_sensitive);
400 }
401
402 if (case_sensitivity != current_language->la_case_sensitivity)
403 warning (_("the current case sensitivity setting does not match "
404 "the language.\n"));
405}
406
407/* Set the status of range and type checking and case sensitivity based on
408 the current modes and the current language.
409 If SHOW is non-zero, then print out the current language,
c50c785c 410 type and range checking status. */
5796c8dc
SS
411static void
412set_type_range_case (void)
413{
414 if (range_mode == range_mode_auto)
415 range_check = current_language->la_range_check;
416
417 if (type_mode == type_mode_auto)
418 type_check = current_language->la_type_check;
419
420 if (case_mode == case_mode_auto)
421 case_sensitivity = current_language->la_case_sensitivity;
422}
423
c50c785c
JM
424/* Set current language to (enum language) LANG. Returns previous
425 language. */
5796c8dc
SS
426
427enum language
428set_language (enum language lang)
429{
430 int i;
431 enum language prev_language;
432
433 prev_language = current_language->la_language;
434
435 for (i = 0; i < languages_size; i++)
436 {
437 if (languages[i]->la_language == lang)
438 {
439 current_language = languages[i];
440 set_type_range_case ();
441 break;
442 }
443 }
444
445 return prev_language;
446}
447\f
448
449/* Print out the current language settings: language, range and
450 type checking. If QUIETLY, print only what has changed. */
451
452void
453language_info (int quietly)
454{
455 if (quietly && expected_language == current_language)
456 return;
457
458 expected_language = current_language;
459 printf_unfiltered (_("Current language: %s\n"), language);
460 show_language_command (NULL, 1, NULL, NULL);
461
462 if (!quietly)
463 {
464 printf_unfiltered (_("Type checking: %s\n"), type);
465 show_type_command (NULL, 1, NULL, NULL);
466 printf_unfiltered (_("Range checking: %s\n"), range);
467 show_range_command (NULL, 1, NULL, NULL);
468 printf_unfiltered (_("Case sensitivity: %s\n"), case_sensitive);
469 show_case_command (NULL, 1, NULL, NULL);
470 }
471}
472\f
c50c785c 473/* Return the result of a binary operation. */
5796c8dc
SS
474
475#if 0 /* Currently unused */
476
477struct type *
478binop_result_type (struct value *v1, struct value *v2)
479{
480 int size, uns;
481 struct type *t1 = check_typedef (VALUE_TYPE (v1));
482 struct type *t2 = check_typedef (VALUE_TYPE (v2));
483
484 int l1 = TYPE_LENGTH (t1);
485 int l2 = TYPE_LENGTH (t2);
486
487 switch (current_language->la_language)
488 {
489 case language_c:
490 case language_cplus:
cf7f2e2d 491 case language_d:
5796c8dc
SS
492 case language_objc:
493 if (TYPE_CODE (t1) == TYPE_CODE_FLT)
494 return TYPE_CODE (t2) == TYPE_CODE_FLT && l2 > l1 ?
495 VALUE_TYPE (v2) : VALUE_TYPE (v1);
496 else if (TYPE_CODE (t2) == TYPE_CODE_FLT)
497 return TYPE_CODE (t1) == TYPE_CODE_FLT && l1 > l2 ?
498 VALUE_TYPE (v1) : VALUE_TYPE (v2);
499 else if (TYPE_UNSIGNED (t1) && l1 > l2)
500 return VALUE_TYPE (v1);
501 else if (TYPE_UNSIGNED (t2) && l2 > l1)
502 return VALUE_TYPE (v2);
c50c785c
JM
503 else /* Both are signed. Result is the
504 longer type. */
5796c8dc
SS
505 return l1 > l2 ? VALUE_TYPE (v1) : VALUE_TYPE (v2);
506 break;
507 case language_m2:
508 /* If we are doing type-checking, l1 should equal l2, so this is
c50c785c 509 not needed. */
5796c8dc
SS
510 return l1 > l2 ? VALUE_TYPE (v1) : VALUE_TYPE (v2);
511 break;
512 }
513 internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
514 return (struct type *) 0; /* For lint */
515}
516
517#endif /* 0 */
518#if 0
519/* This page contains functions that are used in type/range checking.
520 They all return zero if the type/range check fails.
521
522 It is hoped that these will make extending GDB to parse different
523 languages a little easier. These are primarily used in eval.c when
524 evaluating expressions and making sure that their types are correct.
525 Instead of having a mess of conjucted/disjuncted expressions in an "if",
526 the ideas of type can be wrapped up in the following functions.
527
528 Note that some of them are not currently dependent upon which language
529 is currently being parsed. For example, floats are the same in
530 C and Modula-2 (ie. the only floating point type has TYPE_CODE of
c50c785c 531 TYPE_CODE_FLT), while booleans are different. */
5796c8dc
SS
532
533/* Returns non-zero if its argument is a simple type. This is the same for
534 both Modula-2 and for C. In the C case, TYPE_CODE_CHAR will never occur,
c50c785c 535 and thus will never cause the failure of the test. */
5796c8dc
SS
536int
537simple_type (struct type *type)
538{
539 CHECK_TYPEDEF (type);
540 switch (TYPE_CODE (type))
541 {
542 case TYPE_CODE_INT:
543 case TYPE_CODE_CHAR:
544 case TYPE_CODE_ENUM:
545 case TYPE_CODE_FLT:
546 case TYPE_CODE_RANGE:
547 case TYPE_CODE_BOOL:
548 return 1;
549
550 default:
551 return 0;
552 }
553}
554
555/* Returns non-zero if its argument is of an ordered type.
556 An ordered type is one in which the elements can be tested for the
557 properties of "greater than", "less than", etc, or for which the
c50c785c 558 operations "increment" or "decrement" make sense. */
5796c8dc
SS
559int
560ordered_type (struct type *type)
561{
562 CHECK_TYPEDEF (type);
563 switch (TYPE_CODE (type))
564 {
565 case TYPE_CODE_INT:
566 case TYPE_CODE_CHAR:
567 case TYPE_CODE_ENUM:
568 case TYPE_CODE_FLT:
569 case TYPE_CODE_RANGE:
570 return 1;
571
572 default:
573 return 0;
574 }
575}
576
c50c785c 577/* Returns non-zero if the two types are the same. */
5796c8dc
SS
578int
579same_type (struct type *arg1, struct type *arg2)
580{
581 CHECK_TYPEDEF (type);
c50c785c
JM
582 if (structured_type (arg1)
583 ? !structured_type (arg2) : structured_type (arg2))
584 /* One is structured and one isn't. */
5796c8dc
SS
585 return 0;
586 else if (structured_type (arg1) && structured_type (arg2))
587 return arg1 == arg2;
588 else if (numeric_type (arg1) && numeric_type (arg2))
589 return (TYPE_CODE (arg2) == TYPE_CODE (arg1)) &&
590 (TYPE_UNSIGNED (arg1) == TYPE_UNSIGNED (arg2))
591 ? 1 : 0;
592 else
593 return arg1 == arg2;
594}
595
c50c785c 596/* Returns non-zero if the type is integral. */
5796c8dc
SS
597int
598integral_type (struct type *type)
599{
600 CHECK_TYPEDEF (type);
601 switch (current_language->la_language)
602 {
603 case language_c:
604 case language_cplus:
cf7f2e2d 605 case language_d:
5796c8dc
SS
606 case language_objc:
607 return (TYPE_CODE (type) != TYPE_CODE_INT) &&
608 (TYPE_CODE (type) != TYPE_CODE_ENUM) ? 0 : 1;
609 case language_m2:
610 case language_pascal:
611 return TYPE_CODE (type) != TYPE_CODE_INT ? 0 : 1;
612 default:
613 error (_("Language not supported."));
614 }
615}
616
c50c785c 617/* Returns non-zero if the value is numeric. */
5796c8dc
SS
618int
619numeric_type (struct type *type)
620{
621 CHECK_TYPEDEF (type);
622 switch (TYPE_CODE (type))
623 {
624 case TYPE_CODE_INT:
625 case TYPE_CODE_FLT:
626 return 1;
627
628 default:
629 return 0;
630 }
631}
632
c50c785c 633/* Returns non-zero if the value is a character type. */
5796c8dc
SS
634int
635character_type (struct type *type)
636{
637 CHECK_TYPEDEF (type);
638 switch (current_language->la_language)
639 {
640 case language_m2:
641 case language_pascal:
642 return TYPE_CODE (type) != TYPE_CODE_CHAR ? 0 : 1;
643
644 case language_c:
645 case language_cplus:
cf7f2e2d 646 case language_d:
5796c8dc
SS
647 case language_objc:
648 return (TYPE_CODE (type) == TYPE_CODE_INT) &&
649 TYPE_LENGTH (type) == sizeof (char)
650 ? 1 : 0;
651 default:
652 return (0);
653 }
654}
655
c50c785c 656/* Returns non-zero if the value is a string type. */
5796c8dc
SS
657int
658string_type (struct type *type)
659{
660 CHECK_TYPEDEF (type);
661 switch (current_language->la_language)
662 {
663 case language_m2:
664 case language_pascal:
665 return TYPE_CODE (type) != TYPE_CODE_STRING ? 0 : 1;
666
667 case language_c:
668 case language_cplus:
cf7f2e2d 669 case language_d:
5796c8dc 670 case language_objc:
c50c785c 671 /* C does not have distinct string type. */
5796c8dc
SS
672 return (0);
673 default:
674 return (0);
675 }
676}
677
c50c785c 678/* Returns non-zero if the value is a boolean type. */
5796c8dc
SS
679int
680boolean_type (struct type *type)
681{
682 CHECK_TYPEDEF (type);
683 if (TYPE_CODE (type) == TYPE_CODE_BOOL)
684 return 1;
685 switch (current_language->la_language)
686 {
687 case language_c:
688 case language_cplus:
cf7f2e2d 689 case language_d:
5796c8dc
SS
690 case language_objc:
691 /* Might be more cleanly handled by having a
692 TYPE_CODE_INT_NOT_BOOL for (the deleted) CHILL and such
693 languages, or a TYPE_CODE_INT_OR_BOOL for C. */
694 if (TYPE_CODE (type) == TYPE_CODE_INT)
695 return 1;
696 default:
697 break;
698 }
699 return 0;
700}
701
c50c785c 702/* Returns non-zero if the value is a floating-point type. */
5796c8dc
SS
703int
704float_type (struct type *type)
705{
706 CHECK_TYPEDEF (type);
707 return TYPE_CODE (type) == TYPE_CODE_FLT;
708}
cf7f2e2d 709#endif
5796c8dc 710
c50c785c 711/* Returns non-zero if the value is a pointer type. */
5796c8dc
SS
712int
713pointer_type (struct type *type)
714{
715 return TYPE_CODE (type) == TYPE_CODE_PTR ||
716 TYPE_CODE (type) == TYPE_CODE_REF;
717}
718
cf7f2e2d 719#if 0
c50c785c 720/* Returns non-zero if the value is a structured type. */
5796c8dc
SS
721int
722structured_type (struct type *type)
723{
724 CHECK_TYPEDEF (type);
725 switch (current_language->la_language)
726 {
727 case language_c:
728 case language_cplus:
cf7f2e2d 729 case language_d:
5796c8dc
SS
730 case language_objc:
731 return (TYPE_CODE (type) == TYPE_CODE_STRUCT) ||
732 (TYPE_CODE (type) == TYPE_CODE_UNION) ||
733 (TYPE_CODE (type) == TYPE_CODE_ARRAY);
734 case language_pascal:
735 return (TYPE_CODE(type) == TYPE_CODE_STRUCT) ||
736 (TYPE_CODE(type) == TYPE_CODE_UNION) ||
737 (TYPE_CODE(type) == TYPE_CODE_SET) ||
738 (TYPE_CODE(type) == TYPE_CODE_ARRAY);
739 case language_m2:
740 return (TYPE_CODE (type) == TYPE_CODE_STRUCT) ||
741 (TYPE_CODE (type) == TYPE_CODE_SET) ||
742 (TYPE_CODE (type) == TYPE_CODE_ARRAY);
743 default:
744 return (0);
745 }
746}
747#endif
748\f
749/* This page contains functions that return info about
c50c785c 750 (struct value) values used in GDB. */
5796c8dc 751
c50c785c 752/* Returns non-zero if the value VAL represents a true value. */
5796c8dc
SS
753int
754value_true (struct value *val)
755{
756 /* It is possible that we should have some sort of error if a non-boolean
757 value is used in this context. Possibly dependent on some kind of
758 "boolean-checking" option like range checking. But it should probably
759 not depend on the language except insofar as is necessary to identify
760 a "boolean" value (i.e. in C using a float, pointer, etc., as a boolean
761 should be an error, probably). */
762 return !value_logical_not (val);
763}
764\f
765/* This page contains functions for the printing out of
766 error messages that occur during type- and range-
c50c785c 767 checking. */
5796c8dc
SS
768
769/* These are called when a language fails a type- or range-check. The
770 first argument should be a printf()-style format string, and the
771 rest of the arguments should be its arguments. If
772 [type|range]_check is [type|range]_check_on, an error is printed;
773 if [type|range]_check_warn, a warning; otherwise just the
c50c785c 774 message. */
5796c8dc
SS
775
776void
777type_error (const char *string,...)
778{
779 va_list args;
5796c8dc 780
cf7f2e2d 781 va_start (args, string);
5796c8dc
SS
782 switch (type_check)
783 {
784 case type_check_warn:
785 vwarning (string, args);
786 break;
787 case type_check_on:
788 verror (string, args);
789 break;
790 case type_check_off:
791 /* FIXME: cagney/2002-01-30: Should this function print anything
792 when type error is off? */
793 vfprintf_filtered (gdb_stderr, string, args);
794 fprintf_filtered (gdb_stderr, "\n");
795 break;
796 default:
797 internal_error (__FILE__, __LINE__, _("bad switch"));
798 }
799 va_end (args);
800}
801
802void
803range_error (const char *string,...)
804{
805 va_list args;
5796c8dc 806
cf7f2e2d 807 va_start (args, string);
5796c8dc
SS
808 switch (range_check)
809 {
810 case range_check_warn:
811 vwarning (string, args);
812 break;
813 case range_check_on:
814 verror (string, args);
815 break;
816 case range_check_off:
817 /* FIXME: cagney/2002-01-30: Should this function print anything
818 when range error is off? */
819 vfprintf_filtered (gdb_stderr, string, args);
820 fprintf_filtered (gdb_stderr, "\n");
821 break;
822 default:
823 internal_error (__FILE__, __LINE__, _("bad switch"));
824 }
825 va_end (args);
826}
827\f
828
c50c785c 829/* This page contains miscellaneous functions. */
5796c8dc 830
c50c785c 831/* Return the language enum for a given language string. */
5796c8dc
SS
832
833enum language
834language_enum (char *str)
835{
836 int i;
837
838 for (i = 0; i < languages_size; i++)
839 if (strcmp (languages[i]->la_name, str) == 0)
840 return languages[i]->la_language;
841
842 return language_unknown;
843}
844
c50c785c 845/* Return the language struct for a given language enum. */
5796c8dc
SS
846
847const struct language_defn *
848language_def (enum language lang)
849{
850 int i;
851
852 for (i = 0; i < languages_size; i++)
853 {
854 if (languages[i]->la_language == lang)
855 {
856 return languages[i];
857 }
858 }
859 return NULL;
860}
861
c50c785c 862/* Return the language as a string. */
5796c8dc
SS
863char *
864language_str (enum language lang)
865{
866 int i;
867
868 for (i = 0; i < languages_size; i++)
869 {
870 if (languages[i]->la_language == lang)
871 {
872 return languages[i]->la_name;
873 }
874 }
875 return "Unknown";
876}
877
878static void
879set_check (char *ignore, int from_tty)
880{
881 printf_unfiltered (
882 "\"set check\" must be followed by the name of a check subcommand.\n");
883 help_list (setchecklist, "set check ", -1, gdb_stdout);
884}
885
886static void
887show_check (char *ignore, int from_tty)
888{
889 cmd_show_list (showchecklist, from_tty, "");
890}
891\f
892/* Add a language to the set of known languages. */
893
894void
895add_language (const struct language_defn *lang)
896{
897 /* For the "set language" command. */
898 static char **language_names = NULL;
899 /* For the "help set language" command. */
900 char *language_set_doc = NULL;
901
902 int i;
903 struct ui_file *tmp_stream;
904
905 if (lang->la_magic != LANG_MAGIC)
906 {
c50c785c
JM
907 fprintf_unfiltered (gdb_stderr,
908 "Magic number of %s language struct wrong\n",
5796c8dc 909 lang->la_name);
c50c785c
JM
910 internal_error (__FILE__, __LINE__,
911 _("failed internal consistency check"));
5796c8dc
SS
912 }
913
914 if (!languages)
915 {
916 languages_allocsize = DEFAULT_ALLOCSIZE;
917 languages = (const struct language_defn **) xmalloc
918 (languages_allocsize * sizeof (*languages));
919 }
920 if (languages_size >= languages_allocsize)
921 {
922 languages_allocsize *= 2;
923 languages = (const struct language_defn **) xrealloc ((char *) languages,
924 languages_allocsize * sizeof (*languages));
925 }
926 languages[languages_size++] = lang;
927
928 /* Build the language names array, to be used as enumeration in the
929 set language" enum command. */
930 language_names = xrealloc (language_names,
931 (languages_size + 1) * sizeof (const char *));
932 for (i = 0; i < languages_size; ++i)
933 language_names[i] = languages[i]->la_name;
934 language_names[i] = NULL;
935
936 /* Build the "help set language" docs. */
937 tmp_stream = mem_fileopen ();
938
c50c785c
JM
939 fprintf_unfiltered (tmp_stream,
940 _("Set the current source language.\n"
941 "The currently understood settings are:\n\nlocal or "
942 "auto Automatic setting based on source file\n"));
5796c8dc
SS
943
944 for (i = 0; i < languages_size; ++i)
945 {
946 /* Already dealt with these above. */
947 if (languages[i]->la_language == language_unknown
948 || languages[i]->la_language == language_auto)
949 continue;
950
951 /* FIXME: i18n: for now assume that the human-readable name
952 is just a capitalization of the internal name. */
953 fprintf_unfiltered (tmp_stream, "%-16s Use the %c%s language\n",
954 languages[i]->la_name,
955 /* Capitalize first letter of language
956 name. */
957 toupper (languages[i]->la_name[0]),
958 languages[i]->la_name + 1);
959 }
960
961 language_set_doc = ui_file_xstrdup (tmp_stream, NULL);
962 ui_file_delete (tmp_stream);
963
964 add_setshow_enum_cmd ("language", class_support,
965 (const char **) language_names,
966 &language,
c50c785c
JM
967 language_set_doc,
968 _("Show the current source language."),
969 NULL, set_language_command,
5796c8dc
SS
970 show_language_command,
971 &setlist, &showlist);
972
973 xfree (language_set_doc);
974}
975
976/* Iterate through all registered languages looking for and calling
977 any non-NULL struct language_defn.skip_trampoline() functions.
978 Return the result from the first that returns non-zero, or 0 if all
979 `fail'. */
980CORE_ADDR
981skip_language_trampoline (struct frame_info *frame, CORE_ADDR pc)
982{
983 int i;
984
985 for (i = 0; i < languages_size; i++)
986 {
987 if (languages[i]->skip_trampoline)
988 {
989 CORE_ADDR real_pc = (languages[i]->skip_trampoline) (frame, pc);
cf7f2e2d 990
5796c8dc
SS
991 if (real_pc)
992 return real_pc;
993 }
994 }
995
996 return 0;
997}
998
c50c785c 999/* Return demangled language symbol, or NULL.
5796c8dc
SS
1000 FIXME: Options are only useful for certain languages and ignored
1001 by others, so it would be better to remove them here and have a
c50c785c 1002 more flexible demangler for the languages that need it.
5796c8dc
SS
1003 FIXME: Sometimes the demangler is invoked when we don't know the
1004 language, so we can't use this everywhere. */
1005char *
1006language_demangle (const struct language_defn *current_language,
1007 const char *mangled, int options)
1008{
1009 if (current_language != NULL && current_language->la_demangle)
1010 return current_language->la_demangle (mangled, options);
1011 return NULL;
1012}
1013
1014/* Return class name from physname or NULL. */
1015char *
c50c785c 1016language_class_name_from_physname (const struct language_defn *lang,
5796c8dc
SS
1017 const char *physname)
1018{
c50c785c
JM
1019 if (lang != NULL && lang->la_class_name_from_physname)
1020 return lang->la_class_name_from_physname (physname);
5796c8dc
SS
1021 return NULL;
1022}
1023
1024/* Return non-zero if TYPE should be passed (and returned) by
1025 reference at the language level. */
1026int
1027language_pass_by_reference (struct type *type)
1028{
1029 return current_language->la_pass_by_reference (type);
1030}
1031
1032/* Return zero; by default, types are passed by value at the language
1033 level. The target ABI may pass or return some structs by reference
1034 independent of this. */
1035int
1036default_pass_by_reference (struct type *type)
1037{
1038 return 0;
1039}
1040
1041/* Return the default string containing the list of characters
1042 delimiting words. This is a reasonable default value that
1043 most languages should be able to use. */
1044
1045char *
1046default_word_break_characters (void)
1047{
1048 return " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,-";
1049}
1050
1051/* Print the index of array elements using the C99 syntax. */
1052
1053void
1054default_print_array_index (struct value *index_value, struct ui_file *stream,
1055 const struct value_print_options *options)
1056{
1057 fprintf_filtered (stream, "[");
1058 LA_VALUE_PRINT (index_value, stream, options);
1059 fprintf_filtered (stream, "] = ");
1060}
1061
1062void
1063default_get_string (struct value *value, gdb_byte **buffer, int *length,
cf7f2e2d 1064 struct type **char_type, const char **charset)
5796c8dc
SS
1065{
1066 error (_("Getting a string is unsupported in this language."));
1067}
1068
1069/* Define the language that is no language. */
1070
1071static int
1072unk_lang_parser (void)
1073{
1074 return 1;
1075}
1076
1077static void
1078unk_lang_error (char *msg)
1079{
1080 error (_("Attempted to parse an expression with unknown language"));
1081}
1082
1083static void
1084unk_lang_emit_char (int c, struct type *type, struct ui_file *stream,
1085 int quoter)
1086{
c50c785c
JM
1087 error (_("internal error - unimplemented "
1088 "function unk_lang_emit_char called."));
5796c8dc
SS
1089}
1090
1091static void
1092unk_lang_printchar (int c, struct type *type, struct ui_file *stream)
1093{
c50c785c
JM
1094 error (_("internal error - unimplemented "
1095 "function unk_lang_printchar called."));
5796c8dc
SS
1096}
1097
1098static void
1099unk_lang_printstr (struct ui_file *stream, struct type *type,
1100 const gdb_byte *string, unsigned int length,
cf7f2e2d 1101 const char *encoding, int force_ellipses,
5796c8dc
SS
1102 const struct value_print_options *options)
1103{
c50c785c
JM
1104 error (_("internal error - unimplemented "
1105 "function unk_lang_printstr called."));
5796c8dc
SS
1106}
1107
1108static void
cf7f2e2d
JM
1109unk_lang_print_type (struct type *type, const char *varstring,
1110 struct ui_file *stream, int show, int level)
5796c8dc 1111{
c50c785c
JM
1112 error (_("internal error - unimplemented "
1113 "function unk_lang_print_type called."));
5796c8dc
SS
1114}
1115
1116static int
1117unk_lang_val_print (struct type *type, const gdb_byte *valaddr,
1118 int embedded_offset, CORE_ADDR address,
1119 struct ui_file *stream, int recurse,
cf7f2e2d 1120 const struct value *val,
5796c8dc
SS
1121 const struct value_print_options *options)
1122{
c50c785c
JM
1123 error (_("internal error - unimplemented "
1124 "function unk_lang_val_print called."));
5796c8dc
SS
1125}
1126
1127static int
1128unk_lang_value_print (struct value *val, struct ui_file *stream,
1129 const struct value_print_options *options)
1130{
c50c785c
JM
1131 error (_("internal error - unimplemented "
1132 "function unk_lang_value_print called."));
5796c8dc
SS
1133}
1134
1135static CORE_ADDR unk_lang_trampoline (struct frame_info *frame, CORE_ADDR pc)
1136{
1137 return 0;
1138}
1139
1140/* Unknown languages just use the cplus demangler. */
1141static char *unk_lang_demangle (const char *mangled, int options)
1142{
1143 return cplus_demangle (mangled, options);
1144}
1145
1146static char *unk_lang_class_name (const char *mangled)
1147{
1148 return NULL;
1149}
1150
1151static const struct op_print unk_op_print_tab[] =
1152{
1153 {NULL, OP_NULL, PREC_NULL, 0}
1154};
1155
1156static void
1157unknown_language_arch_info (struct gdbarch *gdbarch,
1158 struct language_arch_info *lai)
1159{
1160 lai->string_char_type = builtin_type (gdbarch)->builtin_char;
1161 lai->bool_type_default = builtin_type (gdbarch)->builtin_int;
1162 lai->primitive_type_vector = GDBARCH_OBSTACK_CALLOC (gdbarch, 1,
1163 struct type *);
1164}
1165
1166const struct language_defn unknown_language_defn =
1167{
1168 "unknown",
1169 language_unknown,
1170 range_check_off,
1171 type_check_off,
1172 case_sensitive_on,
1173 array_row_major,
1174 macro_expansion_no,
1175 &exp_descriptor_standard,
1176 unk_lang_parser,
1177 unk_lang_error,
1178 null_post_parser,
1179 unk_lang_printchar, /* Print character constant */
1180 unk_lang_printstr,
1181 unk_lang_emit_char,
1182 unk_lang_print_type, /* Print a type using appropriate syntax */
1183 default_print_typedef, /* Print a typedef using appropriate syntax */
1184 unk_lang_val_print, /* Print a value using appropriate syntax */
1185 unk_lang_value_print, /* Print a top-level value */
1186 unk_lang_trampoline, /* Language specific skip_trampoline */
1187 "this", /* name_of_this */
1188 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1189 basic_lookup_transparent_type,/* lookup_transparent_type */
1190 unk_lang_demangle, /* Language specific symbol demangler */
c50c785c
JM
1191 unk_lang_class_name, /* Language specific
1192 class_name_from_physname */
5796c8dc
SS
1193 unk_op_print_tab, /* expression operators for printing */
1194 1, /* c-style arrays */
1195 0, /* String lower bound */
1196 default_word_break_characters,
1197 default_make_symbol_completion_list,
1198 unknown_language_arch_info, /* la_language_arch_info. */
1199 default_print_array_index,
1200 default_pass_by_reference,
1201 default_get_string,
a45ae5f8
JM
1202 strcmp_iw_ordered,
1203 iterate_over_symbols,
5796c8dc
SS
1204 LANG_MAGIC
1205};
1206
c50c785c
JM
1207/* These two structs define fake entries for the "local" and "auto"
1208 options. */
5796c8dc
SS
1209const struct language_defn auto_language_defn =
1210{
1211 "auto",
1212 language_auto,
1213 range_check_off,
1214 type_check_off,
1215 case_sensitive_on,
1216 array_row_major,
1217 macro_expansion_no,
1218 &exp_descriptor_standard,
1219 unk_lang_parser,
1220 unk_lang_error,
1221 null_post_parser,
1222 unk_lang_printchar, /* Print character constant */
1223 unk_lang_printstr,
1224 unk_lang_emit_char,
1225 unk_lang_print_type, /* Print a type using appropriate syntax */
1226 default_print_typedef, /* Print a typedef using appropriate syntax */
1227 unk_lang_val_print, /* Print a value using appropriate syntax */
1228 unk_lang_value_print, /* Print a top-level value */
1229 unk_lang_trampoline, /* Language specific skip_trampoline */
1230 "this", /* name_of_this */
1231 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1232 basic_lookup_transparent_type,/* lookup_transparent_type */
1233 unk_lang_demangle, /* Language specific symbol demangler */
c50c785c
JM
1234 unk_lang_class_name, /* Language specific
1235 class_name_from_physname */
5796c8dc
SS
1236 unk_op_print_tab, /* expression operators for printing */
1237 1, /* c-style arrays */
1238 0, /* String lower bound */
1239 default_word_break_characters,
1240 default_make_symbol_completion_list,
1241 unknown_language_arch_info, /* la_language_arch_info. */
1242 default_print_array_index,
1243 default_pass_by_reference,
1244 default_get_string,
a45ae5f8
JM
1245 strcmp_iw_ordered,
1246 iterate_over_symbols,
5796c8dc
SS
1247 LANG_MAGIC
1248};
1249
1250const struct language_defn local_language_defn =
1251{
1252 "local",
1253 language_auto,
1254 range_check_off,
1255 type_check_off,
1256 case_sensitive_on,
1257 array_row_major,
1258 macro_expansion_no,
1259 &exp_descriptor_standard,
1260 unk_lang_parser,
1261 unk_lang_error,
1262 null_post_parser,
1263 unk_lang_printchar, /* Print character constant */
1264 unk_lang_printstr,
1265 unk_lang_emit_char,
1266 unk_lang_print_type, /* Print a type using appropriate syntax */
1267 default_print_typedef, /* Print a typedef using appropriate syntax */
1268 unk_lang_val_print, /* Print a value using appropriate syntax */
1269 unk_lang_value_print, /* Print a top-level value */
1270 unk_lang_trampoline, /* Language specific skip_trampoline */
1271 "this", /* name_of_this */
1272 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1273 basic_lookup_transparent_type,/* lookup_transparent_type */
1274 unk_lang_demangle, /* Language specific symbol demangler */
c50c785c
JM
1275 unk_lang_class_name, /* Language specific
1276 class_name_from_physname */
5796c8dc
SS
1277 unk_op_print_tab, /* expression operators for printing */
1278 1, /* c-style arrays */
1279 0, /* String lower bound */
1280 default_word_break_characters,
1281 default_make_symbol_completion_list,
1282 unknown_language_arch_info, /* la_language_arch_info. */
1283 default_print_array_index,
1284 default_pass_by_reference,
1285 default_get_string,
a45ae5f8
JM
1286 strcmp_iw_ordered,
1287 iterate_over_symbols,
5796c8dc
SS
1288 LANG_MAGIC
1289};
1290\f
1291/* Per-architecture language information. */
1292
1293static struct gdbarch_data *language_gdbarch_data;
1294
1295struct language_gdbarch
1296{
1297 /* A vector of per-language per-architecture info. Indexed by "enum
1298 language". */
1299 struct language_arch_info arch_info[nr_languages];
1300};
1301
1302static void *
1303language_gdbarch_post_init (struct gdbarch *gdbarch)
1304{
1305 struct language_gdbarch *l;
1306 int i;
1307
1308 l = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct language_gdbarch);
1309 for (i = 0; i < languages_size; i++)
1310 {
1311 if (languages[i] != NULL
1312 && languages[i]->la_language_arch_info != NULL)
1313 languages[i]->la_language_arch_info
1314 (gdbarch, l->arch_info + languages[i]->la_language);
1315 }
1316 return l;
1317}
1318
1319struct type *
1320language_string_char_type (const struct language_defn *la,
1321 struct gdbarch *gdbarch)
1322{
1323 struct language_gdbarch *ld = gdbarch_data (gdbarch,
1324 language_gdbarch_data);
cf7f2e2d 1325
5796c8dc
SS
1326 return ld->arch_info[la->la_language].string_char_type;
1327}
1328
1329struct type *
1330language_bool_type (const struct language_defn *la,
1331 struct gdbarch *gdbarch)
1332{
1333 struct language_gdbarch *ld = gdbarch_data (gdbarch,
1334 language_gdbarch_data);
1335
1336 if (ld->arch_info[la->la_language].bool_type_symbol)
1337 {
1338 struct symbol *sym;
cf7f2e2d 1339
5796c8dc
SS
1340 sym = lookup_symbol (ld->arch_info[la->la_language].bool_type_symbol,
1341 NULL, VAR_DOMAIN, NULL);
1342 if (sym)
1343 {
1344 struct type *type = SYMBOL_TYPE (sym);
cf7f2e2d 1345
5796c8dc
SS
1346 if (type && TYPE_CODE (type) == TYPE_CODE_BOOL)
1347 return type;
1348 }
1349 }
1350
1351 return ld->arch_info[la->la_language].bool_type_default;
1352}
1353
1354struct type *
1355language_lookup_primitive_type_by_name (const struct language_defn *la,
1356 struct gdbarch *gdbarch,
1357 const char *name)
1358{
1359 struct language_gdbarch *ld = gdbarch_data (gdbarch,
1360 language_gdbarch_data);
1361 struct type *const *p;
cf7f2e2d 1362
5796c8dc
SS
1363 for (p = ld->arch_info[la->la_language].primitive_type_vector;
1364 (*p) != NULL;
1365 p++)
1366 {
1367 if (strcmp (TYPE_NAME (*p), name) == 0)
1368 return (*p);
1369 }
1370 return (NULL);
1371}
1372
c50c785c 1373/* Initialize the language routines. */
5796c8dc
SS
1374
1375void
1376_initialize_language (void)
1377{
1378 static const char *type_or_range_names[]
1379 = { "on", "off", "warn", "auto", NULL };
1380
1381 static const char *case_sensitive_names[]
1382 = { "on", "off", "auto", NULL };
1383
1384 language_gdbarch_data
1385 = gdbarch_data_register_post_init (language_gdbarch_post_init);
1386
c50c785c 1387 /* GDB commands for language specific stuff. */
5796c8dc
SS
1388
1389 add_prefix_cmd ("check", no_class, set_check,
1390 _("Set the status of the type/range checker."),
1391 &setchecklist, "set check ", 0, &setlist);
1392 add_alias_cmd ("c", "check", no_class, 1, &setlist);
1393 add_alias_cmd ("ch", "check", no_class, 1, &setlist);
1394
1395 add_prefix_cmd ("check", no_class, show_check,
1396 _("Show the status of the type/range checker."),
1397 &showchecklist, "show check ", 0, &showlist);
1398 add_alias_cmd ("c", "check", no_class, 1, &showlist);
1399 add_alias_cmd ("ch", "check", no_class, 1, &showlist);
1400
c50c785c
JM
1401 add_setshow_enum_cmd ("type", class_support, type_or_range_names, &type,
1402 _("Set type checking. (on/warn/off/auto)"),
1403 _("Show type checking. (on/warn/off/auto)"),
1404 NULL, set_type_command,
5796c8dc
SS
1405 show_type_command,
1406 &setchecklist, &showchecklist);
1407
1408 add_setshow_enum_cmd ("range", class_support, type_or_range_names,
c50c785c
JM
1409 &range,
1410 _("Set range checking. (on/warn/off/auto)"),
1411 _("Show range checking. (on/warn/off/auto)"),
1412 NULL, set_range_command,
5796c8dc
SS
1413 show_range_command,
1414 &setchecklist, &showchecklist);
1415
1416 add_setshow_enum_cmd ("case-sensitive", class_support, case_sensitive_names,
1417 &case_sensitive, _("\
1418Set case sensitivity in name search. (on/off/auto)"), _("\
1419Show case sensitivity in name search. (on/off/auto)"), _("\
1420For Fortran the default is off; for other languages the default is on."),
1421 set_case_command,
1422 show_case_command,
1423 &setlist, &showlist);
1424
1425 add_language (&auto_language_defn);
1426 add_language (&local_language_defn);
1427 add_language (&unknown_language_defn);
1428
1429 language = xstrdup ("auto");
1430 type = xstrdup ("auto");
1431 range = xstrdup ("auto");
1432 case_sensitive = xstrdup ("auto");
1433
c50c785c 1434 /* Have the above take effect. */
5796c8dc
SS
1435 set_language (language_auto);
1436}