2000-05-10 Elena Zannoni <ezannoni@kwikemart.cygnus.com>

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

diff --git a/gdb/wrapper.c b/gdb/wrapper.c
index be7d4e273914577c0cad3fd02135ad76bb6aef2e..f7b14fca005f8f67a400dc61afb75d09ccca803b 100644 (file)
--- a/gdb/wrapper.c
+++ b/gdb/wrapper.c
@@ -21,29 +21,76 @@
 #include "frame.h"
 #include "wrapper.h"
 
-/* Use this struct used to pass arguments to wrapper routines. We assume
+/* Use this struct to pass arguments to wrapper routines. We assume
    (arbitrarily) that no gdb function takes more than ten arguments. */
 struct gdb_wrapper_arguments
   {
 
     /* Pointer to some result from the gdb function call, if any */
-    char *result;
+    union wrapper_results 
+      {
+       int   integer;
+       void *pointer;
+      } result;
+       
 
     /* The list of arguments. */
-    char *args[10];
+    union wrapper_args 
+      {
+       int   integer;
+       void *pointer;
+      } args[10];
   };
 
-int gdb_evaluate_expression PARAMS ((struct expression *, value_ptr *));
-int wrap_evaluate_expression PARAMS ((char *));
+static int wrap_parse_exp_1 PARAMS ((char *));
 
-int gdb_value_fetch_lazy PARAMS ((value_ptr));
-int wrap_value_fetch_lazy PARAMS ((char *));
+static int wrap_evaluate_expression PARAMS ((char *));
 
-int gdb_value_equal PARAMS ((value_ptr, value_ptr, int *));
-int wrap_value_equal PARAMS ((char *));
+static int wrap_value_fetch_lazy PARAMS ((char *));
 
-int gdb_value_ind PARAMS ((value_ptr val, value_ptr * rval));
-int wrap_value_ind PARAMS ((char *opaque_arg));
+static int wrap_value_equal PARAMS ((char *));
+
+static int wrap_value_subscript PARAMS ((char *));
+
+static int wrap_value_ind PARAMS ((char *opaque_arg));
+
+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;
+{
+  struct gdb_wrapper_arguments args;
+  args.args[0].pointer = stringptr;
+  args.args[1].pointer = block;
+  args.args[2].integer = comma;
+
+  if (!catch_errors ((catch_errors_ftype *) wrap_parse_exp_1, &args,
+                    "", RETURN_MASK_ERROR))
+    {
+      /* An error occurred */
+      return 0;
+    }
+
+  *expression = (struct expression *) args.result.pointer;
+  return 1;
+  
+}
+
+static int
+wrap_parse_exp_1 (argptr)
+     char *argptr;
+{
+  struct gdb_wrapper_arguments *args 
+    = (struct gdb_wrapper_arguments *) argptr;
+  args->result.pointer = parse_exp_1((char **) args->args[0].pointer,
+                                    (struct block *) args->args[1].pointer,
+                                    args->args[2].integer);
+  return 1;
+}
 
 int
 gdb_evaluate_expression (exp, value)
@@ -51,7 +98,7 @@ gdb_evaluate_expression (exp, value)
      value_ptr *value;
 {
   struct gdb_wrapper_arguments args;
-  args.args[0] = (char *) exp;
+  args.args[0].pointer = exp;
 
   if (!catch_errors ((catch_errors_ftype *) wrap_evaluate_expression, &args,
                     "", RETURN_MASK_ERROR))
@@ -60,18 +107,18 @@ gdb_evaluate_expression (exp, value)
       return 0;
     }
 
-  *value = (value_ptr) args.result;
+  *value = (value_ptr) args.result.pointer;
   return 1;
 }
 
-int
+static int
 wrap_evaluate_expression (a)
      char *a;
 {
   struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a;
 
-  (args)->result =
-    (char *) evaluate_expression ((struct expression *) (args)->args[0]);
+  (args)->result.pointer =
+    (char *) evaluate_expression ((struct expression *) args->args[0].pointer);
   return 1;
 }
 
@@ -81,18 +128,18 @@ gdb_value_fetch_lazy (value)
 {
   struct gdb_wrapper_arguments args;
 
-  args.args[0] = (char *) value;
+  args.args[0].pointer = value;
   return catch_errors ((catch_errors_ftype *) wrap_value_fetch_lazy, &args,
                       "", RETURN_MASK_ERROR);
 }
 
-int
+static int
 wrap_value_fetch_lazy (a)
      char *a;
 {
   struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a;
 
-  value_fetch_lazy ((value_ptr) (args)->args[0]);
+  value_fetch_lazy ((value_ptr) (args)->args[0].pointer);
   return 1;
 }
 
@@ -104,8 +151,8 @@ gdb_value_equal (val1, val2, result)
 {
   struct gdb_wrapper_arguments args;
 
-  args.args[0] = (char *) val1;
-  args.args[1] = (char *) val2;
+  args.args[0].pointer = val1;
+  args.args[1].pointer = val2;
 
   if (!catch_errors ((catch_errors_ftype *) wrap_value_equal, &args,
                     "", RETURN_MASK_ERROR))
@@ -114,21 +161,57 @@ gdb_value_equal (val1, val2, result)
       return 0;
     }
 
-  *result = (int) args.result;
+  *result = args.result.integer;
   return 1;
 }
 
-int
+static int
 wrap_value_equal (a)
      char *a;
 {
   struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a;
   value_ptr val1, val2;
 
-  val1 = (value_ptr) (args)->args[0];
-  val2 = (value_ptr) (args)->args[1];
+  val1 = (value_ptr) (args)->args[0].pointer;
+  val2 = (value_ptr) (args)->args[1].pointer;
 
-  (args)->result = (char *) value_equal (val1, val2);
+  (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;
+{
+  struct gdb_wrapper_arguments args;
+
+  args.args[0].pointer = val1;
+  args.args[1].pointer = val2;
+
+  if (!catch_errors ((catch_errors_ftype *) wrap_value_subscript, &args,
+                    "", RETURN_MASK_ERROR))
+    {
+      /* An error occurred */
+      return 0;
+    }
+
+  *rval = (value_ptr) args.result.pointer;
+  return 1;
+}
+
+static int
+wrap_value_subscript (a)
+     char *a;
+{
+  struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a;
+  value_ptr val1, val2;
+
+  val1 = (value_ptr) (args)->args[0].pointer;
+  val2 = (value_ptr) (args)->args[1].pointer;
+
+  (args)->result.pointer = value_subscript (val1, val2);
   return 1;
 }
 
@@ -139,7 +222,7 @@ gdb_value_ind (val, rval)
 {
   struct gdb_wrapper_arguments args;
 
-  args.args[0] = (char *) val;
+  args.args[0].pointer = val;
 
   if (!catch_errors ((catch_errors_ftype *) wrap_value_ind, &args,
                     "", RETURN_MASK_ERROR))
@@ -148,18 +231,49 @@ gdb_value_ind (val, rval)
       return 0;
     }
 
-  *rval = (value_ptr) args.result;
+  *rval = (value_ptr) args.result.pointer;
   return 1;
 }
 
-int
+static int
 wrap_value_ind (opaque_arg)
      char *opaque_arg;
 {
   struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) opaque_arg;
   value_ptr val;
 
-  val = (value_ptr) (args)->args[0];
-  (args)->result = (char *) value_ind (val);
+  val = (value_ptr) (args)->args[0].pointer;
+  (args)->result.pointer = value_ind (val);
+  return 1;
+}
+
+int
+gdb_parse_and_eval_type (char *p, int length, struct type **type)
+{
+  struct gdb_wrapper_arguments args;
+  args.args[0].pointer = p;
+  args.args[1].integer = length;
+
+  if (!catch_errors ((catch_errors_ftype *) wrap_parse_and_eval_type, &args,
+                    "", RETURN_MASK_ALL))
+    {
+      /* An error occurred */
+      return 0;
+    }
+
+  *type = (struct type *) args.result.pointer;
+  return 1;
+}
+
+static int
+wrap_parse_and_eval_type (char *a)
+{
+  struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a;
+
+  char *p = (char *) args->args[0].pointer;
+  int length = args->args[1].integer;
+
+  args->result.pointer = (char *) parse_and_eval_type (p, length);
+
   return 1;
 }