From ba18742c3a1b62ff218db99bee47bb932af6dab9 Mon Sep 17 00:00:00 2001 From: Simon Marchi Date: Sun, 7 Jan 2018 09:25:32 -0500 Subject: C++ify xmethod_worker, get rid of VEC(xmethod_worker_ptr) The initial goal of this patch was to remove the usage of VEC(xmethod_worker_ptr) and corresponding cleanups. I ended up having to C++ify the xmethod_worker code, to be able to have xmethod_workers free their data in destructors, and therefore be able to use vectors of xmethod_worker unique_ptr. The operations in extension_language_ops that act on one instance of xmethod_worker (get result type, get args type, invoke) are transformed to methods of xmethod_worker. xmethod_worker becomes an abstract base class with virtual pure methods which python_xmethod_worker implements. The only xmethod-related operation left in extension_language_ops is get_matching_xmethod_workers, which returns a list of xmethod_workers. The changes are relatively straightforward, but here are some notes on things that may raise eyebrows: - I was not really comfortable with the value_of_xmethod function. At first it looks like a simple getter, so I considered making it a method of xmethod_worker. But actually it creates a value and transfers the ownership of the xmethod_worker to it. It would be a bit weird and error-prone if calling a method on an object silently removed the ownership of the object from the caller. To reflect the behavior more accurately, I renamed it to value_from_xmethod and made it accept an rvalue-reference (so the caller knows it gives away the ownership). I noticed the backlink from xmethod_worker to its owning value was not used, so I removed it. - Some code, like get_matching_xmethod_workers, made each callee fill a new vector, which was then merged in the result vector. I think it's safe if we always pass the same vector around, and each implementation just appends to it. - The clone operation does not seem particularly useful, it is removed in the following patch. gdb/ChangeLog: * extension-priv.h (enum ext_lang_rc): Remove, move to extension.h. (struct extension_language_ops) : Remove. : Remove. : Chance VEC to std::vector. : Remove. : Remove. : Remove. * extension.c (new_xmethod_worker): Remove. (clone_xmethod_worker): Remove. (get_matching_xmethod_workers): Return void, pass std::vector by pointer. (get_xmethod_arg_types): Rename to... (xmethod_worker::get_arg_types): ... this, and adjust. (get_xmethod_result_type): Rename to... (xmethod_worker::get_result_type): ... this, and adjust. (invoke_xmethod): Remove. (free_xmethod_worker): Remove. (free_xmethod_worker_vec): Remove. * extension.h (enum ext_lang_rc): Move here from extension-priv.h. (struct xmethod_worker): Add constructor and destructor. : Remove. : Remove. : New virtual pure methods. : New methods. (xmethod_worker_ptr): Remove typedef. (DEF_VEC_P (xmethod_worker_ptr)): Remove. (xmethod_worker_vec): Remove typedef. (xmethod_worker_up): New typedef. (invoke_xmethod): Remove. (clone_xmethod_worker): Remove. (free_xmethod_worker): Remove. (free_xmethod_worker_vec): Remove. (get_xmethod_arg_types): Remove. (get_xmethod_result_type): Remove. * valops.c (find_method_list): Use std::vector, don't use intermediate vector. (value_find_oload_method_list): Use std::vector. (find_overload_match): Use std::vector. (find_oload_champ): Use std::vector. * value.c (value_free): Use operator delete. (value_of_xmethod): Rename to... (value_from_xmethod): ... this. Don't assign xmethod_worker::value, take rvalue-reference. (result_type_of_xmethod): Adjust. (call_xmethod): Adjust. * value.h: Include extension.h. (struct xmethod_worker): Don't forward-declare. (value_of_xmethod): Rename to... (value_from_xmethod): ... this, take rvalue-reference. * python/py-xmethods.c (struct gdbpy_worker_data): Rename to... (struct python_xmethod_worker): ... this, add constructor and destructor. : Implement. (gdbpy_free_xmethod_worker_data): Rename to... (python_xmethod_worker::~python_xmethod_worker): ... this and adjust. (gdbpy_clone_xmethod_worker_data): Rename to... (python_xmethod_worker::clone): ... this and adjust. (gdbpy_get_matching_xmethod_workers): Use std::vector, don't use temporary vector. (gdbpy_get_xmethod_arg_types): Rename to... (python_xmethod_worker::do_get_arg_types): ... this and adjust. (gdbpy_get_xmethod_result_type): Rename to... (python_xmethod_worker::do_get_result_type): ... this and adjust. (gdbpy_invoke_xmethod): Rename to... (python_xmethod_worker::invoke): ... this and adjust. (new_python_xmethod_worker): Rename to... (python_xmethod_worker::python_xmethod_worker): ... this and adjust. * python/python-internal.h (gdbpy_clone_xmethod_worker_data): Remove. (gdbpy_free_xmethod_worker_data): Remove. (gdbpy_get_matching_xmethod_workers): Use std::vector. (gdbpy_get_xmethod_arg_types): Remove. (gdbpy_get_xmethod_result_type): Remove. (gdbpy_invoke_xmethod): Remove. * python/python.c (python_extension_ops): Remove obsolete callbacks. --- gdb/extension-priv.h | 75 ++++------------------------------------------------ 1 file changed, 5 insertions(+), 70 deletions(-) (limited to 'gdb/extension-priv.h') diff --git a/gdb/extension-priv.h b/gdb/extension-priv.h index 8fbf1b0c769..5843479f93c 100644 --- a/gdb/extension-priv.h +++ b/gdb/extension-priv.h @@ -25,26 +25,6 @@ #include #include "cli/cli-script.h" -/* The return code for some API calls. */ - -enum ext_lang_rc - { - /* The operation completed successfully. */ - EXT_LANG_RC_OK, - - /* The operation was not performed (e.g., no pretty-printer). */ - EXT_LANG_RC_NOP, - - /* There was an error (e.g., Python error while printing a value). - When an error occurs no further extension languages are tried. - This is to preserve existing behaviour, and because it's convenient - for Python developers. - Note: This is different than encountering a memory error trying to read - a value for pretty-printing. Here we're referring to, e.g., programming - errors that trigger an exception in the extension language. */ - EXT_LANG_RC_ERROR - }; - /* High level description of an extension/scripting language. An entry for each is compiled into GDB regardless of whether the support is present. This is done so that we can issue meaningful errors if the @@ -261,63 +241,18 @@ struct extension_language_ops enum ext_lang_rc (*before_prompt) (const struct extension_language_defn *, const char *current_gdb_prompt); - /* xmethod support: - clone_xmethod_worker_data, free_xmethod_worker_data, - get_matching_xmethod_workers, get_xmethod_arg_types, - get_xmethod_return_type, invoke_xmethod. - These methods are optional and may be NULL, but if one of them is - implemented then they all must be. */ - - /* Clone DATA and return a new but identical xmethod worker data - object for this extension language. */ - void * (*clone_xmethod_worker_data) - (const struct extension_language_defn *extlang, void *data); - - /* Free the DATA object of this extension language. */ - void (*free_xmethod_worker_data) - (const struct extension_language_defn *extlang, void *data); - /* Return a vector of matching xmethod workers defined in this extension language. The workers service methods with name METHOD_NAME on objects of type OBJ_TYPE. The vector is returned - in DM_VEC. */ + in DM_VEC. + + This field may be NULL if the extension language does not support + xmethods. */ enum ext_lang_rc (*get_matching_xmethod_workers) (const struct extension_language_defn *extlang, struct type *obj_type, const char *method_name, - xmethod_worker_vec **dm_vec); - - /* Given a WORKER servicing a particular method, return the types - of the arguments the method takes. The number of arguments is - returned in NARGS, and their types are returned in the array - ARGTYPES. */ - enum ext_lang_rc (*get_xmethod_arg_types) - (const struct extension_language_defn *extlang, - struct xmethod_worker *worker, - int *nargs, - struct type ***arg_types); - - /* Given a WORKER servicing a particular method, fetch the type of the - result of the method. OBJECT, ARGS, NARGS are the same as for - invoke_xmethod. The result type is stored in *RESULT_TYPE. - For backward compatibility with 7.9, which did not support getting the - result type, if the get_result_type operation is not provided by WORKER - then EXT_LANG_RC_OK is returned and NULL is returned in *RESULT_TYPE. */ - enum ext_lang_rc (*get_xmethod_result_type) - (const struct extension_language_defn *extlang, - struct xmethod_worker *worker, - struct value *object, struct value **args, int nargs, - struct type **result_type); - - /* Invoke the xmethod serviced by WORKER. The xmethod is invoked - on OBJECT with arguments in the array ARGS. NARGS is the length of - this array. Returns the value returned by the xmethod. */ - struct value * (*invoke_xmethod) - (const struct extension_language_defn *extlang, - struct xmethod_worker *worker, - struct value *object, - struct value **args, - int nargs); + std::vector *dm_vec); }; /* State necessary to restore a signal handler to its previous value. */ -- cgit v1.2.1