X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fax-gdb.c;h=c1aa202cfde02a5e96dd33d8e7c34442916830f5;hb=2ce22c78952effc809d0cae076da571e87708637;hp=6dea775e7ff2e1e2a235a015bf3af716f9d34b44;hpb=ed288bb597072176e84fc8279707a3f2f475779b;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/ax-gdb.c b/gdb/ax-gdb.c
index 6dea775e7f..c1aa202cfd 100644
--- a/gdb/ax-gdb.c
+++ b/gdb/ax-gdb.c
@@ -1,5 +1,7 @@
-/* GDB-specific functions for operating on agent expressions
-   Copyright 1998 Free Software Foundation, Inc.
+/* GDB-specific functions for operating on agent expressions.
+
+   Copyright (C) 1998, 1999, 2000, 2001, 2003 Free Software Foundation,
+   Inc.
 
    This file is part of GDB.
 
@@ -15,8 +17,8 @@
 
    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.  */
+   Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
 
 #include "defs.h"
 #include "symtab.h"
@@ -30,11 +32,15 @@
 #include "target.h"
 #include "ax.h"
 #include "ax-gdb.h"
+#include "gdb_string.h"
+#include "block.h"
+#include "regcache.h"
 
-/* Probably the best way to read this file is to start with the types
-   and enums in ax-gdb.h, and then look at gen_expr, towards the
-   bottom; that's the main function that looks at the GDB expressions
-   and calls everything else to generate code.
+/* To make sense of this file, you should read doc/agentexpr.texi.
+   Then look at the types and enums in ax-gdb.h.  For the code itself,
+   look at gen_expr, towards the bottom; that's the main function that
+   looks at the GDB expressions and calls everything else to generate
+   code.
 
    I'm beginning to wonder whether it wouldn't be nicer to internally
    generate trees, with types, and then spit out the bytecode in
@@ -55,101 +61,80 @@
    struct agent_expr * --- agent expression buffer to generate code into
    struct axs_value * --- describes value left on top of stack  */
 
-static struct value *const_var_ref PARAMS ((struct symbol * var));
-static struct value *const_expr PARAMS ((union exp_element ** pc));
-static struct value *maybe_const_expr PARAMS ((union exp_element ** pc));
-
-static void gen_traced_pop PARAMS ((struct agent_expr *, struct axs_value *));
-
-static void gen_sign_extend PARAMS ((struct agent_expr *, struct type *));
-static void gen_extend PARAMS ((struct agent_expr *, struct type *));
-static void gen_fetch PARAMS ((struct agent_expr *, struct type *));
-static void gen_left_shift PARAMS ((struct agent_expr *, int));
-
-
-static void gen_frame_args_address PARAMS ((struct agent_expr *));
-static void gen_frame_locals_address PARAMS ((struct agent_expr *));
-static void gen_offset PARAMS ((struct agent_expr * ax, int offset));
-static void gen_sym_offset PARAMS ((struct agent_expr *, struct symbol *));
-static void gen_var_ref PARAMS ((struct agent_expr * ax,
-				 struct axs_value * value,
-				 struct symbol * var));
-
-
-static void gen_int_literal PARAMS ((struct agent_expr * ax,
-				     struct axs_value * value,
-				     LONGEST k, struct type * type));
-
-
-static void require_rvalue PARAMS ((struct agent_expr * ax,
-				    struct axs_value * value));
-static void gen_usual_unary PARAMS ((struct agent_expr * ax,
-				     struct axs_value * value));
-static int type_wider_than PARAMS ((struct type * type1,
-				    struct type * type2));
-static struct type *max_type PARAMS ((struct type * type1,
-				      struct type * type2));
-static void gen_conversion PARAMS ((struct agent_expr * ax,
-				    struct type * from,
-				    struct type * to));
-static int is_nontrivial_conversion PARAMS ((struct type * from,
-					     struct type * to));
-static void gen_usual_arithmetic PARAMS ((struct agent_expr * ax,
-					  struct axs_value * value1,
-					  struct axs_value * value2));
-static void gen_integral_promotions PARAMS ((struct agent_expr * ax,
-					     struct axs_value * value));
-static void gen_cast PARAMS ((struct agent_expr * ax,
-			      struct axs_value * value,
-			      struct type * type));
-static void gen_scale PARAMS ((struct agent_expr * ax,
-			       enum agent_op op,
-			       struct type * type));
-static void gen_add PARAMS ((struct agent_expr * ax,
-			     struct axs_value * value,
-			     struct axs_value * value1,
-			     struct axs_value * value2,
-			     char *name));
-static void gen_sub PARAMS ((struct agent_expr * ax,
-			     struct axs_value * value,
-			     struct axs_value * value1,
-			     struct axs_value * value2));
-static void gen_binop PARAMS ((struct agent_expr * ax,
-			       struct axs_value * value,
-			       struct axs_value * value1,
-			       struct axs_value * value2,
-			       enum agent_op op,
-			       enum agent_op op_unsigned,
-			       int may_carry,
-			       char *name));
-static void gen_logical_not PARAMS ((struct agent_expr * ax,
-				     struct axs_value * value));
-static void gen_complement PARAMS ((struct agent_expr * ax,
-				    struct axs_value * value));
-static void gen_deref PARAMS ((struct agent_expr *, struct axs_value *));
-static void gen_address_of PARAMS ((struct agent_expr *, struct axs_value *));
-static int find_field PARAMS ((struct type * type, char *name));
-static void gen_bitfield_ref PARAMS ((struct agent_expr * ax,
-				      struct axs_value * value,
-				      struct type * type,
-				      int start, int end));
-static void gen_struct_ref PARAMS ((struct agent_expr * ax,
-				    struct axs_value * value,
-				    char *field,
-				    char *operator_name,
-				    char *operand_name));
-static void gen_repeat PARAMS ((union exp_element ** pc,
-				struct agent_expr * ax,
-				struct axs_value * value));
-static void gen_sizeof PARAMS ((union exp_element ** pc,
-				struct agent_expr * ax,
-				struct axs_value * value));
-static void gen_expr PARAMS ((union exp_element ** pc,
-			      struct agent_expr * ax,
-			      struct axs_value * value));
-
-static void print_axs_value PARAMS ((GDB_FILE * f, struct axs_value * value));
-static void agent_command PARAMS ((char *exp, int from_tty));
+static struct value *const_var_ref (struct symbol *var);
+static struct value *const_expr (union exp_element **pc);
+static struct value *maybe_const_expr (union exp_element **pc);
+
+static void gen_traced_pop (struct agent_expr *, struct axs_value *);
+
+static void gen_sign_extend (struct agent_expr *, struct type *);
+static void gen_extend (struct agent_expr *, struct type *);
+static void gen_fetch (struct agent_expr *, struct type *);
+static void gen_left_shift (struct agent_expr *, int);
+
+
+static void gen_frame_args_address (struct agent_expr *);
+static void gen_frame_locals_address (struct agent_expr *);
+static void gen_offset (struct agent_expr *ax, int offset);
+static void gen_sym_offset (struct agent_expr *, struct symbol *);
+static void gen_var_ref (struct agent_expr *ax,
+			 struct axs_value *value, struct symbol *var);
+
+
+static void gen_int_literal (struct agent_expr *ax,
+			     struct axs_value *value,
+			     LONGEST k, struct type *type);
+
+
+static void require_rvalue (struct agent_expr *ax, struct axs_value *value);
+static void gen_usual_unary (struct agent_expr *ax, struct axs_value *value);
+static int type_wider_than (struct type *type1, struct type *type2);
+static struct type *max_type (struct type *type1, struct type *type2);
+static void gen_conversion (struct agent_expr *ax,
+			    struct type *from, struct type *to);
+static int is_nontrivial_conversion (struct type *from, struct type *to);
+static void gen_usual_arithmetic (struct agent_expr *ax,
+				  struct axs_value *value1,
+				  struct axs_value *value2);
+static void gen_integral_promotions (struct agent_expr *ax,
+				     struct axs_value *value);
+static void gen_cast (struct agent_expr *ax,
+		      struct axs_value *value, struct type *type);
+static void gen_scale (struct agent_expr *ax,
+		       enum agent_op op, struct type *type);
+static void gen_add (struct agent_expr *ax,
+		     struct axs_value *value,
+		     struct axs_value *value1,
+		     struct axs_value *value2, char *name);
+static void gen_sub (struct agent_expr *ax,
+		     struct axs_value *value,
+		     struct axs_value *value1, struct axs_value *value2);
+static void gen_binop (struct agent_expr *ax,
+		       struct axs_value *value,
+		       struct axs_value *value1,
+		       struct axs_value *value2,
+		       enum agent_op op,
+		       enum agent_op op_unsigned, int may_carry, char *name);
+static void gen_logical_not (struct agent_expr *ax, struct axs_value *value);
+static void gen_complement (struct agent_expr *ax, struct axs_value *value);
+static void gen_deref (struct agent_expr *, struct axs_value *);
+static void gen_address_of (struct agent_expr *, struct axs_value *);
+static int find_field (struct type *type, char *name);
+static void gen_bitfield_ref (struct agent_expr *ax,
+			      struct axs_value *value,
+			      struct type *type, int start, int end);
+static void gen_struct_ref (struct agent_expr *ax,
+			    struct axs_value *value,
+			    char *field,
+			    char *operator_name, char *operand_name);
+static void gen_repeat (union exp_element **pc,
+			struct agent_expr *ax, struct axs_value *value);
+static void gen_sizeof (union exp_element **pc,
+			struct agent_expr *ax, struct axs_value *value);
+static void gen_expr (union exp_element **pc,
+		      struct agent_expr *ax, struct axs_value *value);
+
+static void agent_command (char *exp, int from_tty);
 
 
 /* Detecting constant expressions.  */
@@ -173,8 +158,7 @@ static void agent_command PARAMS ((char *exp, int from_tty));
    proletariat?  */
 
 static struct value *
-const_var_ref (var)
-     struct symbol *var;
+const_var_ref (struct symbol *var)
 {
   struct type *type = SYMBOL_TYPE (var);
 
@@ -184,7 +168,7 @@ const_var_ref (var)
       return value_from_longest (type, (LONGEST) SYMBOL_VALUE (var));
 
     case LOC_LABEL:
-      return value_from_longest (type, (LONGEST) SYMBOL_VALUE_ADDRESS (var));
+      return value_from_pointer (type, (CORE_ADDR) SYMBOL_VALUE_ADDRESS (var));
 
     default:
       return 0;
@@ -197,8 +181,7 @@ const_var_ref (var)
    advanced to the end of it.  If we return zero, *PC could be
    anywhere.  */
 static struct value *
-const_expr (pc)
-     union exp_element **pc;
+const_expr (union exp_element **pc)
 {
   enum exp_opcode op = (*pc)->opcode;
   struct value *v1;
@@ -239,8 +222,7 @@ const_expr (pc)
 /* Like const_expr, but guarantee also that *PC is undisturbed if the
    expression is not constant.  */
 static struct value *
-maybe_const_expr (pc)
-     union exp_element **pc;
+maybe_const_expr (union exp_element **pc)
 {
   union exp_element *tentative_pc = *pc;
   struct value *v = const_expr (&tentative_pc);
@@ -326,9 +308,7 @@ static int trace_kludge;
    the value.  Useful on the left side of a comma, and at the end of
    an expression being used for tracing.  */
 static void
-gen_traced_pop (ax, value)
-     struct agent_expr *ax;
-     struct axs_value *value;
+gen_traced_pop (struct agent_expr *ax, struct axs_value *value)
 {
   if (trace_kludge)
     switch (value->kind)
@@ -373,13 +353,11 @@ gen_traced_pop (ax, value)
 /* Assume that the lower bits of the top of the stack is a value of
    type TYPE, and the upper bits are zero.  Sign-extend if necessary.  */
 static void
-gen_sign_extend (ax, type)
-     struct agent_expr *ax;
-     struct type *type;
+gen_sign_extend (struct agent_expr *ax, struct type *type)
 {
   /* Do we need to sign-extend this?  */
   if (!TYPE_UNSIGNED (type))
-    ax_ext (ax, type->length * TARGET_CHAR_BIT);
+    ax_ext (ax, TYPE_LENGTH (type) * TARGET_CHAR_BIT);
 }
 
 
@@ -387,11 +365,9 @@ gen_sign_extend (ax, type)
    TYPE, and the upper bits are garbage.  Sign-extend or truncate as
    needed.  */
 static void
-gen_extend (ax, type)
-     struct agent_expr *ax;
-     struct type *type;
+gen_extend (struct agent_expr *ax, struct type *type)
 {
-  int bits = type->length * TARGET_CHAR_BIT;
+  int bits = TYPE_LENGTH (type) * TARGET_CHAR_BIT;
   /* I just had to.  */
   ((TYPE_UNSIGNED (type) ? ax_zero_ext : ax_ext) (ax, bits));
 }
@@ -401,9 +377,7 @@ gen_extend (ax, type)
    to TYPE"; generate code to fetch its value.  Note that TYPE is the
    target type, not the pointer type.  */
 static void
-gen_fetch (ax, type)
-     struct agent_expr *ax;
-     struct type *type;
+gen_fetch (struct agent_expr *ax, struct type *type)
 {
   if (trace_kludge)
     {
@@ -411,7 +385,7 @@ gen_fetch (ax, type)
       ax_trace_quick (ax, TYPE_LENGTH (type));
     }
 
-  switch (type->code)
+  switch (TYPE_CODE (type))
     {
     case TYPE_CODE_PTR:
     case TYPE_CODE_ENUM:
@@ -419,7 +393,7 @@ gen_fetch (ax, type)
     case TYPE_CODE_CHAR:
       /* It's a scalar value, so we know how to dereference it.  How
          many bytes long is it?  */
-      switch (type->length)
+      switch (TYPE_LENGTH (type))
 	{
 	case 8 / TARGET_CHAR_BIT:
 	  ax_simple (ax, aop_ref8);
@@ -439,7 +413,8 @@ gen_fetch (ax, type)
 	     implementing something we should be (this code's fault).
 	     In any case, it's a bug the user shouldn't see.  */
 	default:
-	  error ("GDB bug: ax-gdb.c (gen_fetch): strange size");
+	  internal_error (__FILE__, __LINE__,
+			  _("gen_fetch: strange size"));
 	}
 
       gen_sign_extend (ax, type);
@@ -450,7 +425,8 @@ gen_fetch (ax, type)
          pointer (other code's fault), or we're not implementing
          something we should be (this code's fault).  In any case,
          it's a bug the user shouldn't see.  */
-      error ("GDB bug: ax-gdb.c (gen_fetch): bad type code");
+      internal_error (__FILE__, __LINE__,
+		      _("gen_fetch: bad type code"));
     }
 }
 
@@ -459,9 +435,7 @@ gen_fetch (ax, type)
    right shift it by -DISTANCE bits if DISTANCE < 0.  This generates
    unsigned (logical) right shifts.  */
 static void
-gen_left_shift (ax, distance)
-     struct agent_expr *ax;
-     int distance;
+gen_left_shift (struct agent_expr *ax, int distance)
 {
   if (distance > 0)
     {
@@ -482,10 +456,10 @@ gen_left_shift (ax, distance)
 /* Generate code to push the base address of the argument portion of
    the top stack frame.  */
 static void
-gen_frame_args_address (ax)
-     struct agent_expr *ax;
+gen_frame_args_address (struct agent_expr *ax)
 {
-  long frame_reg, frame_offset;
+  int frame_reg;
+  LONGEST frame_offset;
 
   TARGET_VIRTUAL_FRAME_POINTER (ax->scope, &frame_reg, &frame_offset);
   ax_reg (ax, frame_reg);
@@ -496,10 +470,10 @@ gen_frame_args_address (ax)
 /* Generate code to push the base address of the locals portion of the
    top stack frame.  */
 static void
-gen_frame_locals_address (ax)
-     struct agent_expr *ax;
+gen_frame_locals_address (struct agent_expr *ax)
 {
-  long frame_reg, frame_offset;
+  int frame_reg;
+  LONGEST frame_offset;
 
   TARGET_VIRTUAL_FRAME_POINTER (ax->scope, &frame_reg, &frame_offset);
   ax_reg (ax, frame_reg);
@@ -513,9 +487,7 @@ gen_frame_locals_address (ax)
    programming in ML, it would be clearer why these are the same
    thing.  */
 static void
-gen_offset (ax, offset)
-     struct agent_expr *ax;
-     int offset;
+gen_offset (struct agent_expr *ax, int offset)
 {
   /* It would suffice to simply push the offset and add it, but this
      makes it easier to read positive and negative offsets in the
@@ -537,9 +509,7 @@ gen_offset (ax, offset)
    address (stack frame, base register, etc.)  Generate code to add
    VAR's value to the top of the stack.  */
 static void
-gen_sym_offset (ax, var)
-     struct agent_expr *ax;
-     struct symbol *var;
+gen_sym_offset (struct agent_expr *ax, struct symbol *var)
 {
   gen_offset (ax, SYMBOL_VALUE (var));
 }
@@ -549,10 +519,7 @@ gen_sym_offset (ax, var)
    symbol VAR.  Set VALUE to describe the result.  */
 
 static void
-gen_var_ref (ax, value, var)
-     struct agent_expr *ax;
-     struct axs_value *value;
-     struct symbol *var;
+gen_var_ref (struct agent_expr *ax, struct axs_value *value, struct symbol *var)
 {
   /* Dereference any typedefs. */
   value->type = check_typedef (SYMBOL_TYPE (var));
@@ -571,7 +538,8 @@ gen_var_ref (ax, value, var)
       break;
 
     case LOC_CONST_BYTES:
-      error ("GDB bug: ax-gdb.c (gen_var_ref): LOC_CONST_BYTES symbols are not supported");
+      internal_error (__FILE__, __LINE__,
+		      _("gen_var_ref: LOC_CONST_BYTES symbols are not supported"));
 
       /* Variable at a fixed location in memory.  Easy.  */
     case LOC_STATIC:
@@ -610,8 +578,8 @@ gen_var_ref (ax, value, var)
       break;
 
     case LOC_TYPEDEF:
-      error ("Cannot compute value of typedef `%s'.",
-	     SYMBOL_SOURCE_NAME (var));
+      error (_("Cannot compute value of typedef `%s'."),
+	     SYMBOL_PRINT_NAME (var));
       break;
 
     case LOC_BLOCK:
@@ -640,9 +608,9 @@ gen_var_ref (ax, value, var)
     case LOC_UNRESOLVED:
       {
 	struct minimal_symbol *msym
-	= lookup_minimal_symbol (SYMBOL_NAME (var), NULL, NULL);
+	= lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (var), NULL, NULL);
 	if (!msym)
-	  error ("Couldn't resolve symbol `%s'.", SYMBOL_SOURCE_NAME (var));
+	  error (_("Couldn't resolve symbol `%s'."), SYMBOL_PRINT_NAME (var));
 
 	/* Push the address of the variable.  */
 	ax_const_l (ax, SYMBOL_VALUE_ADDRESS (msym));
@@ -650,14 +618,24 @@ gen_var_ref (ax, value, var)
       }
       break;
 
+    case LOC_COMPUTED:
+    case LOC_COMPUTED_ARG:
+      /* FIXME: cagney/2004-01-26: It should be possible to
+	 unconditionally call the SYMBOL_OPS method when available.
+	 Unfortunately DWARF 2 stores the frame-base (instead of the
+	 function) location in a function's symbol.  Oops!  For the
+	 moment enable this when/where applicable.  */
+      SYMBOL_OPS (var)->tracepoint_var_ref (var, ax, value);
+      break;
+
     case LOC_OPTIMIZED_OUT:
-      error ("The variable `%s' has been optimized out.",
-	     SYMBOL_SOURCE_NAME (var));
+      error (_("The variable `%s' has been optimized out."),
+	     SYMBOL_PRINT_NAME (var));
       break;
 
     default:
-      error ("Cannot find value of botched symbol `%s'.",
-	     SYMBOL_SOURCE_NAME (var));
+      error (_("Cannot find value of botched symbol `%s'."),
+	     SYMBOL_PRINT_NAME (var));
       break;
     }
 }
@@ -667,11 +645,8 @@ gen_var_ref (ax, value, var)
 /* Generating bytecode from GDB expressions: literals */
 
 static void
-gen_int_literal (ax, value, k, type)
-     struct agent_expr *ax;
-     struct axs_value *value;
-     LONGEST k;
-     struct type *type;
+gen_int_literal (struct agent_expr *ax, struct axs_value *value, LONGEST k,
+		 struct type *type)
 {
   ax_const_l (ax, k);
   value->kind = axs_rvalue;
@@ -686,9 +661,7 @@ gen_int_literal (ax, value, k, type)
    try to make an rvalue out of it.  Signal an error if we can't do
    that.  */
 static void
-require_rvalue (ax, value)
-     struct agent_expr *ax;
-     struct axs_value *value;
+require_rvalue (struct agent_expr *ax, struct axs_value *value)
 {
   switch (value->kind)
     {
@@ -733,16 +706,14 @@ require_rvalue (ax, value)
    lvalue through unchanged, and let `+' raise an error.  */
 
 static void
-gen_usual_unary (ax, value)
-     struct agent_expr *ax;
-     struct axs_value *value;
+gen_usual_unary (struct agent_expr *ax, struct axs_value *value)
 {
   /* We don't have to generate any code for the usual integral
      conversions, since values are always represented as full-width on
      the stack.  Should we tweak the type?  */
 
   /* Some types require special handling.  */
-  switch (value->type->code)
+  switch (TYPE_CODE (value->type))
     {
       /* Functions get converted to a pointer to the function.  */
     case TYPE_CODE_FUNC:
@@ -782,8 +753,7 @@ gen_usual_unary (ax, value)
 /* Return non-zero iff the type TYPE1 is considered "wider" than the
    type TYPE2, according to the rules described in gen_usual_arithmetic.  */
 static int
-type_wider_than (type1, type2)
-     struct type *type1, *type2;
+type_wider_than (struct type *type1, struct type *type2)
 {
   return (TYPE_LENGTH (type1) > TYPE_LENGTH (type2)
 	  || (TYPE_LENGTH (type1) == TYPE_LENGTH (type2)
@@ -794,8 +764,7 @@ type_wider_than (type1, type2)
 
 /* Return the "wider" of the two types TYPE1 and TYPE2.  */
 static struct type *
-max_type (type1, type2)
-     struct type *type1, *type2;
+max_type (struct type *type1, struct type *type2)
 {
   return type_wider_than (type1, type2) ? type1 : type2;
 }
@@ -803,9 +772,7 @@ max_type (type1, type2)
 
 /* Generate code to convert a scalar value of type FROM to type TO.  */
 static void
-gen_conversion (ax, from, to)
-     struct agent_expr *ax;
-     struct type *from, *to;
+gen_conversion (struct agent_expr *ax, struct type *from, struct type *to)
 {
   /* Perhaps there is a more graceful way to state these rules.  */
 
@@ -835,8 +802,7 @@ gen_conversion (ax, from, to)
 /* Return non-zero iff the type FROM will require any bytecodes to be
    emitted to be converted to the type TO.  */
 static int
-is_nontrivial_conversion (from, to)
-     struct type *from, *to;
+is_nontrivial_conversion (struct type *from, struct type *to)
 {
   struct agent_expr *ax = new_agent_expr (0);
   int nontrivial;
@@ -860,9 +826,8 @@ is_nontrivial_conversion (from, to)
    and promotes each argument to that type.  *VALUE1 and *VALUE2
    describe the values as they are passed in, and as they are left.  */
 static void
-gen_usual_arithmetic (ax, value1, value2)
-     struct agent_expr *ax;
-     struct axs_value *value1, *value2;
+gen_usual_arithmetic (struct agent_expr *ax, struct axs_value *value1,
+		      struct axs_value *value2)
 {
   /* Do the usual binary conversions.  */
   if (TYPE_CODE (value1->type) == TYPE_CODE_INT
@@ -898,9 +863,7 @@ gen_usual_arithmetic (ax, value1, value2)
    the value on the top of the stack, as described by VALUE.  Assume
    the value has integral type.  */
 static void
-gen_integral_promotions (ax, value)
-     struct agent_expr *ax;
-     struct axs_value *value;
+gen_integral_promotions (struct agent_expr *ax, struct axs_value *value)
 {
   if (!type_wider_than (value->type, builtin_type_int))
     {
@@ -917,10 +880,7 @@ gen_integral_promotions (ax, value)
 
 /* Generate code for a cast to TYPE.  */
 static void
-gen_cast (ax, value, type)
-     struct agent_expr *ax;
-     struct axs_value *value;
-     struct type *type;
+gen_cast (struct agent_expr *ax, struct axs_value *value, struct type *type)
 {
   /* GCC does allow casts to yield lvalues, so this should be fixed
      before merging these changes into the trunk.  */
@@ -928,7 +888,7 @@ gen_cast (ax, value, type)
   /* Dereference typedefs. */
   type = check_typedef (type);
 
-  switch (type->code)
+  switch (TYPE_CODE (type))
     {
     case TYPE_CODE_PTR:
       /* It's implementation-defined, and I'll bet this is what GCC
@@ -939,7 +899,7 @@ gen_cast (ax, value, type)
     case TYPE_CODE_STRUCT:
     case TYPE_CODE_UNION:
     case TYPE_CODE_FUNC:
-      error ("Illegal type cast: intended type must be scalar.");
+      error (_("Invalid type cast: intended type must be scalar."));
 
     case TYPE_CODE_ENUM:
       /* We don't have to worry about the size of the value, because
@@ -962,7 +922,7 @@ gen_cast (ax, value, type)
       break;
 
     default:
-      error ("Casts to requested type are not yet implemented.");
+      error (_("Casts to requested type are not yet implemented."));
     }
 
   value->type = type;
@@ -975,16 +935,13 @@ gen_cast (ax, value, type)
 /* Scale the integer on the top of the stack by the size of the target
    of the pointer type TYPE.  */
 static void
-gen_scale (ax, op, type)
-     struct agent_expr *ax;
-     enum agent_op op;
-     struct type *type;
+gen_scale (struct agent_expr *ax, enum agent_op op, struct type *type)
 {
   struct type *element = TYPE_TARGET_TYPE (type);
 
-  if (element->length != 1)
+  if (TYPE_LENGTH (element) != 1)
     {
-      ax_const_l (ax, element->length);
+      ax_const_l (ax, TYPE_LENGTH (element));
       ax_simple (ax, op);
     }
 }
@@ -996,14 +953,12 @@ gen_scale (ax, op, type)
    they've undergone the usual binary conversions.  Used by both
    BINOP_ADD and BINOP_SUBSCRIPT.  NAME is used in error messages.  */
 static void
-gen_add (ax, value, value1, value2, name)
-     struct agent_expr *ax;
-     struct axs_value *value, *value1, *value2;
-     char *name;
+gen_add (struct agent_expr *ax, struct axs_value *value,
+	 struct axs_value *value1, struct axs_value *value2, char *name)
 {
   /* Is it INT+PTR?  */
-  if (value1->type->code == TYPE_CODE_INT
-      && value2->type->code == TYPE_CODE_PTR)
+  if (TYPE_CODE (value1->type) == TYPE_CODE_INT
+      && TYPE_CODE (value2->type) == TYPE_CODE_PTR)
     {
       /* Swap the values and proceed normally.  */
       ax_simple (ax, aop_swap);
@@ -1014,8 +969,8 @@ gen_add (ax, value, value1, value2, name)
     }
 
   /* Is it PTR+INT?  */
-  else if (value1->type->code == TYPE_CODE_PTR
-	   && value2->type->code == TYPE_CODE_INT)
+  else if (TYPE_CODE (value1->type) == TYPE_CODE_PTR
+	   && TYPE_CODE (value2->type) == TYPE_CODE_INT)
     {
       gen_scale (ax, aop_mul, value1->type);
       ax_simple (ax, aop_add);
@@ -1025,8 +980,8 @@ gen_add (ax, value, value1, value2, name)
 
   /* Must be number + number; the usual binary conversions will have
      brought them both to the same width.  */
-  else if (value1->type->code == TYPE_CODE_INT
-	   && value2->type->code == TYPE_CODE_INT)
+  else if (TYPE_CODE (value1->type) == TYPE_CODE_INT
+	   && TYPE_CODE (value2->type) == TYPE_CODE_INT)
     {
       ax_simple (ax, aop_add);
       gen_extend (ax, value1->type);	/* Catch overflow.  */
@@ -1034,7 +989,7 @@ gen_add (ax, value, value1, value2, name)
     }
 
   else
-    error ("Illegal combination of types in %s.", name);
+    error (_("Invalid combination of types in %s."), name);
 
   value->kind = axs_rvalue;
 }
@@ -1045,16 +1000,13 @@ gen_add (ax, value, value1, value2, name)
    value; we assume VALUE1 and VALUE2 describe the two operands, and
    that they've undergone the usual binary conversions.  */
 static void
-gen_sub (ax, value, value1, value2)
-     struct agent_expr *ax;
-     struct axs_value *value, *value1, *value2;
+gen_sub (struct agent_expr *ax, struct axs_value *value,
+	 struct axs_value *value1, struct axs_value *value2)
 {
-  struct type *element;
-
-  if (value1->type->code == TYPE_CODE_PTR)
+  if (TYPE_CODE (value1->type) == TYPE_CODE_PTR)
     {
       /* Is it PTR - INT?  */
-      if (value2->type->code == TYPE_CODE_INT)
+      if (TYPE_CODE (value2->type) == TYPE_CODE_INT)
 	{
 	  gen_scale (ax, aop_mul, value1->type);
 	  ax_simple (ax, aop_sub);
@@ -1065,7 +1017,7 @@ gen_sub (ax, value, value1, value2)
       /* Is it PTR - PTR?  Strictly speaking, the types ought to
          match, but this is what the normal GDB expression evaluator
          tests for.  */
-      else if (value2->type->code == TYPE_CODE_PTR
+      else if (TYPE_CODE (value2->type) == TYPE_CODE_PTR
 	       && (TYPE_LENGTH (TYPE_TARGET_TYPE (value1->type))
 		   == TYPE_LENGTH (TYPE_TARGET_TYPE (value2->type))))
 	{
@@ -1074,14 +1026,14 @@ gen_sub (ax, value, value1, value2)
 	  value->type = builtin_type_long;	/* FIXME --- should be ptrdiff_t */
 	}
       else
-	error ("\
+	error (_("\
 First argument of `-' is a pointer, but second argument is neither\n\
-an integer nor a pointer of the same type.");
+an integer nor a pointer of the same type."));
     }
 
   /* Must be number + number.  */
-  else if (value1->type->code == TYPE_CODE_INT
-	   && value2->type->code == TYPE_CODE_INT)
+  else if (TYPE_CODE (value1->type) == TYPE_CODE_INT
+	   && TYPE_CODE (value2->type) == TYPE_CODE_INT)
     {
       ax_simple (ax, aop_sub);
       gen_extend (ax, value1->type);	/* Catch overflow.  */
@@ -1089,7 +1041,7 @@ an integer nor a pointer of the same type.");
     }
 
   else
-    error ("Illegal combination of types in subtraction.");
+    error (_("Invalid combination of types in subtraction."));
 
   value->kind = axs_rvalue;
 }
@@ -1101,17 +1053,14 @@ an integer nor a pointer of the same type.");
    result needs to be extended.  NAME is the English name of the
    operator, used in error messages */
 static void
-gen_binop (ax, value, value1, value2, op, op_unsigned, may_carry, name)
-     struct agent_expr *ax;
-     struct axs_value *value, *value1, *value2;
-     enum agent_op op, op_unsigned;
-     int may_carry;
-     char *name;
+gen_binop (struct agent_expr *ax, struct axs_value *value,
+	   struct axs_value *value1, struct axs_value *value2, enum agent_op op,
+	   enum agent_op op_unsigned, int may_carry, char *name)
 {
   /* We only handle INT op INT.  */
-  if ((value1->type->code != TYPE_CODE_INT)
-      || (value2->type->code != TYPE_CODE_INT))
-    error ("Illegal combination of types in %s.", name);
+  if ((TYPE_CODE (value1->type) != TYPE_CODE_INT)
+      || (TYPE_CODE (value2->type) != TYPE_CODE_INT))
+    error (_("Invalid combination of types in %s."), name);
 
   ax_simple (ax,
 	     TYPE_UNSIGNED (value1->type) ? op_unsigned : op);
@@ -1123,13 +1072,11 @@ gen_binop (ax, value, value1, value2, op, op_unsigned, may_carry, name)
 
 
 static void
-gen_logical_not (ax, value)
-     struct agent_expr *ax;
-     struct axs_value *value;
+gen_logical_not (struct agent_expr *ax, struct axs_value *value)
 {
   if (TYPE_CODE (value->type) != TYPE_CODE_INT
       && TYPE_CODE (value->type) != TYPE_CODE_PTR)
-    error ("Illegal type of operand to `!'.");
+    error (_("Invalid type of operand to `!'."));
 
   gen_usual_unary (ax, value);
   ax_simple (ax, aop_log_not);
@@ -1138,12 +1085,10 @@ gen_logical_not (ax, value)
 
 
 static void
-gen_complement (ax, value)
-     struct agent_expr *ax;
-     struct axs_value *value;
+gen_complement (struct agent_expr *ax, struct axs_value *value)
 {
   if (TYPE_CODE (value->type) != TYPE_CODE_INT)
-    error ("Illegal type of operand to `~'.");
+    error (_("Invalid type of operand to `~'."));
 
   gen_usual_unary (ax, value);
   gen_integral_promotions (ax, value);
@@ -1157,14 +1102,13 @@ gen_complement (ax, value)
 
 /* Dereference the value on the top of the stack.  */
 static void
-gen_deref (ax, value)
-     struct agent_expr *ax;
-     struct axs_value *value;
+gen_deref (struct agent_expr *ax, struct axs_value *value)
 {
   /* The caller should check the type, because several operators use
      this, and we don't know what error message to generate.  */
-  if (value->type->code != TYPE_CODE_PTR)
-    error ("GDB bug: ax-gdb.c (gen_deref): expected a pointer");
+  if (TYPE_CODE (value->type) != TYPE_CODE_PTR)
+    internal_error (__FILE__, __LINE__,
+		    _("gen_deref: expected a pointer"));
 
   /* We've got an rvalue now, which is a pointer.  We want to yield an
      lvalue, whose address is exactly that pointer.  So we don't
@@ -1172,21 +1116,19 @@ gen_deref (ax, value)
      T" to "T", and mark the value as an lvalue in memory.  Leave it
      to the consumer to actually dereference it.  */
   value->type = check_typedef (TYPE_TARGET_TYPE (value->type));
-  value->kind = ((value->type->code == TYPE_CODE_FUNC)
+  value->kind = ((TYPE_CODE (value->type) == TYPE_CODE_FUNC)
 		 ? axs_rvalue : axs_lvalue_memory);
 }
 
 
 /* Produce the address of the lvalue on the top of the stack.  */
 static void
-gen_address_of (ax, value)
-     struct agent_expr *ax;
-     struct axs_value *value;
+gen_address_of (struct agent_expr *ax, struct axs_value *value)
 {
   /* Special case for taking the address of a function.  The ANSI
      standard describes this as a special case, too, so this
      arrangement is not without motivation.  */
-  if (value->type->code == TYPE_CODE_FUNC)
+  if (TYPE_CODE (value->type) == TYPE_CODE_FUNC)
     /* The value's already an rvalue on the stack, so we just need to
        change the type.  */
     value->type = lookup_pointer_type (value->type);
@@ -1194,10 +1136,10 @@ gen_address_of (ax, value)
     switch (value->kind)
       {
       case axs_rvalue:
-	error ("Operand of `&' is an rvalue, which has no address.");
+	error (_("Operand of `&' is an rvalue, which has no address."));
 
       case axs_lvalue_register:
-	error ("Operand of `&' is in a register, and has no address.");
+	error (_("Operand of `&' is in a register, and has no address."));
 
       case axs_lvalue_memory:
 	value->kind = axs_rvalue;
@@ -1213,9 +1155,7 @@ gen_address_of (ax, value)
 /* Find the field in the structure type TYPE named NAME, and return
    its index in TYPE's field array.  */
 static int
-find_field (type, name)
-     struct type *type;
-     char *name;
+find_field (struct type *type, char *name)
 {
   int i;
 
@@ -1223,21 +1163,23 @@ find_field (type, name)
 
   /* Make sure this isn't C++.  */
   if (TYPE_N_BASECLASSES (type) != 0)
-    error ("GDB bug: ax-gdb.c (find_field): derived classes supported");
+    internal_error (__FILE__, __LINE__,
+		    _("find_field: derived classes supported"));
 
   for (i = 0; i < TYPE_NFIELDS (type); i++)
     {
       char *this_name = TYPE_FIELD_NAME (type, i);
 
-      if (this_name && STREQ (name, this_name))
+      if (this_name && strcmp (name, this_name) == 0)
 	return i;
 
       if (this_name[0] == '\0')
-	error ("GDB bug: ax-gdb.c (find_field): anonymous unions not supported");
+	internal_error (__FILE__, __LINE__,
+			_("find_field: anonymous unions not supported"));
     }
 
-  error ("Couldn't find member named `%s' in struct/union `%s'",
-	 name, type->tag_name);
+  error (_("Couldn't find member named `%s' in struct/union `%s'"),
+	 name, TYPE_TAG_NAME (type));
 
   return 0;
 }
@@ -1248,11 +1190,8 @@ find_field (type, name)
    starting and one-past-ending *bit* numbers of the field within the
    structure.  */
 static void
-gen_bitfield_ref (ax, value, type, start, end)
-     struct agent_expr *ax;
-     struct axs_value *value;
-     struct type *type;
-     int start, end;
+gen_bitfield_ref (struct agent_expr *ax, struct axs_value *value,
+		  struct type *type, int start, int end)
 {
   /* Note that ops[i] fetches 8 << i bits.  */
   static enum agent_op ops[]
@@ -1308,7 +1247,8 @@ gen_bitfield_ref (ax, value, type, start, end)
 
   /* Can we fetch the number of bits requested at all?  */
   if ((end - start) > ((1 << num_ops) * 8))
-    error ("GDB bug: ax-gdb.c (gen_bitfield_ref): bitfield too wide");
+    internal_error (__FILE__, __LINE__,
+		    _("gen_bitfield_ref: bitfield too wide"));
 
   /* Note that we know here that we only need to try each opcode once.
      That may not be true on machines with weird byte sizes.  */
@@ -1377,7 +1317,7 @@ gen_bitfield_ref (ax, value, type, start, end)
 	     the sign/zero extension will wipe them out.
 	     - If we're in the interior of the word, then there is no garbage
 	     on either end, because the ref operators zero-extend.  */
-	  if (TARGET_BYTE_ORDER == BIG_ENDIAN)
+	  if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 	    gen_left_shift (ax, end - (offset + op_size));
 	  else
 	    gen_left_shift (ax, offset - start);
@@ -1411,12 +1351,8 @@ gen_bitfield_ref (ax, value, type, start, end)
    the operator being compiled, and OPERAND_NAME is the kind of thing
    it operates on; we use them in error messages.  */
 static void
-gen_struct_ref (ax, value, field, operator_name, operand_name)
-     struct agent_expr *ax;
-     struct axs_value *value;
-     char *field;
-     char *operator_name;
-     char *operand_name;
+gen_struct_ref (struct agent_expr *ax, struct axs_value *value, char *field,
+		char *operator_name, char *operand_name)
 {
   struct type *type;
   int i;
@@ -1424,23 +1360,23 @@ gen_struct_ref (ax, value, field, operator_name, operand_name)
   /* Follow pointers until we reach a non-pointer.  These aren't the C
      semantics, but they're what the normal GDB evaluator does, so we
      should at least be consistent.  */
-  while (value->type->code == TYPE_CODE_PTR)
+  while (TYPE_CODE (value->type) == TYPE_CODE_PTR)
     {
       gen_usual_unary (ax, value);
       gen_deref (ax, value);
     }
-  type = value->type;
+  type = check_typedef (value->type);
 
   /* This must yield a structure or a union.  */
   if (TYPE_CODE (type) != TYPE_CODE_STRUCT
       && TYPE_CODE (type) != TYPE_CODE_UNION)
-    error ("The left operand of `%s' is not a %s.",
+    error (_("The left operand of `%s' is not a %s."),
 	   operator_name, operand_name);
 
   /* And it must be in memory; we don't deal with structure rvalues,
      or structures living in registers.  */
   if (value->kind != axs_lvalue_memory)
-    error ("Structure does not live in memory.");
+    error (_("Structure does not live in memory."));
 
   i = find_field (type, field);
 
@@ -1471,17 +1407,15 @@ gen_struct_ref (ax, value, field, operator_name, operand_name)
    stack slots, doing weird things with sizeof, etc.  So we require
    the right operand to be a constant expression.  */
 static void
-gen_repeat (pc, ax, value)
-     union exp_element **pc;
-     struct agent_expr *ax;
-     struct axs_value *value;
+gen_repeat (union exp_element **pc, struct agent_expr *ax,
+	    struct axs_value *value)
 {
   struct axs_value value1;
   /* We don't want to turn this into an rvalue, so no conversions
      here.  */
   gen_expr (pc, ax, &value1);
   if (value1.kind != axs_lvalue_memory)
-    error ("Left operand of `@' must be an object in memory.");
+    error (_("Left operand of `@' must be an object in memory."));
 
   /* Evaluate the length; it had better be a constant.  */
   {
@@ -1489,12 +1423,12 @@ gen_repeat (pc, ax, value)
     int length;
 
     if (!v)
-      error ("Right operand of `@' must be a constant, in agent expressions.");
-    if (v->type->code != TYPE_CODE_INT)
-      error ("Right operand of `@' must be an integer.");
+      error (_("Right operand of `@' must be a constant, in agent expressions."));
+    if (TYPE_CODE (value_type (v)) != TYPE_CODE_INT)
+      error (_("Right operand of `@' must be an integer."));
     length = value_as_long (v);
     if (length <= 0)
-      error ("Right operand of `@' must be positive.");
+      error (_("Right operand of `@' must be positive."));
 
     /* The top of the stack is already the address of the object, so
        all we need to do is frob the type of the lvalue.  */
@@ -1516,10 +1450,8 @@ gen_repeat (pc, ax, value)
    *PC should point at the start of the operand expression; we advance it
    to the first instruction after the operand.  */
 static void
-gen_sizeof (pc, ax, value)
-     union exp_element **pc;
-     struct agent_expr *ax;
-     struct axs_value *value;
+gen_sizeof (union exp_element **pc, struct agent_expr *ax,
+	    struct axs_value *value)
 {
   /* We don't care about the value of the operand expression; we only
      care about its type.  However, in the current arrangement, the
@@ -1540,13 +1472,12 @@ gen_sizeof (pc, ax, value)
 
 /* Generating bytecode from GDB expressions: general recursive thingy  */
 
+/* XXX: i18n */
 /* A gen_expr function written by a Gen-X'er guy.
    Append code for the subexpression of EXPR starting at *POS_P to AX.  */
 static void
-gen_expr (pc, ax, value)
-     union exp_element **pc;
-     struct agent_expr *ax;
-     struct axs_value *value;
+gen_expr (union exp_element **pc, struct agent_expr *ax,
+	  struct axs_value *value)
 {
   /* Used to hold the descriptions of operand expressions.  */
   struct axs_value value1, value2;
@@ -1560,7 +1491,7 @@ gen_expr (pc, ax, value)
       {
 	ax_const_l (ax, value_as_long (v));
 	value->kind = axs_rvalue;
-	value->type = check_typedef (VALUE_TYPE (v));
+	value->type = check_typedef (value_type (v));
 	return;
       }
   }
@@ -1607,7 +1538,7 @@ gen_expr (pc, ax, value)
 	case BINOP_SUBSCRIPT:
 	  gen_add (ax, value, &value1, &value2, "array subscripting");
 	  if (TYPE_CODE (value->type) != TYPE_CODE_PTR)
-	    error ("Illegal combination of types in array subscripting.");
+	    error (_("Invalid combination of types in array subscripting."));
 	  gen_deref (ax, value);
 	  break;
 	case BINOP_BITWISE_AND:
@@ -1628,7 +1559,8 @@ gen_expr (pc, ax, value)
 	default:
 	  /* We should only list operators in the outer case statement
 	     that we actually handle in the inner case statement.  */
-	  error ("GDB bug: ax-gdb.c (gen_expr): op case sets don't match");
+	  internal_error (__FILE__, __LINE__,
+			  _("gen_expr: op case sets don't match"));
 	}
       break;
 
@@ -1669,12 +1601,12 @@ gen_expr (pc, ax, value)
 	(*pc) += 3;
 	value->kind = axs_lvalue_register;
 	value->u.reg = reg;
-	value->type = REGISTER_VIRTUAL_TYPE (reg);
+	value->type = register_type (current_gdbarch, reg);
       }
       break;
 
     case OP_INTERNALVAR:
-      error ("GDB agent expressions cannot use convenience variables.");
+      error (_("GDB agent expressions cannot use convenience variables."));
 
       /* Weirdo operator: see comments for gen_repeat for details.  */
     case BINOP_REPEAT:
@@ -1703,12 +1635,20 @@ gen_expr (pc, ax, value)
 	   the given type, and dereference it.  */
 	if (value->kind != axs_rvalue)
 	  /* This would be weird.  */
-	  error ("GDB bug: ax-gdb.c (gen_expr): OP_MEMVAL operand isn't an rvalue???");
+	  internal_error (__FILE__, __LINE__,
+			  _("gen_expr: OP_MEMVAL operand isn't an rvalue???"));
 	value->type = type;
 	value->kind = axs_lvalue_memory;
       }
       break;
 
+    case UNOP_PLUS:
+      (*pc)++;
+      /* + FOO is equivalent to 0 + FOO, which can be optimized. */
+      gen_expr (pc, ax, value);
+      gen_usual_unary (ax, value);
+      break;
+      
     case UNOP_NEG:
       (*pc)++;
       /* -FOO is equivalent to 0 - FOO.  */
@@ -1737,7 +1677,7 @@ gen_expr (pc, ax, value)
       gen_expr (pc, ax, value);
       gen_usual_unary (ax, value);
       if (TYPE_CODE (value->type) != TYPE_CODE_PTR)
-	error ("Argument of unary `*' is not a pointer.");
+	error (_("Argument of unary `*' is not a pointer."));
       gen_deref (ax, value);
       break;
 
@@ -1771,36 +1711,34 @@ gen_expr (pc, ax, value)
 	else
 	  /* If this `if' chain doesn't handle it, then the case list
 	     shouldn't mention it, and we shouldn't be here.  */
-	  error ("GDB bug: ax-gdb.c (gen_expr): unhandled struct case");
+	  internal_error (__FILE__, __LINE__,
+			  _("gen_expr: unhandled struct case"));
       }
       break;
 
     case OP_TYPE:
-      error ("Attempt to use a type name as an expression.");
+      error (_("Attempt to use a type name as an expression."));
 
     default:
-      error ("Unsupported operator in expression.");
+      error (_("Unsupported operator in expression."));
     }
 }
 
 
 
-#if 0				/* not used */
 /* Generating bytecode from GDB expressions: driver */
 
 /* Given a GDB expression EXPR, produce a string of agent bytecode
    which computes its value.  Return the agent expression, and set
    *VALUE to describe its type, and whether it's an lvalue or rvalue.  */
 struct agent_expr *
-expr_to_agent (expr, value)
-     struct expression *expr;
-     struct axs_value *value;
+expr_to_agent (struct expression *expr, struct axs_value *value)
 {
   struct cleanup *old_chain = 0;
-  struct agent_expr *ax = new_agent_expr ();
+  struct agent_expr *ax = new_agent_expr (0);
   union exp_element *pc;
 
-  old_chain = make_cleanup ((make_cleanup_func) free_agent_expr, ax);
+  old_chain = make_cleanup_free_agent_expr (ax);
 
   pc = expr->elts;
   trace_kludge = 0;
@@ -1814,14 +1752,14 @@ expr_to_agent (expr, value)
 }
 
 
+#if 0				/* not used */
 /* Given a GDB expression EXPR denoting an lvalue in memory, produce a
    string of agent bytecode which will leave its address and size on
    the top of stack.  Return the agent expression.
 
    Not sure this function is useful at all.  */
 struct agent_expr *
-expr_to_address_and_size (expr)
-     struct expression *expr;
+expr_to_address_and_size (struct expression *expr)
 {
   struct axs_value value;
   struct agent_expr *ax = expr_to_agent (expr, &value);
@@ -1830,7 +1768,7 @@ expr_to_address_and_size (expr)
   if (value.kind != axs_lvalue_memory)
     {
       free_agent_expr (ax);
-      error ("Expression does not denote an object in memory.");
+      error (_("Expression does not denote an object in memory."));
     }
 
   /* Push the object's size on the stack.  */
@@ -1838,7 +1776,7 @@ expr_to_address_and_size (expr)
 
   return ax;
 }
-#endif /* 0 */
+#endif
 
 /* Given a GDB expression EXPR, return bytecode to trace its value.
    The result will use the `trace' and `trace_quick' bytecodes to
@@ -1846,16 +1784,14 @@ expr_to_address_and_size (expr)
    caller can then use the ax_reqs function to discover which
    registers it relies upon.  */
 struct agent_expr *
-gen_trace_for_expr (scope, expr)
-     CORE_ADDR scope;
-     struct expression *expr;
+gen_trace_for_expr (CORE_ADDR scope, struct expression *expr)
 {
   struct cleanup *old_chain = 0;
   struct agent_expr *ax = new_agent_expr (scope);
   union exp_element *pc;
   struct axs_value value;
 
-  old_chain = make_cleanup ((make_cleanup_func) free_agent_expr, ax);
+  old_chain = make_cleanup_free_agent_expr (ax);
 
   pc = expr->elts;
   trace_kludge = 1;
@@ -1873,60 +1809,29 @@ gen_trace_for_expr (scope, expr)
   discard_cleanups (old_chain);
   return ax;
 }
-
-
-
-/* The "agent" command, for testing: compile and disassemble an expression.  */
 
 static void
-print_axs_value (f, value)
-     GDB_FILE *f;
-     struct axs_value *value;
-{
-  switch (value->kind)
-    {
-    case axs_rvalue:
-      fputs_filtered ("rvalue", f);
-      break;
-
-    case axs_lvalue_memory:
-      fputs_filtered ("memory lvalue", f);
-      break;
-
-    case axs_lvalue_register:
-      fprintf_filtered (f, "register %d lvalue", value->u.reg);
-      break;
-    }
-
-  fputs_filtered (" : ", f);
-  type_print (value->type, "", f, -1);
-}
-
-
-static void
-agent_command (exp, from_tty)
-     char *exp;
-     int from_tty;
+agent_command (char *exp, int from_tty)
 {
   struct cleanup *old_chain = 0;
   struct expression *expr;
   struct agent_expr *agent;
-  struct frame_info *fi = get_current_frame ();		/* need current scope */
+  struct frame_info *fi = get_current_frame ();	/* need current scope */
 
   /* We don't deal with overlay debugging at the moment.  We need to
      think more carefully about this.  If you copy this code into
      another command, change the error message; the user shouldn't
      have to know anything about agent expressions.  */
   if (overlay_debugging)
-    error ("GDB can't do agent expression translation with overlays.");
+    error (_("GDB can't do agent expression translation with overlays."));
 
   if (exp == 0)
-    error_no_arg ("expression to translate");
+    error_no_arg (_("expression to translate"));
 
   expr = parse_expression (exp);
-  old_chain = make_cleanup ((make_cleanup_func) free_current_contents, &expr);
-  agent = gen_trace_for_expr (fi->pc, expr);
-  make_cleanup ((make_cleanup_func) free_agent_expr, agent);
+  old_chain = make_cleanup (free_current_contents, &expr);
+  agent = gen_trace_for_expr (get_frame_pc (fi), expr);
+  make_cleanup_free_agent_expr (agent);
   ax_print (gdb_stdout, agent);
 
   /* It would be nice to call ax_reqs here to gather some general info
@@ -1939,13 +1844,11 @@ agent_command (exp, from_tty)
 
 /* Initialization code.  */
 
-void _initialize_ax_gdb PARAMS ((void));
+void _initialize_ax_gdb (void);
 void
-_initialize_ax_gdb ()
+_initialize_ax_gdb (void)
 {
-  struct cmd_list_element *c;
-
   add_cmd ("agent", class_maintenance, agent_command,
-	   "Translate an expression into remote agent bytecode.",
+	   _("Translate an expression into remote agent bytecode."),
 	   &maintenancelist);
 }