* eval.c (evaluate_subexp): Clean up handling of

	OP_UNDETERMINED_ARGLIST (no backtracking, more general).

	* f-valprint.c (f_val_print):  Print TYPE_CODE_STRING using
	LA_PRINT_STRING, and not val_print_string (which reads from inferior).

	* ch-lang.c (chill_is_varying_struct), ch-lang.h:  Remve function
	duplicate function made redundant by chill_varying_type.

	Re-write of f77 string and complex number support:

	* language.h (struct language_defn):  New fields string_lower_bound
	and string_char_type.
	* c-lang.c (c_language_defn, cplus_language_defn, asm_language_defn),
	language.c (unknown_language_defn, auto_language_defn,
	local_language_defn), m2-lang.c (m2_language_defn), f-lang.c
	(f_language_defn), ch-lang.c (chill_language_defn):  Set new fields.
	* gdbtypes.c (create_string_type):  Use new string_char_type field.
	* valops.c (value_string):  Use new string_lower_bound field.

	* defs.h (TARGET_COMPLEX_BIT, TARGET_DOUBLE_COMPLEX_BIT):  Removed.
	* f-lang.c (f_create_fundamental_type, _initialize_f_language),
	m2-lang.c (m2_create_fundamental_type),
	gdbtypes.c (_initialize_gdbtypes):  Set TYPE_TARGET_TYPE of complex
	types.  Set their TYPE_CODEs to TYPE_CODE_COMPLEX.
	* mdebugread.c (mdebug_type_complex, mdebug_type_double_complex):
	Removed.  Use builtin_type_complex and builtin_type_double_complex.

	* gdbtypes.h (enum type_code):  Removed TYPE_CODE_LITERAL_STRING
	and TYPE_CODE_LITERAL_COMPLEX.
	* c-typeprint.c, f-typeprint.c, f-valprint.c, eval.c:  Removed uses of
	TYPE_CODE_LITERAL_STRING and TYPE_CODE_LITERAL_COMPLEX.
	* gdbtypes.c, gdbtypes.h (f77_create_literal_complex_type,
	f77_create_literal_string_type):  Removed.
	* value.h (VALUE_LITERAL_DATA, VALUE_SUBSTRING_MEMADDR,
	VALUE_SUBSTRING_MYADDR):  Removed.

	* expression.h (enum exp_opcode):  Rename OP_F77_LITERAL_COMPLEX to
	OP_COMPLEX.
	* parse.c:  Update accordingly.

	* f-valprint.c (f77_print_cmplx):  Removed.
	(f_val_print case TYPE_CODE_COMPLEX):  Re-write to use print_floating.

	* f-exp.y (STRING_LITERAL):  Use OP_STRING instead of OP_ARRAY.
	* eval.c (evaluate_subexp):  For case OP_ARRAY, don't call
	f77_value_literal_string.
	* valops.c, value.h (f77_value_literal_string, f77_value_substring,
	f77_assign_from_literal_string, f77_assign_from_literal_complex):
	Removed.
	(value_assign):  No longer need to handle literal types.
	* valops.c (f77_value_literal_complex), value.h:  Re-written and
	renamed to value_literal_complex.  Last arg is now a (complex) type.
	* valops.c (f77_cast_into_complex):  Re-written and renamed to
	cast_into_complex.
	* eval.c (evaluate_subexp):  Update accordingly.

1 files changed, 7 insertions, 83 deletions

diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index cc76898..2ccc845 100644
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -451,7 +451,9 @@ create_string_type (result_type, range_type)
      struct type *result_type;
      struct type *range_type;
 {
-  result_type = create_array_type (result_type, builtin_type_char, range_type);
+  result_type = create_array_type (result_type,
+				   *current_language->string_char_type,
+				   range_type);
   TYPE_CODE (result_type) = TYPE_CODE_STRING;
   return (result_type);
 }
@@ -486,86 +488,6 @@ create_set_type (result_type, domain_type)
   return (result_type);
 }
 
-/* Create an  F77 literal complex type composed of the two types we are 
-   given as arguments.  */
-
-struct type * 
-f77_create_literal_complex_type (type_arg1, type_arg2)
-     struct type *type_arg1;
-     struct type *type_arg2;
-{
-  struct type *result; 
-
-  /* First make sure that the 2 components of the complex 
-     number both have the same type */
-
-  if (TYPE_CODE (type_arg1) != TYPE_CODE (type_arg2))
-    error ("Both components of a F77 complex number must have the same type!");
-   
-  result = alloc_type (TYPE_OBJFILE (type_arg1));
-   
-  TYPE_CODE (result) = TYPE_CODE_LITERAL_COMPLEX;
-  TYPE_LENGTH (result) = TYPE_LENGTH(type_arg1) * 2;
-
-  return result;
-}
-
-/* Create a F77 LITERAL string type supplied by the user from the keyboard.
-
-   Elements will be of type ELEMENT_TYPE, the indices will be of type
-   RANGE_TYPE.
-
-   FIXME:  Maybe we should check the TYPE_CODE of RESULT_TYPE to make
-   sure it is TYPE_CODE_UNDEF before we bash it into an array type? 
-
-   This is a total clone of create_array_type() except that there are 
-   a few simplyfing assumptions (e.g all bound types are simple).  */ 
-
-struct type *
-f77_create_literal_string_type (result_type, range_type)
-     struct type *result_type;
-     struct type *range_type;
-{
-  int low_bound;
-  int high_bound;
-
-  if (TYPE_CODE (range_type) != TYPE_CODE_RANGE)
-    {
-      /* FIXME:  We only handle range types at the moment.  Complain and
-	 create a dummy range type to use. */
-      warning ("internal error:  array index type must be a range type");
-      range_type = lookup_fundamental_type (TYPE_OBJFILE (range_type),
-					    FT_INTEGER);
-      range_type = create_range_type ((struct type *) NULL, range_type, 0, 0);
-    }
-  if (result_type == NULL)
-    result_type = alloc_type (TYPE_OBJFILE (range_type));
-  TYPE_CODE (result_type) = TYPE_CODE_LITERAL_STRING;
-  TYPE_TARGET_TYPE (result_type) = builtin_type_f_character; 
-  low_bound = TYPE_FIELD_BITPOS (range_type, 0);
-  high_bound = TYPE_FIELD_BITPOS (range_type, 1);
-
-  /* Safely can assume that all bound types are simple */ 
-
-  TYPE_LENGTH (result_type) =
-    TYPE_LENGTH (builtin_type_f_character) * (high_bound - low_bound + 1);
-
-  TYPE_NFIELDS (result_type) = 1;
-  TYPE_FIELDS (result_type) =
-    (struct field *) TYPE_ALLOC (result_type, sizeof (struct field));
-  memset (TYPE_FIELDS (result_type), 0, sizeof (struct field));
-  TYPE_FIELD_TYPE (result_type, 0) = range_type;
-  TYPE_VPTR_FIELDNO (result_type) = -1;
-
-  /* Remember that all literal strings in F77 are of the 
-     character*N type. */
-
-  TYPE_ARRAY_LOWER_BOUND_TYPE (result_type) = BOUND_SIMPLE; 
-  TYPE_ARRAY_UPPER_BOUND_TYPE (result_type) = BOUND_SIMPLE; 
-
-  return result_type;
-}
-
 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE. 
    A MEMBER is a wierd thing -- it amounts to a typed offset into
    a struct, e.g. "an int at offset 8".  A MEMBER TYPE doesn't
@@ -1663,13 +1585,15 @@ _initialize_gdbtypes ()
 	       0,
 	       "long double", (struct objfile *) NULL);
   builtin_type_complex =
-    init_type (TYPE_CODE_FLT, TARGET_COMPLEX_BIT / TARGET_CHAR_BIT,
+    init_type (TYPE_CODE_COMPLEX, 2 * TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
 	       0,
 	       "complex", (struct objfile *) NULL);
+  TYPE_TARGET_TYPE (builtin_type_complex) = builtin_type_float;
   builtin_type_double_complex =
-    init_type (TYPE_CODE_FLT, TARGET_DOUBLE_COMPLEX_BIT / TARGET_CHAR_BIT,
+    init_type (TYPE_CODE_COMPLEX, 2 * TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
 	       0,
 	       "double complex", (struct objfile *) NULL);
+  TYPE_TARGET_TYPE (builtin_type_double_complex) = builtin_type_double;
   builtin_type_string =
     init_type (TYPE_CODE_STRING, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 	       0,