-/* Longjump free calls to gdb internal routines.
- Copyright 1999 Free Software Foundation, Inc.
+/* Longjump free calls to GDB internal routines.
+
+ Copyright (C) 1999, 2000, 2005, 2007, 2008, 2009, 2010, 2011
+ Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "value.h"
-#include "frame.h"
+#include "exceptions.h"
#include "wrapper.h"
-
-/* 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 */
- union wrapper_results
- {
- int integer;
- void *pointer;
- } result;
-
-
- /* The list of arguments. */
- union wrapper_args
- {
- int integer;
- void *pointer;
- } args[10];
- };
-
-int gdb_parse_exp_1 PARAMS ((char **, struct block *,
- int, struct expression **));
-int wrap_parse_exp_1 PARAMS ((char *));
-
-int gdb_evaluate_expression PARAMS ((struct expression *, value_ptr *));
-int wrap_evaluate_expression PARAMS ((char *));
-
-int gdb_value_fetch_lazy PARAMS ((value_ptr));
-int wrap_value_fetch_lazy PARAMS ((char *));
-
-int gdb_value_equal PARAMS ((value_ptr, value_ptr, int *));
-int wrap_value_equal PARAMS ((char *));
-
-int gdb_value_subscript PARAMS ((value_ptr, value_ptr, value_ptr * rval));
-int wrap_value_subscript PARAMS ((char *));
-
-int gdb_value_ind PARAMS ((value_ptr val, value_ptr * rval));
-int wrap_value_ind PARAMS ((char *opaque_arg));
+#include "ui-out.h"
+#include "target.h"
int
-gdb_parse_exp_1 (stringptr, block, comma, expression)
- char **stringptr;
- struct block *block;
- int comma;
- struct expression **expression;
+gdb_parse_exp_1 (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;
+ volatile struct gdb_exception except;
- if (!catch_errors ((catch_errors_ftype *) wrap_parse_exp_1, &args,
- "", RETURN_MASK_ERROR))
+ TRY_CATCH (except, RETURN_MASK_ERROR)
{
- /* An error occurred */
- return 0;
+ *expression = parse_exp_1 (stringptr, block, comma);
}
- *expression = (struct expression *) args.result.pointer;
+ if (except.reason < 0)
+ return 0;
return 1;
-
}
int
-wrap_parse_exp_1 (argptr)
- char *argptr;
+gdb_evaluate_expression (struct expression *exp, struct value **value)
{
- 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)
- struct expression *exp;
- value_ptr *value;
-{
- struct gdb_wrapper_arguments args;
- args.args[0].pointer = exp;
+ volatile struct gdb_exception except;
- if (!catch_errors ((catch_errors_ftype *) wrap_evaluate_expression, &args,
- "", RETURN_MASK_ERROR))
+ TRY_CATCH (except, RETURN_MASK_ERROR)
{
- /* An error occurred */
- return 0;
+ *value = evaluate_expression(exp);
}
- *value = (value_ptr) args.result.pointer;
+ if (except.reason < 0)
+ return 0;
return 1;
}
int
-wrap_evaluate_expression (a)
- char *a;
+gdb_value_fetch_lazy (struct value *val)
{
- struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a;
+ volatile struct gdb_exception except;
- (args)->result.pointer =
- (char *) evaluate_expression ((struct expression *) args->args[0].pointer);
+ TRY_CATCH (except, RETURN_MASK_ERROR)
+ {
+ value_fetch_lazy (val);
+ }
+
+ if (except.reason < 0)
+ return 0;
return 1;
}
int
-gdb_value_fetch_lazy (value)
- value_ptr value;
+gdb_value_equal (struct value *val1, struct value *val2, int *result)
{
- struct gdb_wrapper_arguments args;
+ volatile struct gdb_exception except;
- args.args[0].pointer = value;
- return catch_errors ((catch_errors_ftype *) wrap_value_fetch_lazy, &args,
- "", RETURN_MASK_ERROR);
-}
-
-int
-wrap_value_fetch_lazy (a)
- char *a;
-{
- struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a;
+ TRY_CATCH (except, RETURN_MASK_ERROR)
+ {
+ *result = value_equal (val1, val2);
+ }
- value_fetch_lazy ((value_ptr) (args)->args[0].pointer);
+ if (except.reason < 0)
+ return 0;
return 1;
}
int
-gdb_value_equal (val1, val2, result)
- value_ptr val1;
- value_ptr val2;
- int *result;
+gdb_value_assign (struct value *val1, struct value *val2,
+ struct value **result)
{
- struct gdb_wrapper_arguments args;
+ volatile struct gdb_exception except;
- args.args[0].pointer = val1;
- args.args[1].pointer = val2;
-
- if (!catch_errors ((catch_errors_ftype *) wrap_value_equal, &args,
- "", RETURN_MASK_ERROR))
+ TRY_CATCH (except, RETURN_MASK_ERROR)
{
- /* An error occurred */
- return 0;
+ *result = value_assign (val1, val2);
}
- *result = args.result.integer;
+ if (except.reason < 0)
+ return 0;
return 1;
}
int
-wrap_value_equal (a)
- char *a;
+gdb_value_subscript (struct value *val, LONGEST index,
+ struct value **result)
{
- struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a;
- value_ptr val1, val2;
+ volatile struct gdb_exception except;
- val1 = (value_ptr) (args)->args[0].pointer;
- val2 = (value_ptr) (args)->args[1].pointer;
+ TRY_CATCH (except, RETURN_MASK_ERROR)
+ {
+ *result = value_subscript (val, index);
+ }
- (args)->result.integer = value_equal (val1, val2);
+ if (except.reason < 0)
+ return 0;
return 1;
}
int
-gdb_value_subscript (val1, val2, rval)
- value_ptr val1;
- value_ptr val2;
- value_ptr * rval;
+gdb_value_ind (struct value *val, struct value **result)
{
- struct gdb_wrapper_arguments args;
-
- args.args[0].pointer = val1;
- args.args[1].pointer = val2;
+ volatile struct gdb_exception except;
- if (!catch_errors ((catch_errors_ftype *) wrap_value_subscript, &args,
- "", RETURN_MASK_ERROR))
+ TRY_CATCH (except, RETURN_MASK_ERROR)
{
- /* An error occurred */
- return 0;
+ *result = value_ind (val);
}
- *rval = (value_ptr) args.result.pointer;
+ if (except.reason < 0)
+ return 0;
return 1;
}
int
-wrap_value_subscript (a)
- char *a;
+gdb_parse_and_eval_type (char *p, int length, struct type **type)
{
- struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a;
- value_ptr val1, val2;
+ volatile struct gdb_exception except;
- val1 = (value_ptr) (args)->args[0].pointer;
- val2 = (value_ptr) (args)->args[1].pointer;
+ TRY_CATCH (except, RETURN_MASK_ERROR)
+ {
+ *type = parse_and_eval_type (p, length);
+ }
- (args)->result.pointer = value_subscript (val1, val2);
+ if (except.reason < 0)
+ return 0;
return 1;
}
-int
-gdb_value_ind (val, rval)
- value_ptr val;
- value_ptr *rval;
+enum gdb_rc
+gdb_value_struct_elt (struct ui_out *uiout, struct value **result,
+ struct value **argp, struct value **args, char *name,
+ int *static_memfuncp, char *err)
{
- struct gdb_wrapper_arguments args;
+ volatile struct gdb_exception except;
- args.args[0].pointer = val;
-
- if (!catch_errors ((catch_errors_ftype *) wrap_value_ind, &args,
- "", RETURN_MASK_ERROR))
+ TRY_CATCH (except, RETURN_MASK_ERROR)
{
- /* An error occurred */
- return 0;
+ *result = value_struct_elt (argp, args, name, static_memfuncp, err);
}
- *rval = (value_ptr) args.result.pointer;
- return 1;
+ if (except.reason < 0)
+ return GDB_RC_FAIL;
+ return GDB_RC_OK;
}
+/* Call target_find_new_threads without throwing exception. Exception is
+ printed if it got thrown. */
+
int
-wrap_value_ind (opaque_arg)
- char *opaque_arg;
+gdb_target_find_new_threads (void)
{
- struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) opaque_arg;
- value_ptr val;
+ volatile struct gdb_exception except;
- val = (value_ptr) (args)->args[0].pointer;
- (args)->result.pointer = value_ind (val);
+ TRY_CATCH (except, RETURN_MASK_ERROR)
+ {
+ target_find_new_threads ();
+ }
+
+ if (except.reason < 0)
+ {
+ exception_print (gdb_stderr, except);
+ return 0;
+ }
return 1;
}
-
projects / deliverable / binutils-gdb.git / blobdiff