gdb/wrapper.c

   1 /* Longjump free calls to gdb internal routines.
   2    Copyright 1999, 2000 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 2 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software
  16    Foundation, Inc., 59 Temple Place - Suite 330,
  17    Boston, MA 02111-1307, USA.  */
  18
  19 #include "defs.h"
  20 #include "value.h"
  21 #include "frame.h"
  22 #include "wrapper.h"
  23
  24 /* Use this struct to pass arguments to wrapper routines. We assume
  25    (arbitrarily) that no gdb function takes more than ten arguments. */
  26 struct gdb_wrapper_arguments
  27   {
  28
  29     /* Pointer to some result from the gdb function call, if any */
  30     union wrapper_results
  31       {
  32         int   integer;
  33         void *pointer;
  34       } result;
  35
  36
  37     /* The list of arguments. */
  38     union wrapper_args
  39       {
  40         int   integer;
  41         void *pointer;
  42       } args[10];
  43   };
  44
  45 static int wrap_parse_exp_1 (char *);
  46
  47 static int wrap_evaluate_expression (char *);
  48
  49 static int wrap_value_fetch_lazy (char *);
  50
  51 static int wrap_value_equal (char *);
  52
  53 static int wrap_value_assign (char *);
  54
  55 static int wrap_value_subscript (char *);
  56
  57 static int wrap_value_ind (char *opaque_arg);
  58
  59 static int wrap_parse_and_eval_type (char *);
  60
  61 int
  62 gdb_parse_exp_1 (char **stringptr, struct block *block, int comma,
  63                  struct expression **expression)
  64 {
  65   struct gdb_wrapper_arguments args;
  66   args.args[0].pointer = stringptr;
  67   args.args[1].pointer = block;
  68   args.args[2].integer = comma;
  69
  70   if (!catch_errors ((catch_errors_ftype *) wrap_parse_exp_1, &args,
  71                      "", RETURN_MASK_ERROR))
  72     {
  73       /* An error occurred */
  74       return 0;
  75     }
  76
  77   *expression = (struct expression *) args.result.pointer;
  78   return 1;
  79
  80 }
  81
  82 static int
  83 wrap_parse_exp_1 (char *argptr)
  84 {
  85   struct gdb_wrapper_arguments *args
  86     = (struct gdb_wrapper_arguments *) argptr;
  87   args->result.pointer = parse_exp_1((char **) args->args[0].pointer,
  88                                      (struct block *) args->args[1].pointer,
  89                                      args->args[2].integer);
  90   return 1;
  91 }
  92
  93 int
  94 gdb_evaluate_expression (struct expression *exp, value_ptr *value)
  95 {
  96   struct gdb_wrapper_arguments args;
  97   args.args[0].pointer = exp;
  98
  99   if (!catch_errors ((catch_errors_ftype *) wrap_evaluate_expression, &args,
 100                      "", RETURN_MASK_ERROR))
 101     {
 102       /* An error occurred */
 103       return 0;
 104     }
 105
 106   *value = (value_ptr) args.result.pointer;
 107   return 1;
 108 }
 109
 110 static int
 111 wrap_evaluate_expression (char *a)
 112 {
 113   struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a;
 114
 115   (args)->result.pointer =
 116     (char *) evaluate_expression ((struct expression *) args->args[0].pointer);
 117   return 1;
 118 }
 119
 120 int
 121 gdb_value_fetch_lazy (value_ptr value)
 122 {
 123   struct gdb_wrapper_arguments args;
 124
 125   args.args[0].pointer = value;
 126   return catch_errors ((catch_errors_ftype *) wrap_value_fetch_lazy, &args,
 127                        "", RETURN_MASK_ERROR);
 128 }
 129
 130 static int
 131 wrap_value_fetch_lazy (char *a)
 132 {
 133   struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a;
 134
 135   value_fetch_lazy ((value_ptr) (args)->args[0].pointer);
 136   return 1;
 137 }
 138
 139 int
 140 gdb_value_equal (value_ptr val1, value_ptr val2, int *result)
 141 {
 142   struct gdb_wrapper_arguments args;
 143
 144   args.args[0].pointer = val1;
 145   args.args[1].pointer = val2;
 146
 147   if (!catch_errors ((catch_errors_ftype *) wrap_value_equal, &args,
 148                      "", RETURN_MASK_ERROR))
 149     {
 150       /* An error occurred */
 151       return 0;
 152     }
 153
 154   *result = args.result.integer;
 155   return 1;
 156 }
 157
 158 static int
 159 wrap_value_equal (char *a)
 160 {
 161   struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a;
 162   value_ptr val1, val2;
 163
 164   val1 = (value_ptr) (args)->args[0].pointer;
 165   val2 = (value_ptr) (args)->args[1].pointer;
 166
 167   (args)->result.integer = value_equal (val1, val2);
 168   return 1;
 169 }
 170
 171 int
 172 gdb_value_assign (value_ptr val1, value_ptr val2, value_ptr *result)
 173 {
 174   struct gdb_wrapper_arguments args;
 175
 176   args.args[0].pointer = val1;
 177   args.args[1].pointer = val2;
 178
 179   if (!catch_errors ((catch_errors_ftype *) wrap_value_assign, &args,
 180                      "", RETURN_MASK_ERROR))
 181     {
 182       /* An error occurred */
 183       return 0;
 184     }
 185
 186   *result = (value_ptr) args.result.pointer;
 187   return 1;
 188 }
 189
 190 static int
 191 wrap_value_assign (char *a)
 192 {
 193   struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a;
 194   value_ptr val1, val2;
 195
 196   val1 = (value_ptr) (args)->args[0].pointer;
 197   val2 = (value_ptr) (args)->args[1].pointer;
 198
 199   (args)->result.pointer = value_assign (val1, val2);
 200   return 1;
 201 }
 202
 203 int
 204 gdb_value_subscript (value_ptr val1, value_ptr val2, value_ptr *rval)
 205 {
 206   struct gdb_wrapper_arguments args;
 207
 208   args.args[0].pointer = val1;
 209   args.args[1].pointer = val2;
 210
 211   if (!catch_errors ((catch_errors_ftype *) wrap_value_subscript, &args,
 212                      "", RETURN_MASK_ERROR))
 213     {
 214       /* An error occurred */
 215       return 0;
 216     }
 217
 218   *rval = (value_ptr) args.result.pointer;
 219   return 1;
 220 }
 221
 222 static int
 223 wrap_value_subscript (char *a)
 224 {
 225   struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a;
 226   value_ptr val1, val2;
 227
 228   val1 = (value_ptr) (args)->args[0].pointer;
 229   val2 = (value_ptr) (args)->args[1].pointer;
 230
 231   (args)->result.pointer = value_subscript (val1, val2);
 232   return 1;
 233 }
 234
 235 int
 236 gdb_value_ind (value_ptr val, value_ptr *rval)
 237 {
 238   struct gdb_wrapper_arguments args;
 239
 240   args.args[0].pointer = val;
 241
 242   if (!catch_errors ((catch_errors_ftype *) wrap_value_ind, &args,
 243                      "", RETURN_MASK_ERROR))
 244     {
 245       /* An error occurred */
 246       return 0;
 247     }
 248
 249   *rval = (value_ptr) args.result.pointer;
 250   return 1;
 251 }
 252
 253 static int
 254 wrap_value_ind (char *opaque_arg)
 255 {
 256   struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) opaque_arg;
 257   value_ptr val;
 258
 259   val = (value_ptr) (args)->args[0].pointer;
 260   (args)->result.pointer = value_ind (val);
 261   return 1;
 262 }
 263
 264 int
 265 gdb_parse_and_eval_type (char *p, int length, struct type **type)
 266 {
 267   struct gdb_wrapper_arguments args;
 268   args.args[0].pointer = p;
 269   args.args[1].integer = length;
 270
 271   if (!catch_errors ((catch_errors_ftype *) wrap_parse_and_eval_type, &args,
 272                      "", RETURN_MASK_ALL))
 273     {
 274       /* An error occurred */
 275       return 0;
 276     }
 277
 278   *type = (struct type *) args.result.pointer;
 279   return 1;
 280 }
 281
 282 static int
 283 wrap_parse_and_eval_type (char *a)
 284 {
 285   struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a;
 286
 287   char *p = (char *) args->args[0].pointer;
 288   int length = args->args[1].integer;
 289
 290   args->result.pointer = (char *) parse_and_eval_type (p, length);
 291
 292   return 1;
 293 }