*** empty log message ***

[deliverable/binutils-gdb.git] / gdb / ax-gdb.c

diff --git a/gdb/ax-gdb.c b/gdb/ax-gdb.c
index e0d6ce581c637dd791ed1c4c5fb3b781a04ff4d2..b527663fe01f32420b7729b35406d2f12957d9b9 100644 (file)
--- a/gdb/ax-gdb.c
+++ b/gdb/ax-gdb.c
@@ -1,11 +1,13 @@
-/* GDB-specific functions for operating on agent expressions
-   Copyright 1998, 2000 Free Software Foundation, Inc.
+/* GDB-specific functions for operating on agent expressions.
+
+   Copyright (C) 1998, 1999, 2000, 2001, 2003, 2007, 2008
+   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
 
    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,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,


@@ -14,9 +16,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    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 "symtab.h"
 
 #include "defs.h"
 #include "symtab.h"


@@ -30,6 +30,9 @@
 #include "target.h"
 #include "ax.h"
 #include "ax-gdb.h"
 #include "target.h"
 #include "ax.h"
 #include "ax-gdb.h"

+#include "gdb_string.h"
+#include "block.h"
+#include "regcache.h"

 
 /* 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,
 
 /* 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,


@@ -129,7 +132,6 @@ static void gen_sizeof (union exp_element **pc,
 static void gen_expr (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 print_axs_value (struct ui_file *f, struct axs_value * value);

 static void agent_command (char *exp, int from_tty);
 \f
 
 static void agent_command (char *exp, int from_tty);
 \f
 


@@ -154,8 +156,7 @@ static void agent_command (char *exp, int from_tty);
    proletariat?  */
 
 static struct value *
    proletariat?  */
 
 static struct value *

-const_var_ref (var)
-     struct symbol *var;
+const_var_ref (struct symbol *var)

 {
   struct type *type = SYMBOL_TYPE (var);
 
 {
   struct type *type = SYMBOL_TYPE (var);
 


@@ -178,8 +179,7 @@ const_var_ref (var)
    advanced to the end of it.  If we return zero, *PC could be
    anywhere.  */
 static struct value *
    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;
 {
   enum exp_opcode op = (*pc)->opcode;
   struct value *v1;


@@ -220,8 +220,7 @@ const_expr (pc)
 /* Like const_expr, but guarantee also that *PC is undisturbed if the
    expression is not constant.  */
 static struct value *
 /* 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);
 {
   union exp_element *tentative_pc = *pc;
   struct value *v = const_expr (&tentative_pc);


@@ -307,9 +306,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
    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)
 {
   if (trace_kludge)
     switch (value->kind)


@@ -322,7 +319,7 @@ gen_traced_pop (ax, value)
 
       case axs_lvalue_memory:
        {
 
       case axs_lvalue_memory:
        {

-         int length = TYPE_LENGTH (value->type);
+         int length = TYPE_LENGTH (check_typedef (value->type));

 
          /* There's no point in trying to use a trace_quick bytecode
             here, since "trace_quick SIZE pop" is three bytes, whereas
 
          /* There's no point in trying to use a trace_quick bytecode
             here, since "trace_quick SIZE pop" is three bytes, whereas


@@ -354,13 +351,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
 /* 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))
 {
   /* 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);

 }
 
 
 }
 
 


@@ -368,11 +363,9 @@ gen_sign_extend (ax, type)
    TYPE, and the upper bits are garbage.  Sign-extend or truncate as
    needed.  */
 static void
    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));
 }
   /* I just had to.  */
   ((TYPE_UNSIGNED (type) ? ax_zero_ext : ax_ext) (ax, bits));
 }


@@ -382,9 +375,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
    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)
     {
 {
   if (trace_kludge)
     {


@@ -392,7 +383,7 @@ gen_fetch (ax, type)
       ax_trace_quick (ax, TYPE_LENGTH (type));
     }
 
       ax_trace_quick (ax, TYPE_LENGTH (type));
     }
 

-  switch (type->code)
+  switch (TYPE_CODE (type))

     {
     case TYPE_CODE_PTR:
     case TYPE_CODE_ENUM:
     {
     case TYPE_CODE_PTR:
     case TYPE_CODE_ENUM:


@@ -400,7 +391,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?  */
     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);
        {
        case 8 / TARGET_CHAR_BIT:
          ax_simple (ax, aop_ref8);


@@ -420,7 +411,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:
             implementing something we should be (this code's fault).
             In any case, it's a bug the user shouldn't see.  */
        default:

-         internal_error ("ax-gdb.c (gen_fetch): strange size");
+         internal_error (__FILE__, __LINE__,
+                         _("gen_fetch: strange size"));

        }
 
       gen_sign_extend (ax, type);
        }
 
       gen_sign_extend (ax, type);


@@ -431,7 +423,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.  */
          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.  */

-      internal_error ("ax-gdb.c (gen_fetch): bad type code");
+      internal_error (__FILE__, __LINE__,
+                     _("gen_fetch: bad type code"));

     }
 }
 
     }
 }
 


@@ -440,9 +433,7 @@ gen_fetch (ax, type)
    right shift it by -DISTANCE bits if DISTANCE < 0.  This generates
    unsigned (logical) right shifts.  */
 static void
    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)
     {
 {
   if (distance > 0)
     {


@@ -463,12 +454,13 @@ gen_left_shift (ax, distance)
 /* Generate code to push the base address of the argument portion of
    the top stack frame.  */
 static void
 /* 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);
+  gdbarch_virtual_frame_pointer (current_gdbarch,
+                                ax->scope, &frame_reg, &frame_offset);

   ax_reg (ax, frame_reg);
   gen_offset (ax, frame_offset);
 }
   ax_reg (ax, frame_reg);
   gen_offset (ax, frame_offset);
 }


@@ -477,12 +469,13 @@ gen_frame_args_address (ax)
 /* Generate code to push the base address of the locals portion of the
    top stack frame.  */
 static void
 /* 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);
+  gdbarch_virtual_frame_pointer (current_gdbarch,
+                                ax->scope, &frame_reg, &frame_offset);

   ax_reg (ax, frame_reg);
   gen_offset (ax, frame_offset);
 }
   ax_reg (ax, frame_reg);
   gen_offset (ax, frame_offset);
 }


@@ -494,9 +487,7 @@ gen_frame_locals_address (ax)
    programming in ML, it would be clearer why these are the same
    thing.  */
 static void
    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
 {
   /* It would suffice to simply push the offset and add it, but this
      makes it easier to read positive and negative offsets in the


@@ -518,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
    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));
 }
 {
   gen_offset (ax, SYMBOL_VALUE (var));
 }


@@ -530,10 +519,7 @@ gen_sym_offset (ax, var)
    symbol VAR.  Set VALUE to describe the result.  */
 
 static void
    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));
 {
   /* Dereference any typedefs. */
   value->type = check_typedef (SYMBOL_TYPE (var));


@@ -552,7 +538,8 @@ gen_var_ref (ax, value, var)
       break;
 
     case LOC_CONST_BYTES:
       break;
 
     case LOC_CONST_BYTES:

-      internal_error ("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:
 
       /* Variable at a fixed location in memory.  Easy.  */
     case LOC_STATIC:


@@ -591,8 +578,8 @@ gen_var_ref (ax, value, var)
       break;
 
     case LOC_TYPEDEF:
       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:
       break;
 
     case LOC_BLOCK:


@@ -621,9 +608,9 @@ gen_var_ref (ax, value, var)
     case LOC_UNRESOLVED:
       {
        struct minimal_symbol *msym
     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)
        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));
 
        /* Push the address of the variable.  */
        ax_const_l (ax, SYMBOL_VALUE_ADDRESS (msym));


@@ -631,14 +618,24 @@ gen_var_ref (ax, value, var)
       }
       break;
 
       }
       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:
     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:
       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;
     }
 }
       break;
     }
 }


@@ -648,15 +645,12 @@ gen_var_ref (ax, value, var)
 /* Generating bytecode from GDB expressions: literals */
 
 static void
 /* 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;
 {
   ax_const_l (ax, k);
   value->kind = axs_rvalue;

-  value->type = type;
+  value->type = check_typedef (type);

 }
 \f
 
 }
 \f
 


@@ -667,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
    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)
     {
 {
   switch (value->kind)
     {


@@ -714,16 +706,14 @@ require_rvalue (ax, value)
    lvalue through unchanged, and let `+' raise an error.  */
 
 static void
    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.  */
 {
   /* 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:
     {
       /* Functions get converted to a pointer to the function.  */
     case TYPE_CODE_FUNC:


@@ -763,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
 /* 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)
 {
   return (TYPE_LENGTH (type1) > TYPE_LENGTH (type2)
          || (TYPE_LENGTH (type1) == TYPE_LENGTH (type2)


@@ -775,8 +764,7 @@ type_wider_than (type1, type2)
 
 /* Return the "wider" of the two types TYPE1 and TYPE2.  */
 static struct type *
 
 /* 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;
 }
 {
   return type_wider_than (type1, type2) ? type1 : type2;
 }


@@ -784,9 +772,7 @@ max_type (type1, type2)
 
 /* Generate code to convert a scalar value of type FROM to type TO.  */
 static void
 
 /* 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.  */
 
 {
   /* Perhaps there is a more graceful way to state these rules.  */
 


@@ -816,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
 /* 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;
 {
   struct agent_expr *ax = new_agent_expr (0);
   int nontrivial;


@@ -841,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
    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
 {
   /* Do the usual binary conversions.  */
   if (TYPE_CODE (value1->type) == TYPE_CODE_INT


@@ -870,7 +854,7 @@ gen_usual_arithmetic (ax, value1, value2)
          ax_simple (ax, aop_swap);
        }
 
          ax_simple (ax, aop_swap);
        }
 

-      value1->type = value2->type = target;
+      value1->type = value2->type = check_typedef (target);

     }
 }
 
     }
 }
 


@@ -879,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
    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))
     {
 {
   if (!type_wider_than (value->type, builtin_type_int))
     {


@@ -898,10 +880,7 @@ gen_integral_promotions (ax, value)
 
 /* Generate code for a cast to TYPE.  */
 static void
 
 /* 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.  */
 {
   /* GCC does allow casts to yield lvalues, so this should be fixed
      before merging these changes into the trunk.  */


@@ -909,7 +888,7 @@ gen_cast (ax, value, type)
   /* Dereference typedefs. */
   type = check_typedef (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
     {
     case TYPE_CODE_PTR:
       /* It's implementation-defined, and I'll bet this is what GCC


@@ -920,15 +899,14 @@ gen_cast (ax, value, type)
     case TYPE_CODE_STRUCT:
     case TYPE_CODE_UNION:
     case TYPE_CODE_FUNC:
     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
          all our integral values are fully sign-extended, and when
          casting pointers we can do anything we like.  Is there any
 
     case TYPE_CODE_ENUM:
       /* We don't have to worry about the size of the value, because
          all our integral values are fully sign-extended, and when
          casting pointers we can do anything we like.  Is there any

-         way for us to actually know what GCC actually does with a
-         cast like this?  */
-      value->type = type;
+         way for us to know what GCC actually does with a cast like
+         this?  */

       break;
 
     case TYPE_CODE_INT:
       break;
 
     case TYPE_CODE_INT:


@@ -943,7 +921,7 @@ gen_cast (ax, value, type)
       break;
 
     default:
       break;
 
     default:

-      error ("Casts to requested type are not yet implemented.");
+      error (_("Casts to requested type are not yet implemented."));

     }
 
   value->type = type;
     }
 
   value->type = type;


@@ -956,16 +934,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
 /* 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);
 
 {
   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);
     }
 }
       ax_simple (ax, op);
     }
 }


@@ -977,14 +952,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
    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?  */
 {
   /* 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);
     {
       /* Swap the values and proceed normally.  */
       ax_simple (ax, aop_swap);


@@ -995,8 +968,8 @@ gen_add (ax, value, value1, value2, name)
     }
 
   /* Is it PTR+INT?  */
     }
 
   /* 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);
     {
       gen_scale (ax, aop_mul, value1->type);
       ax_simple (ax, aop_add);


@@ -1006,8 +979,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.  */
 
   /* 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.  */
     {
       ax_simple (ax, aop_add);
       gen_extend (ax, value1->type);   /* Catch overflow.  */


@@ -1015,7 +988,7 @@ gen_add (ax, value, value1, value2, name)
     }
 
   else
     }
 
   else

-    error ("Illegal combination of types in %s.", name);
+    error (_("Invalid combination of types in %s."), name);

 
   value->kind = axs_rvalue;
 }
 
   value->kind = axs_rvalue;
 }


@@ -1026,14 +999,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
    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)

 {
 {

-  if (value1->type->code == TYPE_CODE_PTR)
+  if (TYPE_CODE (value1->type) == TYPE_CODE_PTR)

     {
       /* Is it PTR - INT?  */
     {
       /* 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);
        {
          gen_scale (ax, aop_mul, value1->type);
          ax_simple (ax, aop_sub);


@@ -1044,7 +1016,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.  */
       /* 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))))
        {
               && (TYPE_LENGTH (TYPE_TARGET_TYPE (value1->type))
                   == TYPE_LENGTH (TYPE_TARGET_TYPE (value2->type))))
        {


@@ -1053,14 +1025,14 @@ gen_sub (ax, value, value1, value2)
          value->type = builtin_type_long;      /* FIXME --- should be ptrdiff_t */
        }
       else
          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\
 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.  */
     }
 
   /* 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.  */
     {
       ax_simple (ax, aop_sub);
       gen_extend (ax, value1->type);   /* Catch overflow.  */


@@ -1068,7 +1040,7 @@ an integer nor a pointer of the same type.");
     }
 
   else
     }
 
   else

-    error ("Illegal combination of types in subtraction.");
+    error (_("Invalid combination of types in subtraction."));

 
   value->kind = axs_rvalue;
 }
 
   value->kind = axs_rvalue;
 }


@@ -1080,17 +1052,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
    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.  */
 {
   /* 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);
 
   ax_simple (ax,
             TYPE_UNSIGNED (value1->type) ? op_unsigned : op);


@@ -1102,13 +1071,11 @@ gen_binop (ax, value, value1, value2, op, op_unsigned, may_carry, name)
 
 
 static void
 
 
 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)
 {
   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);
 
   gen_usual_unary (ax, value);
   ax_simple (ax, aop_log_not);


@@ -1117,12 +1084,10 @@ gen_logical_not (ax, value)
 
 
 static void
 
 
 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)
 {
   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);
 
   gen_usual_unary (ax, value);
   gen_integral_promotions (ax, value);


@@ -1136,14 +1101,13 @@ gen_complement (ax, value)
 
 /* Dereference the value on the top of the stack.  */
 static void
 
 /* 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.  */
 {
   /* 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)
-    internal_error ("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
 
   /* 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


@@ -1151,21 +1115,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));
      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
                 ? 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.  */
 {
   /* 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);
     /* The value's already an rvalue on the stack, so we just need to
        change the type.  */
     value->type = lookup_pointer_type (value->type);


@@ -1173,10 +1135,10 @@ gen_address_of (ax, value)
     switch (value->kind)
       {
       case axs_rvalue:
     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:
 
       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;
 
       case axs_lvalue_memory:
        value->kind = axs_rvalue;


@@ -1192,9 +1154,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 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;
 
 {
   int i;
 


@@ -1202,21 +1162,26 @@ find_field (type, name)
 
   /* Make sure this isn't C++.  */
   if (TYPE_N_BASECLASSES (type) != 0)
 
   /* Make sure this isn't C++.  */
   if (TYPE_N_BASECLASSES (type) != 0)

-    internal_error ("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);
 
 
   for (i = 0; i < TYPE_NFIELDS (type); i++)
     {
       char *this_name = TYPE_FIELD_NAME (type, i);
 

-      if (this_name && STREQ (name, this_name))
-       return i;
+      if (this_name)
+       {
+         if (strcmp (name, this_name) == 0)
+           return i;

 
 

-      if (this_name[0] == '\0')
-       internal_error ("ax-gdb.c (find_field): anonymous unions not supported");
+         if (this_name[0] == '\0')
+           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;
 }
 
   return 0;
 }


@@ -1227,11 +1192,8 @@ find_field (type, name)
    starting and one-past-ending *bit* numbers of the field within the
    structure.  */
 static void
    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[]
 {
   /* Note that ops[i] fetches 8 << i bits.  */
   static enum agent_op ops[]


@@ -1287,7 +1249,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))
 
   /* Can we fetch the number of bits requested at all?  */
   if ((end - start) > ((1 << num_ops) * 8))

-    internal_error ("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.  */
 
   /* 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.  */


@@ -1356,7 +1319,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.  */
             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 (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)

            gen_left_shift (ax, end - (offset + op_size));
          else
            gen_left_shift (ax, offset - start);
            gen_left_shift (ax, end - (offset + op_size));
          else
            gen_left_shift (ax, offset - start);


@@ -1390,12 +1353,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
    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;
 {
   struct type *type;
   int i;


@@ -1403,23 +1362,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.  */
   /* 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);
     }
     {
       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)
 
   /* 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)
           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);
 
 
   i = find_field (type, field);
 


@@ -1450,17 +1409,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
    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)
 {
   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.  */
   {
 
   /* Evaluate the length; it had better be a constant.  */
   {


@@ -1468,12 +1425,12 @@ gen_repeat (pc, ax, value)
     int length;
 
     if (!v)
     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)
     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.  */
 
     /* 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.  */


@@ -1495,10 +1452,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
    *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
 {
   /* We don't care about the value of the operand expression; we only
      care about its type.  However, in the current arrangement, the


@@ -1519,13 +1474,12 @@ gen_sizeof (pc, ax, value)
 
 /* Generating bytecode from GDB expressions: general recursive thingy  */
 
 
 /* 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
 /* 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;
 {
   /* Used to hold the descriptions of operand expressions.  */
   struct axs_value value1, value2;


@@ -1539,7 +1493,7 @@ gen_expr (pc, ax, value)
       {
        ax_const_l (ax, value_as_long (v));
        value->kind = axs_rvalue;
       {
        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;
       }
   }
        return;
       }
   }


@@ -1586,7 +1540,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)
        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:
          gen_deref (ax, value);
          break;
        case BINOP_BITWISE_AND:


@@ -1607,7 +1561,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.  */
        default:
          /* We should only list operators in the outer case statement
             that we actually handle in the inner case statement.  */

-         internal_error ("ax-gdb.c (gen_expr): op case sets don't match");
+         internal_error (__FILE__, __LINE__,
+                         _("gen_expr: op case sets don't match"));

        }
       break;
 
        }
       break;
 


@@ -1644,16 +1599,22 @@ gen_expr (pc, ax, value)
 
     case OP_REGISTER:
       {
 
     case OP_REGISTER:
       {

-       int reg = (int) (*pc)[1].longconst;
-       (*pc) += 3;
+       const char *name = &(*pc)[2].string;
+       int reg;
+       (*pc) += 4 + BYTES_TO_EXP_ELEM ((*pc)[1].longconst + 1);
+       reg = frame_map_name_to_regnum (deprecated_safe_get_selected_frame (),
+                                       name, strlen (name));
+       if (reg == -1)
+         internal_error (__FILE__, __LINE__,
+                         _("Register $%s not available"), name);

        value->kind = axs_lvalue_register;
        value->u.reg = reg;
        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:
       }
       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:
 
       /* Weirdo operator: see comments for gen_repeat for details.  */
     case BINOP_REPEAT:


@@ -1682,12 +1643,20 @@ gen_expr (pc, ax, value)
           the given type, and dereference it.  */
        if (value->kind != axs_rvalue)
          /* This would be weird.  */
           the given type, and dereference it.  */
        if (value->kind != axs_rvalue)
          /* This would be weird.  */

-         internal_error ("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;
 
        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.  */
     case UNOP_NEG:
       (*pc)++;
       /* -FOO is equivalent to 0 - FOO.  */


@@ -1716,7 +1685,7 @@ gen_expr (pc, ax, value)
       gen_expr (pc, ax, value);
       gen_usual_unary (ax, value);
       if (TYPE_CODE (value->type) != TYPE_CODE_PTR)
       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;
 
       gen_deref (ax, value);
       break;
 


@@ -1750,15 +1719,16 @@ 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.  */
        else
          /* If this `if' chain doesn't handle it, then the case list
             shouldn't mention it, and we shouldn't be here.  */

-         internal_error ("ax-gdb.c (gen_expr): unhandled struct case");
+         internal_error (__FILE__, __LINE__,
+                         _("gen_expr: unhandled struct case"));

       }
       break;
 
     case OP_TYPE:
       }
       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:
 
     default:

-      error ("Unsupported operator in expression.");
+      error (_("Unsupported operator in expression."));

     }
 }
 \f
     }
 }
 \f


@@ -1766,68 +1736,13 @@ gen_expr (pc, ax, value)
 
 /* Generating bytecode from GDB expressions: driver */
 
 
 /* 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;
-{
-  struct cleanup *old_chain = 0;
-  struct agent_expr *ax = new_agent_expr (0);
-  union exp_element *pc;
-
-  old_chain = make_cleanup_free_agent_expr (ax);
-
-  pc = expr->elts;
-  trace_kludge = 0;
-  gen_expr (&pc, ax, value);
-
-  /* We have successfully built the agent expr, so cancel the cleanup
-     request.  If we add more cleanups that we always want done, this
-     will have to get more complicated.  */
-  discard_cleanups (old_chain);
-  return ax;
-}
-
-
-#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;
-{
-  struct axs_value value;
-  struct agent_expr *ax = expr_to_agent (expr, &value);
-
-  /* Complain if the result is not a memory lvalue.  */
-  if (value.kind != axs_lvalue_memory)
-    {
-      free_agent_expr (ax);
-      error ("Expression does not denote an object in memory.");
-    }
-
-  /* Push the object's size on the stack.  */
-  ax_const_l (ax, TYPE_LENGTH (value.type));
-
-  return ax;
-}
-#endif
-

 /* Given a GDB expression EXPR, return bytecode to trace its value.
    The result will use the `trace' and `trace_quick' bytecodes to
    record the value of all memory touched by the expression.  The
    caller can then use the ax_reqs function to discover which
    registers it relies upon.  */
 struct agent_expr *
 /* Given a GDB expression EXPR, return bytecode to trace its value.
    The result will use the `trace' and `trace_quick' bytecodes to
    record the value of all memory touched by the expression.  The
    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);
 {
   struct cleanup *old_chain = 0;
   struct agent_expr *ax = new_agent_expr (scope);


@@ -1852,40 +1767,9 @@ gen_trace_for_expr (scope, expr)
   discard_cleanups (old_chain);
   return ax;
 }
   discard_cleanups (old_chain);
   return ax;
 }

-\f
-
-
-/* The "agent" command, for testing: compile and disassemble an expression.  */
-
-static void
-print_axs_value (f, value)
-     struct ui_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
 
 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 cleanup *old_chain = 0;
   struct expression *expr;


@@ -1897,14 +1781,14 @@ agent_command (exp, from_tty)
      another command, change the error message; the user shouldn't
      have to know anything about agent expressions.  */
   if (overlay_debugging)
      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)
 
   if (exp == 0)

-    error_no_arg ("expression to translate");
+    error_no_arg (_("expression to translate"));

 
   expr = parse_expression (exp);
   old_chain = make_cleanup (free_current_contents, &expr);
 
   expr = parse_expression (exp);
   old_chain = make_cleanup (free_current_contents, &expr);

-  agent = gen_trace_for_expr (fi->pc, expr);
+  agent = gen_trace_for_expr (get_frame_pc (fi), expr);

   make_cleanup_free_agent_expr (agent);
   ax_print (gdb_stdout, agent);
 
   make_cleanup_free_agent_expr (agent);
   ax_print (gdb_stdout, agent);
 


@@ -1920,9 +1804,9 @@ agent_command (exp, from_tty)
 
 void _initialize_ax_gdb (void);
 void
 
 void _initialize_ax_gdb (void);
 void

-_initialize_ax_gdb ()
+_initialize_ax_gdb (void)

 {
   add_cmd ("agent", class_maintenance, agent_command,
 {
   add_cmd ("agent", class_maintenance, agent_command,

-          "Translate an expression into remote agent bytecode.",
+          _("Translate an expression into remote agent bytecode."),

           &maintenancelist);
 }
           &maintenancelist);
 }