* f-typeprint.c, valarith.c, valprint.c, typeprint.c, eval.c:

	Add check_typedef/CHECK_TYPEDEF as needed.
	* f-typeprint.c:  Various cleaning up.
	* valarith.c (value_subscript):  Also subscript bitstrings (for Chill).
	* typeprint.c (print_type_scalar):  Also support TYPE_CODE_RANGE.
	* eval.c (evaluate_subexp_standard case OP_ARRAY):  Implement
	support for labelled array tuples and ranges in powerset tuples.
	(init_array_element):  New function.

6 files changed, 355 insertions, 251 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 7c7b994..fd6f1eb 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -27,6 +27,15 @@ Wed Nov 29 13:35:18 1995  Per Bothner  <bothner@kalessin.cygnus.com>
 	findvar.c, hppa-tdep.c, infcmd.c, language.c, printcmd.c,
  	rs6000-tdep.c, symmisc.c, symtab.c:
 	Add check_typedef/CHECK_TYPEDEF as needed.
+
+	* f-typeprint.c, valarith.c, valprint.c, typeprint.c, eval.c:
+	Add check_typedef/CHECK_TYPEDEF as needed.
+	* f-typeprint.c:  Various cleaning up.
+	* valarith.c (value_subscript):  Also subscript bitstrings (for Chill).
+	* typeprint.c (print_type_scalar):  Also support TYPE_CODE_RANGE.
+	* eval.c (evaluate_subexp_standard case OP_ARRAY):  Implement
+	support for labelled array tuples and ranges in powerset tuples.
+	(init_array_element):  New function.
 	
 	* top.c (command_line_input):  Only strip out an initial #-comment.
 	Looking for internal comments is language-specific (breaks Scheme).
diff --git a/gdb/eval.c b/gdb/eval.c
index 05adc90..b45c3c8 100644
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -177,13 +177,13 @@ evaluate_struct_tuple (struct_val, exp, pos, noside, nargs)
      enum noside noside;
      int nargs;
 {
-  struct type *struct_type = VALUE_TYPE (struct_val);
+  struct type *struct_type = check_typedef (VALUE_TYPE (struct_val));
   struct type *substruct_type = struct_type;
   struct type *field_type;
   int fieldno = -1;
   int variantno = -1;
   int subfieldno = -1;
-  while (--nargs >= 0)
+   while (--nargs >= 0)
     {
       int pc = *pos;
       value_ptr val = NULL;
@@ -307,6 +307,58 @@ evaluate_struct_tuple (struct_val, exp, pos, noside, nargs)
   return struct_val;
 }
 
+/* Recursive helper function for setting elements of array tuples for Chill.
+   The target is ARRAY (which has bounds LOW_BOUND to HIGH_BOUND);
+   the element value is ELEMENT;
+   EXP, POS and NOSIDE are as usual.
+   Evaluates index expresions and sets the specified element(s) of
+   ARRAY to ELEMENT.
+   Returns last index value.  */
+
+static LONGEST
+init_array_element (array, element, exp, pos, noside, low_bound, high_bound)
+     value_ptr array, element;
+     register struct expression *exp;
+     register int *pos;
+     enum noside noside;
+{
+  LONGEST index;
+  int element_size = TYPE_LENGTH (VALUE_TYPE (element));
+  if (exp->elts[*pos].opcode == BINOP_COMMA)
+    {
+      (*pos)++;
+      init_array_element (array, element, exp, pos, noside,
+			  low_bound, high_bound);
+      return init_array_element (array, element,
+				 exp, pos, noside, low_bound, high_bound);
+    }
+  else if (exp->elts[*pos].opcode == BINOP_RANGE)
+    {
+      LONGEST low, high;
+      value_ptr val;
+      (*pos)++;
+      low = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
+      high = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
+      if (low < low_bound || high > high_bound)
+	error ("tuple range index out of range");
+      for (index = low ; index <= high; index++)
+	{
+	  memcpy (VALUE_CONTENTS_RAW (array)
+		  + (index - low_bound) * element_size,
+		  VALUE_CONTENTS (element), element_size);
+	}
+    }
+  else
+    {
+      index = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
+      if (index < low_bound || index > high_bound)
+	error ("tuple index out of range");
+      memcpy (VALUE_CONTENTS_RAW (array) + (index - low_bound) * element_size,
+	      VALUE_CONTENTS (element), element_size);
+    }
+  return index;
+}
+
 value_ptr
 evaluate_subexp_standard (expect_type, exp, pos, noside)
      struct type *expect_type;
@@ -440,62 +492,107 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
       tem2 = longest_to_int (exp->elts[pc + 1].longconst);
       tem3 = longest_to_int (exp->elts[pc + 2].longconst);
       nargs = tem3 - tem2 + 1;
+      type = expect_type ? check_typedef (expect_type) : NULL_TYPE;
 
       if (expect_type != NULL_TYPE && noside != EVAL_SKIP
-	  && TYPE_CODE (expect_type) == TYPE_CODE_STRUCT)
+	  && TYPE_CODE (type) == TYPE_CODE_STRUCT)
 	{
 	  value_ptr rec = allocate_value (expect_type);
-	  memset (VALUE_CONTENTS_RAW (rec), '\0', TYPE_LENGTH (expect_type));
+	  memset (VALUE_CONTENTS_RAW (rec), '\0', TYPE_LENGTH (type));
 	  return evaluate_struct_tuple (rec, exp, pos, noside, nargs);
 	}
 
       if (expect_type != NULL_TYPE && noside != EVAL_SKIP
-	  && TYPE_CODE (expect_type) == TYPE_CODE_ARRAY)
+	  && TYPE_CODE (type) == TYPE_CODE_ARRAY)
 	{
-	  struct type *range_type = TYPE_FIELD_TYPE (expect_type, 0);
-	  struct type *element_type = TYPE_TARGET_TYPE (expect_type);
-	  LONGEST low_bound =  TYPE_FIELD_BITPOS (range_type, 0);
-	  LONGEST high_bound = TYPE_FIELD_BITPOS (range_type, 1);
-	  int element_size = TYPE_LENGTH (element_type);
+	  struct type *range_type = TYPE_FIELD_TYPE (type, 0);
+	  struct type *element_type = TYPE_TARGET_TYPE (type);
 	  value_ptr array = allocate_value (expect_type);
-	  if (nargs != (high_bound - low_bound + 1))
-	    error ("wrong number of initialiers for array type");
-	  for (tem = low_bound;  tem <= high_bound;  tem++)
+	  int element_size = TYPE_LENGTH (check_typedef (element_type));
+	  LONGEST low_bound, high_bound, index;
+	  if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
+	    {
+	      low_bound = 0;
+	      high_bound = (TYPE_LENGTH (type) / element_size) - 1;
+	    }
+	  index = low_bound;
+	  memset (VALUE_CONTENTS_RAW (array), 0, TYPE_LENGTH (expect_type));
+	  for (tem = nargs;  --nargs >= 0;  )
 	    {
-	      value_ptr element = evaluate_subexp (element_type,
-						   exp, pos, noside);
+	      value_ptr element;
+	      int index_pc = 0;
+	      if (exp->elts[*pos].opcode == BINOP_RANGE)
+		{
+		  index_pc = ++(*pos);
+		  evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
+		}
+	      element = evaluate_subexp (element_type, exp, pos, noside);
 	      if (VALUE_TYPE (element) != element_type)
 		element = value_cast (element_type, element);
-	      memcpy (VALUE_CONTENTS_RAW (array)
-		      + (tem - low_bound) * element_size,
-		      VALUE_CONTENTS (element),
-		      element_size);
+	      if (index_pc)
+		{
+		  int continue_pc = *pos;
+		  *pos = index_pc;
+		  index = init_array_element (array, element, exp, pos, noside,
+					      low_bound, high_bound);
+		  *pos = continue_pc;
+		}
+	      else
+		{
+		  memcpy (VALUE_CONTENTS_RAW (array)
+			  + (index - low_bound) * element_size,
+			  VALUE_CONTENTS (element),
+			  element_size);
+		}
+	      index++;
 	    }
 	  return array;
 	}
 
       if (expect_type != NULL_TYPE && noside != EVAL_SKIP
-	  && TYPE_CODE (expect_type) == TYPE_CODE_SET)
+	  && TYPE_CODE (type) == TYPE_CODE_SET)
 	{
 	  value_ptr set = allocate_value (expect_type);
-	  struct type *element_type = TYPE_INDEX_TYPE (expect_type);
-	  int low_bound = TYPE_LOW_BOUND (element_type);
-	  int high_bound = TYPE_HIGH_BOUND (element_type);
 	  char *valaddr = VALUE_CONTENTS_RAW (set);
-	  memset (valaddr, '\0', TYPE_LENGTH (expect_type));
+	  struct type *element_type = TYPE_INDEX_TYPE (type);
+	  LONGEST low_bound, high_bound;
+	  if (get_discrete_bounds (element_type, &low_bound, &high_bound) < 0)
+	    error ("(power)set type with unknown size");
+	  memset (valaddr, '\0', TYPE_LENGTH (type));
 	  for (tem = 0; tem < nargs; tem++)
 	    {
-	      value_ptr element_val = evaluate_subexp (element_type,
-						       exp, pos, noside);
-	      LONGEST element = value_as_long (element_val);
-	      int bit_index;
-	      if (element < low_bound || element > high_bound)
+	      LONGEST range_low, range_high;
+	      value_ptr elem_val;
+	      if (exp->elts[*pos].opcode == BINOP_RANGE)
+		{
+		  (*pos)++;
+		  elem_val = evaluate_subexp (element_type, exp, pos, noside);
+		  range_low = value_as_long (elem_val);
+		  elem_val = evaluate_subexp (element_type, exp, pos, noside);
+		  range_high = value_as_long (elem_val);
+		}
+	      else
+		{
+		  elem_val = evaluate_subexp (element_type, exp, pos, noside);
+		  range_low = range_high = value_as_long (elem_val);
+		}
+	      if (range_low > range_high)
+		{
+		  warning ("empty POWERSET tuple range");
+		  continue;
+		}
+	      if (range_low < low_bound || range_high > high_bound)
 		error ("POWERSET tuple element out of range");
-	      element -= low_bound;
-	      bit_index = (unsigned) element % TARGET_CHAR_BIT;
-	      if (BITS_BIG_ENDIAN)
-		bit_index = TARGET_CHAR_BIT - 1 - bit_index;
-	      valaddr [(unsigned) element / TARGET_CHAR_BIT] |= 1 << bit_index;
+	      range_low -= low_bound;
+	      range_high -= low_bound;
+	      for ( ; range_low <= range_high; range_low++)
+		{
+		  int bit_index = (unsigned) range_low % TARGET_CHAR_BIT;
+		  if (BITS_BIG_ENDIAN)
+		    bit_index = TARGET_CHAR_BIT - 1 - bit_index;
+		  valaddr [(unsigned) range_low / TARGET_CHAR_BIT]
+		    |= 1 << bit_index;
+		}
 	    }
 	  return set;
 	}
@@ -517,6 +614,8 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
 	  = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
 	int upper
 	  = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
+	if (noside == EVAL_SKIP)
+	  goto nosideret;
 	return value_slice (array, lowbound, upper - lowbound + 1);
       }
 
@@ -740,7 +839,8 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
 
       /* First determine the type code we are dealing with.  */ 
       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
-      code = TYPE_CODE (VALUE_TYPE (arg1)); 
+      type = check_typedef (VALUE_TYPE (arg1));
+      code = TYPE_CODE (type);
 
       switch (code) 
 	{
@@ -775,29 +875,17 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
 
       arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
 
-      if (TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_INT)
-         error ("Substring arguments must be of type integer");
-
       if (nargs < 2)
 	return value_subscript (arg1, arg2);
 
       arg3 = evaluate_subexp_with_coercion (exp, pos, noside);
 
-      if (TYPE_CODE (VALUE_TYPE (arg3)) != TYPE_CODE_INT)
-         error ("Substring arguments must be of type integer");
-
-      tem2 = *((int *) VALUE_CONTENTS_RAW (arg2)); 
-      tem3 = *((int *) VALUE_CONTENTS_RAW (arg3)); 
-
-      if ((tem2 < 1) || (tem2 > tem3))
-         error ("Bad 'from' value %d on substring operation", tem2); 
-
-      if ((tem3 < tem2) || (tem3 > (TYPE_LENGTH (VALUE_TYPE (arg1)))))
-         error ("Bad 'to' value %d on substring operation", tem3); 
-      
       if (noside == EVAL_SKIP)
         goto nosideret;
       
+      tem2 = value_as_long (arg2);
+      tem2 = value_as_long (arg3);
+      
       return value_slice (arg1, tem2, tem3 - tem2 + 1);
 
     case OP_COMPLEX:
@@ -883,9 +971,10 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
       if (noside == EVAL_SKIP)
 	goto nosideret;
-      if (TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_PTR)
+      type = check_typedef (VALUE_TYPE (arg2));
+      if (TYPE_CODE (type) != TYPE_CODE_PTR)
 	goto bad_pointer_to_member;
-      type = TYPE_TARGET_TYPE (VALUE_TYPE (arg2));
+      type = check_typedef (TYPE_TARGET_TYPE (type));
       if (TYPE_CODE (type) == TYPE_CODE_METHOD)
 	error ("not implemented: pointer-to-method in pointer-to-member construct");
       if (TYPE_CODE (type) != TYPE_CODE_MEMBER)
@@ -996,7 +1085,7 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
 	     type (like a plain int variable for example), then report this
 	     as an error. */
 
-	  type = TYPE_TARGET_TYPE (VALUE_TYPE (arg1));
+	  type = TYPE_TARGET_TYPE (check_typedef (VALUE_TYPE (arg1)));
 	  if (type)
 	    return value_zero (type, VALUE_LVAL (arg1));
 	  else
@@ -1042,7 +1131,7 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
 		 type (like a plain int variable for example), then report this
 		 as an error. */
 	      
-	      type = TYPE_TARGET_TYPE (VALUE_TYPE (arg1));
+	      type = TYPE_TARGET_TYPE (check_typedef (VALUE_TYPE (arg1)));
 	      if (type != NULL)
 		{
 		  arg1 = value_zero (type, VALUE_LVAL (arg1));
@@ -1078,8 +1167,9 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
 
 	if (nargs > MAX_FORTRAN_DIMS)
 	  error ("Too many subscripts for F77 (%d Max)", MAX_FORTRAN_DIMS);
-         
-	ndimensions = calc_f77_array_dims (VALUE_TYPE (arg1)); 
+
+	tmp_type = check_typedef (VALUE_TYPE (arg1));
+	ndimensions = calc_f77_array_dims (type);
 
 	if (nargs != ndimensions)
 	  error ("Wrong number of subscripts");
@@ -1087,7 +1177,6 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
 	/* Now that we know we have a legal array subscript expression 
 	   let us actually find out where this element exists in the array. */ 
 
-	tmp_type = VALUE_TYPE (arg1);
 	offset_item = 0; 
 	for (i = 1; i <= nargs; i++)
 	  {
@@ -1121,7 +1210,7 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
 	       offset to. */ 
 
 	    if (i < nargs) 
-	      tmp_type = TYPE_TARGET_TYPE (tmp_type); 
+	      tmp_type = check_typedef (TYPE_TARGET_TYPE (tmp_type)); 
 	  }
 
 	/* Now let us calculate the offset for this item */
@@ -1341,20 +1430,21 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
 
     case UNOP_IND:
       if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_PTR)
-        expect_type = TYPE_TARGET_TYPE (expect_type);
+        expect_type = TYPE_TARGET_TYPE (check_typedef (expect_type));
       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
       if (noside == EVAL_SKIP)
 	goto nosideret;
       if (noside == EVAL_AVOID_SIDE_EFFECTS)
 	{
-	  if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR
-	      || TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_REF
+	  type = check_typedef (VALUE_TYPE (arg1));
+	  if (TYPE_CODE (type) == TYPE_CODE_PTR
+	      || TYPE_CODE (type) == TYPE_CODE_REF
 	      /* In C you can dereference an array to get the 1st elt.  */
-	      || TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_ARRAY
+	      || TYPE_CODE (type) == TYPE_CODE_ARRAY
 	      )
-	    return value_zero (TYPE_TARGET_TYPE (VALUE_TYPE (arg1)),
+	    return value_zero (TYPE_TARGET_TYPE (type),
 			       lval_memory);
-	  else if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_INT)
+	  else if (TYPE_CODE (type) == TYPE_CODE_INT)
 	    /* GDB allows dereferencing an int.  */
 	    return value_zero (builtin_type_int, lval_memory);
 	  else
@@ -1605,7 +1695,7 @@ evaluate_subexp_with_coercion (exp, pos, noside)
     {
     case OP_VAR_VALUE:
       var = exp->elts[pc + 2].symbol;
-      if (TYPE_CODE (SYMBOL_TYPE (var)) == TYPE_CODE_ARRAY
+      if (TYPE_CODE (check_typedef (SYMBOL_TYPE (var))) == TYPE_CODE_ARRAY
 	  && CAST_IS_CONVERSION)
 	{
 	  (*pos) += 4;
@@ -1633,6 +1723,7 @@ evaluate_subexp_for_sizeof (exp, pos)
 {
   enum exp_opcode op;
   register int pc;
+  struct type *type;
   value_ptr val;
 
   pc = (*pos);
@@ -1647,20 +1738,22 @@ evaluate_subexp_for_sizeof (exp, pos)
     case UNOP_IND:
       (*pos)++;
       val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
+      type = check_typedef (VALUE_TYPE (val));
+      type = check_typedef (TYPE_TARGET_TYPE (type));
       return value_from_longest (builtin_type_int, (LONGEST)
-		      TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (val))));
+		      TYPE_LENGTH (type));
 
     case UNOP_MEMVAL:
       (*pos) += 3;
-      return value_from_longest (builtin_type_int, 
-			      (LONGEST) TYPE_LENGTH (exp->elts[pc + 1].type));
+      type = check_typedef (exp->elts[pc + 1].type);
+      return value_from_longest (builtin_type_int,
+				 (LONGEST) TYPE_LENGTH (type));
 
     case OP_VAR_VALUE:
       (*pos) += 4;
+      type = check_typedef (SYMBOL_TYPE (exp->elts[pc + 2].symbol));
       return
-	value_from_longest
-	  (builtin_type_int,
-	   (LONGEST) TYPE_LENGTH (SYMBOL_TYPE (exp->elts[pc + 2].symbol)));
+	value_from_longest (builtin_type_int, (LONGEST) TYPE_LENGTH (type));
 
     default:
       val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
diff --git a/gdb/f-typeprint.c b/gdb/f-typeprint.c
index b090e0b..7a160bc 100644
--- a/gdb/f-typeprint.c
+++ b/gdb/f-typeprint.c
@@ -314,16 +314,7 @@ print_equivalent_f77_float_type (type, stream)
      appropriate real. XLC stupidly outputs -12 as a type
      for real when it really should be outputting -18 */
 
-  switch (TYPE_LENGTH (type))
-    {
-    case 4:
-      fprintf_filtered (stream, "real*4");
-      break;
-
-    case 8:
-      fprintf_filtered(stream,"real*8");
-      break;
-    }
+  fprintf_filtered (stream, "real*%d", TYPE_LENGTH (type));
 }
 
 /* Print the name of the type (or the ultimate pointer target,
@@ -370,19 +361,23 @@ f_type_print_base (type, stream, show, level)
       return;
     }
 
+  if (TYPE_CODE (type) != TYPE_CODE_TYPEDEF)
+    CHECK_TYPEDEF (type);
+
   switch (TYPE_CODE (type))
     {
-    case TYPE_CODE_ARRAY:
-      f_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
+    case TYPE_CODE_TYPEDEF:
+      f_type_print_base (TYPE_TARGET_TYPE (type), stream, 0, level);
       break;
 
+    case TYPE_CODE_ARRAY:
     case TYPE_CODE_FUNC:
       f_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
       break;
 
    case TYPE_CODE_PTR:
       fprintf_filtered (stream, "PTR TO -> ( ");
-      f_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
+      f_type_print_base (TYPE_TARGET_TYPE (type), stream, 0, level);
       break;
 
     case TYPE_CODE_VOID:
@@ -419,8 +414,7 @@ f_type_print_base (type, stream, show, level)
       break;
 
     case TYPE_CODE_COMPLEX:
-      fprintf_filtered (stream, "complex*");
-      fprintf_filtered (stream, "%d", TYPE_LENGTH (type));
+      fprintf_filtered (stream, "complex*%d", TYPE_LENGTH (type));
       break;
 
     case TYPE_CODE_FLT:
diff --git a/gdb/typeprint.c b/gdb/typeprint.c
index 135c928..6b1c6de 100644
--- a/gdb/typeprint.c
+++ b/gdb/typeprint.c
@@ -180,6 +180,8 @@ print_type_scalar (type, val, stream)
   unsigned int i;
   unsigned len;
 
+  CHECK_TYPEDEF (type);
+
   switch (TYPE_CODE (type))
     {
 
@@ -214,6 +216,10 @@ print_type_scalar (type, val, stream)
       fprintf_filtered (stream, val ? "TRUE" : "FALSE");
       break;
 
+    case TYPE_CODE_RANGE:
+      print_type_scalar (TYPE_TARGET_TYPE (type), val, stream);
+      return;
+
     case TYPE_CODE_UNDEF:
     case TYPE_CODE_PTR:
     case TYPE_CODE_ARRAY:
@@ -223,7 +229,6 @@ print_type_scalar (type, val, stream)
     case TYPE_CODE_FLT:
     case TYPE_CODE_VOID:
     case TYPE_CODE_SET:
-    case TYPE_CODE_RANGE:
     case TYPE_CODE_STRING:
     case TYPE_CODE_ERROR:
     case TYPE_CODE_MEMBER:
diff --git a/gdb/valarith.c b/gdb/valarith.c
index 9af5bb0..50759da 100644
--- a/gdb/valarith.c
+++ b/gdb/valarith.c
@@ -16,7 +16,7 @@ GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 #include "defs.h"
 #include "value.h"
@@ -44,30 +44,35 @@ value_add (arg1, arg2)
 {
   register value_ptr valint, valptr;
   register int len;
+  struct type *type1, *type2, *valptrtype;
 
   COERCE_ARRAY (arg1);
   COERCE_ARRAY (arg2);
+  type1 = check_typedef (VALUE_TYPE (arg1));
+  type2 = check_typedef (VALUE_TYPE (arg2));
 
-  if ((TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR
-       || TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_PTR)
+  if ((TYPE_CODE (type1) == TYPE_CODE_PTR
+       || TYPE_CODE (type2) == TYPE_CODE_PTR)
       &&
-      (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_INT
-       || TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_INT))
+      (TYPE_CODE (type1) == TYPE_CODE_INT
+       || TYPE_CODE (type2) == TYPE_CODE_INT))
     /* Exactly one argument is a pointer, and one is an integer.  */
     {
-      if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR)
+      if (TYPE_CODE (type1) == TYPE_CODE_PTR)
 	{
 	  valptr = arg1;
 	  valint = arg2;
+	  valptrtype = type1;
 	}
       else
 	{
 	  valptr = arg2;
 	  valint = arg1;
+	  valptrtype = type2;
 	}
-      len = TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (valptr)));
+      len = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (valptrtype)));
       if (len == 0) len = 1;	/* For (void *) */
-      return value_from_longest (VALUE_TYPE (valptr),
+      return value_from_longest (valptrtype,
 			      value_as_long (valptr)
 			      + (len * value_as_long (valint)));
     }
@@ -79,30 +84,31 @@ value_ptr
 value_sub (arg1, arg2)
      value_ptr arg1, arg2;
 {
-
+  struct type *type1, *type2;
   COERCE_ARRAY (arg1);
   COERCE_ARRAY (arg2);
+  type1 = check_typedef (VALUE_TYPE (arg1));
+  type2 = check_typedef (VALUE_TYPE (arg2));
 
-  if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR)
+  if (TYPE_CODE (type1) == TYPE_CODE_PTR)
     {
-      if (TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_INT)
+      if (TYPE_CODE (type2) == TYPE_CODE_INT)
 	{
 	  /* pointer - integer.  */
+	  LONGEST sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)));
 	  return value_from_longest
 	    (VALUE_TYPE (arg1),
-	     value_as_long (arg1)
-	     - (TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (arg1)))
-		* value_as_long (arg2)));
+	     value_as_long (arg1) - (sz * value_as_long (arg2)));
 	}
-      else if (TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_PTR
-	       && TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (arg1)))
-		  == TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (arg2))))
+      else if (TYPE_CODE (type2) == TYPE_CODE_PTR
+	       && TYPE_LENGTH (TYPE_TARGET_TYPE (type1))
+		  == TYPE_LENGTH (TYPE_TARGET_TYPE (type2)))
 	{
 	  /* pointer to <type x> - pointer to <type x>.  */
+	  LONGEST sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)));
 	  return value_from_longest
 	    (builtin_type_long,		/* FIXME -- should be ptrdiff_t */
-	     (value_as_long (arg1) - value_as_long (arg2))
-	     / (LONGEST) (TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (arg1)))));
+	     (value_as_long (arg1) - value_as_long (arg2)) / sz);
 	}
       else
 	{
@@ -127,16 +133,18 @@ value_subscript (array, idx)
 {
   value_ptr bound;
   int c_style = current_language->c_style_arrays;
+  struct type *tarray, *tint;
 
   COERCE_REF (array);
-  COERCE_VARYING_ARRAY (array);
+  tarray = check_typedef (VALUE_TYPE (array));
+  COERCE_VARYING_ARRAY (array, tarray);
 
-  if (TYPE_CODE (VALUE_TYPE (array)) == TYPE_CODE_ARRAY
-      || TYPE_CODE (VALUE_TYPE (array)) == TYPE_CODE_STRING)
+  if (TYPE_CODE (tarray) == TYPE_CODE_ARRAY
+      || TYPE_CODE (tarray) == TYPE_CODE_STRING)
     {
-      struct type *range_type = TYPE_FIELD_TYPE (VALUE_TYPE (array), 0);
-      int lowerbound = TYPE_LOW_BOUND (range_type);
-      int upperbound = TYPE_HIGH_BOUND (range_type);
+      struct type *range_type = TYPE_INDEX_TYPE (tarray);
+      LONGEST lowerbound, upperbound;
+      get_discrete_bounds (range_type, &lowerbound, &upperbound);
 
       if (VALUE_LVAL (array) != lval_memory)
 	return value_subscripted_rvalue (array, idx, lowerbound);
@@ -159,6 +167,33 @@ value_subscript (array, idx)
 
       array = value_coerce_array (array);
     }
+
+  if (TYPE_CODE (tarray) == TYPE_CODE_BITSTRING)
+    {
+      struct type *range_type = TYPE_INDEX_TYPE (tarray);
+      LONGEST index = value_as_long (idx);
+      value_ptr v;
+      int offset, byte, bit_index;
+      LONGEST lowerbound, upperbound, word;
+      get_discrete_bounds (range_type, &lowerbound, &upperbound);
+      if (index < lowerbound || index > upperbound)
+	error ("bitstring index out of range");
+      index -= lowerbound;
+      offset = index / TARGET_CHAR_BIT;
+      byte = *((char*)VALUE_CONTENTS (array) + offset);
+      bit_index = index % TARGET_CHAR_BIT;
+      byte >>= (BITS_BIG_ENDIAN ? TARGET_CHAR_BIT - 1 - bit_index : bit_index);
+      v = value_from_longest (builtin_type_int, byte & 1);
+      VALUE_BITPOS (v) = bit_index;
+      VALUE_BITSIZE (v) = 1;
+      VALUE_LVAL (v) = VALUE_LVAL (array);
+      if (VALUE_LVAL (array) == lval_internalvar)
+	VALUE_LVAL (v) = lval_internalvar_component;
+      VALUE_ADDRESS (v) = VALUE_ADDRESS (array);
+      VALUE_OFFSET (v) = offset + VALUE_OFFSET (array);
+      return v;
+    }
+
   if (c_style)
     return value_ind (value_add (array, idx));
   else
@@ -174,13 +209,14 @@ value_subscripted_rvalue (array, idx, lowerbound)
      value_ptr array, idx;
      int lowerbound;
 {
-  struct type *elt_type = TYPE_TARGET_TYPE (VALUE_TYPE (array));
+  struct type *array_type = check_typedef (VALUE_TYPE (array));
+  struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (array_type));
   int elt_size = TYPE_LENGTH (elt_type);
   LONGEST index = value_as_long (idx);
   int elt_offs = elt_size * longest_to_int (index - lowerbound);
   value_ptr v;
 
-  if (index < lowerbound || elt_offs >= TYPE_LENGTH (VALUE_TYPE (array)))
+  if (index < lowerbound || elt_offs >= TYPE_LENGTH (array_type))
     error ("no such vector element");
 
   v = allocate_value (elt_type);
@@ -195,7 +231,6 @@ value_subscripted_rvalue (array, idx, lowerbound)
     VALUE_LVAL (v) = VALUE_LVAL (array);
   VALUE_ADDRESS (v) = VALUE_ADDRESS (array);
   VALUE_OFFSET (v) = VALUE_OFFSET (array) + elt_offs;
-  VALUE_BITSIZE (v) = elt_size * 8;
   return v;
 }
 
@@ -210,14 +245,17 @@ binop_user_defined_p (op, arg1, arg2)
      enum exp_opcode op;
      value_ptr arg1, arg2;
 {
+  struct type *type1, *type2;
   if (op == BINOP_ASSIGN)
     return 0;
-  return (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_STRUCT
-	  || TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_STRUCT
-	  || (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_REF
-	      && TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))) == TYPE_CODE_STRUCT)
-	  || (TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_REF
-	      && TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg2))) == TYPE_CODE_STRUCT));
+  type1 = check_typedef (VALUE_TYPE (arg1));
+  type2 = check_typedef (VALUE_TYPE (arg2));
+  return (TYPE_CODE (type1) == TYPE_CODE_STRUCT
+	  || TYPE_CODE (type2) == TYPE_CODE_STRUCT
+	  || (TYPE_CODE (type1) == TYPE_CODE_REF
+	      && TYPE_CODE (TYPE_TARGET_TYPE (type1)) == TYPE_CODE_STRUCT)
+	  || (TYPE_CODE (type2) == TYPE_CODE_REF
+	      && TYPE_CODE (TYPE_TARGET_TYPE (type2)) == TYPE_CODE_STRUCT));
 }
 
 /* Check to see if argument is a structure.  This is called so
@@ -230,11 +268,19 @@ int unop_user_defined_p (op, arg1)
      enum exp_opcode op;
      value_ptr arg1;
 {
+  struct type *type1;
   if (op == UNOP_ADDR)
     return 0;
-  return (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_STRUCT
-	  || (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_REF
-	      && TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))) == TYPE_CODE_STRUCT));
+  type1 = check_typedef (VALUE_TYPE (arg1));
+  for (;;)
+    {
+      if (TYPE_CODE (type1) == TYPE_CODE_STRUCT)
+	return 1;
+      else if (TYPE_CODE (type1) == TYPE_CODE_REF)
+	type1 = TYPE_TARGET_TYPE (type1);
+      else
+	return 0;
+    }
 }
 
 /* We know either arg1 or arg2 is a structure, so try to find the right
@@ -264,7 +310,7 @@ value_x_binop (arg1, arg2, op, otherop)
   /* now we know that what we have to do is construct our
      arg vector and find the right function to call it with.  */
 
-  if (TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_STRUCT)
+  if (TYPE_CODE (check_typedef (VALUE_TYPE (arg1))) != TYPE_CODE_STRUCT)
     error ("Can't do that binary op on that type");  /* FIXME be explicit */
 
   argvec = (value_ptr *) alloca (sizeof (value_ptr) * 4);
@@ -358,7 +404,7 @@ value_x_unop (arg1, op)
   /* now we know that what we have to do is construct our
      arg vector and find the right function to call it with.  */
 
-  if (TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_STRUCT)
+  if (TYPE_CODE (check_typedef (VALUE_TYPE (arg1))) != TYPE_CODE_STRUCT)
     error ("Can't do that unary op on that type");  /* FIXME be explicit */
 
   argvec = (value_ptr *) alloca (sizeof (value_ptr) * 3);
@@ -429,6 +475,8 @@ value_concat (arg1, arg2)
   int count, idx;
   char *ptr;
   char inchar;
+  struct type *type1 = check_typedef (VALUE_TYPE (arg1));
+  struct type *type2 = check_typedef (VALUE_TYPE (arg2));
 
   /* First figure out if we are dealing with two values to be concatenated
      or a repeat count and a value to be repeated.  INVAL1 is set to the
@@ -436,8 +484,11 @@ value_concat (arg1, arg2)
      to the second of the two concatenated values or the value to be 
      repeated. */
 
-  if (TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_INT)
+  if (TYPE_CODE (type2) == TYPE_CODE_INT)
     {
+      struct type *tmp = type1;
+      type1 = tmp;
+      tmp = type2;
       inval1 = arg2;
       inval2 = arg1;
     }
@@ -449,19 +500,19 @@ value_concat (arg1, arg2)
 
   /* Now process the input values. */
 
-  if (TYPE_CODE (VALUE_TYPE (inval1)) == TYPE_CODE_INT)
+  if (TYPE_CODE (type1) == TYPE_CODE_INT)
     {
       /* We have a repeat count.  Validate the second value and then
 	 construct a value repeated that many times. */
-      if (TYPE_CODE (VALUE_TYPE (inval2)) == TYPE_CODE_STRING
-	  || TYPE_CODE (VALUE_TYPE (inval2)) == TYPE_CODE_CHAR)
+      if (TYPE_CODE (type2) == TYPE_CODE_STRING
+	  || TYPE_CODE (type2) == TYPE_CODE_CHAR)
 	{
 	  count = longest_to_int (value_as_long (inval1));
-	  inval2len = TYPE_LENGTH (VALUE_TYPE (inval2));
+	  inval2len = TYPE_LENGTH (type2);
 	  ptr = (char *) alloca (count * inval2len);
-	  if (TYPE_CODE (VALUE_TYPE (inval2)) == TYPE_CODE_CHAR)
+	  if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
 	    {
-	      inchar = (char) unpack_long (VALUE_TYPE (inval2),
+	      inchar = (char) unpack_long (type2,
 					   VALUE_CONTENTS (inval2));
 	      for (idx = 0; idx < count; idx++)
 		{
@@ -478,8 +529,8 @@ value_concat (arg1, arg2)
 	    }
 	  outval = value_string (ptr, count * inval2len);
 	}
-      else if (TYPE_CODE (VALUE_TYPE (inval2)) == TYPE_CODE_BITSTRING
-	       || TYPE_CODE (VALUE_TYPE (inval2)) == TYPE_CODE_BOOL)
+      else if (TYPE_CODE (type2) == TYPE_CODE_BITSTRING
+	       || TYPE_CODE (type2) == TYPE_CODE_BOOL)
 	{
 	  error ("unimplemented support for bitstring/boolean repeats");
 	}
@@ -488,30 +539,30 @@ value_concat (arg1, arg2)
 	  error ("can't repeat values of that type");
 	}
     }
-  else if (TYPE_CODE (VALUE_TYPE (inval1)) == TYPE_CODE_STRING
-      || TYPE_CODE (VALUE_TYPE (inval1)) == TYPE_CODE_CHAR)
+  else if (TYPE_CODE (type1) == TYPE_CODE_STRING
+      || TYPE_CODE (type1) == TYPE_CODE_CHAR)
     {
       /* We have two character strings to concatenate. */
-      if (TYPE_CODE (VALUE_TYPE (inval2)) != TYPE_CODE_STRING
-	  && TYPE_CODE (VALUE_TYPE (inval2)) != TYPE_CODE_CHAR)
+      if (TYPE_CODE (type2) != TYPE_CODE_STRING
+	  && TYPE_CODE (type2) != TYPE_CODE_CHAR)
 	{
 	  error ("Strings can only be concatenated with other strings.");
 	}
-      inval1len = TYPE_LENGTH (VALUE_TYPE (inval1));
-      inval2len = TYPE_LENGTH (VALUE_TYPE (inval2));
+      inval1len = TYPE_LENGTH (type1);
+      inval2len = TYPE_LENGTH (type2);
       ptr = (char *) alloca (inval1len + inval2len);
-      if (TYPE_CODE (VALUE_TYPE (inval1)) == TYPE_CODE_CHAR)
+      if (TYPE_CODE (type1) == TYPE_CODE_CHAR)
 	{
-	  *ptr = (char) unpack_long (VALUE_TYPE (inval1), VALUE_CONTENTS (inval1));
+	  *ptr = (char) unpack_long (type1, VALUE_CONTENTS (inval1));
 	}
       else
 	{
 	  memcpy (ptr, VALUE_CONTENTS (inval1), inval1len);
 	}
-      if (TYPE_CODE (VALUE_TYPE (inval2)) == TYPE_CODE_CHAR)
+      if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
 	{
 	  *(ptr + inval1len) = 
-	    (char) unpack_long (VALUE_TYPE (inval2), VALUE_CONTENTS (inval2));
+	    (char) unpack_long (type2, VALUE_CONTENTS (inval2));
 	}
       else
 	{
@@ -519,12 +570,12 @@ value_concat (arg1, arg2)
 	}
       outval = value_string (ptr, inval1len + inval2len);
     }
-  else if (TYPE_CODE (VALUE_TYPE (inval1)) == TYPE_CODE_BITSTRING
-	   || TYPE_CODE (VALUE_TYPE (inval1)) == TYPE_CODE_BOOL)
+  else if (TYPE_CODE (type1) == TYPE_CODE_BITSTRING
+	   || TYPE_CODE (type1) == TYPE_CODE_BOOL)
     {
       /* We have two bitstrings to concatenate. */
-      if (TYPE_CODE (VALUE_TYPE (inval2)) != TYPE_CODE_BITSTRING
-	  && TYPE_CODE (VALUE_TYPE (inval2)) != TYPE_CODE_BOOL)
+      if (TYPE_CODE (type2) != TYPE_CODE_BITSTRING
+	  && TYPE_CODE (type2) != TYPE_CODE_BOOL)
 	{
 	  error ("Bitstrings or booleans can only be concatenated with other bitstrings or booleans.");
 	}
@@ -552,26 +603,29 @@ value_binop (arg1, arg2, op)
      enum exp_opcode op;
 {
   register value_ptr val;
+  struct type *type1, *type2;
 
   COERCE_ENUM (arg1);
   COERCE_ENUM (arg2);
-
-  if ((TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_FLT
-       && TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_CHAR
-       && TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_INT
-       && TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_BOOL
-       && TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_RANGE)
+  type1 = check_typedef (VALUE_TYPE (arg1));
+  type2 = check_typedef (VALUE_TYPE (arg2));
+
+  if ((TYPE_CODE (type1) != TYPE_CODE_FLT
+       && TYPE_CODE (type1) != TYPE_CODE_CHAR
+       && TYPE_CODE (type1) != TYPE_CODE_INT
+       && TYPE_CODE (type1) != TYPE_CODE_BOOL
+       && TYPE_CODE (type1) != TYPE_CODE_RANGE)
       ||
-      (TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_FLT
-       && TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_CHAR
-       && TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_INT
-       && TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_BOOL
-       && TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_RANGE))
+      (TYPE_CODE (type2) != TYPE_CODE_FLT
+       && TYPE_CODE (type2) != TYPE_CODE_CHAR
+       && TYPE_CODE (type2) != TYPE_CODE_INT
+       && TYPE_CODE (type2) != TYPE_CODE_BOOL
+       && TYPE_CODE (type2) != TYPE_CODE_RANGE))
     error ("Argument to arithmetic operation not a number or boolean.");
 
-  if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_FLT
+  if (TYPE_CODE (type1) == TYPE_CODE_FLT
       ||
-      TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_FLT)
+      TYPE_CODE (type2) == TYPE_CODE_FLT)
     {
       /* FIXME-if-picky-about-floating-accuracy: Should be doing this
 	 in target format.  real.c in GCC probably has the necessary
@@ -605,9 +659,9 @@ value_binop (arg1, arg2, op)
       store_floating (VALUE_CONTENTS_RAW (val), TYPE_LENGTH (VALUE_TYPE (val)),
 		      v);
     }
-  else if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_BOOL
+  else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
 	   &&
-	   TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_BOOL)
+	   TYPE_CODE (type2) == TYPE_CODE_BOOL)
       {
 	  LONGEST v1, v2, v;
 	  v1 = value_as_long (arg1);
@@ -631,9 +685,9 @@ value_binop (arg1, arg2, op)
 	      error ("Invalid operation on booleans.");
 	    }
 	  
-	  val = allocate_value (builtin_type_chill_bool);
+	  val = allocate_value (type1);
 	  store_signed_integer (VALUE_CONTENTS_RAW (val),
-				TYPE_LENGTH (VALUE_TYPE (val)),
+				TYPE_LENGTH (type1),
 				v);
       }
   else
@@ -642,8 +696,6 @@ value_binop (arg1, arg2, op)
     /* FIXME: This implements ANSI C rules (also correct for C++).
        What about FORTRAN and chill?  */
     {
-      struct type *type1 = VALUE_TYPE (arg1);
-      struct type *type2 = VALUE_TYPE (arg2);
       int promoted_len1 = TYPE_LENGTH (type1);
       int promoted_len2 = TYPE_LENGTH (type2);
       int is_unsigned1 = TYPE_UNSIGNED (type1);
@@ -937,13 +989,15 @@ value_logical_not (arg1)
 {
   register int len;
   register char *p;
+  struct type *type1;
 
   COERCE_ARRAY (arg1);
+  type1 = check_typedef (VALUE_TYPE (arg1));
 
-  if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_FLT)
+  if (TYPE_CODE (type1) == TYPE_CODE_FLT)
     return 0 == value_as_double (arg1);
 
-  len = TYPE_LENGTH (VALUE_TYPE (arg1));
+  len = TYPE_LENGTH (type1);
   p = VALUE_CONTENTS (arg1);
 
   while (--len >= 0)
@@ -965,14 +1019,17 @@ value_equal (arg1, arg2)
 {
   register int len;
   register char *p1, *p2;
+  struct type *type1, *type2;
   enum type_code code1;
   enum type_code code2;
 
   COERCE_ARRAY (arg1);
   COERCE_ARRAY (arg2);
 
-  code1 = TYPE_CODE (VALUE_TYPE (arg1));
-  code2 = TYPE_CODE (VALUE_TYPE (arg2));
+  type1 = check_typedef (VALUE_TYPE (arg1));
+  type2 = check_typedef (VALUE_TYPE (arg2));
+  code1 = TYPE_CODE (type1);
+  code2 = TYPE_CODE (type2);
 
   if (code1 == TYPE_CODE_INT && code2 == TYPE_CODE_INT)
     return longest_to_int (value_as_long (value_binop (arg1, arg2,
@@ -989,8 +1046,8 @@ value_equal (arg1, arg2)
     return (CORE_ADDR) value_as_long (arg1) == value_as_pointer (arg2);
 
   else if (code1 == code2
-	   && ((len = TYPE_LENGTH (VALUE_TYPE (arg1)))
-	       == TYPE_LENGTH (VALUE_TYPE (arg2))))
+	   && ((len = TYPE_LENGTH (type1))
+	       == TYPE_LENGTH (type2)))
     {
       p1 = VALUE_CONTENTS (arg1);
       p2 = VALUE_CONTENTS (arg2);
@@ -1017,12 +1074,15 @@ value_less (arg1, arg2)
 {
   register enum type_code code1;
   register enum type_code code2;
+  struct type *type1, *type2;
 
   COERCE_ARRAY (arg1);
   COERCE_ARRAY (arg2);
 
-  code1 = TYPE_CODE (VALUE_TYPE (arg1));
-  code2 = TYPE_CODE (VALUE_TYPE (arg2));
+  type1 = check_typedef (VALUE_TYPE (arg1));
+  type2 = check_typedef (VALUE_TYPE (arg2));
+  code1 = TYPE_CODE (type1);
+  code2 = TYPE_CODE (type2);
 
   if (code1 == TYPE_CODE_INT && code2 == TYPE_CODE_INT)
     return longest_to_int (value_as_long (value_binop (arg1, arg2,
@@ -1057,7 +1117,7 @@ value_neg (arg1)
 
   COERCE_ENUM (arg1);
 
-  type = VALUE_TYPE (arg1);
+  type = check_typedef (VALUE_TYPE (arg1));
 
   if (TYPE_CODE (type) == TYPE_CODE_FLT)
     return value_from_double (type, - value_as_double (arg1));
@@ -1075,7 +1135,7 @@ value_complement (arg1)
 {
   COERCE_ENUM (arg1);
 
-  if (TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_INT)
+  if (TYPE_CODE (check_typedef (VALUE_TYPE (arg1))) != TYPE_CODE_INT)
     error ("Argument to complement operation not an integer.");
 
   return value_from_longest (VALUE_TYPE (arg1), ~ value_as_long (arg1));
@@ -1091,15 +1151,12 @@ value_bit_index (type, valaddr, index)
      char *valaddr;
      int index;
 {
-  struct type *range;
-  int low_bound, high_bound;
+  LONGEST low_bound, high_bound;
   LONGEST word;
   unsigned rel_index;
-  range = TYPE_FIELD_TYPE (type, 0);
-  if (TYPE_CODE (range) != TYPE_CODE_RANGE)
+  struct type *range = TYPE_FIELD_TYPE (type, 0);
+  if (get_discrete_bounds (range, &low_bound, &high_bound) < 0)
     return -2;
-  low_bound = TYPE_LOW_BOUND (range);
-  high_bound = TYPE_HIGH_BOUND (range);
   if (index < low_bound || index > high_bound)
     return -1;
   rel_index = index - low_bound;
@@ -1116,14 +1173,16 @@ value_in (element, set)
      value_ptr element, set;
 {
   int member;
-  if (TYPE_CODE (VALUE_TYPE (set)) != TYPE_CODE_SET)
+  struct type *settype = check_typedef (VALUE_TYPE (set));
+  struct type *eltype = check_typedef (VALUE_TYPE (element));
+  if (TYPE_CODE (settype) != TYPE_CODE_SET)
     error ("Second argument of 'IN' has wrong type");
-  if (TYPE_CODE (VALUE_TYPE (element)) != TYPE_CODE_INT
-      && TYPE_CODE (VALUE_TYPE (element)) != TYPE_CODE_CHAR
-      && TYPE_CODE (VALUE_TYPE (element)) != TYPE_CODE_ENUM
-      && TYPE_CODE (VALUE_TYPE (element)) != TYPE_CODE_BOOL)
+  if (TYPE_CODE (eltype) != TYPE_CODE_INT
+      && TYPE_CODE (eltype) != TYPE_CODE_CHAR
+      && TYPE_CODE (eltype) != TYPE_CODE_ENUM
+      && TYPE_CODE (eltype) != TYPE_CODE_BOOL)
     error ("First argument of 'IN' has wrong type");
-  member = value_bit_index (VALUE_TYPE (set), VALUE_CONTENTS (set),
+  member = value_bit_index (settype, VALUE_CONTENTS (set),
 			    value_as_long (element));
   if (member < 0)
     error ("First argument of 'IN' not in range");
diff --git a/gdb/valprint.c b/gdb/valprint.c
index 591978a..b734eb4 100644
--- a/gdb/valprint.c
+++ b/gdb/valprint.c
@@ -16,7 +16,7 @@ GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 #include "defs.h"
 #include "gdb_string.h"
@@ -135,6 +135,7 @@ val_print (type, valaddr, address, stream, format, deref_ref, recurse, pretty)
      int recurse;
      enum val_prettyprint pretty;
 {
+  struct type *real_type = check_typedef (type);
   if (pretty == Val_pretty_default)
     {
       pretty = prettyprint_structs ? Val_prettyprint : Val_no_prettyprint;
@@ -146,8 +147,8 @@ val_print (type, valaddr, address, stream, format, deref_ref, recurse, pretty)
      only a stub and we can't find and substitute its complete type, then
      print appropriate string and return.  */
 
-  check_stub_type (type);
-  if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
+  if (TYPE_FLAGS (real_type) & TYPE_FLAG_STUB
+      || TYPE_LENGTH (real_type) == 0)
     {
       fprintf_filtered (stream, "<incomplete type>");
       gdb_flush (stream);
@@ -576,7 +577,7 @@ val_print_array_elements (type, valaddr, address, stream, format, deref_ref,
   unsigned int reps;
       
   elttype = TYPE_TARGET_TYPE (type);
-  eltlen = TYPE_LENGTH (elttype);
+  eltlen = TYPE_LENGTH (check_typedef (elttype));
   len = TYPE_LENGTH (type) / eltlen;
 
   annotate_array_section_begin (i, elttype);
@@ -632,63 +633,6 @@ val_print_array_elements (type, valaddr, address, stream, format, deref_ref,
     }
 }
 
-void
-value_print_array_elements (val, stream, format, pretty)
-     value_ptr val;
-     GDB_FILE *stream;
-     int format;
-     enum val_prettyprint pretty;
-{
-  unsigned int things_printed = 0;
-  register unsigned int i, n, typelen;
-  /* Position of the array elem we are examining to see if it is repeated.  */
-  unsigned int rep1;
-  /* Number of repetitions we have detected so far.  */
-  unsigned int reps;
-    
-  n = VALUE_REPETITIONS (val);
-  typelen = TYPE_LENGTH (VALUE_TYPE (val));
-  for (i = 0; i < n && things_printed < print_max; i++)
-    {
-      if (i != 0)
-	{
-	  fprintf_filtered (stream, ", ");
-	}
-      wrap_here ("");
-      
-      rep1 = i + 1;
-      reps = 1;
-      while (rep1 < n && !memcmp (VALUE_CONTENTS (val) + typelen * i,
-				  VALUE_CONTENTS (val) + typelen * rep1,
-				  typelen))
-	{
-	  ++reps;
-	  ++rep1;
-	}
-      
-      if (reps > repeat_count_threshold)
-	{
-	  val_print (VALUE_TYPE (val), VALUE_CONTENTS (val) + typelen * i,
-		     VALUE_ADDRESS (val) + typelen * i, stream, format, 1,
-		     0, pretty);
-	  fprintf_filtered (stream, " <repeats %u times>", reps);
-	  i = rep1 - 1;
-	  things_printed += repeat_count_threshold;
-	}
-      else
-	{
-	  val_print (VALUE_TYPE (val), VALUE_CONTENTS (val) + typelen * i,
-		     VALUE_ADDRESS (val) + typelen * i, stream, format, 1,
-		     0, pretty);
-	  things_printed++;
-	}
-    }
-  if (i < n)
-    {
-      fprintf_filtered (stream, "...");
-    }
-}
-
 /*  Print a string from the inferior, starting at ADDR and printing up to LEN
     characters, to STREAM.  If LEN is zero, printing stops at the first null
     byte, otherwise printing proceeds (including null bytes) until either