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. */ 25struct 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 44struct captured_value_struct_elt_args 45{ 46 struct value **argp; 47 struct value **args; 48 char *name; 49 int *static_memfuncp; 50 char *err; 51 struct value **result_ptr; 52}; 53 54static int wrap_parse_exp_1 (char *); 55 56static int wrap_evaluate_expression (char *); 57 58static int wrap_value_fetch_lazy (char *); 59 60static int wrap_value_equal (char *); 61 62static int wrap_value_assign (char *); 63 64static int wrap_value_subscript (char *); 65 66static int wrap_value_ind (char *opaque_arg); 67 68static int do_captured_value_struct_elt (struct ui_out *uiout, void *data); 69 70static int wrap_parse_and_eval_type (char *); 71 72int 73gdb_parse_exp_1 (char **stringptr, struct block *block, int comma, 74 struct expression **expression) 75{ 76 struct gdb_wrapper_arguments args; 77 args.args[0].pointer = stringptr; 78 args.args[1].pointer = block; 79 args.args[2].integer = comma; 80 81 if (!catch_errors ((catch_errors_ftype *) wrap_parse_exp_1, &args, 82 "", RETURN_MASK_ERROR)) 83 { 84 /* An error occurred */ 85 return 0; 86 } 87 88 *expression = (struct expression *) args.result.pointer; 89 return 1; 90 91} 92 93static int 94wrap_parse_exp_1 (char *argptr) 95{ 96 struct gdb_wrapper_arguments *args 97 = (struct gdb_wrapper_arguments *) argptr; 98 args->result.pointer = parse_exp_1((char **) args->args[0].pointer, 99 (struct block *) args->args[1].pointer, 100 args->args[2].integer); 101 return 1; 102} 103 104int 105gdb_evaluate_expression (struct expression *exp, struct value **value) 106{ 107 struct gdb_wrapper_arguments args; 108 args.args[0].pointer = exp; 109 110 if (!catch_errors ((catch_errors_ftype *) wrap_evaluate_expression, &args, 111 "", RETURN_MASK_ERROR)) 112 { 113 /* An error occurred */ 114 return 0; 115 } 116 117 *value = (struct value *) args.result.pointer; 118 return 1; 119} 120 121static int 122wrap_evaluate_expression (char *a) 123{ 124 struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a; 125 126 (args)->result.pointer = 127 (char *) evaluate_expression ((struct expression *) args->args[0].pointer); 128 return 1; 129} 130 131int 132gdb_value_fetch_lazy (struct value *value) 133{ 134 struct gdb_wrapper_arguments args; 135 136 args.args[0].pointer = value; 137 return catch_errors ((catch_errors_ftype *) wrap_value_fetch_lazy, &args, 138 "", RETURN_MASK_ERROR); 139} 140 141static int 142wrap_value_fetch_lazy (char *a) 143{ 144 struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a; 145 146 value_fetch_lazy ((struct value *) (args)->args[0].pointer); 147 return 1; 148} 149 150int 151gdb_value_equal (struct value *val1, struct value *val2, int *result) 152{ 153 struct gdb_wrapper_arguments args; 154 155 args.args[0].pointer = val1; 156 args.args[1].pointer = val2; 157 158 if (!catch_errors ((catch_errors_ftype *) wrap_value_equal, &args, 159 "", RETURN_MASK_ERROR)) 160 { 161 /* An error occurred */ 162 return 0; 163 } 164 165 *result = args.result.integer; 166 return 1; 167} 168 169static int 170wrap_value_equal (char *a) 171{ 172 struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a; 173 struct value *val1; 174 struct value *val2; 175 176 val1 = (struct value *) (args)->args[0].pointer; 177 val2 = (struct value *) (args)->args[1].pointer; 178 179 (args)->result.integer = value_equal (val1, val2); 180 return 1; 181} 182 183int 184gdb_value_assign (struct value *val1, struct value *val2, struct value **result) 185{ 186 struct gdb_wrapper_arguments args; 187 188 args.args[0].pointer = val1; 189 args.args[1].pointer = val2; 190 191 if (!catch_errors ((catch_errors_ftype *) wrap_value_assign, &args, 192 "", RETURN_MASK_ERROR)) 193 { 194 /* An error occurred */ 195 return 0; 196 } 197 198 *result = (struct value *) args.result.pointer; 199 return 1; 200} 201 202static int 203wrap_value_assign (char *a) 204{ 205 struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a; 206 struct value *val1; 207 struct value *val2; 208 209 val1 = (struct value *) (args)->args[0].pointer; 210 val2 = (struct value *) (args)->args[1].pointer; 211 212 (args)->result.pointer = value_assign (val1, val2); 213 return 1; 214} 215 216int 217gdb_value_subscript (struct value *val1, struct value *val2, struct value **rval) 218{ 219 struct gdb_wrapper_arguments args; 220 221 args.args[0].pointer = val1; 222 args.args[1].pointer = val2; 223 224 if (!catch_errors ((catch_errors_ftype *) wrap_value_subscript, &args, 225 "", RETURN_MASK_ERROR)) 226 { 227 /* An error occurred */ 228 return 0; 229 } 230 231 *rval = (struct value *) args.result.pointer; 232 return 1; 233} 234 235static int 236wrap_value_subscript (char *a) 237{ 238 struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a; 239 struct value *val1; 240 struct value *val2; 241 242 val1 = (struct value *) (args)->args[0].pointer; 243 val2 = (struct value *) (args)->args[1].pointer; 244 245 (args)->result.pointer = value_subscript (val1, val2); 246 return 1; 247} 248 249int 250gdb_value_ind (struct value *val, struct value **rval) 251{ 252 struct gdb_wrapper_arguments args; 253 254 args.args[0].pointer = val; 255 256 if (!catch_errors ((catch_errors_ftype *) wrap_value_ind, &args, 257 "", RETURN_MASK_ERROR)) 258 { 259 /* An error occurred */ 260 return 0; 261 } 262 263 *rval = (struct value *) args.result.pointer; 264 return 1; 265} 266 267static int 268wrap_value_ind (char *opaque_arg) 269{ 270 struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) opaque_arg; 271 struct value *val; 272 273 val = (struct value *) (args)->args[0].pointer; 274 (args)->result.pointer = value_ind (val); 275 return 1; 276} 277 278int 279gdb_parse_and_eval_type (char *p, int length, struct type **type) 280{ 281 struct gdb_wrapper_arguments args; 282 args.args[0].pointer = p; 283 args.args[1].integer = length; 284 285 if (!catch_errors ((catch_errors_ftype *) wrap_parse_and_eval_type, &args, 286 "", RETURN_MASK_ALL)) 287 { 288 /* An error occurred */ 289 return 0; 290 } 291 292 *type = (struct type *) args.result.pointer; 293 return 1; 294} 295 296static int 297wrap_parse_and_eval_type (char *a) 298{ 299 struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a; 300 301 char *p = (char *) args->args[0].pointer; 302 int length = args->args[1].integer; 303 304 args->result.pointer = (char *) parse_and_eval_type (p, length); 305 306 return 1; 307} 308 309enum gdb_rc 310gdb_value_struct_elt (struct ui_out *uiout, struct value **result, struct value **argp, 311 struct value **args, char *name, int *static_memfuncp, 312 char *err) 313{ 314 struct captured_value_struct_elt_args cargs; 315 cargs.argp = argp; 316 cargs.args = args; 317 cargs.name = name; 318 cargs.static_memfuncp = static_memfuncp; 319 cargs.err = err; 320 cargs.result_ptr = result; 321 return catch_exceptions (uiout, do_captured_value_struct_elt, &cargs, 322 NULL, RETURN_MASK_ALL); 323} 324 325static int 326do_captured_value_struct_elt (struct ui_out *uiout, void *data) 327{ 328 struct captured_value_struct_elt_args *cargs = data; 329 *cargs->result_ptr = value_struct_elt (cargs->argp, cargs->args, cargs->name, 330 cargs->static_memfuncp, cargs->err); 331 return GDB_RC_OK; 332} 333 334