X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Feval.c;h=df730057d80edc8b63f7b15366375dc35c83d5ae;hb=3b7538c0317072d430eca4e808b183dac5bd5e45;hp=0a727ef914c1a0f6b6f61b696205ef4f183efa7a;hpb=d69fe07ead0b14603cb37fd9659bffc11afa37b1;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/eval.c b/gdb/eval.c
index 0a727ef914..df730057d8 100644
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -1,14 +1,14 @@
 /* Evaluate expressions for GDB.
 
-   Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
-   1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005 Free
-   Software Foundation, Inc.
+   Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
+   1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006, 2007, 2008,
+   2009 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
@@ -17,9 +17,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., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
 #include "gdb_string.h"
@@ -36,14 +34,21 @@
 #include "objc-lang.h"
 #include "block.h"
 #include "parser-defs.h"
+#include "cp-support.h"
+#include "ui-out.h"
+#include "exceptions.h"
+#include "regcache.h"
+#include "user-regs.h"
+#include "valprint.h"
+#include "python/python.h"
+
+#include "gdb_assert.h"
+
+#include <ctype.h>
 
 /* This is defined in valops.c */
 extern int overload_resolution;
 
-/* JYG: lookup rtti type of STRUCTOP_PTR when this is set to continue
-   on with successful lookup for member/method of the rtti type. */
-extern int objectprint;
-
 /* Prototypes for local functions. */
 
 static struct value *evaluate_subexp_for_sizeof (struct expression *, int *);
@@ -171,6 +176,36 @@ evaluate_type (struct expression *exp)
   return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
 }
 
+/* Evaluate a subexpression, avoiding all memory references and
+   getting a value whose type alone is correct.  */
+
+struct value *
+evaluate_subexpression_type (struct expression *exp, int subexp)
+{
+  return evaluate_subexp (NULL_TYPE, exp, &subexp, EVAL_AVOID_SIDE_EFFECTS);
+}
+
+/* Extract a field operation from an expression.  If the subexpression
+   of EXP starting at *SUBEXP is not a structure dereference
+   operation, return NULL.  Otherwise, return the name of the
+   dereferenced field, and advance *SUBEXP to point to the
+   subexpression of the left-hand-side of the dereference.  This is
+   used when completing field names.  */
+
+char *
+extract_field_op (struct expression *exp, int *subexp)
+{
+  int tem;
+  char *result;
+  if (exp->elts[*subexp].opcode != STRUCTOP_STRUCT
+      && exp->elts[*subexp].opcode != STRUCTOP_PTR)
+    return NULL;
+  tem = longest_to_int (exp->elts[*subexp + 1].longconst);
+  result = &exp->elts[*subexp + 2].string;
+  (*subexp) += 1 + 3 + BYTES_TO_EXP_ELEM (tem + 1);
+  return result;
+}
+
 /* If the next expression is an OP_LABELED, skips past it,
    returning the label.  Otherwise, does nothing and returns NULL. */
 
@@ -209,7 +244,7 @@ evaluate_struct_tuple (struct value *struct_val,
       struct value *val = NULL;
       int nlabels = 0;
       int bitpos, bitsize;
-      char *addr;
+      bfd_byte *addr;
 
       /* Skip past the labels, and count them. */
       while (get_label (exp, pos) != NULL)
@@ -224,7 +259,7 @@ evaluate_struct_tuple (struct value *struct_val,
 		   fieldno++)
 		{
 		  char *field_name = TYPE_FIELD_NAME (struct_type, fieldno);
-		  if (field_name != NULL && DEPRECATED_STREQ (field_name, label))
+		  if (field_name != NULL && strcmp (field_name, label) == 0)
 		    {
 		      variantno = -1;
 		      subfieldno = fieldno;
@@ -252,9 +287,9 @@ evaluate_struct_tuple (struct value *struct_val,
 				 subfieldno < TYPE_NFIELDS (substruct_type);
 				   subfieldno++)
 				{
-				  if (DEPRECATED_STREQ (TYPE_FIELD_NAME (substruct_type,
+				  if (strcmp(TYPE_FIELD_NAME (substruct_type,
 							      subfieldno),
-					     label))
+					     label) == 0)
 				    {
 				      goto found;
 				    }
@@ -263,7 +298,7 @@ evaluate_struct_tuple (struct value *struct_val,
 			}
 		    }
 		}
-	      error ("there is no field named %s", label);
+	      error (_("there is no field named %s"), label);
 	    found:
 	      ;
 	    }
@@ -282,13 +317,18 @@ evaluate_struct_tuple (struct value *struct_val,
 	      if (variantno < 0)
 		{
 		  fieldno++;
+		  /* Skip static fields.  */
+		  while (fieldno < TYPE_NFIELDS (struct_type)
+			 && field_is_static (&TYPE_FIELD (struct_type,
+							  fieldno)))
+		    fieldno++;
 		  subfieldno = fieldno;
 		  if (fieldno >= TYPE_NFIELDS (struct_type))
-		    error ("too many initializers");
+		    error (_("too many initializers"));
 		  field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
 		  if (TYPE_CODE (field_type) == TYPE_CODE_UNION
 		      && TYPE_FIELD_NAME (struct_type, fieldno)[0] == '0')
-		    error ("don't know which variant you want to set");
+		    error (_("don't know which variant you want to set"));
 		}
 	    }
 
@@ -315,12 +355,12 @@ evaluate_struct_tuple (struct value *struct_val,
 	  bitpos = TYPE_FIELD_BITPOS (struct_type, fieldno);
 	  if (variantno >= 0)
 	    bitpos += TYPE_FIELD_BITPOS (substruct_type, subfieldno);
-	  addr = VALUE_CONTENTS (struct_val) + bitpos / 8;
+	  addr = value_contents_writeable (struct_val) + bitpos / 8;
 	  if (bitsize)
 	    modify_field (addr, value_as_long (val),
 			  bitpos % 8, bitsize);
 	  else
-	    memcpy (addr, VALUE_CONTENTS (val),
+	    memcpy (addr, value_contents (val),
 		    TYPE_LENGTH (value_type (val)));
 	}
       while (--nlabels > 0);
@@ -357,25 +397,263 @@ init_array_element (struct value *array, struct value *element,
       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");
+	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);
+		  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");
+	error (_("tuple index out of range"));
       memcpy (value_contents_raw (array) + (index - low_bound) * element_size,
-	      VALUE_CONTENTS (element), element_size);
+	      value_contents (element), element_size);
     }
   return index;
 }
 
+static struct value *
+value_f90_subarray (struct value *array,
+		    struct expression *exp, int *pos, enum noside noside)
+{
+  int pc = (*pos) + 1;
+  LONGEST low_bound, high_bound;
+  struct type *range = check_typedef (TYPE_INDEX_TYPE (value_type (array)));
+  enum f90_range_type range_type = longest_to_int (exp->elts[pc].longconst);
+ 
+  *pos += 3;
+
+  if (range_type == LOW_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)
+    low_bound = TYPE_LOW_BOUND (range);
+  else
+    low_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
+
+  if (range_type == HIGH_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)
+    high_bound = TYPE_HIGH_BOUND (range);
+  else
+    high_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
+
+  return value_slice (array, low_bound, high_bound - low_bound + 1);
+}
+
+
+/* Promote value ARG1 as appropriate before performing a unary operation
+   on this argument.
+   If the result is not appropriate for any particular language then it
+   needs to patch this function.  */
+
+void
+unop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
+	      struct value **arg1)
+{
+  struct type *type1;
+
+  *arg1 = coerce_ref (*arg1);
+  type1 = check_typedef (value_type (*arg1));
+
+  if (is_integral_type (type1))
+    {
+      switch (language->la_language)
+	{
+	default:
+	  /* Perform integral promotion for ANSI C/C++.
+	     If not appropropriate for any particular language
+	     it needs to modify this function.  */
+	  {
+	    struct type *builtin_int = builtin_type (gdbarch)->builtin_int;
+	    if (TYPE_LENGTH (type1) < TYPE_LENGTH (builtin_int))
+	      *arg1 = value_cast (builtin_int, *arg1);
+	  }
+	  break;
+	}
+    }
+}
+
+/* Promote values ARG1 and ARG2 as appropriate before performing a binary
+   operation on those two operands.
+   If the result is not appropriate for any particular language then it
+   needs to patch this function.  */
+
+void
+binop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
+	       struct value **arg1, struct value **arg2)
+{
+  struct type *promoted_type = NULL;
+  struct type *type1;
+  struct type *type2;
+
+  *arg1 = coerce_ref (*arg1);
+  *arg2 = coerce_ref (*arg2);
+
+  type1 = check_typedef (value_type (*arg1));
+  type2 = check_typedef (value_type (*arg2));
+
+  if ((TYPE_CODE (type1) != TYPE_CODE_FLT
+       && TYPE_CODE (type1) != TYPE_CODE_DECFLOAT
+       && !is_integral_type (type1))
+      || (TYPE_CODE (type2) != TYPE_CODE_FLT
+	  && TYPE_CODE (type2) != TYPE_CODE_DECFLOAT
+	  && !is_integral_type (type2)))
+    return;
+
+  if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
+      || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
+    {
+      /* No promotion required.  */
+    }
+  else if (TYPE_CODE (type1) == TYPE_CODE_FLT
+	   || TYPE_CODE (type2) == TYPE_CODE_FLT)
+    {
+      switch (language->la_language)
+	{
+	case language_c:
+	case language_cplus:
+	case language_asm:
+	case language_objc:
+	  /* No promotion required.  */
+	  break;
+
+	default:
+	  /* For other languages the result type is unchanged from gdb
+	     version 6.7 for backward compatibility.
+	     If either arg was long double, make sure that value is also long
+	     double.  Otherwise use double.  */
+	  if (TYPE_LENGTH (type1) * 8 > gdbarch_double_bit (gdbarch)
+	      || TYPE_LENGTH (type2) * 8 > gdbarch_double_bit (gdbarch))
+	    promoted_type = builtin_type (gdbarch)->builtin_long_double;
+	  else
+	    promoted_type = builtin_type (gdbarch)->builtin_double;
+	  break;
+	}
+    }
+  else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
+	   && TYPE_CODE (type2) == TYPE_CODE_BOOL)
+    {
+      /* No promotion required.  */
+    }
+  else
+    /* Integral operations here.  */
+    /* FIXME: Also mixed integral/booleans, with result an integer.  */
+    {
+      const struct builtin_type *builtin = builtin_type (gdbarch);
+      unsigned int promoted_len1 = TYPE_LENGTH (type1);
+      unsigned int promoted_len2 = TYPE_LENGTH (type2);
+      int is_unsigned1 = TYPE_UNSIGNED (type1);
+      int is_unsigned2 = TYPE_UNSIGNED (type2);
+      unsigned int result_len;
+      int unsigned_operation;
+
+      /* Determine type length and signedness after promotion for
+         both operands.  */
+      if (promoted_len1 < TYPE_LENGTH (builtin->builtin_int))
+	{
+	  is_unsigned1 = 0;
+	  promoted_len1 = TYPE_LENGTH (builtin->builtin_int);
+	}
+      if (promoted_len2 < TYPE_LENGTH (builtin->builtin_int))
+	{
+	  is_unsigned2 = 0;
+	  promoted_len2 = TYPE_LENGTH (builtin->builtin_int);
+	}
+
+      if (promoted_len1 > promoted_len2)
+	{
+	  unsigned_operation = is_unsigned1;
+	  result_len = promoted_len1;
+	}
+      else if (promoted_len2 > promoted_len1)
+	{
+	  unsigned_operation = is_unsigned2;
+	  result_len = promoted_len2;
+	}
+      else
+	{
+	  unsigned_operation = is_unsigned1 || is_unsigned2;
+	  result_len = promoted_len1;
+	}
+
+      switch (language->la_language)
+	{
+	case language_c:
+	case language_cplus:
+	case language_asm:
+	case language_objc:
+	  if (result_len <= TYPE_LENGTH (builtin->builtin_int))
+	    {
+	      promoted_type = (unsigned_operation
+			       ? builtin->builtin_unsigned_int
+			       : builtin->builtin_int);
+	    }
+	  else if (result_len <= TYPE_LENGTH (builtin->builtin_long))
+	    {
+	      promoted_type = (unsigned_operation
+			       ? builtin->builtin_unsigned_long
+			       : builtin->builtin_long);
+	    }
+	  else
+	    {
+	      promoted_type = (unsigned_operation
+			       ? builtin->builtin_unsigned_long_long
+			       : builtin->builtin_long_long);
+	    }
+	  break;
+
+	default:
+	  /* For other languages the result type is unchanged from gdb
+	     version 6.7 for backward compatibility.
+	     If either arg was long long, make sure that value is also long
+	     long.  Otherwise use long.  */
+	  if (unsigned_operation)
+	    {
+	      if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT)
+		promoted_type = builtin->builtin_unsigned_long_long;
+	      else
+		promoted_type = builtin->builtin_unsigned_long;
+	    }
+	  else
+	    {
+	      if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT)
+		promoted_type = builtin->builtin_long_long;
+	      else
+		promoted_type = builtin->builtin_long;
+	    }
+	  break;
+	}
+    }
+
+  if (promoted_type)
+    {
+      /* Promote both operands to common type.  */
+      *arg1 = value_cast (promoted_type, *arg1);
+      *arg2 = value_cast (promoted_type, *arg2);
+    }
+}
+
+static int
+ptrmath_type_p (struct type *type)
+{
+  type = check_typedef (type);
+  if (TYPE_CODE (type) == TYPE_CODE_REF)
+    type = TYPE_TARGET_TYPE (type);
+
+  switch (TYPE_CODE (type))
+    {
+    case TYPE_CODE_PTR:
+    case TYPE_CODE_FUNC:
+      return 1;
+
+    case TYPE_CODE_ARRAY:
+      return current_language->c_style_arrays;
+
+    default:
+      return 0;
+    }
+}
+
 struct value *
 evaluate_subexp_standard (struct type *expect_type,
 			  struct expression *exp, int *pos,
@@ -405,11 +683,13 @@ evaluate_subexp_standard (struct type *expect_type,
     case OP_SCOPE:
       tem = longest_to_int (exp->elts[pc + 2].longconst);
       (*pos) += 4 + BYTES_TO_EXP_ELEM (tem + 1);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
       arg1 = value_aggregate_elt (exp->elts[pc + 1].type,
 				  &exp->elts[pc + 3].string,
-				  noside);
+				  0, noside);
       if (arg1 == NULL)
-	error ("There is no field named %s", &exp->elts[pc + 3].string);
+	error (_("There is no field named %s"), &exp->elts[pc + 3].string);
       return arg1;
 
     case OP_LONG:
@@ -422,6 +702,11 @@ evaluate_subexp_standard (struct type *expect_type,
       return value_from_double (exp->elts[pc + 1].type,
 				exp->elts[pc + 2].doubleconst);
 
+    case OP_DECFLOAT:
+      (*pos) += 3;
+      return value_from_decfloat (exp->elts[pc + 1].type,
+				  exp->elts[pc + 2].decfloatconst);
+
     case OP_VAR_VALUE:
       (*pos) += 3;
       if (noside == EVAL_SKIP)
@@ -436,8 +721,26 @@ evaluate_subexp_standard (struct type *expect_type,
 	 value_rtti_target_type () if we are dealing with a pointer
 	 or reference to a base class and print object is on. */
 
-	return value_of_variable (exp->elts[pc + 2].symbol,
-				  exp->elts[pc + 1].block);
+      {
+	volatile struct gdb_exception except;
+	struct value *ret = NULL;
+
+	TRY_CATCH (except, RETURN_MASK_ERROR)
+	  {
+	    ret = value_of_variable (exp->elts[pc + 2].symbol,
+				     exp->elts[pc + 1].block);
+	  }
+
+	if (except.reason < 0)
+	  {
+	    if (noside == EVAL_AVOID_SIDE_EFFECTS)
+	      ret = value_zero (SYMBOL_TYPE (exp->elts[pc + 2].symbol), not_lval);
+	    else
+	      throw_exception (except);
+	  }
+
+	return ret;
+      }
 
     case OP_LAST:
       (*pos) += 2;
@@ -446,19 +749,36 @@ evaluate_subexp_standard (struct type *expect_type,
 
     case OP_REGISTER:
       {
-	int regno = longest_to_int (exp->elts[pc + 1].longconst);
-	struct value *val = value_of_register (regno, get_selected_frame (NULL));
-	(*pos) += 2;
+	const char *name = &exp->elts[pc + 2].string;
+	int regno;
+	struct value *val;
+
+	(*pos) += 3 + BYTES_TO_EXP_ELEM (exp->elts[pc + 1].longconst + 1);
+	regno = user_reg_map_name_to_regnum (exp->gdbarch,
+					     name, strlen (name));
+	if (regno == -1)
+	  error (_("Register $%s not available."), name);
+
+        /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
+           a value with the appropriate register type.  Unfortunately,
+           we don't have easy access to the type of user registers.
+           So for these registers, we fetch the register value regardless
+           of the evaluation mode.  */
+	if (noside == EVAL_AVOID_SIDE_EFFECTS
+	    && regno < gdbarch_num_regs (exp->gdbarch)
+			+ gdbarch_num_pseudo_regs (exp->gdbarch))
+	  val = value_zero (register_type (exp->gdbarch, regno), not_lval);
+	else
+	  val = value_of_register (regno, get_selected_frame (NULL));
 	if (val == NULL)
-	  error ("Value of register %s not available.",
-		 frame_map_regnum_to_name (get_selected_frame (NULL), regno));
+	  error (_("Value of register %s not available."), name);
 	else
 	  return val;
       }
     case OP_BOOL:
       (*pos) += 2;
-      return value_from_longest (LA_BOOL_TYPE,
-				 exp->elts[pc + 1].longconst);
+      type = language_bool_type (exp->language_defn, exp->gdbarch);
+      return value_from_longest (type, exp->elts[pc + 1].longconst);
 
     case OP_INTERNALVAR:
       (*pos) += 2;
@@ -469,7 +789,8 @@ evaluate_subexp_standard (struct type *expect_type,
       (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
       if (noside == EVAL_SKIP)
 	goto nosideret;
-      return value_string (&exp->elts[pc + 2].string, tem);
+      type = language_string_char_type (exp->language_defn, exp->gdbarch);
+      return value_string (&exp->elts[pc + 2].string, tem, type);
 
     case OP_OBJC_NSSTRING:		/* Objective C Foundation Class NSString constant.  */
       tem = longest_to_int (exp->elts[pc + 1].longconst);
@@ -478,7 +799,7 @@ evaluate_subexp_standard (struct type *expect_type,
 	{
 	  goto nosideret;
 	}
-      return (struct value *) value_nsstring (&exp->elts[pc + 2].string, tem + 1);
+      return value_nsstring (exp->gdbarch, &exp->elts[pc + 2].string, tem + 1);
 
     case OP_BITSTRING:
       tem = longest_to_int (exp->elts[pc + 1].longconst);
@@ -507,7 +828,7 @@ evaluate_subexp_standard (struct type *expect_type,
       if (expect_type != NULL_TYPE && noside != EVAL_SKIP
 	  && TYPE_CODE (type) == TYPE_CODE_ARRAY)
 	{
-	  struct type *range_type = TYPE_FIELD_TYPE (type, 0);
+	  struct type *range_type = TYPE_INDEX_TYPE (type);
 	  struct type *element_type = TYPE_TARGET_TYPE (type);
 	  struct value *array = allocate_value (expect_type);
 	  int element_size = TYPE_LENGTH (check_typedef (element_type));
@@ -543,10 +864,10 @@ evaluate_subexp_standard (struct type *expect_type,
 		{
 		  if (index > high_bound)
 		    /* to avoid memory corruption */
-		    error ("Too many array elements");
+		    error (_("Too many array elements"));
 		  memcpy (value_contents_raw (array)
 			  + (index - low_bound) * element_size,
-			  VALUE_CONTENTS (element),
+			  value_contents (element),
 			  element_size);
 		}
 	      index++;
@@ -558,7 +879,7 @@ evaluate_subexp_standard (struct type *expect_type,
 	  && TYPE_CODE (type) == TYPE_CODE_SET)
 	{
 	  struct value *set = allocate_value (expect_type);
-	  char *valaddr = value_contents_raw (set);
+	  gdb_byte *valaddr = value_contents_raw (set);
 	  struct type *element_type = TYPE_INDEX_TYPE (type);
 	  struct type *check_type = element_type;
 	  LONGEST low_bound, high_bound;
@@ -569,7 +890,7 @@ evaluate_subexp_standard (struct type *expect_type,
 	    check_type = TYPE_TARGET_TYPE (check_type);
 
 	  if (get_discrete_bounds (element_type, &low_bound, &high_bound) < 0)
-	    error ("(power)set type with unknown size");
+	    error (_("(power)set type with unknown size"));
 	  memset (valaddr, '\0', TYPE_LENGTH (type));
 	  for (tem = 0; tem < nargs; tem++)
 	    {
@@ -603,24 +924,24 @@ evaluate_subexp_standard (struct type *expect_type,
 		  (TYPE_CODE (range_low_type) == TYPE_CODE_ENUM &&
 		   (range_low_type != range_high_type)))
 		/* different element modes */
-		error ("POWERSET tuple elements of different mode");
+		error (_("POWERSET tuple elements of different mode"));
 	      if ((TYPE_CODE (check_type) != TYPE_CODE (range_low_type)) ||
 		  (TYPE_CODE (check_type) == TYPE_CODE_ENUM &&
 		   range_low_type != check_type))
-		error ("incompatible POWERSET tuple elements");
+		error (_("incompatible POWERSET tuple elements"));
 	      if (range_low > range_high)
 		{
-		  warning ("empty POWERSET tuple range");
+		  warning (_("empty POWERSET tuple range"));
 		  continue;
 		}
 	      if (range_low < low_bound || range_high > high_bound)
-		error ("POWERSET tuple element out of range");
+		error (_("POWERSET tuple element out of range"));
 	      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)
+		  if (gdbarch_bits_big_endian (current_gdbarch))
 		    bit_index = TARGET_CHAR_BIT - 1 - bit_index;
 		  valaddr[(unsigned) range_low / TARGET_CHAR_BIT]
 		    |= 1 << bit_index;
@@ -680,6 +1001,7 @@ evaluate_subexp_standard (struct type *expect_type,
       {				/* Objective C @selector operator.  */
 	char *sel = &exp->elts[pc + 2].string;
 	int len = longest_to_int (exp->elts[pc + 1].longconst);
+	struct type *selector_type;
 
 	(*pos) += 3 + BYTES_TO_EXP_ELEM (len + 1);
 	if (noside == EVAL_SKIP)
@@ -687,31 +1009,33 @@ evaluate_subexp_standard (struct type *expect_type,
 
 	if (sel[len] != 0)
 	  sel[len] = 0;		/* Make sure it's terminated.  */
-	return value_from_longest (lookup_pointer_type (builtin_type_void),
-				   lookup_child_selector (sel));
+
+	selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
+	return value_from_longest (selector_type,
+				   lookup_child_selector (exp->gdbarch, sel));
       }
 
     case OP_OBJC_MSGCALL:
       {				/* Objective C message (method) call.  */
 
-	static CORE_ADDR responds_selector = 0;
-	static CORE_ADDR method_selector = 0;
+	CORE_ADDR responds_selector = 0;
+	CORE_ADDR method_selector = 0;
 
 	CORE_ADDR selector = 0;
 
-	int using_gcc = 0;
 	int struct_return = 0;
 	int sub_no_side = 0;
 
-	static struct value *msg_send = NULL;
-	static struct value *msg_send_stret = NULL;
-	static int gnu_runtime = 0;
+	struct value *msg_send = NULL;
+	struct value *msg_send_stret = NULL;
+	int gnu_runtime = 0;
 
 	struct value *target = NULL;
 	struct value *method = NULL;
 	struct value *called_method = NULL; 
 
 	struct type *selector_type = NULL;
+	struct type *long_type;
 
 	struct value *ret = NULL;
 	CORE_ADDR addr = 0;
@@ -723,7 +1047,9 @@ evaluate_subexp_standard (struct type *expect_type,
 
 	(*pos) += 3;
 
-	selector_type = lookup_pointer_type (builtin_type_void);
+	long_type = builtin_type (exp->gdbarch)->builtin_long;
+	selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
+
 	if (noside == EVAL_AVOID_SIDE_EFFECTS)
 	  sub_no_side = EVAL_NORMAL;
 	else
@@ -732,7 +1058,7 @@ evaluate_subexp_standard (struct type *expect_type,
 	target = evaluate_subexp (selector_type, exp, pos, sub_no_side);
 
 	if (value_as_long (target) == 0)
- 	  return value_from_longest (builtin_type_long, 0);
+ 	  return value_from_longest (long_type, 0);
 	
 	if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0))
 	  gnu_runtime = 1;
@@ -747,15 +1073,15 @@ evaluate_subexp_standard (struct type *expect_type,
 	   only).  */
 	if (gnu_runtime)
 	  {
-	    struct type *type;
-	    type = lookup_pointer_type (builtin_type_void);
+	    struct type *type = selector_type;
 	    type = lookup_function_type (type);
 	    type = lookup_pointer_type (type);
 	    type = lookup_function_type (type);
 	    type = lookup_pointer_type (type);
 
-	    msg_send = find_function_in_inferior ("objc_msg_lookup");
-	    msg_send_stret = find_function_in_inferior ("objc_msg_lookup");
+	    msg_send = find_function_in_inferior ("objc_msg_lookup", NULL);
+	    msg_send_stret
+	      = find_function_in_inferior ("objc_msg_lookup", NULL);
 
 	    msg_send = value_from_pointer (type, value_as_address (msg_send));
 	    msg_send_stret = value_from_pointer (type, 
@@ -763,9 +1089,10 @@ evaluate_subexp_standard (struct type *expect_type,
 	  }
 	else
 	  {
-	    msg_send = find_function_in_inferior ("objc_msgSend");
+	    msg_send = find_function_in_inferior ("objc_msgSend", NULL);
 	    /* Special dispatcher for methods returning structs */
-	    msg_send_stret = find_function_in_inferior ("objc_msgSend_stret");
+	    msg_send_stret
+	      = find_function_in_inferior ("objc_msgSend_stret", NULL);
 	  }
 
 	/* Verify the target object responds to this method. The
@@ -773,27 +1100,31 @@ evaluate_subexp_standard (struct type *expect_type,
 	   the verification method than the non-standard, but more
 	   often used, 'NSObject' class. Make sure we check for both. */
 
-	responds_selector = lookup_child_selector ("respondsToSelector:");
+	responds_selector
+	  = lookup_child_selector (exp->gdbarch, "respondsToSelector:");
 	if (responds_selector == 0)
-	  responds_selector = lookup_child_selector ("respondsTo:");
+	  responds_selector
+	    = lookup_child_selector (exp->gdbarch, "respondsTo:");
 	
 	if (responds_selector == 0)
-	  error ("no 'respondsTo:' or 'respondsToSelector:' method");
+	  error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
 	
-	method_selector = lookup_child_selector ("methodForSelector:");
+	method_selector
+	  = lookup_child_selector (exp->gdbarch, "methodForSelector:");
 	if (method_selector == 0)
-	  method_selector = lookup_child_selector ("methodFor:");
+	  method_selector
+	    = lookup_child_selector (exp->gdbarch, "methodFor:");
 	
 	if (method_selector == 0)
-	  error ("no 'methodFor:' or 'methodForSelector:' method");
+	  error (_("no 'methodFor:' or 'methodForSelector:' method"));
 
 	/* Call the verification method, to make sure that the target
 	 class implements the desired method. */
 
 	argvec[0] = msg_send;
 	argvec[1] = target;
-	argvec[2] = value_from_longest (builtin_type_long, responds_selector);
-	argvec[3] = value_from_longest (builtin_type_long, selector);
+	argvec[2] = value_from_longest (long_type, responds_selector);
+	argvec[3] = value_from_longest (long_type, selector);
 	argvec[4] = 0;
 
 	ret = call_function_by_hand (argvec[0], 3, argvec + 1);
@@ -804,7 +1135,7 @@ evaluate_subexp_standard (struct type *expect_type,
 	    ret = call_function_by_hand (argvec[0], 3, argvec + 1);
 	  }
 	if (value_as_long (ret) == 0)
-	  error ("Target does not respond to this message selector.");
+	  error (_("Target does not respond to this message selector."));
 
 	/* Call "methodForSelector:" method, to get the address of a
 	   function method that implements this selector for this
@@ -814,8 +1145,8 @@ evaluate_subexp_standard (struct type *expect_type,
 
 	argvec[0] = msg_send;
 	argvec[1] = target;
-	argvec[2] = value_from_longest (builtin_type_long, method_selector);
-	argvec[3] = value_from_longest (builtin_type_long, selector);
+	argvec[2] = value_from_longest (long_type, method_selector);
+	argvec[3] = value_from_longest (long_type, selector);
 	argvec[4] = 0;
 
 	ret = call_function_by_hand (argvec[0], 3, argvec + 1);
@@ -845,29 +1176,28 @@ evaluate_subexp_standard (struct type *expect_type,
 	  {
 	    struct block *b;
 	    CORE_ADDR funaddr;
-	    struct type *value_type;
+	    struct type *val_type;
 
-	    funaddr = find_function_addr (method, &value_type);
+	    funaddr = find_function_addr (method, &val_type);
 
 	    b = block_for_pc (funaddr);
 
-	    /* If compiled without -g, assume GCC 2.  */
-	    using_gcc = (b == NULL ? 2 : BLOCK_GCC_COMPILED (b));
-
-	    CHECK_TYPEDEF (value_type);
+	    CHECK_TYPEDEF (val_type);
 	  
-	    if ((value_type == NULL) 
-		|| (TYPE_CODE(value_type) == TYPE_CODE_ERROR))
+	    if ((val_type == NULL) 
+		|| (TYPE_CODE(val_type) == TYPE_CODE_ERROR))
 	      {
 		if (expect_type != NULL)
-		  value_type = expect_type;
+		  val_type = expect_type;
 	      }
 
-	    struct_return = using_struct_return (value_type, using_gcc);
+	    struct_return = using_struct_return (exp->gdbarch,
+						 value_type (method), val_type);
 	  }
 	else if (expect_type != NULL)
 	  {
-	    struct_return = using_struct_return (check_typedef (expect_type), using_gcc);
+	    struct_return = using_struct_return (exp->gdbarch, NULL,
+						 check_typedef (expect_type));
 	  }
 	
 	/* Found a function symbol.  Now we will substitute its
@@ -886,11 +1216,11 @@ evaluate_subexp_standard (struct type *expect_type,
 	if (method)
 	  {
 	    if (TYPE_CODE (value_type (method)) != TYPE_CODE_FUNC)
-	      error ("method address has symbol information with non-function type; skipping");
+	      error (_("method address has symbol information with non-function type; skipping"));
 	    if (struct_return)
-	      VALUE_ADDRESS (method) = value_as_address (msg_send_stret);
+	      set_value_address (method, value_as_address (msg_send_stret));
 	    else
-	      VALUE_ADDRESS (method) = value_as_address (msg_send);
+	      set_value_address (method, value_as_address (msg_send));
 	    called_method = method;
 	  }
 	else
@@ -927,7 +1257,7 @@ evaluate_subexp_standard (struct type *expect_type,
 		return allocate_value (type);
 	    }
 	    else
-	      error ("Expression of type other than \"method returning ...\" used as a method");
+	      error (_("Expression of type other than \"method returning ...\" used as a method"));
 	  }
 
 	/* Now depending on whether we found a symbol for the method,
@@ -936,7 +1266,7 @@ evaluate_subexp_standard (struct type *expect_type,
 
 	argvec[0] = called_method;
 	argvec[1] = target;
-	argvec[2] = value_from_longest (builtin_type_long, selector);
+	argvec[2] = value_from_longest (long_type, selector);
 	/* User-supplied arguments.  */
 	for (tem = 0; tem < nargs; tem++)
 	  argvec[tem + 3] = evaluate_subexp_with_coercion (exp, pos, noside);
@@ -945,8 +1275,8 @@ evaluate_subexp_standard (struct type *expect_type,
 	if (gnu_runtime && (method != NULL))
 	  {
 	    /* Function objc_msg_lookup returns a pointer.  */
-	    argvec[0]->type
-	      = lookup_function_type (lookup_pointer_type (value_type (argvec[0])));
+	    deprecated_set_value_type (argvec[0],
+				       lookup_function_type (lookup_pointer_type (value_type (argvec[0]))));
 	    argvec[0] = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);
 	  }
 
@@ -964,16 +1294,6 @@ evaluate_subexp_standard (struct type *expect_type,
       argvec = (struct value **) alloca (sizeof (struct value *) * (nargs + 3));
       if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
 	{
-	  LONGEST fnptr;
-
-	  /* 1997-08-01 Currently we do not support function invocation
-	     via pointers-to-methods with HP aCC. Pointer does not point
-	     to the function, but possibly to some thunk. */
-	  if (deprecated_hp_som_som_object_present)
-	    {
-	      error ("Not implemented: function invocation through pointer to method with HP aCC");
-	    }
-
 	  nargs++;
 	  /* First, evaluate the structure into arg2 */
 	  pc2 = (*pos)++;
@@ -998,41 +1318,18 @@ evaluate_subexp_standard (struct type *expect_type,
 
 	  arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
 
-	  fnptr = value_as_long (arg1);
+	  if (TYPE_CODE (check_typedef (value_type (arg1)))
+	      != TYPE_CODE_METHODPTR)
+	    error (_("Non-pointer-to-member value used in pointer-to-member "
+		     "construct"));
 
-	  if (METHOD_PTR_IS_VIRTUAL (fnptr))
+	  if (noside == EVAL_AVOID_SIDE_EFFECTS)
 	    {
-	      int fnoffset = METHOD_PTR_TO_VOFFSET (fnptr);
-	      struct type *basetype;
-	      struct type *domain_type =
-	      TYPE_DOMAIN_TYPE (TYPE_TARGET_TYPE (value_type (arg1)));
-	      int i, j;
-	      basetype = TYPE_TARGET_TYPE (value_type (arg2));
-	      if (domain_type != basetype)
-		arg2 = value_cast (lookup_pointer_type (domain_type), arg2);
-	      basetype = TYPE_VPTR_BASETYPE (domain_type);
-	      for (i = TYPE_NFN_FIELDS (basetype) - 1; i >= 0; i--)
-		{
-		  struct fn_field *f = TYPE_FN_FIELDLIST1 (basetype, i);
-		  /* If one is virtual, then all are virtual.  */
-		  if (TYPE_FN_FIELD_VIRTUAL_P (f, 0))
-		    for (j = TYPE_FN_FIELDLIST_LENGTH (basetype, i) - 1; j >= 0; --j)
-		      if ((int) TYPE_FN_FIELD_VOFFSET (f, j) == fnoffset)
-			{
-			  struct value *temp = value_ind (arg2);
-			  arg1 = value_virtual_fn_field (&temp, f, j, domain_type, 0);
-			  arg2 = value_addr (temp);
-			  goto got_it;
-			}
-		}
-	      if (i < 0)
-		error ("virtual function at index %d not found", fnoffset);
+	      struct type *method_type = check_typedef (value_type (arg1));
+	      arg1 = value_zero (method_type, not_lval);
 	    }
 	  else
-	    {
-	      arg1->type = lookup_pointer_type (TYPE_TARGET_TYPE (value_type (arg1)));
-	    }
-	got_it:
+	    arg1 = cplus_method_ptr_to_value (&arg2, arg1);
 
 	  /* Now, say which argument to start evaluating from */
 	  tem = 2;
@@ -1147,8 +1444,8 @@ evaluate_subexp_standard (struct type *expect_type,
 	 	 of the ``this'' pointer if necessary, so modify argvec[1] to
 		 reflect any ``this'' changes.  */
 	      arg2 = value_from_longest (lookup_pointer_type(value_type (temp)),
-					 VALUE_ADDRESS (temp) + value_offset (temp)
-					 + VALUE_EMBEDDED_OFFSET (temp));
+					 value_address (temp)
+					 + value_embedded_offset (temp));
 	      argvec[1] = arg2;	/* the ``this'' pointer */
 	    }
 
@@ -1207,7 +1504,7 @@ evaluate_subexp_standard (struct type *expect_type,
       if (noside == EVAL_SKIP)
 	goto nosideret;
       if (argvec[0] == NULL)
-	error ("Cannot evaluate function -- may be inlined");
+	error (_("Cannot evaluate function -- may be inlined"));
       if (noside == EVAL_AVOID_SIDE_EFFECTS)
 	{
 	  /* If the return type doesn't look like a function type, call an
@@ -1223,8 +1520,11 @@ evaluate_subexp_standard (struct type *expect_type,
 	  if (ftype)
 	    return allocate_value (TYPE_TARGET_TYPE (value_type (argvec[0])));
 	  else
-	    error ("Expression of type other than \"Function returning ...\" used as function");
+	    error (_("Expression of type other than \"Function returning ...\" used as function"));
 	}
+      if (TYPE_CODE (value_type (argvec[0])) == TYPE_CODE_INTERNAL_FUNCTION)
+	return call_internal_function (argvec[0], nargs, argvec + 1);
+
       return call_function_by_hand (argvec[0], nargs, argvec + 1);
       /* pai: FIXME save value from call_function_by_hand, then adjust pc by adjust_fn_pc if +ve  */
 
@@ -1245,13 +1545,40 @@ evaluate_subexp_standard (struct type *expect_type,
       type = check_typedef (value_type (arg1));
       code = TYPE_CODE (type);
 
+      if (code == TYPE_CODE_PTR)
+	{
+	  /* Fortran always passes variable to subroutines as pointer.
+	     So we need to look into its target type to see if it is
+	     array, string or function.  If it is, we need to switch
+	     to the target value the original one points to.  */ 
+	  struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
+
+	  if (TYPE_CODE (target_type) == TYPE_CODE_ARRAY
+	      || TYPE_CODE (target_type) == TYPE_CODE_STRING
+	      || TYPE_CODE (target_type) == TYPE_CODE_FUNC)
+	    {
+	      arg1 = value_ind (arg1);
+	      type = check_typedef (value_type (arg1));
+	      code = TYPE_CODE (type);
+	    }
+	} 
+
       switch (code)
 	{
 	case TYPE_CODE_ARRAY:
-	  goto multi_f77_subscript;
+	  if (exp->elts[*pos].opcode == OP_F90_RANGE)
+	    return value_f90_subarray (arg1, exp, pos, noside);
+	  else
+	    goto multi_f77_subscript;
 
 	case TYPE_CODE_STRING:
-	  goto op_f77_substr;
+	  if (exp->elts[*pos].opcode == OP_F90_RANGE)
+	    return value_f90_subarray (arg1, exp, pos, noside);
+	  else
+	    {
+	      arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
+	      return value_subscript (arg1, arg2);
+	    }
 
 	case TYPE_CODE_PTR:
 	case TYPE_CODE_FUNC:
@@ -1267,37 +1594,17 @@ evaluate_subexp_standard (struct type *expect_type,
 	  goto do_call_it;
 
 	default:
-	  error ("Cannot perform substring on this type");
+	  error (_("Cannot perform substring on this type"));
 	}
 
-    op_f77_substr:
-      /* We have a substring operation on our hands here, 
-         let us get the string we will be dealing with */
-
-      /* Now evaluate the 'from' and 'to' */
-
-      arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
-
-      if (nargs < 2)
-	return value_subscript (arg1, arg2);
-
-      arg3 = evaluate_subexp_with_coercion (exp, pos, noside);
-
-      if (noside == EVAL_SKIP)
-	goto nosideret;
-
-      tem2 = value_as_long (arg2);
-      tem3 = value_as_long (arg3);
-
-      return value_slice (arg1, tem2, tem3 - tem2 + 1);
-
     case OP_COMPLEX:
       /* We have a complex number, There should be 2 floating 
          point numbers that compose it */
+      (*pos) += 2;
       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
 
-      return value_literal_complex (arg1, arg2, builtin_type_f_complex_s16);
+      return value_literal_complex (arg1, arg2, exp->elts[pc + 1].type);
 
     case STRUCTOP_STRUCT:
       tem = longest_to_int (exp->elts[pc + 1].longconst);
@@ -1331,8 +1638,10 @@ evaluate_subexp_standard (struct type *expect_type,
         struct type *type = value_type (arg1);
         struct type *real_type;
         int full, top, using_enc;
-        
-        if (objectprint && TYPE_TARGET_TYPE(type) &&
+	struct value_print_options opts;
+
+	get_user_print_options (&opts);
+        if (opts.objectprint && TYPE_TARGET_TYPE(type) &&
             (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
           {
             real_type = value_rtti_target_type (arg1, &full, &top, &using_enc);
@@ -1361,57 +1670,44 @@ evaluate_subexp_standard (struct type *expect_type,
 	}
 
     case STRUCTOP_MEMBER:
-      arg1 = evaluate_subexp_for_address (exp, pos, noside);
+    case STRUCTOP_MPTR:
+      if (op == STRUCTOP_MEMBER)
+	arg1 = evaluate_subexp_for_address (exp, pos, noside);
+      else
+	arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+
       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
 
-      /* With HP aCC, pointers to methods do not point to the function code */
-      if (deprecated_hp_som_som_object_present &&
-	  (TYPE_CODE (value_type (arg2)) == TYPE_CODE_PTR) &&
-      (TYPE_CODE (TYPE_TARGET_TYPE (value_type (arg2))) == TYPE_CODE_METHOD))
-	error ("Pointers to methods not supported with HP aCC");	/* 1997-08-19 */
+      if (noside == EVAL_SKIP)
+	goto nosideret;
 
-      mem_offset = value_as_long (arg2);
-      goto handle_pointer_to_member;
+      type = check_typedef (value_type (arg2));
+      switch (TYPE_CODE (type))
+	{
+	case TYPE_CODE_METHODPTR:
+	  if (noside == EVAL_AVOID_SIDE_EFFECTS)
+	    return value_zero (TYPE_TARGET_TYPE (type), not_lval);
+	  else
+	    {
+	      arg2 = cplus_method_ptr_to_value (&arg1, arg2);
+	      gdb_assert (TYPE_CODE (value_type (arg2)) == TYPE_CODE_PTR);
+	      return value_ind (arg2);
+	    }
 
-    case STRUCTOP_MPTR:
-      arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
-      arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+	case TYPE_CODE_MEMBERPTR:
+	  /* Now, convert these values to an address.  */
+	  arg1 = value_cast (lookup_pointer_type (TYPE_DOMAIN_TYPE (type)),
+			     arg1);
 
-      /* With HP aCC, pointers to methods do not point to the function code */
-      if (deprecated_hp_som_som_object_present &&
-	  (TYPE_CODE (value_type (arg2)) == TYPE_CODE_PTR) &&
-      (TYPE_CODE (TYPE_TARGET_TYPE (value_type (arg2))) == TYPE_CODE_METHOD))
-	error ("Pointers to methods not supported with HP aCC");	/* 1997-08-19 */
+	  mem_offset = value_as_long (arg2);
 
-      mem_offset = value_as_long (arg2);
+	  arg3 = value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
+				     value_as_long (arg1) + mem_offset);
+	  return value_ind (arg3);
 
-    handle_pointer_to_member:
-      /* HP aCC generates offsets that have bit #29 set; turn it off to get
-         a real offset to the member. */
-      if (deprecated_hp_som_som_object_present)
-	{
-	  if (!mem_offset)	/* no bias -> really null */
-	    error ("Attempted dereference of null pointer-to-member");
-	  mem_offset &= ~0x20000000;
+	default:
+	  error (_("non-pointer-to-member value used in pointer-to-member construct"));
 	}
-      if (noside == EVAL_SKIP)
-	goto nosideret;
-      type = check_typedef (value_type (arg2));
-      if (TYPE_CODE (type) != TYPE_CODE_PTR)
-	goto bad_pointer_to_member;
-      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)
-	goto bad_pointer_to_member;
-      /* Now, convert these values to an address.  */
-      arg1 = value_cast (lookup_pointer_type (TYPE_DOMAIN_TYPE (type)),
-			 arg1);
-      arg3 = value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
-				 value_as_long (arg1) + mem_offset);
-      return value_ind (arg3);
-    bad_pointer_to_member:
-      error ("non-pointer-to-member value used in pointer-to-member construct");
 
     case BINOP_CONCAT:
       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
@@ -1427,26 +1723,6 @@ evaluate_subexp_standard (struct type *expect_type,
       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
       arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
 
-      /* Do special stuff for HP aCC pointers to members */
-      if (deprecated_hp_som_som_object_present)
-	{
-	  /* 1997-08-19 Can't assign HP aCC pointers to methods. No details of
-	     the implementation yet; but the pointer appears to point to a code
-	     sequence (thunk) in memory -- in any case it is *not* the address
-	     of the function as it would be in a naive implementation. */
-	  if ((TYPE_CODE (value_type (arg1)) == TYPE_CODE_PTR) &&
-	      (TYPE_CODE (TYPE_TARGET_TYPE (value_type (arg1))) == TYPE_CODE_METHOD))
-	    error ("Assignment to pointers to methods not implemented with HP aCC");
-
-	  /* HP aCC pointers to data members require a constant bias */
-	  if ((TYPE_CODE (value_type (arg1)) == TYPE_CODE_PTR) &&
-	      (TYPE_CODE (TYPE_TARGET_TYPE (value_type (arg1))) == TYPE_CODE_MEMBER))
-	    {
-	      unsigned int *ptr = (unsigned int *) VALUE_CONTENTS (arg2);	/* forces evaluation */
-	      *ptr |= 0x20000000;	/* set 29th bit */
-	    }
-	}
-
       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
 	return arg1;
       if (binop_user_defined_p (op, arg1, arg2))
@@ -1463,12 +1739,24 @@ evaluate_subexp_standard (struct type *expect_type,
       op = exp->elts[pc + 1].opcode;
       if (binop_user_defined_p (op, arg1, arg2))
 	return value_x_binop (arg1, arg2, BINOP_ASSIGN_MODIFY, op, noside);
-      else if (op == BINOP_ADD)
-	arg2 = value_add (arg1, arg2);
-      else if (op == BINOP_SUB)
-	arg2 = value_sub (arg1, arg2);
+      else if (op == BINOP_ADD && ptrmath_type_p (value_type (arg1)))
+	arg2 = value_ptradd (arg1, arg2);
+      else if (op == BINOP_SUB && ptrmath_type_p (value_type (arg1)))
+	arg2 = value_ptrsub (arg1, arg2);
       else
-	arg2 = value_binop (arg1, arg2, op);
+	{
+	  struct value *tmp = arg1;
+
+	  /* For shift and integer exponentiation operations,
+	     only promote the first argument.  */
+	  if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
+	      && is_integral_type (value_type (arg2)))
+	    unop_promote (exp->language_defn, exp->gdbarch, &tmp);
+	  else
+	    binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
+
+	  arg2 = value_binop (tmp, arg2, op);
+	}
       return value_assign (arg1, arg2);
 
     case BINOP_ADD:
@@ -1478,8 +1766,15 @@ evaluate_subexp_standard (struct type *expect_type,
 	goto nosideret;
       if (binop_user_defined_p (op, arg1, arg2))
 	return value_x_binop (arg1, arg2, op, OP_NULL, noside);
+      else if (ptrmath_type_p (value_type (arg1)))
+	return value_ptradd (arg1, arg2);
+      else if (ptrmath_type_p (value_type (arg2)))
+	return value_ptradd (arg2, arg1);
       else
-	return value_add (arg1, arg2);
+	{
+	  binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
+	  return value_binop (arg1, arg2, BINOP_ADD);
+	}
 
     case BINOP_SUB:
       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
@@ -1488,11 +1783,27 @@ evaluate_subexp_standard (struct type *expect_type,
 	goto nosideret;
       if (binop_user_defined_p (op, arg1, arg2))
 	return value_x_binop (arg1, arg2, op, OP_NULL, noside);
+      else if (ptrmath_type_p (value_type (arg1)))
+	{
+	  if (ptrmath_type_p (value_type (arg2)))
+	    {
+	      /* FIXME -- should be ptrdiff_t */
+	      type = builtin_type (exp->gdbarch)->builtin_long;
+	      return value_from_longest (type, value_ptrdiff (arg1, arg2));
+	    }
+	  else
+	    return value_ptrsub (arg1, arg2);
+	}
       else
-	return value_sub (arg1, arg2);
+	{
+	  binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
+	  return value_binop (arg1, arg2, BINOP_SUB);
+	}
 
+    case BINOP_EXP:
     case BINOP_MUL:
     case BINOP_DIV:
+    case BINOP_INTDIV:
     case BINOP_REM:
     case BINOP_MOD:
     case BINOP_LSH:
@@ -1506,18 +1817,48 @@ evaluate_subexp_standard (struct type *expect_type,
 	goto nosideret;
       if (binop_user_defined_p (op, arg1, arg2))
 	return value_x_binop (arg1, arg2, op, OP_NULL, noside);
-      else if (noside == EVAL_AVOID_SIDE_EFFECTS
-	       && (op == BINOP_DIV || op == BINOP_REM || op == BINOP_MOD))
-	return value_zero (value_type (arg1), not_lval);
       else
-	return value_binop (arg1, arg2, op);
+	{
+	  /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
+	     fudge arg2 to avoid division-by-zero, the caller is
+	     (theoretically) only looking for the type of the result.  */
+	  if (noside == EVAL_AVOID_SIDE_EFFECTS
+	      /* ??? Do we really want to test for BINOP_MOD here?
+		 The implementation of value_binop gives it a well-defined
+		 value.  */
+	      && (op == BINOP_DIV
+		  || op == BINOP_INTDIV
+		  || op == BINOP_REM
+		  || op == BINOP_MOD)
+	      && value_logical_not (arg2))
+	    {
+	      struct value *v_one, *retval;
+
+	      v_one = value_one (value_type (arg2), not_lval);
+	      binop_promote (exp->language_defn, exp->gdbarch, &arg1, &v_one);
+	      retval = value_binop (arg1, v_one, op);
+	      return retval;
+	    }
+	  else
+	    {
+	      /* For shift and integer exponentiation operations,
+		 only promote the first argument.  */
+	      if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
+		  && is_integral_type (value_type (arg2)))
+		unop_promote (exp->language_defn, exp->gdbarch, &arg1);
+	      else
+		binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
+
+	      return value_binop (arg1, arg2, op);
+	    }
+	}
 
     case BINOP_RANGE:
       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
       if (noside == EVAL_SKIP)
 	goto nosideret;
-      error ("':' operator used in invalid context");
+      error (_("':' operator used in invalid context"));
 
     case BINOP_SUBSCRIPT:
       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
@@ -1538,10 +1879,10 @@ evaluate_subexp_standard (struct type *expect_type,
 	      && TYPE_CODE (type) != TYPE_CODE_PTR)
 	    {
 	      if (TYPE_NAME (type))
-		error ("cannot subscript something of type `%s'",
+		error (_("cannot subscript something of type `%s'"),
 		       TYPE_NAME (type));
 	      else
-		error ("cannot subscript requested type");
+		error (_("cannot subscript requested type"));
 	    }
 
 	  if (noside == EVAL_AVOID_SIDE_EFFECTS)
@@ -1555,7 +1896,8 @@ evaluate_subexp_standard (struct type *expect_type,
       arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
       if (noside == EVAL_SKIP)
 	goto nosideret;
-      return value_in (arg1, arg2);
+      type = language_bool_type (exp->language_defn, exp->gdbarch);
+      return value_from_longest (type, (LONGEST) value_in (arg1, arg2));
 
     case MULTI_SUBSCRIPT:
       (*pos) += 2;
@@ -1592,7 +1934,7 @@ evaluate_subexp_standard (struct type *expect_type,
 		}
 	      else
 		{
-		  error ("cannot subscript something of type `%s'",
+		  error (_("cannot subscript something of type `%s'"),
 			 TYPE_NAME (value_type (arg1)));
 		}
 	    }
@@ -1603,7 +1945,29 @@ evaluate_subexp_standard (struct type *expect_type,
 	    }
 	  else
 	    {
-	      arg1 = value_subscript (arg1, arg2);
+	      arg1 = coerce_ref (arg1);
+	      type = check_typedef (value_type (arg1));
+
+	      switch (TYPE_CODE (type))
+		{
+		case TYPE_CODE_PTR:
+		case TYPE_CODE_ARRAY:
+		case TYPE_CODE_STRING:
+		  arg1 = value_subscript (arg1, arg2);
+		  break;
+
+		case TYPE_CODE_BITSTRING:
+		  type = language_bool_type (exp->language_defn, exp->gdbarch);
+		  arg1 = value_bitstring_subscript (type, arg1, arg2);
+		  break;
+
+		default:
+		  if (TYPE_NAME (type))
+		    error (_("cannot subscript something of type `%s'"),
+			   TYPE_NAME (type));
+		  else
+		    error (_("cannot subscript requested type"));
+		}
 	    }
 	}
       return (arg1);
@@ -1617,13 +1981,15 @@ evaluate_subexp_standard (struct type *expect_type,
 	int offset_item;	/* The array offset where the item lives */
 
 	if (nargs > MAX_FORTRAN_DIMS)
-	  error ("Too many subscripts for F77 (%d Max)", MAX_FORTRAN_DIMS);
+	  error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS);
 
 	tmp_type = check_typedef (value_type (arg1));
 	ndimensions = calc_f77_array_dims (type);
 
 	if (nargs != ndimensions)
-	  error ("Wrong number of subscripts");
+	  error (_("Wrong number of subscripts"));
+
+	gdb_assert (nargs > 0);
 
 	/* Now that we know we have a legal array subscript expression 
 	   let us actually find out where this element exists in the array. */
@@ -1643,13 +2009,8 @@ evaluate_subexp_standard (struct type *expect_type,
 	/* Internal type of array is arranged right to left */
 	for (i = 0; i < nargs; i++)
 	  {
-	    retcode = f77_get_dynamic_upperbound (tmp_type, &upper);
-	    if (retcode == BOUND_FETCH_ERROR)
-	      error ("Cannot obtain dynamic upper bound");
-
-	    retcode = f77_get_dynamic_lowerbound (tmp_type, &lower);
-	    if (retcode == BOUND_FETCH_ERROR)
-	      error ("Cannot obtain dynamic lower bound");
+	    upper = f77_get_upperbound (tmp_type);
+	    lower = f77_get_lowerbound (tmp_type);
 
 	    array_size_array[nargs - i - 1] = upper - lower + 1;
 
@@ -1679,7 +2040,7 @@ evaluate_subexp_standard (struct type *expect_type,
 
 	/* Construct a value node with the value of the offset */
 
-	arg2 = value_from_longest (builtin_type_f_integer, offset_item);
+	arg2 = value_from_longest (builtin_type_int32, offset_item);
 
 	/* Let us now play a dirty trick: we will take arg1 
 	   which is a value node pointing to the topmost level
@@ -1688,8 +2049,8 @@ evaluate_subexp_standard (struct type *expect_type,
 	   type, this will ensure that value_subscript()
 	   returns the correct type value */
 
-	arg1->type = tmp_type;
-	return value_ind (value_add (value_coerce_array (arg1), arg2));
+	deprecated_set_value_type (arg1, tmp_type);
+	return value_subscripted_rvalue (arg1, arg2, 0);
       }
 
     case BINOP_LOGICAL_AND:
@@ -1714,7 +2075,8 @@ evaluate_subexp_standard (struct type *expect_type,
 	  tem = value_logical_not (arg1);
 	  arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
 				  (tem ? EVAL_SKIP : noside));
-	  return value_from_longest (LA_BOOL_TYPE,
+	  type = language_bool_type (exp->language_defn, exp->gdbarch);
+	  return value_from_longest (type,
 			     (LONGEST) (!tem && !value_logical_not (arg2)));
 	}
 
@@ -1740,7 +2102,8 @@ evaluate_subexp_standard (struct type *expect_type,
 	  tem = value_logical_not (arg1);
 	  arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
 				  (!tem ? EVAL_SKIP : noside));
-	  return value_from_longest (LA_BOOL_TYPE,
+	  type = language_bool_type (exp->language_defn, exp->gdbarch);
+	  return value_from_longest (type,
 			     (LONGEST) (!tem || !value_logical_not (arg2)));
 	}
 
@@ -1755,8 +2118,10 @@ evaluate_subexp_standard (struct type *expect_type,
 	}
       else
 	{
+	  binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
 	  tem = value_equal (arg1, arg2);
-	  return value_from_longest (LA_BOOL_TYPE, (LONGEST) tem);
+	  type = language_bool_type (exp->language_defn, exp->gdbarch);
+	  return value_from_longest (type, (LONGEST) tem);
 	}
 
     case BINOP_NOTEQUAL:
@@ -1770,8 +2135,10 @@ evaluate_subexp_standard (struct type *expect_type,
 	}
       else
 	{
+	  binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
 	  tem = value_equal (arg1, arg2);
-	  return value_from_longest (LA_BOOL_TYPE, (LONGEST) ! tem);
+	  type = language_bool_type (exp->language_defn, exp->gdbarch);
+	  return value_from_longest (type, (LONGEST) ! tem);
 	}
 
     case BINOP_LESS:
@@ -1785,8 +2152,10 @@ evaluate_subexp_standard (struct type *expect_type,
 	}
       else
 	{
+	  binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
 	  tem = value_less (arg1, arg2);
-	  return value_from_longest (LA_BOOL_TYPE, (LONGEST) tem);
+	  type = language_bool_type (exp->language_defn, exp->gdbarch);
+	  return value_from_longest (type, (LONGEST) tem);
 	}
 
     case BINOP_GTR:
@@ -1800,8 +2169,10 @@ evaluate_subexp_standard (struct type *expect_type,
 	}
       else
 	{
+	  binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
 	  tem = value_less (arg2, arg1);
-	  return value_from_longest (LA_BOOL_TYPE, (LONGEST) tem);
+	  type = language_bool_type (exp->language_defn, exp->gdbarch);
+	  return value_from_longest (type, (LONGEST) tem);
 	}
 
     case BINOP_GEQ:
@@ -1815,8 +2186,10 @@ evaluate_subexp_standard (struct type *expect_type,
 	}
       else
 	{
+	  binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
 	  tem = value_less (arg2, arg1) || value_equal (arg1, arg2);
-	  return value_from_longest (LA_BOOL_TYPE, (LONGEST) tem);
+	  type = language_bool_type (exp->language_defn, exp->gdbarch);
+	  return value_from_longest (type, (LONGEST) tem);
 	}
 
     case BINOP_LEQ:
@@ -1830,8 +2203,10 @@ evaluate_subexp_standard (struct type *expect_type,
 	}
       else
 	{
+	  binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
 	  tem = value_less (arg1, arg2) || value_equal (arg1, arg2);
-	  return value_from_longest (LA_BOOL_TYPE, (LONGEST) tem);
+	  type = language_bool_type (exp->language_defn, exp->gdbarch);
+	  return value_from_longest (type, (LONGEST) tem);
 	}
 
     case BINOP_REPEAT:
@@ -1841,7 +2216,7 @@ evaluate_subexp_standard (struct type *expect_type,
 	goto nosideret;
       type = check_typedef (value_type (arg2));
       if (TYPE_CODE (type) != TYPE_CODE_INT)
-	error ("Non-integral right operand for \"@\" operator.");
+	error (_("Non-integral right operand for \"@\" operator."));
       if (noside == EVAL_AVOID_SIDE_EFFECTS)
 	{
 	  return allocate_repeat_value (value_type (arg1),
@@ -1854,6 +2229,18 @@ evaluate_subexp_standard (struct type *expect_type,
       evaluate_subexp (NULL_TYPE, exp, pos, noside);
       return evaluate_subexp (NULL_TYPE, exp, pos, noside);
 
+    case UNOP_PLUS:
+      arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      if (unop_user_defined_p (op, arg1))
+	return value_x_unop (arg1, op, noside);
+      else
+	{
+	  unop_promote (exp->language_defn, exp->gdbarch, &arg1);
+	  return value_pos (arg1);
+	}
+      
     case UNOP_NEG:
       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
       if (noside == EVAL_SKIP)
@@ -1861,7 +2248,10 @@ evaluate_subexp_standard (struct type *expect_type,
       if (unop_user_defined_p (op, arg1))
 	return value_x_unop (arg1, op, noside);
       else
-	return value_neg (arg1);
+	{
+	  unop_promote (exp->language_defn, exp->gdbarch, &arg1);
+	  return value_neg (arg1);
+	}
 
     case UNOP_COMPLEMENT:
       /* C++: check for and handle destructor names.  */
@@ -1873,7 +2263,10 @@ evaluate_subexp_standard (struct type *expect_type,
       if (unop_user_defined_p (UNOP_COMPLEMENT, arg1))
 	return value_x_unop (arg1, UNOP_COMPLEMENT, noside);
       else
-	return value_complement (arg1);
+	{
+	  unop_promote (exp->language_defn, exp->gdbarch, &arg1);
+	  return value_complement (arg1);
+	}
 
     case UNOP_LOGICAL_NOT:
       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
@@ -1882,17 +2275,19 @@ evaluate_subexp_standard (struct type *expect_type,
       if (unop_user_defined_p (op, arg1))
 	return value_x_unop (arg1, op, noside);
       else
-	return value_from_longest (LA_BOOL_TYPE,
-				   (LONGEST) value_logical_not (arg1));
+	{
+	  type = language_bool_type (exp->language_defn, exp->gdbarch);
+	  return value_from_longest (type, (LONGEST) value_logical_not (arg1));
+	}
 
     case UNOP_IND:
       if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_PTR)
 	expect_type = TYPE_TARGET_TYPE (check_typedef (expect_type));
       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
-      if ((TYPE_TARGET_TYPE (value_type (arg1))) &&
-	  ((TYPE_CODE (TYPE_TARGET_TYPE (value_type (arg1))) == TYPE_CODE_METHOD) ||
-	   (TYPE_CODE (TYPE_TARGET_TYPE (value_type (arg1))) == TYPE_CODE_MEMBER)))
-	error ("Attempt to dereference pointer to member without an object");
+      type = check_typedef (value_type (arg1));
+      if (TYPE_CODE (type) == TYPE_CODE_METHODPTR
+	  || TYPE_CODE (type) == TYPE_CODE_MEMBERPTR)
+	error (_("Attempt to dereference pointer to member without an object"));
       if (noside == EVAL_SKIP)
 	goto nosideret;
       if (unop_user_defined_p (op, arg1))
@@ -1909,10 +2304,19 @@ evaluate_subexp_standard (struct type *expect_type,
 			       lval_memory);
 	  else if (TYPE_CODE (type) == TYPE_CODE_INT)
 	    /* GDB allows dereferencing an int.  */
-	    return value_zero (builtin_type_int, lval_memory);
+	    return value_zero (builtin_type (exp->gdbarch)->builtin_int,
+			       lval_memory);
 	  else
-	    error ("Attempt to take contents of a non-pointer value.");
+	    error (_("Attempt to take contents of a non-pointer value."));
 	}
+
+      /* Allow * on an integer so we can cast it to whatever we want.
+	 This returns an int, which seems like the most C-like thing to
+	 do.  "long long" variables are rare enough that
+	 BUILTIN_TYPE_LONGEST would seem to be a mistake.  */
+      if (TYPE_CODE (type) == TYPE_CODE_INT)
+	return value_at_lazy (builtin_type (exp->gdbarch)->builtin_int,
+			      (CORE_ADDR) value_as_address (arg1));
       return value_ind (arg1);
 
     case UNOP_ADDR:
@@ -1922,26 +2326,12 @@ evaluate_subexp_standard (struct type *expect_type,
 
       if (noside == EVAL_SKIP)
 	{
-	  if (op == OP_SCOPE)
-	    {
-	      int temm = longest_to_int (exp->elts[pc + 3].longconst);
-	      (*pos) += 3 + BYTES_TO_EXP_ELEM (temm + 1);
-	    }
-	  else
-	    evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
+	  evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
 	  goto nosideret;
 	}
       else
 	{
 	  struct value *retvalp = evaluate_subexp_for_address (exp, pos, noside);
-	  /* If HP aCC object, use bias for pointers to members */
-	  if (deprecated_hp_som_som_object_present &&
-	      (TYPE_CODE (value_type (retvalp)) == TYPE_CODE_PTR) &&
-	      (TYPE_CODE (TYPE_TARGET_TYPE (value_type (retvalp))) == TYPE_CODE_MEMBER))
-	    {
-	      unsigned int *ptr = (unsigned int *) VALUE_CONTENTS (retvalp);	/* forces evaluation */
-	      *ptr |= 0x20000000;	/* set 29th bit */
-	    }
 	  return retvalp;
 	}
 
@@ -1974,6 +2364,21 @@ evaluate_subexp_standard (struct type *expect_type,
 	return value_at_lazy (exp->elts[pc + 1].type,
 			      value_as_address (arg1));
 
+    case UNOP_MEMVAL_TLS:
+      (*pos) += 3;
+      arg1 = evaluate_subexp (expect_type, exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      if (noside == EVAL_AVOID_SIDE_EFFECTS)
+	return value_zero (exp->elts[pc + 2].type, lval_memory);
+      else
+	{
+	  CORE_ADDR tls_addr;
+	  tls_addr = target_translate_tls_address (exp->elts[pc + 1].objfile,
+						   value_as_address (arg1));
+	  return value_at_lazy (exp->elts[pc + 2].type, tls_addr);
+	}
+
     case UNOP_PREINCREMENT:
       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
@@ -1984,8 +2389,16 @@ evaluate_subexp_standard (struct type *expect_type,
 	}
       else
 	{
-	  arg2 = value_add (arg1, value_from_longest (builtin_type_char,
-						      (LONGEST) 1));
+	  arg2 = value_from_longest (builtin_type_uint8, (LONGEST) 1);
+	  if (ptrmath_type_p (value_type (arg1)))
+	    arg2 = value_ptradd (arg1, arg2);
+	  else
+	    {
+	      struct value *tmp = arg1;
+	      binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
+	      arg2 = value_binop (tmp, arg2, BINOP_ADD);
+	    }
+
 	  return value_assign (arg1, arg2);
 	}
 
@@ -1999,8 +2412,16 @@ evaluate_subexp_standard (struct type *expect_type,
 	}
       else
 	{
-	  arg2 = value_sub (arg1, value_from_longest (builtin_type_char,
-						      (LONGEST) 1));
+	  arg2 = value_from_longest (builtin_type_uint8, (LONGEST) 1);
+	  if (ptrmath_type_p (value_type (arg1)))
+	    arg2 = value_ptrsub (arg1, arg2);
+	  else
+	    {
+	      struct value *tmp = arg1;
+	      binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
+	      arg2 = value_binop (tmp, arg2, BINOP_SUB);
+	    }
+
 	  return value_assign (arg1, arg2);
 	}
 
@@ -2014,8 +2435,16 @@ evaluate_subexp_standard (struct type *expect_type,
 	}
       else
 	{
-	  arg2 = value_add (arg1, value_from_longest (builtin_type_char,
-						      (LONGEST) 1));
+	  arg2 = value_from_longest (builtin_type_uint8, (LONGEST) 1);
+	  if (ptrmath_type_p (value_type (arg1)))
+	    arg2 = value_ptradd (arg1, arg2);
+	  else
+	    {
+	      struct value *tmp = arg1;
+	      binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
+	      arg2 = value_binop (tmp, arg2, BINOP_ADD);
+	    }
+
 	  value_assign (arg1, arg2);
 	  return arg1;
 	}
@@ -2030,8 +2459,16 @@ evaluate_subexp_standard (struct type *expect_type,
 	}
       else
 	{
-	  arg2 = value_sub (arg1, value_from_longest (builtin_type_char,
-						      (LONGEST) 1));
+	  arg2 = value_from_longest (builtin_type_uint8, (LONGEST) 1);
+	  if (ptrmath_type_p (value_type (arg1)))
+	    arg2 = value_ptrsub (arg1, arg2);
+	  else
+	    {
+	      struct value *tmp = arg1;
+	      binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
+	      arg2 = value_binop (tmp, arg2, BINOP_SUB);
+	    }
+
 	  value_assign (arg1, arg2);
 	  return arg1;
 	}
@@ -2045,7 +2482,25 @@ evaluate_subexp_standard (struct type *expect_type,
       return value_of_local ("self", 1);
 
     case OP_TYPE:
-      error ("Attempt to use a type name as an expression");
+      /* The value is not supposed to be used.  This is here to make it
+         easier to accommodate expressions that contain types.  */
+      (*pos) += 2;
+      if (noside == EVAL_SKIP)
+        goto nosideret;
+      else if (noside == EVAL_AVOID_SIDE_EFFECTS)
+	{
+	  struct type *type = exp->elts[pc + 1].type;
+	  /* If this is a typedef, then find its immediate target.  We
+	     use check_typedef to resolve stubs, but we ignore its
+	     result because we do not want to dig past all
+	     typedefs.  */
+	  check_typedef (type);
+	  if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
+	    type = TYPE_TARGET_TYPE (type);
+	  return allocate_value (type);
+	}
+      else
+        error (_("Attempt to use a type name as an expression"));
 
     default:
       /* Removing this case and compiling with gcc -Wall reveals that
@@ -2057,12 +2512,12 @@ evaluate_subexp_standard (struct type *expect_type,
          then they should be separate cases, with more descriptive
          error messages.  */
 
-      error ("\
-GDB does not (yet) know how to evaluate that kind of expression");
+      error (_("\
+GDB does not (yet) know how to evaluate that kind of expression"));
     }
 
 nosideret:
-  return value_from_longest (builtin_type_long, (LONGEST) 1);
+  return value_from_longest (builtin_type_int8, (LONGEST) 1);
 }
 
 /* Evaluate a subexpression of EXP, at index *POS,
@@ -2079,6 +2534,8 @@ evaluate_subexp_for_address (struct expression *exp, int *pos,
   enum exp_opcode op;
   int pc;
   struct symbol *var;
+  struct value *x;
+  int tem;
 
   pc = (*pos);
   op = exp->elts[pc].opcode;
@@ -2087,7 +2544,16 @@ evaluate_subexp_for_address (struct expression *exp, int *pos,
     {
     case UNOP_IND:
       (*pos)++;
-      return evaluate_subexp (NULL_TYPE, exp, pos, noside);
+      x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+
+      /* We can't optimize out "&*" if there's a user-defined operator*.  */
+      if (unop_user_defined_p (op, x))
+	{
+	  x = value_x_unop (x, op, noside);
+	  goto default_case_after_eval;
+	}
+
+      return x;
 
     case UNOP_MEMVAL:
       (*pos) += 3;
@@ -2111,31 +2577,43 @@ evaluate_subexp_for_address (struct expression *exp, int *pos,
 
 	  if (sym_class == LOC_CONST
 	      || sym_class == LOC_CONST_BYTES
-	      || sym_class == LOC_REGISTER
-	      || sym_class == LOC_REGPARM)
-	    error ("Attempt to take address of register or constant.");
+	      || sym_class == LOC_REGISTER)
+	    error (_("Attempt to take address of register or constant."));
 
 	  return
 	    value_zero (type, not_lval);
 	}
       else
-	return
-	  locate_var_value
-	  (var,
-	   block_innermost_frame (exp->elts[pc + 1].block));
+	return address_of_variable (var, exp->elts[pc + 1].block);
+
+    case OP_SCOPE:
+      tem = longest_to_int (exp->elts[pc + 2].longconst);
+      (*pos) += 5 + BYTES_TO_EXP_ELEM (tem + 1);
+      x = value_aggregate_elt (exp->elts[pc + 1].type,
+			       &exp->elts[pc + 3].string,
+			       1, noside);
+      if (x == NULL)
+	error (_("There is no field named %s"), &exp->elts[pc + 3].string);
+      return x;
 
     default:
     default_case:
+      x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+    default_case_after_eval:
       if (noside == EVAL_AVOID_SIDE_EFFECTS)
 	{
-	  struct value *x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
-	  if (VALUE_LVAL (x) == lval_memory)
+	  struct type *type = check_typedef (value_type (x));
+
+	  if (VALUE_LVAL (x) == lval_memory || value_must_coerce_to_target (x))
 	    return value_zero (lookup_pointer_type (value_type (x)),
 			       not_lval);
+	  else if (TYPE_CODE (type) == TYPE_CODE_REF)
+	    return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
+			       not_lval);
 	  else
-	    error ("Attempt to take address of non-lval");
+	    error (_("Attempt to take address of value not located in memory."));
 	}
-      return value_addr (evaluate_subexp (NULL_TYPE, exp, pos, noside));
+      return value_addr (x);
     }
 }
 
@@ -2160,6 +2638,7 @@ evaluate_subexp_with_coercion (struct expression *exp,
   int pc;
   struct value *val;
   struct symbol *var;
+  struct type *type;
 
   pc = (*pos);
   op = exp->elts[pc].opcode;
@@ -2168,14 +2647,13 @@ evaluate_subexp_with_coercion (struct expression *exp,
     {
     case OP_VAR_VALUE:
       var = exp->elts[pc + 2].symbol;
-      if (TYPE_CODE (check_typedef (SYMBOL_TYPE (var))) == TYPE_CODE_ARRAY
+      type = check_typedef (SYMBOL_TYPE (var));
+      if (TYPE_CODE (type) == TYPE_CODE_ARRAY
 	  && CAST_IS_CONVERSION)
 	{
 	  (*pos) += 4;
-	  val =
-	    locate_var_value
-	    (var, block_innermost_frame (exp->elts[pc + 1].block));
-	  return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (check_typedef (SYMBOL_TYPE (var)))),
+	  val = address_of_variable (var, exp->elts[pc + 1].block);
+	  return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
 			     val);
 	}
       /* FALLTHROUGH */
@@ -2192,6 +2670,8 @@ evaluate_subexp_with_coercion (struct expression *exp,
 static struct value *
 evaluate_subexp_for_sizeof (struct expression *exp, int *pos)
 {
+  /* FIXME: This should be size_t.  */
+  struct type *size_type = builtin_type (exp->gdbarch)->builtin_int;
   enum exp_opcode op;
   int pc;
   struct type *type;
@@ -2213,26 +2693,24 @@ evaluate_subexp_for_sizeof (struct expression *exp, int *pos)
       if (TYPE_CODE (type) != TYPE_CODE_PTR
 	  && TYPE_CODE (type) != TYPE_CODE_REF
 	  && TYPE_CODE (type) != TYPE_CODE_ARRAY)
-	error ("Attempt to take contents of a non-pointer value.");
+	error (_("Attempt to take contents of a non-pointer value."));
       type = check_typedef (TYPE_TARGET_TYPE (type));
-      return value_from_longest (builtin_type_int, (LONGEST)
-				 TYPE_LENGTH (type));
+      return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
 
     case UNOP_MEMVAL:
       (*pos) += 3;
       type = check_typedef (exp->elts[pc + 1].type);
-      return value_from_longest (builtin_type_int,
-				 (LONGEST) TYPE_LENGTH (type));
+      return value_from_longest (size_type, (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 (type));
+	value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
 
     default:
       val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
-      return value_from_longest (builtin_type_int,
+      return value_from_longest (size_type,
 				 (LONGEST) TYPE_LENGTH (value_type (val)));
     }
 }
@@ -2251,7 +2729,7 @@ parse_and_eval_type (char *p, int length)
   tmp[length + 3] = '\0';
   expr = parse_expression (tmp);
   if (expr->elts[0].opcode != UNOP_CAST)
-    error ("Internal error in eval_type.");
+    error (_("Internal error in eval_type."));
   return expr->elts[1].type;
 }
 
@@ -2262,7 +2740,7 @@ calc_f77_array_dims (struct type *array_type)
   struct type *tmp_type;
 
   if ((TYPE_CODE (array_type) != TYPE_CODE_ARRAY))
-    error ("Can't get dimensions for a non-array type");
+    error (_("Can't get dimensions for a non-array type"));
 
   tmp_type = array_type;