1 /* Multiple source language support for GDB.
3 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000,
4 2001, 2002, 2003 Free Software Foundation, Inc.
6 Contributed by the Department of Computer Science at the State University
7 of New York at Buffalo.
9 This file is part of GDB.
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 2 of the License, or
14 (at your option) any later version.
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.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 59 Temple Place - Suite 330,
24 Boston, MA 02111-1307, USA. */
26 /* This file contains functions that return things that are specific
27 to languages. Each function should examine current_language if necessary,
28 and return the appropriate result. */
30 /* FIXME: Most of these would be better organized as macros which
31 return data out of a "language-specific" struct pointer that is set
32 whenever the working language changes. That would be a lot faster. */
36 #include "gdb_string.h"
42 #include "expression.h"
45 #include "parser-defs.h"
48 extern void _initialize_language (void);
50 static void show_language_command (char *, int);
52 static void set_language_command (char *, int);
54 static void show_type_command (char *, int);
56 static void set_type_command (char *, int);
58 static void show_range_command (char *, int);
60 static void set_range_command (char *, int);
62 static void show_case_command (char *, int);
64 static void set_case_command (char *, int);
66 static void set_case_str (void);
68 static void set_range_str (void);
70 static void set_type_str (void);
72 static void set_lang_str (void);
74 static void unk_lang_error (char *);
76 static int unk_lang_parser (void);
78 static void show_check (char *, int);
80 static void set_check (char *, int);
82 static void set_type_range_case (void);
84 static void unk_lang_emit_char (int c
, struct ui_file
*stream
, int quoter
);
86 static void unk_lang_printchar (int c
, struct ui_file
*stream
);
88 static void unk_lang_printstr (struct ui_file
* stream
, char *string
,
89 unsigned int length
, int width
,
92 static struct type
*unk_lang_create_fundamental_type (struct objfile
*, int);
94 static void unk_lang_print_type (struct type
*, char *, struct ui_file
*,
97 static int unk_lang_val_print (struct type
*, char *, int, CORE_ADDR
,
98 struct ui_file
*, int, int, int,
99 enum val_prettyprint
);
101 static int unk_lang_value_print (struct value
*, struct ui_file
*, int, enum val_prettyprint
);
103 /* Forward declaration */
104 extern const struct language_defn unknown_language_defn
;
106 /* The current (default at startup) state of type and range checking.
107 (If the modes are set to "auto", though, these are changed based
108 on the default language at startup, and then again based on the
109 language of the first source file. */
111 enum range_mode range_mode
= range_mode_auto
;
112 enum range_check range_check
= range_check_off
;
113 enum type_mode type_mode
= type_mode_auto
;
114 enum type_check type_check
= type_check_off
;
115 enum case_mode case_mode
= case_mode_auto
;
116 enum case_sensitivity case_sensitivity
= case_sensitive_on
;
118 /* The current language and language_mode (see language.h) */
120 const struct language_defn
*current_language
= &unknown_language_defn
;
121 enum language_mode language_mode
= language_mode_auto
;
123 /* The language that the user expects to be typing in (the language
124 of main(), or the last language we notified them about, or C). */
126 const struct language_defn
*expected_language
;
128 /* The list of supported languages. The list itself is malloc'd. */
130 static const struct language_defn
**languages
;
131 static unsigned languages_size
;
132 static unsigned languages_allocsize
;
133 #define DEFAULT_ALLOCSIZE 4
135 /* The "set language/type/range" commands all put stuff in these
136 buffers. This is to make them work as set/show commands. The
137 user's string is copied here, then the set_* commands look at
138 them and update them to something that looks nice when it is
141 static char *language
;
144 static char *case_sensitive
;
146 /* Warning issued when current_language and the language of the current
147 frame do not match. */
148 char lang_frame_mismatch_warn
[] =
149 "Warning: the current language does not match this frame.";
152 /* This page contains the functions corresponding to GDB commands
153 and their helpers. */
155 /* Show command. Display a warning if the language set
156 does not match the frame. */
158 show_language_command (char *ignore
, int from_tty
)
160 enum language flang
; /* The language of the current frame */
162 flang
= get_frame_language ();
163 if (flang
!= language_unknown
&&
164 language_mode
== language_mode_manual
&&
165 current_language
->la_language
!= flang
)
166 printf_filtered ("%s\n", lang_frame_mismatch_warn
);
169 /* Set command. Change the current working language. */
171 set_language_command (char *ignore
, int from_tty
)
177 if (!language
|| !language
[0])
179 printf_unfiltered ("The currently understood settings are:\n\n");
180 printf_unfiltered ("local or auto Automatic setting based on source file\n");
182 for (i
= 0; i
< languages_size
; ++i
)
184 /* Already dealt with these above. */
185 if (languages
[i
]->la_language
== language_unknown
186 || languages
[i
]->la_language
== language_auto
)
189 /* FIXME for now assume that the human-readable name is just
190 a capitalization of the internal name. */
191 printf_unfiltered ("%-16s Use the %c%s language\n",
192 languages
[i
]->la_name
,
193 /* Capitalize first letter of language
195 toupper (languages
[i
]->la_name
[0]),
196 languages
[i
]->la_name
+ 1);
198 /* Restore the silly string. */
199 set_language (current_language
->la_language
);
203 /* Search the list of languages for a match. */
204 for (i
= 0; i
< languages_size
; i
++)
206 if (STREQ (languages
[i
]->la_name
, language
))
208 /* Found it! Go into manual mode, and use this language. */
209 if (languages
[i
]->la_language
== language_auto
)
211 /* Enter auto mode. Set to the current frame's language, if known. */
212 language_mode
= language_mode_auto
;
213 flang
= get_frame_language ();
214 if (flang
!= language_unknown
)
215 set_language (flang
);
216 expected_language
= current_language
;
221 /* Enter manual mode. Set the specified language. */
222 language_mode
= language_mode_manual
;
223 current_language
= languages
[i
];
224 set_type_range_case ();
226 expected_language
= current_language
;
232 /* Reset the language (esp. the global string "language") to the
234 err_lang
= savestring (language
, strlen (language
));
235 make_cleanup (xfree
, err_lang
); /* Free it after error */
236 set_language (current_language
->la_language
);
237 error ("Unknown language `%s'.", err_lang
);
240 /* Show command. Display a warning if the type setting does
241 not match the current language. */
243 show_type_command (char *ignore
, int from_tty
)
245 if (type_check
!= current_language
->la_type_check
)
247 "Warning: the current type check setting does not match the language.\n");
250 /* Set command. Change the setting for type checking. */
252 set_type_command (char *ignore
, int from_tty
)
254 if (STREQ (type
, "on"))
256 type_check
= type_check_on
;
257 type_mode
= type_mode_manual
;
259 else if (STREQ (type
, "warn"))
261 type_check
= type_check_warn
;
262 type_mode
= type_mode_manual
;
264 else if (STREQ (type
, "off"))
266 type_check
= type_check_off
;
267 type_mode
= type_mode_manual
;
269 else if (STREQ (type
, "auto"))
271 type_mode
= type_mode_auto
;
272 set_type_range_case ();
273 /* Avoid hitting the set_type_str call below. We
274 did it in set_type_range_case. */
279 warning ("Unrecognized type check setting: \"%s\"", type
);
282 show_type_command ((char *) NULL
, from_tty
);
285 /* Show command. Display a warning if the range setting does
286 not match the current language. */
288 show_range_command (char *ignore
, int from_tty
)
291 if (range_check
!= current_language
->la_range_check
)
293 "Warning: the current range check setting does not match the language.\n");
296 /* Set command. Change the setting for range checking. */
298 set_range_command (char *ignore
, int from_tty
)
300 if (STREQ (range
, "on"))
302 range_check
= range_check_on
;
303 range_mode
= range_mode_manual
;
305 else if (STREQ (range
, "warn"))
307 range_check
= range_check_warn
;
308 range_mode
= range_mode_manual
;
310 else if (STREQ (range
, "off"))
312 range_check
= range_check_off
;
313 range_mode
= range_mode_manual
;
315 else if (STREQ (range
, "auto"))
317 range_mode
= range_mode_auto
;
318 set_type_range_case ();
319 /* Avoid hitting the set_range_str call below. We
320 did it in set_type_range_case. */
325 warning ("Unrecognized range check setting: \"%s\"", range
);
328 show_range_command ((char *) 0, from_tty
);
331 /* Show command. Display a warning if the case sensitivity setting does
332 not match the current language. */
334 show_case_command (char *ignore
, int from_tty
)
336 if (case_sensitivity
!= current_language
->la_case_sensitivity
)
338 "Warning: the current case sensitivity setting does not match the language.\n");
341 /* Set command. Change the setting for case sensitivity. */
343 set_case_command (char *ignore
, int from_tty
)
345 if (STREQ (case_sensitive
, "on"))
347 case_sensitivity
= case_sensitive_on
;
348 case_mode
= case_mode_manual
;
350 else if (STREQ (case_sensitive
, "off"))
352 case_sensitivity
= case_sensitive_off
;
353 case_mode
= case_mode_manual
;
355 else if (STREQ (case_sensitive
, "auto"))
357 case_mode
= case_mode_auto
;
358 set_type_range_case ();
359 /* Avoid hitting the set_case_str call below. We
360 did it in set_type_range_case. */
365 warning ("Unrecognized case-sensitive setting: \"%s\"", case_sensitive
);
368 show_case_command ((char *) NULL
, from_tty
);
371 /* Set the status of range and type checking and case sensitivity based on
372 the current modes and the current language.
373 If SHOW is non-zero, then print out the current language,
374 type and range checking status. */
376 set_type_range_case (void)
379 if (range_mode
== range_mode_auto
)
380 range_check
= current_language
->la_range_check
;
382 if (type_mode
== type_mode_auto
)
383 type_check
= current_language
->la_type_check
;
385 if (case_mode
== case_mode_auto
)
386 case_sensitivity
= current_language
->la_case_sensitivity
;
393 /* Set current language to (enum language) LANG. Returns previous language. */
396 set_language (enum language lang
)
399 enum language prev_language
;
401 prev_language
= current_language
->la_language
;
403 for (i
= 0; i
< languages_size
; i
++)
405 if (languages
[i
]->la_language
== lang
)
407 current_language
= languages
[i
];
408 set_type_range_case ();
414 return prev_language
;
417 /* This page contains functions that update the global vars
418 language, type and range. */
426 if (language_mode
== language_mode_auto
)
427 prefix
= "auto; currently ";
429 language
= concat (prefix
, current_language
->la_name
, NULL
);
435 char *tmp
= NULL
, *prefix
= "";
439 if (type_mode
== type_mode_auto
)
440 prefix
= "auto; currently ";
450 case type_check_warn
:
454 error ("Unrecognized type check setting.");
457 type
= concat (prefix
, tmp
, NULL
);
463 char *tmp
, *pref
= "";
465 if (range_mode
== range_mode_auto
)
466 pref
= "auto; currently ";
473 case range_check_off
:
476 case range_check_warn
:
480 error ("Unrecognized range check setting.");
485 range
= concat (pref
, tmp
, NULL
);
491 char *tmp
= NULL
, *prefix
= "";
493 if (case_mode
==case_mode_auto
)
494 prefix
= "auto; currently ";
496 switch (case_sensitivity
)
498 case case_sensitive_on
:
501 case case_sensitive_off
:
505 error ("Unrecognized case-sensitive setting.");
508 xfree (case_sensitive
);
509 case_sensitive
= concat (prefix
, tmp
, NULL
);
512 /* Print out the current language settings: language, range and
513 type checking. If QUIETLY, print only what has changed. */
516 language_info (int quietly
)
518 if (quietly
&& expected_language
== current_language
)
521 expected_language
= current_language
;
522 printf_unfiltered ("Current language: %s\n", language
);
523 show_language_command ((char *) 0, 1);
527 printf_unfiltered ("Type checking: %s\n", type
);
528 show_type_command ((char *) 0, 1);
529 printf_unfiltered ("Range checking: %s\n", range
);
530 show_range_command ((char *) 0, 1);
531 printf_unfiltered ("Case sensitivity: %s\n", case_sensitive
);
532 show_case_command ((char *) 0, 1);
536 /* Return the result of a binary operation. */
538 #if 0 /* Currently unused */
541 binop_result_type (struct value
*v1
, struct value
*v2
)
544 struct type
*t1
= check_typedef (VALUE_TYPE (v1
));
545 struct type
*t2
= check_typedef (VALUE_TYPE (v2
));
547 int l1
= TYPE_LENGTH (t1
);
548 int l2
= TYPE_LENGTH (t2
);
550 switch (current_language
->la_language
)
555 if (TYPE_CODE (t1
) == TYPE_CODE_FLT
)
556 return TYPE_CODE (t2
) == TYPE_CODE_FLT
&& l2
> l1
?
557 VALUE_TYPE (v2
) : VALUE_TYPE (v1
);
558 else if (TYPE_CODE (t2
) == TYPE_CODE_FLT
)
559 return TYPE_CODE (t1
) == TYPE_CODE_FLT
&& l1
> l2
?
560 VALUE_TYPE (v1
) : VALUE_TYPE (v2
);
561 else if (TYPE_UNSIGNED (t1
) && l1
> l2
)
562 return VALUE_TYPE (v1
);
563 else if (TYPE_UNSIGNED (t2
) && l2
> l1
)
564 return VALUE_TYPE (v2
);
565 else /* Both are signed. Result is the longer type */
566 return l1
> l2
? VALUE_TYPE (v1
) : VALUE_TYPE (v2
);
569 /* If we are doing type-checking, l1 should equal l2, so this is
571 return l1
> l2
? VALUE_TYPE (v1
) : VALUE_TYPE (v2
);
574 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
575 return (struct type
*) 0; /* For lint */
581 /* This page contains functions that return format strings for
582 printf for printing out numbers in different formats */
584 /* Returns the appropriate printf format for hexadecimal
587 local_hex_format_custom (char *pre
)
589 static char form
[50];
591 strcpy (form
, local_hex_format_prefix ());
594 strcat (form
, local_hex_format_specifier ());
595 strcat (form
, local_hex_format_suffix ());
599 /* Converts a LONGEST to custom hexadecimal and stores it in a static
600 string. Returns a pointer to this string. */
602 local_hex_string (LONGEST num
)
604 return local_hex_string_custom (num
, "l");
607 /* Converts a LONGEST number to custom hexadecimal and stores it in a static
608 string. Returns a pointer to this string. Note that the width parameter
609 should end with "l", e.g. "08l" as with calls to local_hex_string_custom */
612 local_hex_string_custom (LONGEST num
, char *width
)
614 #define RESULT_BUF_LEN 50
615 static char res2
[RESULT_BUF_LEN
];
616 char format
[RESULT_BUF_LEN
];
620 char *pad_char
; /* string with one character */
623 char temp_nbr_buf
[RESULT_BUF_LEN
];
625 /* Use phex_nz to print the number into a string, then
626 build the result string from local_hex_format_prefix, padding and
627 the hex representation as indicated by "width". */
628 strcpy (temp_nbr_buf
, phex_nz (num
, sizeof (num
)));
633 if (*parse_ptr
== '-')
638 if (*parse_ptr
== '0')
642 pad_char
= "0"; /* If padding is on the right, it is blank */
644 field_width
= atoi (parse_ptr
);
645 num_len
= strlen (temp_nbr_buf
);
646 num_pad_chars
= field_width
- strlen (temp_nbr_buf
); /* possibly negative */
648 if (strlen (local_hex_format_prefix ()) + num_len
+ num_pad_chars
649 >= RESULT_BUF_LEN
) /* paranoia */
650 internal_error (__FILE__
, __LINE__
,
651 "local_hex_string_custom: insufficient space to store result");
653 strcpy (res2
, local_hex_format_prefix ());
656 while (num_pad_chars
> 0)
658 strcat (res2
, pad_char
);
662 strcat (res2
, temp_nbr_buf
);
665 while (num_pad_chars
> 0)
667 strcat (res2
, pad_char
);
673 } /* local_hex_string_custom */
675 /* Returns the appropriate printf format for octal
678 local_octal_format_custom (char *pre
)
680 static char form
[50];
682 strcpy (form
, local_octal_format_prefix ());
685 strcat (form
, local_octal_format_specifier ());
686 strcat (form
, local_octal_format_suffix ());
690 /* Returns the appropriate printf format for decimal numbers. */
692 local_decimal_format_custom (char *pre
)
694 static char form
[50];
696 strcpy (form
, local_decimal_format_prefix ());
699 strcat (form
, local_decimal_format_specifier ());
700 strcat (form
, local_decimal_format_suffix ());
705 /* This page contains functions that are used in type/range checking.
706 They all return zero if the type/range check fails.
708 It is hoped that these will make extending GDB to parse different
709 languages a little easier. These are primarily used in eval.c when
710 evaluating expressions and making sure that their types are correct.
711 Instead of having a mess of conjucted/disjuncted expressions in an "if",
712 the ideas of type can be wrapped up in the following functions.
714 Note that some of them are not currently dependent upon which language
715 is currently being parsed. For example, floats are the same in
716 C and Modula-2 (ie. the only floating point type has TYPE_CODE of
717 TYPE_CODE_FLT), while booleans are different. */
719 /* Returns non-zero if its argument is a simple type. This is the same for
720 both Modula-2 and for C. In the C case, TYPE_CODE_CHAR will never occur,
721 and thus will never cause the failure of the test. */
723 simple_type (struct type
*type
)
725 CHECK_TYPEDEF (type
);
726 switch (TYPE_CODE (type
))
732 case TYPE_CODE_RANGE
:
741 /* Returns non-zero if its argument is of an ordered type.
742 An ordered type is one in which the elements can be tested for the
743 properties of "greater than", "less than", etc, or for which the
744 operations "increment" or "decrement" make sense. */
746 ordered_type (struct type
*type
)
748 CHECK_TYPEDEF (type
);
749 switch (TYPE_CODE (type
))
755 case TYPE_CODE_RANGE
:
763 /* Returns non-zero if the two types are the same */
765 same_type (struct type
*arg1
, struct type
*arg2
)
767 CHECK_TYPEDEF (type
);
768 if (structured_type (arg1
) ? !structured_type (arg2
) : structured_type (arg2
))
769 /* One is structured and one isn't */
771 else if (structured_type (arg1
) && structured_type (arg2
))
773 else if (numeric_type (arg1
) && numeric_type (arg2
))
774 return (TYPE_CODE (arg2
) == TYPE_CODE (arg1
)) &&
775 (TYPE_UNSIGNED (arg1
) == TYPE_UNSIGNED (arg2
))
781 /* Returns non-zero if the type is integral */
783 integral_type (struct type
*type
)
785 CHECK_TYPEDEF (type
);
786 switch (current_language
->la_language
)
791 return (TYPE_CODE (type
) != TYPE_CODE_INT
) &&
792 (TYPE_CODE (type
) != TYPE_CODE_ENUM
) ? 0 : 1;
794 case language_pascal
:
795 return TYPE_CODE (type
) != TYPE_CODE_INT
? 0 : 1;
797 error ("Language not supported.");
801 /* Returns non-zero if the value is numeric */
803 numeric_type (struct type
*type
)
805 CHECK_TYPEDEF (type
);
806 switch (TYPE_CODE (type
))
817 /* Returns non-zero if the value is a character type */
819 character_type (struct type
*type
)
821 CHECK_TYPEDEF (type
);
822 switch (current_language
->la_language
)
825 case language_pascal
:
826 return TYPE_CODE (type
) != TYPE_CODE_CHAR
? 0 : 1;
831 return (TYPE_CODE (type
) == TYPE_CODE_INT
) &&
832 TYPE_LENGTH (type
) == sizeof (char)
839 /* Returns non-zero if the value is a string type */
841 string_type (struct type
*type
)
843 CHECK_TYPEDEF (type
);
844 switch (current_language
->la_language
)
847 case language_pascal
:
848 return TYPE_CODE (type
) != TYPE_CODE_STRING
? 0 : 1;
853 /* C does not have distinct string type. */
860 /* Returns non-zero if the value is a boolean type */
862 boolean_type (struct type
*type
)
864 CHECK_TYPEDEF (type
);
865 if (TYPE_CODE (type
) == TYPE_CODE_BOOL
)
867 switch (current_language
->la_language
)
872 /* Might be more cleanly handled by having a
873 TYPE_CODE_INT_NOT_BOOL for (the deleted) CHILL and such
874 languages, or a TYPE_CODE_INT_OR_BOOL for C. */
875 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
883 /* Returns non-zero if the value is a floating-point type */
885 float_type (struct type
*type
)
887 CHECK_TYPEDEF (type
);
888 return TYPE_CODE (type
) == TYPE_CODE_FLT
;
891 /* Returns non-zero if the value is a pointer type */
893 pointer_type (struct type
*type
)
895 return TYPE_CODE (type
) == TYPE_CODE_PTR
||
896 TYPE_CODE (type
) == TYPE_CODE_REF
;
899 /* Returns non-zero if the value is a structured type */
901 structured_type (struct type
*type
)
903 CHECK_TYPEDEF (type
);
904 switch (current_language
->la_language
)
909 return (TYPE_CODE (type
) == TYPE_CODE_STRUCT
) ||
910 (TYPE_CODE (type
) == TYPE_CODE_UNION
) ||
911 (TYPE_CODE (type
) == TYPE_CODE_ARRAY
);
912 case language_pascal
:
913 return (TYPE_CODE(type
) == TYPE_CODE_STRUCT
) ||
914 (TYPE_CODE(type
) == TYPE_CODE_UNION
) ||
915 (TYPE_CODE(type
) == TYPE_CODE_SET
) ||
916 (TYPE_CODE(type
) == TYPE_CODE_ARRAY
);
918 return (TYPE_CODE (type
) == TYPE_CODE_STRUCT
) ||
919 (TYPE_CODE (type
) == TYPE_CODE_SET
) ||
920 (TYPE_CODE (type
) == TYPE_CODE_ARRAY
);
928 lang_bool_type (void)
932 switch (current_language
->la_language
)
934 case language_fortran
:
935 sym
= lookup_symbol ("logical", NULL
, VAR_NAMESPACE
, NULL
, NULL
);
938 type
= SYMBOL_TYPE (sym
);
939 if (type
&& TYPE_CODE (type
) == TYPE_CODE_BOOL
)
942 return builtin_type_f_logical_s2
;
944 case language_pascal
:
945 if (current_language
->la_language
==language_cplus
)
946 {sym
= lookup_symbol ("bool", NULL
, VAR_NAMESPACE
, NULL
, NULL
);}
948 {sym
= lookup_symbol ("boolean", NULL
, VAR_NAMESPACE
, NULL
, NULL
);}
951 type
= SYMBOL_TYPE (sym
);
952 if (type
&& TYPE_CODE (type
) == TYPE_CODE_BOOL
)
955 return builtin_type_bool
;
957 sym
= lookup_symbol ("boolean", NULL
, VAR_NAMESPACE
, NULL
, NULL
);
960 type
= SYMBOL_TYPE (sym
);
961 if (type
&& TYPE_CODE (type
) == TYPE_CODE_BOOL
)
964 return java_boolean_type
;
966 return builtin_type_int
;
970 /* This page contains functions that return info about
971 (struct value) values used in GDB. */
973 /* Returns non-zero if the value VAL represents a true value. */
975 value_true (struct value
*val
)
977 /* It is possible that we should have some sort of error if a non-boolean
978 value is used in this context. Possibly dependent on some kind of
979 "boolean-checking" option like range checking. But it should probably
980 not depend on the language except insofar as is necessary to identify
981 a "boolean" value (i.e. in C using a float, pointer, etc., as a boolean
982 should be an error, probably). */
983 return !value_logical_not (val
);
986 /* Returns non-zero if the operator OP is defined on
987 the values ARG1 and ARG2. */
989 #if 0 /* Currently unused */
992 binop_type_check (struct value
*arg1
, struct value
*arg2
, int op
)
994 struct type
*t1
, *t2
;
996 /* If we're not checking types, always return success. */
1000 t1
= VALUE_TYPE (arg1
);
1002 t2
= VALUE_TYPE (arg2
);
1010 if ((numeric_type (t1
) && pointer_type (t2
)) ||
1011 (pointer_type (t1
) && numeric_type (t2
)))
1013 warning ("combining pointer and integer.\n");
1019 if (!numeric_type (t1
) || !numeric_type (t2
))
1020 type_op_error ("Arguments to %s must be numbers.", op
);
1021 else if (!same_type (t1
, t2
))
1022 type_op_error ("Arguments to %s must be of the same type.", op
);
1025 case BINOP_LOGICAL_AND
:
1026 case BINOP_LOGICAL_OR
:
1027 if (!boolean_type (t1
) || !boolean_type (t2
))
1028 type_op_error ("Arguments to %s must be of boolean type.", op
);
1032 if ((pointer_type (t1
) && !(pointer_type (t2
) || integral_type (t2
))) ||
1033 (pointer_type (t2
) && !(pointer_type (t1
) || integral_type (t1
))))
1034 type_op_error ("A pointer can only be compared to an integer or pointer.", op
);
1035 else if ((pointer_type (t1
) && integral_type (t2
)) ||
1036 (integral_type (t1
) && pointer_type (t2
)))
1038 warning ("combining integer and pointer.\n");
1041 else if (!simple_type (t1
) || !simple_type (t2
))
1042 type_op_error ("Arguments to %s must be of simple type.", op
);
1043 else if (!same_type (t1
, t2
))
1044 type_op_error ("Arguments to %s must be of the same type.", op
);
1049 if (!integral_type (t1
) || !integral_type (t2
))
1050 type_op_error ("Arguments to %s must be of integral type.", op
);
1057 if (!ordered_type (t1
) || !ordered_type (t2
))
1058 type_op_error ("Arguments to %s must be of ordered type.", op
);
1059 else if (!same_type (t1
, t2
))
1060 type_op_error ("Arguments to %s must be of the same type.", op
);
1064 if (pointer_type (t1
) && !integral_type (t2
))
1065 type_op_error ("A pointer can only be assigned an integer.", op
);
1066 else if (pointer_type (t1
) && integral_type (t2
))
1068 warning ("combining integer and pointer.");
1071 else if (!simple_type (t1
) || !simple_type (t2
))
1072 type_op_error ("Arguments to %s must be of simple type.", op
);
1073 else if (!same_type (t1
, t2
))
1074 type_op_error ("Arguments to %s must be of the same type.", op
);
1078 /* FIXME: Needs to handle bitstrings as well. */
1079 if (!(string_type (t1
) || character_type (t1
) || integral_type (t1
))
1080 || !(string_type (t2
) || character_type (t2
) || integral_type (t2
)))
1081 type_op_error ("Arguments to %s must be strings or characters.", op
);
1084 /* Unary checks -- arg2 is null */
1086 case UNOP_LOGICAL_NOT
:
1087 if (!boolean_type (t1
))
1088 type_op_error ("Argument to %s must be of boolean type.", op
);
1093 if (!numeric_type (t1
))
1094 type_op_error ("Argument to %s must be of numeric type.", op
);
1098 if (integral_type (t1
))
1100 warning ("combining pointer and integer.\n");
1103 else if (!pointer_type (t1
))
1104 type_op_error ("Argument to %s must be a pointer.", op
);
1107 case UNOP_PREINCREMENT
:
1108 case UNOP_POSTINCREMENT
:
1109 case UNOP_PREDECREMENT
:
1110 case UNOP_POSTDECREMENT
:
1111 if (!ordered_type (t1
))
1112 type_op_error ("Argument to %s must be of an ordered type.", op
);
1116 /* Ok. The following operators have different meanings in
1117 different languages. */
1118 switch (current_language
->la_language
)
1122 case language_cplus
:
1127 if (!numeric_type (t1
) || !numeric_type (t2
))
1128 type_op_error ("Arguments to %s must be numbers.", op
);
1139 if (!float_type (t1
) || !float_type (t2
))
1140 type_op_error ("Arguments to %s must be floating point numbers.", op
);
1143 if (!integral_type (t1
) || !integral_type (t2
))
1144 type_op_error ("Arguments to %s must be of integral type.", op
);
1150 case language_pascal
:
1154 if (!float_type(t1
) && !float_type(t2
))
1155 type_op_error ("Arguments to %s must be floating point numbers.",op
);
1158 if (!integral_type(t1
) || !integral_type(t2
))
1159 type_op_error ("Arguments to %s must be of integral type.",op
);
1171 /* This page contains functions for the printing out of
1172 error messages that occur during type- and range-
1175 /* Prints the format string FMT with the operator as a string
1176 corresponding to the opcode OP. If FATAL is non-zero, then
1177 this is an error and error () is called. Otherwise, it is
1178 a warning and printf() is called. */
1180 op_error (char *fmt
, enum exp_opcode op
, int fatal
)
1183 error (fmt
, op_string (op
));
1186 warning (fmt
, op_string (op
));
1190 /* These are called when a language fails a type- or range-check. The
1191 first argument should be a printf()-style format string, and the
1192 rest of the arguments should be its arguments. If
1193 [type|range]_check is [type|range]_check_on, an error is printed;
1194 if [type|range]_check_warn, a warning; otherwise just the
1198 type_error (const char *string
,...)
1201 va_start (args
, string
);
1205 case type_check_warn
:
1206 vwarning (string
, args
);
1209 verror (string
, args
);
1211 case type_check_off
:
1212 /* FIXME: cagney/2002-01-30: Should this function print anything
1213 when type error is off? */
1214 vfprintf_filtered (gdb_stderr
, string
, args
);
1215 fprintf_filtered (gdb_stderr
, "\n");
1218 internal_error (__FILE__
, __LINE__
, "bad switch");
1224 range_error (const char *string
,...)
1227 va_start (args
, string
);
1229 switch (range_check
)
1231 case range_check_warn
:
1232 vwarning (string
, args
);
1234 case range_check_on
:
1235 verror (string
, args
);
1237 case range_check_off
:
1238 /* FIXME: cagney/2002-01-30: Should this function print anything
1239 when range error is off? */
1240 vfprintf_filtered (gdb_stderr
, string
, args
);
1241 fprintf_filtered (gdb_stderr
, "\n");
1244 internal_error (__FILE__
, __LINE__
, "bad switch");
1250 /* This page contains miscellaneous functions */
1252 /* Return the language enum for a given language string. */
1255 language_enum (char *str
)
1259 for (i
= 0; i
< languages_size
; i
++)
1260 if (STREQ (languages
[i
]->la_name
, str
))
1261 return languages
[i
]->la_language
;
1263 return language_unknown
;
1266 /* Return the language struct for a given language enum. */
1268 const struct language_defn
*
1269 language_def (enum language lang
)
1273 for (i
= 0; i
< languages_size
; i
++)
1275 if (languages
[i
]->la_language
== lang
)
1277 return languages
[i
];
1283 /* Return the language as a string */
1285 language_str (enum language lang
)
1289 for (i
= 0; i
< languages_size
; i
++)
1291 if (languages
[i
]->la_language
== lang
)
1293 return languages
[i
]->la_name
;
1300 set_check (char *ignore
, int from_tty
)
1303 "\"set check\" must be followed by the name of a check subcommand.\n");
1304 help_list (setchecklist
, "set check ", -1, gdb_stdout
);
1308 show_check (char *ignore
, int from_tty
)
1310 cmd_show_list (showchecklist
, from_tty
, "");
1313 /* Add a language to the set of known languages. */
1316 add_language (const struct language_defn
*lang
)
1318 if (lang
->la_magic
!= LANG_MAGIC
)
1320 fprintf_unfiltered (gdb_stderr
, "Magic number of %s language struct wrong\n",
1322 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
1327 languages_allocsize
= DEFAULT_ALLOCSIZE
;
1328 languages
= (const struct language_defn
**) xmalloc
1329 (languages_allocsize
* sizeof (*languages
));
1331 if (languages_size
>= languages_allocsize
)
1333 languages_allocsize
*= 2;
1334 languages
= (const struct language_defn
**) xrealloc ((char *) languages
,
1335 languages_allocsize
* sizeof (*languages
));
1337 languages
[languages_size
++] = lang
;
1340 /* Define the language that is no language. */
1343 unk_lang_parser (void)
1349 unk_lang_error (char *msg
)
1351 error ("Attempted to parse an expression with unknown language");
1355 unk_lang_emit_char (register int c
, struct ui_file
*stream
, int quoter
)
1357 error ("internal error - unimplemented function unk_lang_emit_char called.");
1361 unk_lang_printchar (register int c
, struct ui_file
*stream
)
1363 error ("internal error - unimplemented function unk_lang_printchar called.");
1367 unk_lang_printstr (struct ui_file
*stream
, char *string
, unsigned int length
,
1368 int width
, int force_ellipses
)
1370 error ("internal error - unimplemented function unk_lang_printstr called.");
1373 static struct type
*
1374 unk_lang_create_fundamental_type (struct objfile
*objfile
, int typeid)
1376 error ("internal error - unimplemented function unk_lang_create_fundamental_type called.");
1380 unk_lang_print_type (struct type
*type
, char *varstring
, struct ui_file
*stream
,
1381 int show
, int level
)
1383 error ("internal error - unimplemented function unk_lang_print_type called.");
1387 unk_lang_val_print (struct type
*type
, char *valaddr
, int embedded_offset
,
1388 CORE_ADDR address
, struct ui_file
*stream
, int format
,
1389 int deref_ref
, int recurse
, enum val_prettyprint pretty
)
1391 error ("internal error - unimplemented function unk_lang_val_print called.");
1395 unk_lang_value_print (struct value
*val
, struct ui_file
*stream
, int format
,
1396 enum val_prettyprint pretty
)
1398 error ("internal error - unimplemented function unk_lang_value_print called.");
1401 static struct type
**const (unknown_builtin_types
[]) =
1405 static const struct op_print unk_op_print_tab
[] =
1407 {NULL
, OP_NULL
, PREC_NULL
, 0}
1410 const struct language_defn unknown_language_defn
=
1414 &unknown_builtin_types
[0],
1420 evaluate_subexp_standard
,
1421 unk_lang_printchar
, /* Print character constant */
1424 unk_lang_create_fundamental_type
,
1425 unk_lang_print_type
, /* Print a type using appropriate syntax */
1426 unk_lang_val_print
, /* Print a value using appropriate syntax */
1427 unk_lang_value_print
, /* Print a top-level value */
1428 {"", "", "", ""}, /* Binary format info */
1429 {"0%lo", "0", "o", ""}, /* Octal format info */
1430 {"%ld", "", "d", ""}, /* Decimal format info */
1431 {"0x%lx", "0x", "x", ""}, /* Hex format info */
1432 unk_op_print_tab
, /* expression operators for printing */
1433 1, /* c-style arrays */
1434 0, /* String lower bound */
1435 &builtin_type_char
, /* Type of string elements */
1439 /* These two structs define fake entries for the "local" and "auto" options. */
1440 const struct language_defn auto_language_defn
=
1444 &unknown_builtin_types
[0],
1450 evaluate_subexp_standard
,
1451 unk_lang_printchar
, /* Print character constant */
1454 unk_lang_create_fundamental_type
,
1455 unk_lang_print_type
, /* Print a type using appropriate syntax */
1456 unk_lang_val_print
, /* Print a value using appropriate syntax */
1457 unk_lang_value_print
, /* Print a top-level value */
1458 {"", "", "", ""}, /* Binary format info */
1459 {"0%lo", "0", "o", ""}, /* Octal format info */
1460 {"%ld", "", "d", ""}, /* Decimal format info */
1461 {"0x%lx", "0x", "x", ""}, /* Hex format info */
1462 unk_op_print_tab
, /* expression operators for printing */
1463 1, /* c-style arrays */
1464 0, /* String lower bound */
1465 &builtin_type_char
, /* Type of string elements */
1469 const struct language_defn local_language_defn
=
1473 &unknown_builtin_types
[0],
1479 evaluate_subexp_standard
,
1480 unk_lang_printchar
, /* Print character constant */
1483 unk_lang_create_fundamental_type
,
1484 unk_lang_print_type
, /* Print a type using appropriate syntax */
1485 unk_lang_val_print
, /* Print a value using appropriate syntax */
1486 unk_lang_value_print
, /* Print a top-level value */
1487 {"", "", "", ""}, /* Binary format info */
1488 {"0%lo", "0", "o", ""}, /* Octal format info */
1489 {"%ld", "", "d", ""}, /* Decimal format info */
1490 {"0x%lx", "0x", "x", ""}, /* Hex format info */
1491 unk_op_print_tab
, /* expression operators for printing */
1492 1, /* c-style arrays */
1493 0, /* String lower bound */
1494 &builtin_type_char
, /* Type of string elements */
1498 /* Initialize the language routines */
1501 _initialize_language (void)
1503 struct cmd_list_element
*set
, *show
;
1505 /* GDB commands for language specific stuff */
1507 set
= add_set_cmd ("language", class_support
, var_string_noescape
,
1509 "Set the current source language.",
1511 show
= add_show_from_set (set
, &showlist
);
1512 set_cmd_cfunc (set
, set_language_command
);
1513 set_cmd_cfunc (show
, show_language_command
);
1515 add_prefix_cmd ("check", no_class
, set_check
,
1516 "Set the status of the type/range checker.",
1517 &setchecklist
, "set check ", 0, &setlist
);
1518 add_alias_cmd ("c", "check", no_class
, 1, &setlist
);
1519 add_alias_cmd ("ch", "check", no_class
, 1, &setlist
);
1521 add_prefix_cmd ("check", no_class
, show_check
,
1522 "Show the status of the type/range checker.",
1523 &showchecklist
, "show check ", 0, &showlist
);
1524 add_alias_cmd ("c", "check", no_class
, 1, &showlist
);
1525 add_alias_cmd ("ch", "check", no_class
, 1, &showlist
);
1527 set
= add_set_cmd ("type", class_support
, var_string_noescape
,
1529 "Set type checking. (on/warn/off/auto)",
1531 show
= add_show_from_set (set
, &showchecklist
);
1532 set_cmd_cfunc (set
, set_type_command
);
1533 set_cmd_cfunc (show
, show_type_command
);
1535 set
= add_set_cmd ("range", class_support
, var_string_noescape
,
1537 "Set range checking. (on/warn/off/auto)",
1539 show
= add_show_from_set (set
, &showchecklist
);
1540 set_cmd_cfunc (set
, set_range_command
);
1541 set_cmd_cfunc (show
, show_range_command
);
1543 set
= add_set_cmd ("case-sensitive", class_support
, var_string_noescape
,
1544 (char *) &case_sensitive
,
1545 "Set case sensitivity in name search. (on/off/auto)\n\
1546 For Fortran the default is off; for other languages the default is on.",
1548 show
= add_show_from_set (set
, &showlist
);
1549 set_cmd_cfunc (set
, set_case_command
);
1550 set_cmd_cfunc (show
, show_case_command
);
1552 add_language (&unknown_language_defn
);
1553 add_language (&local_language_defn
);
1554 add_language (&auto_language_defn
);
1556 language
= savestring ("auto", strlen ("auto"));
1557 type
= savestring ("auto", strlen ("auto"));
1558 range
= savestring ("auto", strlen ("auto"));
1559 case_sensitive
= savestring ("auto",strlen ("auto"));
1561 /* Have the above take effect */
1562 set_language (language_auto
);