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 "wrapper.h"
  22
  23 /* Use this struct to pass arguments to wrapper routines. We assume
  24    (arbitrarily) that no gdb function takes more than ten arguments. */
  25 struct gdb_wrapper_arguments
  26   {
  27
  28     /* Pointer to some result from the gdb function call, if any */
  29     union wrapper_results
  30       {
  31         int   integer;
  32         void *pointer;
  33       } result;
  34
  35
  36     /* The list of arguments. */
  37     union wrapper_args
  38       {
  39         int   integer;
  40         void *pointer;
  41       } args[10];
  42   };
  43
  44 static int wrap_parse_exp_1 (char *);
  45
  46 static int wrap_evaluate_expression (char *);
  47
  48 static int wrap_value_fetch_lazy (char *);
  49
  50 static int wrap_value_equal (char *);
  51
  52 static int wrap_value_assign (char *);
  53
  54 static int wrap_value_subscript (char *);
  55
  56 static int wrap_value_ind (char *opaque_arg);
  57
  58 static int wrap_parse_and_eval_type (char *);
  59
  60 int
  61 gdb_parse_exp_1 (char **stringptr, struct block *block, int comma,
  62                  struct expression **expression)
  63 {
  64   struct gdb_wrapper_arguments args;
  65   args.args[0].pointer = stringptr;
  66   args.args[1].pointer = block;
  67   args.args[2].integer = comma;
  68
  69   if (!catch_errors ((catch_errors_ftype *) wrap_parse_exp_1, &args,
  70                      "", RETURN_MASK_ERROR))
  71     {
  72       /* An error occurred */
  73       return 0;
  74     }
  75
  76   *expression = (struct expression *) args.result.pointer;
  77   return 1;
  78
  79 }
  80
  81 static int
  82 wrap_parse_exp_1 (char *argptr)
  83 {
  84   struct gdb_wrapper_arguments *args
  85     = (struct gdb_wrapper_arguments *) argptr;
  86   args->result.pointer = parse_exp_1((char **) args->args[0].pointer,
  87                                      (struct block *) args->args[1].pointer,
  88                                      args->args[2].integer);
  89   return 1;
  90 }
  91
  92 int
  93 gdb_evaluate_expression (struct expression *exp, struct value **value)
  94 {
  95   struct gdb_wrapper_arguments args;
  96   args.args[0].pointer = exp;
  97
  98   if (!catch_errors ((catch_errors_ftype *) wrap_evaluate_expression, &args,
  99                      "", RETURN_MASK_ERROR))
 100     {
 101       /* An error occurred */
 102       return 0;
 103     }
 104
 105   *value = (struct value *) args.result.pointer;
 106   return 1;
 107 }
 108
 109 static int
 110 wrap_evaluate_expression (char *a)
 111 {
 112   struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a;
 113
 114   (args)->result.pointer =
 115     (char *) evaluate_expression ((struct expression *) args->args[0].pointer);
 116   return 1;
 117 }
 118
 119 int
 120 gdb_value_fetch_lazy (struct value *value)
 121 {
 122   struct gdb_wrapper_arguments args;
 123
 124   args.args[0].pointer = value;
 125   return catch_errors ((catch_errors_ftype *) wrap_value_fetch_lazy, &args,
 126                        "", RETURN_MASK_ERROR);
 127 }
 128
 129 static int
 130 wrap_value_fetch_lazy (char *a)
 131 {
 132   struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a;
 133
 134   value_fetch_lazy ((struct value *) (args)->args[0].pointer);
 135   return 1;
 136 }
 137
 138 int
 139 gdb_value_equal (struct value *val1, struct value *val2, int *result)
 140 {
 141   struct gdb_wrapper_arguments args;
 142
 143   args.args[0].pointer = val1;
 144   args.args[1].pointer = val2;
 145
 146   if (!catch_errors ((catch_errors_ftype *) wrap_value_equal, &args,
 147                      "", RETURN_MASK_ERROR))
 148     {
 149       /* An error occurred */
 150       return 0;
 151     }
 152
 153   *result = args.result.integer;
 154   return 1;
 155 }
 156
 157 static int
 158 wrap_value_equal (char *a)
 159 {
 160   struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a;
 161   struct value *val1;
 162   struct value *val2;
 163
 164   val1 = (struct value *) (args)->args[0].pointer;
 165   val2 = (struct value *) (args)->args[1].pointer;
 166
 167   (args)->result.integer = value_equal (val1, val2);
 168   return 1;
 169 }
 170
 171 int
 172 gdb_value_assign (struct value *val1, struct value *val2, struct value **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 = (struct value *) 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   struct value *val1;
 195   struct value *val2;
 196
 197   val1 = (struct value *) (args)->args[0].pointer;
 198   val2 = (struct value *) (args)->args[1].pointer;
 199
 200   (args)->result.pointer = value_assign (val1, val2);
 201   return 1;
 202 }
 203
 204 int
 205 gdb_value_subscript (struct value *val1, struct value *val2, struct value **rval)
 206 {
 207   struct gdb_wrapper_arguments args;
 208
 209   args.args[0].pointer = val1;
 210   args.args[1].pointer = val2;
 211
 212   if (!catch_errors ((catch_errors_ftype *) wrap_value_subscript, &args,
 213                      "", RETURN_MASK_ERROR))
 214     {
 215       /* An error occurred */
 216       return 0;
 217     }
 218
 219   *rval = (struct value *) args.result.pointer;
 220   return 1;
 221 }
 222
 223 static int
 224 wrap_value_subscript (char *a)
 225 {
 226   struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a;
 227   struct value *val1;
 228   struct value *val2;
 229
 230   val1 = (struct value *) (args)->args[0].pointer;
 231   val2 = (struct value *) (args)->args[1].pointer;
 232
 233   (args)->result.pointer = value_subscript (val1, val2);
 234   return 1;
 235 }
 236
 237 int
 238 gdb_value_ind (struct value *val, struct value **rval)
 239 {
 240   struct gdb_wrapper_arguments args;
 241
 242   args.args[0].pointer = val;
 243
 244   if (!catch_errors ((catch_errors_ftype *) wrap_value_ind, &args,
 245                      "", RETURN_MASK_ERROR))
 246     {
 247       /* An error occurred */
 248       return 0;
 249     }
 250
 251   *rval = (struct value *) args.result.pointer;
 252   return 1;
 253 }
 254
 255 static int
 256 wrap_value_ind (char *opaque_arg)
 257 {
 258   struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) opaque_arg;
 259   struct value *val;
 260
 261   val = (struct value *) (args)->args[0].pointer;
 262   (args)->result.pointer = value_ind (val);
 263   return 1;
 264 }
 265
 266 int
 267 gdb_parse_and_eval_type (char *p, int length, struct type **type)
 268 {
 269   struct gdb_wrapper_arguments args;
 270   args.args[0].pointer = p;
 271   args.args[1].integer = length;
 272
 273   if (!catch_errors ((catch_errors_ftype *) wrap_parse_and_eval_type, &args,
 274                      "", RETURN_MASK_ALL))
 275     {
 276       /* An error occurred */
 277       return 0;
 278     }
 279
 280   *type = (struct type *) args.result.pointer;
 281   return 1;
 282 }
 283
 284 static int
 285 wrap_parse_and_eval_type (char *a)
 286 {
 287   struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a;
 288
 289   char *p = (char *) args->args[0].pointer;
 290   int length = args->args[1].integer;
 291
 292   args->result.pointer = (char *) parse_and_eval_type (p, length);
 293
 294   return 1;
 295 }