this will be set to NULL. LANGUAGE is also a pass-through argument
denoting the language attributed to the Symbol. In the case of SYM
being NULL, this will be set to the current language. Returns
- PY_BT_ERROR on error with the appropriate Python exception set, and
- PY_BT_OK on success. */
+ EXT_LANG_BT_ERROR on error with the appropriate Python exception set, and
+ EXT_LANG_BT_OK on success. */
-static enum py_bt_status
+static enum ext_lang_bt_status
extract_sym (PyObject *obj, char **name, struct symbol **sym,
const struct language_defn **language)
{
PyObject *result = PyObject_CallMethod (obj, "symbol", NULL);
if (result == NULL)
- return PY_BT_ERROR;
+ return EXT_LANG_BT_ERROR;
/* For 'symbol' callback, the function can return a symbol or a
string. */
Py_DECREF (result);
if (*name == NULL)
- return PY_BT_ERROR;
+ return EXT_LANG_BT_ERROR;
/* If the API returns a string (and not a symbol), then there is
no symbol derived language available and the frame filter has
either overridden the symbol with a string, or supplied a
PyErr_SetString (PyExc_RuntimeError,
_("Unexpected value. Expecting a "
"gdb.Symbol or a Python string."));
- return PY_BT_ERROR;
+ return EXT_LANG_BT_ERROR;
}
/* Duplicate the symbol name, so the caller has consistency
*language = current_language;
}
- return PY_BT_OK;
+ return EXT_LANG_BT_OK;
}
/* Helper function to extract a value from an object that conforms to
the value from. VALUE is a pass-through argument where the value
will be written. If the object does not have the value attribute,
or provides the Python None for a value, VALUE will be set to NULL
- and this function will return as successful. Returns PY_BT_ERROR
- on error with the appropriate Python exception set, and PY_BT_OK on
+ and this function will return as successful. Returns EXT_LANG_BT_ERROR
+ on error with the appropriate Python exception set, and EXT_LANG_BT_OK on
success. */
-static enum py_bt_status
+static enum ext_lang_bt_status
extract_value (PyObject *obj, struct value **value)
{
if (PyObject_HasAttrString (obj, "value"))
PyObject *vresult = PyObject_CallMethod (obj, "value", NULL);
if (vresult == NULL)
- return PY_BT_ERROR;
+ return EXT_LANG_BT_ERROR;
/* The Python code has returned 'None' for a value, so we set
value to NULL. This flags that GDB should read the
{
Py_DECREF (vresult);
*value = NULL;
- return PY_BT_OK;
+ return EXT_LANG_BT_OK;
}
else
{
Py_DECREF (vresult);
if (*value == NULL)
- return PY_BT_ERROR;
+ return EXT_LANG_BT_ERROR;
- return PY_BT_OK;
+ return EXT_LANG_BT_OK;
}
}
else
*value = NULL;
- return PY_BT_OK;
+ return EXT_LANG_BT_OK;
}
/* MI prints only certain values according to the type of symbol and
/* Helper function which outputs a type name extracted from VAL to a
"type" field in the output stream OUT. OUT is the ui-out structure
the type name will be output too, and VAL is the value that the
- type will be extracted from. Returns PY_BT_ERROR on error, with
- any GDB exceptions converted to a Python exception, or PY_BT_OK on
+ type will be extracted from. Returns EXT_LANG_BT_ERROR on error, with
+ any GDB exceptions converted to a Python exception, or EXT_LANG_BT_OK on
success. */
-static enum py_bt_status
+static enum ext_lang_bt_status
py_print_type (struct ui_out *out, struct value *val)
{
volatile struct gdb_exception except;
if (except.reason < 0)
{
gdbpy_convert_exception (except);
- return PY_BT_ERROR;
+ return EXT_LANG_BT_ERROR;
}
- return PY_BT_OK;
+ return EXT_LANG_BT_OK;
}
/* Helper function which outputs a value to an output field in a
VAL is the value that will be printed, OPTS contains the value
printing options, ARGS_TYPE is an enumerator describing the
argument format, and LANGUAGE is the language_defn that the value
- will be printed with. Returns PY_BT_ERROR on error, with any GDB
- exceptions converted to a Python exception, or PY_BT_OK on
+ will be printed with. Returns EXT_LANG_BT_ERROR on error, with any GDB
+ exceptions converted to a Python exception, or EXT_LANG_BT_OK on
success. */
-static enum py_bt_status
+static enum ext_lang_bt_status
py_print_value (struct ui_out *out, struct value *val,
const struct value_print_options *opts,
int indent,
- enum py_frame_args args_type,
+ enum ext_lang_frame_args args_type,
const struct language_defn *language)
{
int should_print = 0;
if (except.reason < 0)
{
gdbpy_convert_exception (except);
- return PY_BT_ERROR;
+ return EXT_LANG_BT_ERROR;
}
if (args_type == MI_PRINT_ALL_VALUES)
if (except.reason < 0)
{
gdbpy_convert_exception (except);
- return PY_BT_ERROR;
+ return EXT_LANG_BT_ERROR;
}
}
- return PY_BT_OK;
+ return EXT_LANG_BT_OK;
}
/* Helper function to call a Python method and extract an iterator
ARGS_TYPE is an enumerator describing the argument format,
PRINT_ARGS_FIELD is a flag which indicates if we output "ARGS=1"
in MI output in commands where both arguments and locals are
- printed. Returns PY_BT_ERROR on error, with any GDB exceptions
- converted to a Python exception, or PY_BT_OK on success. */
+ printed. Returns EXT_LANG_BT_ERROR on error, with any GDB exceptions
+ converted to a Python exception, or EXT_LANG_BT_OK on success. */
-static enum py_bt_status
+static enum ext_lang_bt_status
py_print_single_arg (struct ui_out *out,
const char *sym_name,
struct frame_arg *fa,
struct value *fv,
const struct value_print_options *opts,
- enum py_frame_args args_type,
+ enum ext_lang_frame_args args_type,
int print_args_field,
const struct language_defn *language)
{
types. */
if (args_type == MI_PRINT_SIMPLE_VALUES)
{
- if (py_print_type (out, val) == PY_BT_ERROR)
+ if (py_print_type (out, val) == EXT_LANG_BT_ERROR)
{
do_cleanups (cleanups);
goto error;
if (args_type != NO_VALUES)
{
if (py_print_value (out, val, opts, 0, args_type, language)
- == PY_BT_ERROR)
+ == EXT_LANG_BT_ERROR)
{
do_cleanups (cleanups);
goto error;
goto error;
}
- return PY_BT_OK;
+ return EXT_LANG_BT_OK;
error:
- return PY_BT_ERROR;
+ return EXT_LANG_BT_ERROR;
}
/* Helper function to loop over frame arguments provided by the
enumerator describing the argument format, PRINT_ARGS_FIELD is a
flag which indicates if we output "ARGS=1" in MI output in commands
where both arguments and locals are printed, and FRAME is the
- backing frame. Returns PY_BT_ERROR on error, with any GDB
- exceptions converted to a Python exception, or PY_BT_OK on
+ backing frame. Returns EXT_LANG_BT_ERROR on error, with any GDB
+ exceptions converted to a Python exception, or EXT_LANG_BT_OK on
success. */
-static enum py_bt_status
+static enum ext_lang_bt_status
enumerate_args (PyObject *iter,
struct ui_out *out,
- enum py_frame_args args_type,
+ enum ext_lang_frame_args args_type,
int print_args_field,
struct frame_info *frame)
{
char *sym_name;
struct symbol *sym;
struct value *val;
- enum py_bt_status success = PY_BT_ERROR;
+ enum ext_lang_bt_status success = EXT_LANG_BT_ERROR;
success = extract_sym (item, &sym_name, &sym, &language);
- if (success == PY_BT_ERROR)
+ if (success == EXT_LANG_BT_ERROR)
{
Py_DECREF (item);
goto error;
}
success = extract_value (item, &val);
- if (success == PY_BT_ERROR)
+ if (success == EXT_LANG_BT_ERROR)
{
xfree (sym_name);
Py_DECREF (item);
NULL, &opts,
args_type,
print_args_field,
- NULL) == PY_BT_ERROR)
+ NULL) == EXT_LANG_BT_ERROR)
{
xfree (arg.error);
xfree (entryarg.error);
}
}
- if (py_print_single_arg (out, NULL, &entryarg, NULL,
- &opts, args_type,
- print_args_field, NULL) == PY_BT_ERROR)
+ if (py_print_single_arg (out, NULL, &entryarg, NULL, &opts,
+ args_type, print_args_field, NULL)
+ == EXT_LANG_BT_ERROR)
{
xfree (arg.error);
xfree (entryarg.error);
{
if (py_print_single_arg (out, sym_name, NULL, val, &opts,
args_type, print_args_field,
- language) == PY_BT_ERROR)
+ language) == EXT_LANG_BT_ERROR)
{
xfree (sym_name);
goto error;
}
}
- return PY_BT_OK;
+ return EXT_LANG_BT_OK;
error:
- return PY_BT_ERROR;
+ return EXT_LANG_BT_ERROR;
}
the argument format, PRINT_ARGS_FIELD is flag which indicates
whether to output the ARGS field in the case of
-stack-list-variables and FRAME is the backing frame. Returns
- PY_BT_ERROR on error, with any GDB exceptions converted to a Python
- exception, or PY_BT_OK on success. */
+ EXT_LANG_BT_ERROR on error, with any GDB exceptions converted to a Python
+ exception, or EXT_LANG_BT_OK on success. */
-static enum py_bt_status
+static enum ext_lang_bt_status
enumerate_locals (PyObject *iter,
struct ui_out *out,
int indent,
- enum py_frame_args args_type,
+ enum ext_lang_frame_args args_type,
int print_args_field,
struct frame_info *frame)
{
const struct language_defn *language;
char *sym_name;
struct value *val;
- enum py_bt_status success = PY_BT_ERROR;
+ enum ext_lang_bt_status success = EXT_LANG_BT_ERROR;
struct symbol *sym;
volatile struct gdb_exception except;
int local_indent = 8 + (8 * indent);
locals_cleanups = make_cleanup_py_decref (item);
success = extract_sym (item, &sym_name, &sym, &language);
- if (success == PY_BT_ERROR)
+ if (success == EXT_LANG_BT_ERROR)
{
do_cleanups (locals_cleanups);
goto error;
make_cleanup (xfree, sym_name);
success = extract_value (item, &val);
- if (success == PY_BT_ERROR)
+ if (success == EXT_LANG_BT_ERROR)
{
do_cleanups (locals_cleanups);
goto error;
if (args_type == MI_PRINT_SIMPLE_VALUES)
{
- if (py_print_type (out, val) == PY_BT_ERROR)
+ if (py_print_type (out, val) == EXT_LANG_BT_ERROR)
{
do_cleanups (locals_cleanups);
goto error;
int val_indent = (indent + 1) * 4;
if (py_print_value (out, val, &opts, val_indent, args_type,
- language) == PY_BT_ERROR)
+ language) == EXT_LANG_BT_ERROR)
{
do_cleanups (locals_cleanups);
goto error;
if (args_type != NO_VALUES)
{
if (py_print_value (out, val, &opts, 0, args_type,
- language) == PY_BT_ERROR)
+ language) == EXT_LANG_BT_ERROR)
{
do_cleanups (locals_cleanups);
goto error;
if (item == NULL && PyErr_Occurred ())
goto error;
- return PY_BT_OK;
+ return EXT_LANG_BT_OK;
error:
- return PY_BT_ERROR;
+ return EXT_LANG_BT_ERROR;
}
-/* Helper function for -stack-list-variables. Returns PY_BT_ERROR on
- error, or PY_BT_OK on success. */
+/* Helper function for -stack-list-variables. Returns EXT_LANG_BT_ERROR on
+ error, or EXT_LANG_BT_OK on success. */
-static enum py_bt_status
+static enum ext_lang_bt_status
py_mi_print_variables (PyObject *filter, struct ui_out *out,
struct value_print_options *opts,
- enum py_frame_args args_type,
+ enum ext_lang_frame_args args_type,
struct frame_info *frame)
{
struct cleanup *old_chain;
make_cleanup_ui_out_list_begin_end (out, "variables");
if (args_iter != Py_None)
- if (enumerate_args (args_iter, out, args_type, 1, frame) == PY_BT_ERROR)
+ if (enumerate_args (args_iter, out, args_type, 1, frame)
+ == EXT_LANG_BT_ERROR)
goto error;
if (locals_iter != Py_None)
if (enumerate_locals (locals_iter, out, 1, args_type, 1, frame)
- == PY_BT_ERROR)
+ == EXT_LANG_BT_ERROR)
goto error;
do_cleanups (old_chain);
- return PY_BT_OK;
+ return EXT_LANG_BT_OK;
error:
do_cleanups (old_chain);
- return PY_BT_ERROR;
+ return EXT_LANG_BT_ERROR;
}
/* Helper function for printing locals. This function largely just
creates the wrapping tuple, and calls enumerate_locals. Returns
- PY_BT_ERROR on error, or PY_BT_OK on success.*/
+ EXT_LANG_BT_ERROR on error, or EXT_LANG_BT_OK on success. */
-static enum py_bt_status
+static enum ext_lang_bt_status
py_print_locals (PyObject *filter,
struct ui_out *out,
- enum py_frame_args args_type,
+ enum ext_lang_frame_args args_type,
int indent,
struct frame_info *frame)
{
if (locals_iter != Py_None)
if (enumerate_locals (locals_iter, out, indent, args_type,
- 0, frame) == PY_BT_ERROR)
+ 0, frame) == EXT_LANG_BT_ERROR)
goto locals_error;
do_cleanups (old_chain);
- return PY_BT_OK;;
+ return EXT_LANG_BT_OK;
locals_error:
do_cleanups (old_chain);
- return PY_BT_ERROR;
+ return EXT_LANG_BT_ERROR;
}
/* Helper function for printing frame arguments. This function
largely just creates the wrapping tuple, and calls enumerate_args.
- Returns PY_BT_ERROR on error, with any GDB exceptions converted to
- a Python exception, or PY_BT_OK on success. */
+ Returns EXT_LANG_BT_ERROR on error, with any GDB exceptions converted to
+ a Python exception, or EXT_LANG_BT_OK on success. */
-static enum py_bt_status
+static enum ext_lang_bt_status
py_print_args (PyObject *filter,
struct ui_out *out,
- enum py_frame_args args_type,
+ enum ext_lang_frame_args args_type,
struct frame_info *frame)
{
PyObject *args_iter = get_py_iter_from_func (filter, "frame_args");
}
if (args_iter != Py_None)
- if (enumerate_args (args_iter, out, args_type, 0, frame) == PY_BT_ERROR)
+ if (enumerate_args (args_iter, out, args_type, 0, frame)
+ == EXT_LANG_BT_ERROR)
goto args_error;
TRY_CATCH (except, RETURN_MASK_ALL)
}
do_cleanups (old_chain);
- return PY_BT_OK;
+ return EXT_LANG_BT_OK;
args_error:
do_cleanups (old_chain);
- return PY_BT_ERROR;
+ return EXT_LANG_BT_ERROR;
}
/* Print a single frame to the designated output stream, detecting
(in the case of elided frames), and LEVELS_PRINTED is a hash-table
containing all the frames level that have already been printed.
If a frame level has been printed, do not print it again (in the
- case of elided frames). Returns PY_BT_ERROR on error, with any
- GDB exceptions converted to a Python exception, or PY_BT_COMPLETED
+ case of elided frames). Returns EXT_LANG_BT_ERROR on error, with any
+ GDB exceptions converted to a Python exception, or EXT_LANG_BT_COMPLETED
on success. */
-static enum py_bt_status
-py_print_frame (PyObject *filter, int flags, enum py_frame_args args_type,
+static enum ext_lang_bt_status
+py_print_frame (PyObject *filter, int flags,
+ enum ext_lang_frame_args args_type,
struct ui_out *out, int indent, htab_t levels_printed)
{
int has_addr = 0;
if (print_locals && print_args && ! print_frame_info)
{
if (py_mi_print_variables (filter, out, &opts,
- args_type, frame) == PY_BT_ERROR)
+ args_type, frame) == EXT_LANG_BT_ERROR)
goto error;
else
{
do_cleanups (cleanup_stack);
- return PY_BT_COMPLETED;
+ return EXT_LANG_BT_COMPLETED;
}
}
wrong. */
if (print_args)
{
- if (py_print_args (filter, out, args_type, frame) == PY_BT_ERROR)
+ if (py_print_args (filter, out, args_type, frame) == EXT_LANG_BT_ERROR)
goto error;
}
if (print_locals)
{
if (py_print_locals (filter, out, args_type, indent,
- frame) == PY_BT_ERROR)
+ frame) == EXT_LANG_BT_ERROR)
goto error;
}
while ((item = PyIter_Next (elided)))
{
- enum py_bt_status success = py_print_frame (item, flags,
- args_type, out,
- indent,
- levels_printed);
+ enum ext_lang_bt_status success = py_print_frame (item, flags,
+ args_type, out,
+ indent,
+ levels_printed);
- if (success == PY_BT_ERROR)
+ if (success == EXT_LANG_BT_ERROR)
{
Py_DECREF (item);
goto error;
do_cleanups (cleanup_stack);
- return PY_BT_COMPLETED;
+ return EXT_LANG_BT_COMPLETED;
error:
do_cleanups (cleanup_stack);
- return PY_BT_ERROR;
+ return EXT_LANG_BT_ERROR;
}
/* Helper function to initiate frame filter invocation at starting
variables. ARGS_TYPE is an enumerator describing the argument
format, OUT is the output stream to print. FRAME_LOW is the
beginning of the slice of frames to print, and FRAME_HIGH is the
- upper limit of the frames to count. Returns PY_BT_ERROR on error,
- or PY_BT_COMPLETED on success.*/
-
-enum py_bt_status
-apply_frame_filter (struct frame_info *frame, int flags,
- enum py_frame_args args_type,
- struct ui_out *out, int frame_low,
- int frame_high)
-
+ upper limit of the frames to count. Returns EXT_LANG_BT_ERROR on error,
+ or EXT_LANG_BT_COMPLETED on success. */
+
+enum ext_lang_bt_status
+gdbpy_apply_frame_filter (const struct extension_language_defn *extlang,
+ struct frame_info *frame, int flags,
+ enum ext_lang_frame_args args_type,
+ struct ui_out *out, int frame_low, int frame_high)
{
struct gdbarch *gdbarch = NULL;
struct cleanup *cleanups;
- enum py_bt_status success = PY_BT_ERROR;
+ enum ext_lang_bt_status success = EXT_LANG_BT_ERROR;
PyObject *iterable;
volatile struct gdb_exception except;
PyObject *item;
htab_t levels_printed;
if (!gdb_python_initialized)
- return PY_BT_NO_FILTERS;
+ return EXT_LANG_BT_NO_FILTERS;
TRY_CATCH (except, RETURN_MASK_ALL)
{
if (except.reason < 0)
{
/* Let gdb try to print the stack trace. */
- return PY_BT_NO_FILTERS;
+ return EXT_LANG_BT_NO_FILTERS;
}
cleanups = ensure_python_env (gdbarch, current_language);
where GDB cannot initialize the frame filters (most likely
due to incorrect auto-load paths), GDB has printed nothing.
In this case it is OK to print the default backtrace after
- printing the error message. GDB returns PY_BT_NO_FILTERS
+ printing the error message. GDB returns EXT_LANG_BT_NO_FILTERS
here to signify there are no filters after printing the
initialization error. This return code will trigger a
default backtrace. */
gdbpy_print_stack ();
do_cleanups (cleanups);
- return PY_BT_NO_FILTERS;
+ return EXT_LANG_BT_NO_FILTERS;
}
/* If iterable is None, then there are no frame filters registered.
make_cleanup_py_decref (iterable);
if (iterable == Py_None)
{
- success = PY_BT_NO_FILTERS;
+ success = EXT_LANG_BT_NO_FILTERS;
goto done;
}
/* Do not exit on error printing a single frame. Print the
error and continue with other frames. */
- if (success == PY_BT_ERROR)
+ if (success == EXT_LANG_BT_ERROR)
gdbpy_print_stack ();
Py_DECREF (item);
error:
gdbpy_print_stack ();
do_cleanups (cleanups);
- return PY_BT_ERROR;
+ return EXT_LANG_BT_ERROR;
}
projects / deliverable / binutils-gdb.git / blobdiff