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 struct 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 54 static int wrap_parse_exp_1 (char *); 55 56 static int wrap_evaluate_expression (char *); 57 58 static int wrap_value_fetch_lazy (char *); 59 60 static int wrap_value_equal (char *); 61 62 static int wrap_value_assign (char *); 63 64 static int wrap_value_subscript (char *); 65 66 static int wrap_value_ind (char *opaque_arg); 67 68 static int do_captured_value_struct_elt (struct ui_out *uiout, void *data); 69 70 static int wrap_parse_and_eval_type (char *); 71 72 int 73 gdb_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 93 static int 94 wrap_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 104 int 105 gdb_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 121 static int 122 wrap_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 131 int 132 gdb_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 141 static int 142 wrap_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 150 int 151 gdb_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 169 static int 170 wrap_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 183 int 184 gdb_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 202 static int 203 wrap_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 216 int 217 gdb_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 235 static int 236 wrap_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 249 int 250 gdb_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 267 static int 268 wrap_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 278 int 279 gdb_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 296 static int 297 wrap_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 309 enum gdb_rc 310 gdb_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 325 static int 326 do_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