1 /* Multiple source language support for GDB.
2 Copyright 1991, 1992 Free Software Foundation, Inc.
3 Contributed by the Department of Computer Science at the State University
4 of New York at Buffalo.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
22 /* This file contains functions that return things that are specific
23 to languages. Each function should examine current_language if necessary,
24 and return the appropriate result. */
26 /* FIXME: Most of these would be better organized as macros which
27 return data out of a "language-specific" struct pointer that is set
28 whenever the working language changes. That would be a lot faster. */
39 #include "expression.h"
42 #include "parser-defs.h"
45 show_language_command PARAMS ((char *, int));
48 set_language_command PARAMS ((char *, int));
51 show_type_command PARAMS ((char *, int));
54 set_type_command PARAMS ((char *, int));
57 show_range_command PARAMS ((char *, int));
60 set_range_command PARAMS ((char *, int));
63 set_range_str PARAMS ((void));
66 set_type_str PARAMS ((void));
69 set_lang_str PARAMS ((void));
72 unk_lang_error PARAMS ((char *));
75 unk_lang_parser PARAMS ((void));
78 show_check PARAMS ((char *, int));
81 set_check PARAMS ((char *, int));
84 set_type_range PARAMS ((void));
86 /* Forward declaration */
87 extern const struct language_defn unknown_language_defn;
88 extern char *warning_pre_print;
90 /* The current (default at startup) state of type and range checking.
91 (If the modes are set to "auto", though, these are changed based
92 on the default language at startup, and then again based on the
93 language of the first source file. */
95 enum range_mode range_mode = range_mode_auto;
96 enum range_check range_check = range_check_off;
97 enum type_mode type_mode = type_mode_auto;
98 enum type_check type_check = type_check_off;
100 /* The current language and language_mode (see language.h) */
102 const struct language_defn *current_language = &unknown_language_defn;
103 enum language_mode language_mode = language_mode_auto;
105 /* The language that the user expects to be typing in (the language
106 of main(), or the last language we notified them about, or C). */
108 const struct language_defn *expected_language;
110 /* The list of supported languages. The list itself is malloc'd. */
112 static const struct language_defn **languages;
113 static unsigned languages_size;
114 static unsigned languages_allocsize;
115 #define DEFAULT_ALLOCSIZE 3
117 /* The "set language/type/range" commands all put stuff in these
118 buffers. This is to make them work as set/show commands. The
119 user's string is copied here, then the set_* commands look at
120 them and update them to something that looks nice when it is
123 static char *language;
127 /* Warning issued when current_language and the language of the current
128 frame do not match. */
129 char lang_frame_mismatch_warn[] =
130 "Warning: the current language does not match this frame.";
133 /* This page contains the functions corresponding to GDB commands
134 and their helpers. */
136 /* Show command. Display a warning if the language set
137 does not match the frame. */
139 show_language_command (ignore, from_tty)
143 enum language flang; /* The language of the current frame */
145 flang = get_frame_language();
146 if (flang != language_unknown &&
147 language_mode == language_mode_manual &&
148 current_language->la_language != flang)
149 printf_filtered("%s\n",lang_frame_mismatch_warn);
152 /* Set command. Change the current working language. */
154 set_language_command (ignore, from_tty)
162 /* FIXME -- do this from the list, with HELP. */
163 if (!language || !language[0]) {
164 printf("The currently understood settings are:\n\n\
165 local or auto Automatic setting based on source file\n\
166 c Use the C language\n\
167 c++ Use the C++ language\n\
168 modula-2 Use the Modula-2 language\n");
169 /* Restore the silly string. */
170 set_language(current_language->la_language);
174 /* Search the list of languages for a match. */
175 for (i = 0; i < languages_size; i++) {
176 if (!strcmp (languages[i]->la_name, language)) {
177 /* Found it! Go into manual mode, and use this language. */
178 if (languages[i]->la_language == language_auto) {
179 /* Enter auto mode. Set to the current frame's language, if known. */
180 language_mode = language_mode_auto;
181 flang = get_frame_language();
182 if (flang!=language_unknown)
184 expected_language = current_language;
187 /* Enter manual mode. Set the specified language. */
188 language_mode = language_mode_manual;
189 current_language = languages[i];
192 expected_language = current_language;
198 /* Reset the language (esp. the global string "language") to the
200 err_lang=savestring(language,strlen(language));
201 make_cleanup (free, err_lang); /* Free it after error */
202 set_language(current_language->la_language);
203 error ("Unknown language `%s'.",err_lang);
206 /* Show command. Display a warning if the type setting does
207 not match the current language. */
209 show_type_command(ignore, from_tty)
213 if (type_check != current_language->la_type_check)
215 "Warning: the current type check setting does not match the language.\n");
218 /* Set command. Change the setting for type checking. */
220 set_type_command(ignore, from_tty)
224 if (!strcmp(type,"on"))
226 type_check = type_check_on;
227 type_mode = type_mode_manual;
229 else if (!strcmp(type,"warn"))
231 type_check = type_check_warn;
232 type_mode = type_mode_manual;
234 else if (!strcmp(type,"off"))
236 type_check = type_check_off;
237 type_mode = type_mode_manual;
239 else if (!strcmp(type,"auto"))
241 type_mode = type_mode_auto;
243 /* Avoid hitting the set_type_str call below. We
244 did it in set_type_range. */
248 show_type_command((char *)NULL, from_tty);
251 /* Show command. Display a warning if the range setting does
252 not match the current language. */
254 show_range_command(ignore, from_tty)
259 if (range_check != current_language->la_range_check)
261 "Warning: the current range check setting does not match the language.\n");
264 /* Set command. Change the setting for range checking. */
266 set_range_command(ignore, from_tty)
270 if (!strcmp(range,"on"))
272 range_check = range_check_on;
273 range_mode = range_mode_manual;
275 else if (!strcmp(range,"warn"))
277 range_check = range_check_warn;
278 range_mode = range_mode_manual;
280 else if (!strcmp(range,"off"))
282 range_check = range_check_off;
283 range_mode = range_mode_manual;
285 else if (!strcmp(range,"auto"))
287 range_mode = range_mode_auto;
289 /* Avoid hitting the set_range_str call below. We
290 did it in set_type_range. */
294 show_range_command((char *)0, from_tty);
297 /* Set the status of range and type checking based on
298 the current modes and the current language.
299 If SHOW is non-zero, then print out the current language,
300 type and range checking status. */
305 if (range_mode == range_mode_auto)
306 range_check = current_language->la_range_check;
308 if (type_mode == type_mode_auto)
309 type_check = current_language->la_type_check;
315 /* Set current language to (enum language) LANG. */
323 for (i = 0; i < languages_size; i++) {
324 if (languages[i]->la_language == lang) {
325 current_language = languages[i];
333 /* This page contains functions that update the global vars
334 language, type and range. */
341 if (language_mode == language_mode_auto)
342 prefix = "auto; currently ";
344 language = concat(prefix, current_language->la_name, NULL);
350 char *tmp, *prefix = "";
353 if (type_mode==type_mode_auto)
354 prefix = "auto; currently ";
364 case type_check_warn:
368 error ("Unrecognized type check setting.");
371 type = concat(prefix,tmp,NULL);
377 char *tmp, *pref = "";
380 if (range_mode==range_mode_auto)
381 pref = "auto; currently ";
388 case range_check_off:
391 case range_check_warn:
395 error ("Unrecognized range check setting.");
398 range = concat(pref,tmp,NULL);
402 /* Print out the current language settings: language, range and
403 type checking. If QUIETLY, print only what has changed. */
406 language_info (quietly)
409 if (quietly && expected_language == current_language)
412 expected_language = current_language;
413 printf("Current language: %s\n",language);
414 show_language_command((char *)0, 1);
418 printf("Type checking: %s\n",type);
419 show_type_command((char *)0, 1);
420 printf("Range checking: %s\n",range);
421 show_range_command((char *)0, 1);
425 /* Return the result of a binary operation. */
427 #if 0 /* Currently unused */
430 binop_result_type(v1,v2)
435 l1 = TYPE_LENGTH(VALUE_TYPE(v1));
436 l2 = TYPE_LENGTH(VALUE_TYPE(v2));
438 switch(current_language->la_language)
442 if (TYPE_CODE(VALUE_TYPE(v1))==TYPE_CODE_FLT)
443 return TYPE_CODE(VALUE_TYPE(v2)) == TYPE_CODE_FLT && l2 > l1 ?
444 VALUE_TYPE(v2) : VALUE_TYPE(v1);
445 else if (TYPE_CODE(VALUE_TYPE(v2))==TYPE_CODE_FLT)
446 return TYPE_CODE(VALUE_TYPE(v1)) == TYPE_CODE_FLT && l1 > l2 ?
447 VALUE_TYPE(v1) : VALUE_TYPE(v2);
448 else if (TYPE_UNSIGNED(VALUE_TYPE(v1)) && l1 > l2)
449 return VALUE_TYPE(v1);
450 else if (TYPE_UNSIGNED(VALUE_TYPE(v2)) && l2 > l1)
451 return VALUE_TYPE(v2);
452 else /* Both are signed. Result is the longer type */
453 return l1 > l2 ? VALUE_TYPE(v1) : VALUE_TYPE(v2);
456 /* If we are doing type-checking, l1 should equal l2, so this is
458 return l1 > l2 ? VALUE_TYPE(v1) : VALUE_TYPE(v2);
462 return (struct type *)0; /* For lint */
468 /* This page contains functions that return format strings for
469 printf for printing out numbers in different formats */
471 /* Returns the appropriate printf format for hexadecimal
474 local_hex_format_custom(pre)
477 static char form[50];
479 strcpy (form, current_language->la_hex_format_pre);
481 strcat (form, current_language->la_hex_format_suf);
485 /* Converts a number to hexadecimal and stores it in a static
486 string. Returns a pointer to this string. */
488 local_hex_string (num)
493 sprintf (res, current_language->la_hex_format, num);
497 /* Converts a number to custom hexadecimal and stores it in a static
498 string. Returns a pointer to this string. */
500 local_hex_string_custom(num,pre)
506 sprintf (res, local_hex_format_custom(pre), num);
510 /* Returns the appropriate printf format for octal
513 local_octal_format_custom(pre)
516 static char form[50];
518 strcpy (form, current_language->la_octal_format_pre);
520 strcat (form, current_language->la_octal_format_suf);
524 /* This page contains functions that are used in type/range checking.
525 They all return zero if the type/range check fails.
527 It is hoped that these will make extending GDB to parse different
528 languages a little easier. These are primarily used in eval.c when
529 evaluating expressions and making sure that their types are correct.
530 Instead of having a mess of conjucted/disjuncted expressions in an "if",
531 the ideas of type can be wrapped up in the following functions.
533 Note that some of them are not currently dependent upon which language
534 is currently being parsed. For example, floats are the same in
535 C and Modula-2 (ie. the only floating point type has TYPE_CODE of
536 TYPE_CODE_FLT), while booleans are different. */
538 /* Returns non-zero if its argument is a simple type. This is the same for
539 both Modula-2 and for C. In the C case, TYPE_CODE_CHAR will never occur,
540 and thus will never cause the failure of the test. */
545 switch (TYPE_CODE (type)) {
550 case TYPE_CODE_RANGE:
559 /* Returns non-zero if its argument is of an ordered type. */
564 switch (TYPE_CODE (type)) {
569 case TYPE_CODE_RANGE:
577 /* Returns non-zero if the two types are the same */
579 same_type (arg1, arg2)
580 struct type *arg1, *arg2;
582 if (structured_type(arg1) ? !structured_type(arg2) : structured_type(arg2))
583 /* One is structured and one isn't */
585 else if (structured_type(arg1) && structured_type(arg2))
587 else if (numeric_type(arg1) && numeric_type(arg2))
588 return (TYPE_CODE(arg2) == TYPE_CODE(arg1)) &&
589 (TYPE_UNSIGNED(arg1) == TYPE_UNSIGNED(arg2))
595 /* Returns non-zero if the type is integral */
600 switch(current_language->la_language)
604 return (TYPE_CODE(type) != TYPE_CODE_INT) &&
605 (TYPE_CODE(type) != TYPE_CODE_ENUM) ? 0 : 1;
607 return TYPE_CODE(type) != TYPE_CODE_INT ? 0 : 1;
609 error ("Language not supported.");
613 /* Returns non-zero if the value is numeric */
618 switch (TYPE_CODE (type)) {
628 /* Returns non-zero if the value is a character type */
630 character_type (type)
633 switch(current_language->la_language)
636 return TYPE_CODE(type) != TYPE_CODE_CHAR ? 0 : 1;
640 return (TYPE_CODE(type) == TYPE_CODE_INT) &&
641 TYPE_LENGTH(type) == sizeof(char)
648 /* Returns non-zero if the value is a boolean type */
653 switch(current_language->la_language)
656 return TYPE_CODE(type) != TYPE_CODE_BOOL ? 0 : 1;
660 return TYPE_CODE(type) != TYPE_CODE_INT ? 0 : 1;
666 /* Returns non-zero if the value is a floating-point type */
671 return TYPE_CODE(type) == TYPE_CODE_FLT;
674 /* Returns non-zero if the value is a pointer type */
679 return TYPE_CODE(type) == TYPE_CODE_PTR ||
680 TYPE_CODE(type) == TYPE_CODE_REF;
683 /* Returns non-zero if the value is a structured type */
685 structured_type(type)
688 switch(current_language->la_language)
692 return (TYPE_CODE(type) == TYPE_CODE_STRUCT) ||
693 (TYPE_CODE(type) == TYPE_CODE_UNION) ||
694 (TYPE_CODE(type) == TYPE_CODE_ARRAY);
696 return (TYPE_CODE(type) == TYPE_CODE_STRUCT) ||
697 (TYPE_CODE(type) == TYPE_CODE_SET) ||
698 (TYPE_CODE(type) == TYPE_CODE_ARRAY);
704 /* This page contains functions that return info about
705 (struct value) values used in GDB. */
707 /* Returns non-zero if the value VAL represents a true value. */
716 switch (current_language->la_language) {
720 return !value_zerop (val);
723 type = VALUE_TYPE(val);
724 if (TYPE_CODE (type) != TYPE_CODE_BOOL)
725 return 0; /* Not a BOOLEAN at all */
726 /* Search the fields for one that matches the current value. */
727 len = TYPE_NFIELDS (type);
728 v = value_as_long (val);
729 for (i = 0; i < len; i++)
732 if (v == TYPE_FIELD_BITPOS (type, i))
736 return 0; /* Not a valid BOOLEAN value */
737 if (!strcmp ("TRUE", TYPE_FIELD_NAME(VALUE_TYPE(val), i)))
738 return 1; /* BOOLEAN with value TRUE */
740 return 0; /* BOOLEAN with value FALSE */
744 error ("Language not supported.");
748 /* Returns non-zero if the operator OP is defined on
749 the values ARG1 and ARG2. */
751 #if 0 /* Currently unused */
754 binop_type_check(arg1,arg2,op)
758 struct type *t1, *t2;
760 /* If we're not checking types, always return success. */
765 if (arg2!=(value)NULL)
774 if ((numeric_type(t1) && pointer_type(t2)) ||
775 (pointer_type(t1) && numeric_type(t2)))
777 warning ("combining pointer and integer.\n");
783 if (!numeric_type(t1) || !numeric_type(t2))
784 type_op_error ("Arguments to %s must be numbers.",op);
785 else if (!same_type(t1,t2))
786 type_op_error ("Arguments to %s must be of the same type.",op);
791 if (!boolean_type(t1) || !boolean_type(t2))
792 type_op_error ("Arguments to %s must be of boolean type.",op);
796 if ((pointer_type(t1) && !(pointer_type(t2) || integral_type(t2))) ||
797 (pointer_type(t2) && !(pointer_type(t1) || integral_type(t1))))
798 type_op_error ("A pointer can only be compared to an integer or pointer.",op);
799 else if ((pointer_type(t1) && integral_type(t2)) ||
800 (integral_type(t1) && pointer_type(t2)))
802 warning ("combining integer and pointer.\n");
805 else if (!simple_type(t1) || !simple_type(t2))
806 type_op_error ("Arguments to %s must be of simple type.",op);
807 else if (!same_type(t1,t2))
808 type_op_error ("Arguments to %s must be of the same type.",op);
812 if (!integral_type(t1) || !integral_type(t2))
813 type_op_error ("Arguments to %s must be of integral type.",op);
820 if (!ordered_type(t1) || !ordered_type(t2))
821 type_op_error ("Arguments to %s must be of ordered type.",op);
822 else if (!same_type(t1,t2))
823 type_op_error ("Arguments to %s must be of the same type.",op);
827 if (pointer_type(t1) && !integral_type(t2))
828 type_op_error ("A pointer can only be assigned an integer.",op);
829 else if (pointer_type(t1) && integral_type(t2))
831 warning ("combining integer and pointer.");
834 else if (!simple_type(t1) || !simple_type(t2))
835 type_op_error ("Arguments to %s must be of simple type.",op);
836 else if (!same_type(t1,t2))
837 type_op_error ("Arguments to %s must be of the same type.",op);
840 /* Unary checks -- arg2 is null */
843 if (!boolean_type(t1))
844 type_op_error ("Argument to %s must be of boolean type.",op);
849 if (!numeric_type(t1))
850 type_op_error ("Argument to %s must be of numeric type.",op);
854 if (integral_type(t1))
856 warning ("combining pointer and integer.\n");
859 else if (!pointer_type(t1))
860 type_op_error ("Argument to %s must be a pointer.",op);
863 case UNOP_PREINCREMENT:
864 case UNOP_POSTINCREMENT:
865 case UNOP_PREDECREMENT:
866 case UNOP_POSTDECREMENT:
867 if (!ordered_type(t1))
868 type_op_error ("Argument to %s must be of an ordered type.",op);
872 /* Ok. The following operators have different meanings in
873 different languages. */
874 switch(current_language->la_language)
882 if (!numeric_type(t1) || !numeric_type(t2))
883 type_op_error ("Arguments to %s must be numbers.",op);
894 if (!float_type(t1) || !float_type(t2))
895 type_op_error ("Arguments to %s must be floating point numbers.",op);
898 if (!integral_type(t1) || !integral_type(t2))
899 type_op_error ("Arguments to %s must be of integral type.",op);
910 /* This page contains functions for the printing out of
911 error messages that occur during type- and range-
914 /* Prints the format string FMT with the operator as a string
915 corresponding to the opcode OP. If FATAL is non-zero, then
916 this is an error and error () is called. Otherwise, it is
917 a warning and printf() is called. */
919 op_error (fmt,op,fatal)
925 error (fmt,op_string(op));
928 warning (fmt,op_string(op));
932 /* These are called when a language fails a type- or range-check.
933 The first argument should be a printf()-style format string, and
934 the rest of the arguments should be its arguments. If
935 [type|range]_check is [type|range]_check_on, then return_to_top_level()
936 is called in the style of error (). Otherwise, the message is prefixed
937 by the value of warning_pre_print and we do not return to the top level. */
940 type_error (va_alist)
946 if (type_check==type_check_warn)
947 fprintf(stderr,warning_pre_print);
949 target_terminal_ours();
952 string = va_arg (args, char *);
953 vfprintf (stderr, string, args);
954 fprintf (stderr, "\n");
956 if (type_check==type_check_on)
957 return_to_top_level();
961 range_error (va_alist)
967 if (range_check==range_check_warn)
968 fprintf(stderr,warning_pre_print);
970 target_terminal_ours();
973 string = va_arg (args, char *);
974 vfprintf (stderr, string, args);
975 fprintf (stderr, "\n");
977 if (range_check==range_check_on)
978 return_to_top_level();
982 /* This page contains miscellaneous functions */
984 /* Return the language as a string */
991 for (i = 0; i < languages_size; i++) {
992 if (languages[i]->la_language == lang) {
993 return languages[i]->la_name;
1000 set_check (ignore, from_tty)
1005 "\"set check\" must be followed by the name of a check subcommand.\n");
1006 help_list(setchecklist, "set check ", -1, stdout);
1010 show_check (ignore, from_tty)
1014 cmd_show_list(showchecklist, from_tty, "");
1017 /* Add a language to the set of known languages. */
1021 const struct language_defn *lang;
1023 if (lang->la_magic != LANG_MAGIC)
1025 fprintf(stderr, "Magic number of %s language struct wrong\n",
1032 languages_allocsize = DEFAULT_ALLOCSIZE;
1033 languages = (const struct language_defn **) xmalloc
1034 (languages_allocsize * sizeof (*languages));
1036 if (languages_size >= languages_allocsize)
1038 languages_allocsize *= 2;
1039 languages = (const struct language_defn **) xrealloc ((char *) languages,
1040 languages_allocsize * sizeof (*languages));
1042 languages[languages_size++] = lang;
1045 /* Define the language that is no language. */
1054 unk_lang_error (msg)
1057 error ("Attempted to parse an expression with unknown language");
1060 static struct type ** const (unknown_builtin_types[]) = { 0 };
1061 static const struct op_print unk_op_print_tab[] = { 0 };
1063 const struct language_defn unknown_language_defn = {
1066 &unknown_builtin_types[0],
1071 &builtin_type_error, /* longest signed integral type */
1072 &builtin_type_error, /* longest unsigned integral type */
1073 &builtin_type_error, /* longest floating point type */
1074 "0x%x", "0x%", "x", /* Hex format, prefix, suffix */
1075 "0%o", "0%", "o", /* Octal format, prefix, suffix */
1076 unk_op_print_tab, /* expression operators for printing */
1080 /* These two structs define fake entries for the "local" and "auto" options. */
1081 const struct language_defn auto_language_defn = {
1084 &unknown_builtin_types[0],
1089 &builtin_type_error, /* longest signed integral type */
1090 &builtin_type_error, /* longest unsigned integral type */
1091 &builtin_type_error, /* longest floating point type */
1092 "0x%x", "0x%", "x", /* Hex format, prefix, suffix */
1093 "0%o", "0%", "o", /* Octal format, prefix, suffix */
1094 unk_op_print_tab, /* expression operators for printing */
1098 const struct language_defn local_language_defn = {
1101 &unknown_builtin_types[0],
1106 &builtin_type_error, /* longest signed integral type */
1107 &builtin_type_error, /* longest unsigned integral type */
1108 &builtin_type_error, /* longest floating point type */
1109 "0x%x", "0x%", "x", /* Hex format, prefix, suffix */
1110 "0%o", "0%", "o", /* Octal format, prefix, suffix */
1111 unk_op_print_tab, /* expression operators for printing */
1115 /* Initialize the language routines */
1118 _initialize_language()
1120 struct cmd_list_element *set, *show;
1122 /* GDB commands for language specific stuff */
1124 set = add_set_cmd ("language", class_support, var_string_noescape,
1126 "Set the current source language.",
1128 show = add_show_from_set (set, &showlist);
1129 set->function.cfunc = set_language_command;
1130 show->function.cfunc = show_language_command;
1132 add_prefix_cmd ("check", no_class, set_check,
1133 "Set the status of the type/range checker",
1134 &setchecklist, "set check ", 0, &setlist);
1135 add_alias_cmd ("c", "check", no_class, 1, &setlist);
1136 add_alias_cmd ("ch", "check", no_class, 1, &setlist);
1138 add_prefix_cmd ("check", no_class, show_check,
1139 "Show the status of the type/range checker",
1140 &showchecklist, "show check ", 0, &showlist);
1141 add_alias_cmd ("c", "check", no_class, 1, &showlist);
1142 add_alias_cmd ("ch", "check", no_class, 1, &showlist);
1144 set = add_set_cmd ("type", class_support, var_string_noescape,
1146 "Set type checking. (on/warn/off/auto)",
1148 show = add_show_from_set (set, &showchecklist);
1149 set->function.cfunc = set_type_command;
1150 show->function.cfunc = show_type_command;
1152 set = add_set_cmd ("range", class_support, var_string_noescape,
1154 "Set range checking. (on/warn/off/auto)",
1156 show = add_show_from_set (set, &showchecklist);
1157 set->function.cfunc = set_range_command;
1158 show->function.cfunc = show_range_command;
1160 add_language (&unknown_language_defn);
1161 add_language (&local_language_defn);
1162 add_language (&auto_language_defn);
1164 language = savestring ("auto",strlen("auto"));
1165 range = savestring ("auto",strlen("auto"));
1166 type = savestring ("auto",strlen("auto"));
1168 /* Have the above take effect */
1170 set_language_command (language, 0);
1171 set_type_command (NULL, 0);
1172 set_range_command (NULL, 0);