oops - omitted from previous delta

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

diff --git a/gdb/wrapper.c b/gdb/wrapper.c
index 4ee8fa248c1d5d4643a4568274eee5109a412c90..6c9c6d60cefe378d1c05710db66ffa243c328cbe 100644 (file)
--- a/gdb/wrapper.c
+++ b/gdb/wrapper.c
@@ -1,5 +1,5 @@
 /* Longjump free calls to gdb internal routines.
-   Copyright 1999 Free Software Foundation, Inc.
+   Copyright 1999, 2000 Free Software Foundation, Inc.
 
    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
@@ -18,7 +18,6 @@
 
 #include "defs.h"
 #include "value.h"
-#include "frame.h"
 #include "wrapper.h"
 
 /* Use this struct to pass arguments to wrapper routines. We assume
@@ -42,6 +41,16 @@ struct gdb_wrapper_arguments
       } args[10];
   };
 
+struct captured_value_struct_elt_args
+{
+  struct value **argp;
+  struct value **args;
+  char *name;
+  int *static_memfuncp;
+  char *err;
+  struct value **result_ptr;
+};
+
 static int wrap_parse_exp_1 (char *);
 
 static int wrap_evaluate_expression (char *);
@@ -50,18 +59,19 @@ static int wrap_value_fetch_lazy (char *);
 
 static int wrap_value_equal (char *);
 
+static int wrap_value_assign (char *);
+
 static int wrap_value_subscript (char *);
 
 static int wrap_value_ind (char *opaque_arg);
 
+static int do_captured_value_struct_elt (struct ui_out *uiout, void *data);
+
 static int wrap_parse_and_eval_type (char *);
 
 int
-gdb_parse_exp_1 (stringptr, block, comma, expression)
-     char **stringptr;
-     struct block *block;
-     int comma;
-     struct expression **expression;
+gdb_parse_exp_1 (char **stringptr, struct block *block, int comma,
+                struct expression **expression)
 {
   struct gdb_wrapper_arguments args;
   args.args[0].pointer = stringptr;
@@ -81,8 +91,7 @@ gdb_parse_exp_1 (stringptr, block, comma, expression)
 }
 
 static int
-wrap_parse_exp_1 (argptr)
-     char *argptr;
+wrap_parse_exp_1 (char *argptr)
 {
   struct gdb_wrapper_arguments *args 
     = (struct gdb_wrapper_arguments *) argptr;
@@ -93,9 +102,7 @@ wrap_parse_exp_1 (argptr)
 }
 
 int
-gdb_evaluate_expression (exp, value)
-     struct expression *exp;
-     value_ptr *value;
+gdb_evaluate_expression (struct expression *exp, struct value **value)
 {
   struct gdb_wrapper_arguments args;
   args.args[0].pointer = exp;
@@ -107,13 +114,12 @@ gdb_evaluate_expression (exp, value)
       return 0;
     }
 
-  *value = (value_ptr) args.result.pointer;
+  *value = (struct value *) args.result.pointer;
   return 1;
 }
 
 static int
-wrap_evaluate_expression (a)
-     char *a;
+wrap_evaluate_expression (char *a)
 {
   struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a;
 
@@ -123,8 +129,7 @@ wrap_evaluate_expression (a)
 }
 
 int
-gdb_value_fetch_lazy (value)
-     value_ptr value;
+gdb_value_fetch_lazy (struct value *value)
 {
   struct gdb_wrapper_arguments args;
 
@@ -134,20 +139,16 @@ gdb_value_fetch_lazy (value)
 }
 
 static int
-wrap_value_fetch_lazy (a)
-     char *a;
+wrap_value_fetch_lazy (char *a)
 {
   struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a;
 
-  value_fetch_lazy ((value_ptr) (args)->args[0].pointer);
+  value_fetch_lazy ((struct value *) (args)->args[0].pointer);
   return 1;
 }
 
 int
-gdb_value_equal (val1, val2, result)
-     value_ptr val1;
-     value_ptr val2;
-     int *result;
+gdb_value_equal (struct value *val1, struct value *val2, int *result)
 {
   struct gdb_wrapper_arguments args;
 
@@ -166,24 +167,54 @@ gdb_value_equal (val1, val2, result)
 }
 
 static int
-wrap_value_equal (a)
-     char *a;
+wrap_value_equal (char *a)
 {
   struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a;
-  value_ptr val1, val2;
+  struct value *val1;
+  struct value *val2;
 
-  val1 = (value_ptr) (args)->args[0].pointer;
-  val2 = (value_ptr) (args)->args[1].pointer;
+  val1 = (struct value *) (args)->args[0].pointer;
+  val2 = (struct value *) (args)->args[1].pointer;
 
   (args)->result.integer = value_equal (val1, val2);
   return 1;
 }
 
 int
-gdb_value_subscript (val1, val2, rval)
-     value_ptr val1;
-     value_ptr val2;
-     value_ptr * rval;
+gdb_value_assign (struct value *val1, struct value *val2, struct value **result)
+{
+  struct gdb_wrapper_arguments args;
+
+  args.args[0].pointer = val1;
+  args.args[1].pointer = val2;
+
+  if (!catch_errors ((catch_errors_ftype *) wrap_value_assign, &args,
+                    "", RETURN_MASK_ERROR))
+    {
+      /* An error occurred */
+      return 0;
+    }
+
+  *result = (struct value *) args.result.pointer;
+  return 1;
+}
+
+static int
+wrap_value_assign (char *a)
+{
+  struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a;
+  struct value *val1;
+  struct value *val2;
+
+  val1 = (struct value *) (args)->args[0].pointer;
+  val2 = (struct value *) (args)->args[1].pointer;
+
+  (args)->result.pointer = value_assign (val1, val2);
+  return 1;
+}
+
+int
+gdb_value_subscript (struct value *val1, struct value *val2, struct value **rval)
 {
   struct gdb_wrapper_arguments args;
 
@@ -197,28 +228,26 @@ gdb_value_subscript (val1, val2, rval)
       return 0;
     }
 
-  *rval = (value_ptr) args.result.pointer;
+  *rval = (struct value *) args.result.pointer;
   return 1;
 }
 
 static int
-wrap_value_subscript (a)
-     char *a;
+wrap_value_subscript (char *a)
 {
   struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a;
-  value_ptr val1, val2;
+  struct value *val1;
+  struct value *val2;
 
-  val1 = (value_ptr) (args)->args[0].pointer;
-  val2 = (value_ptr) (args)->args[1].pointer;
+  val1 = (struct value *) (args)->args[0].pointer;
+  val2 = (struct value *) (args)->args[1].pointer;
 
   (args)->result.pointer = value_subscript (val1, val2);
   return 1;
 }
 
 int
-gdb_value_ind (val, rval)
-     value_ptr val;
-     value_ptr *rval;
+gdb_value_ind (struct value *val, struct value **rval)
 {
   struct gdb_wrapper_arguments args;
 
@@ -231,18 +260,17 @@ gdb_value_ind (val, rval)
       return 0;
     }
 
-  *rval = (value_ptr) args.result.pointer;
+  *rval = (struct value *) args.result.pointer;
   return 1;
 }
 
 static int
-wrap_value_ind (opaque_arg)
-     char *opaque_arg;
+wrap_value_ind (char *opaque_arg)
 {
   struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) opaque_arg;
-  value_ptr val;
+  struct value *val;
 
-  val = (value_ptr) (args)->args[0].pointer;
+  val = (struct value *) (args)->args[0].pointer;
   (args)->result.pointer = value_ind (val);
   return 1;
 }
@@ -277,3 +305,29 @@ wrap_parse_and_eval_type (char *a)
 
   return 1;
 }
+
+enum gdb_rc
+gdb_value_struct_elt (struct ui_out *uiout, struct value **result, struct value **argp,
+                     struct value **args, char *name, int *static_memfuncp,
+                     char *err)
+{
+  struct captured_value_struct_elt_args cargs;
+  cargs.argp = argp;
+  cargs.args = args;
+  cargs.name = name;
+  cargs.static_memfuncp = static_memfuncp;
+  cargs.err = err;
+  cargs.result_ptr = result;
+  return catch_exceptions (uiout, do_captured_value_struct_elt, &cargs,
+                          NULL, RETURN_MASK_ALL);
+}
+
+static int
+do_captured_value_struct_elt (struct ui_out *uiout, void *data)
+{
+  struct captured_value_struct_elt_args *cargs = data;
+  *cargs->result_ptr = value_struct_elt (cargs->argp, cargs->args, cargs->name,
+                            cargs->static_memfuncp, cargs->err);
+  return GDB_RC_OK;
+}
+