feature branch for creating MI commands with python (was: How to create new mi commands via python / get current interpreter in python)

feature branch for creating MI commands with python (was: How to create new mi commands via python / get current interpreter in python)

[Simon Sobisch]

Am 05.11.2021 um 19:51 schrieb Jan Vrany:
>>
>>> In any case that looks quite promising, would be nice to see it at
>>> least
>>> in a feature-branch in the official gdb repo until it is ready to
>>> be
>>> merged.
>>
>> Good idea, I can do that. I'll post here when done.
>>
>>
> 
> Done. Rebased on a recent master and pushed into branch:
> "users/jv/patches/feature-python-mi":
> 
> https://sourceware.org/git/?p=binutils-gdb.git;a=shortlog;h=refs/heads/users/jv/patches/feature-python-mi
> 
> HTH, Jan

Thanks, I think this discussion should now move to gdb-patches.
I'd be interested what is missing to integrate this for GDB 12 
(obviously a "stable" ABI would be needed).

I'm looking forward to read about that in gdb-patches (hopefully sooner 
than later).

Thanks again for taking the time to answer and for your work on 
improving GDB's Python API.

Simon

[PATCH 0/5] refactoring towards Python MI command API

[Andrew Burgess]

Jan, Simon,

I have also wanted Python support for creating MI commands in the
past, so was really interested to read through your patches.

To answer Simon's question about what would be needed to get this
merged; what's needed is to get the patch series posted to the list
(e.g. using git-format-patch / git-send-email), then the review
process can start.

That said, I took a look through the series.  The patches to actually
add the Python API will definitely need documentation writing, I also
had some thoughts on some minor details of the implementation, but, in
general I thought it looked pretty good.

Given Jan mentioned that he might not have time to work on this soon,
I thought I'd take the liberty of trying to move this work forward.

So, the patches below are based on the first half of Jan's branch,
this is all the setup work before the actual Python API is added.  The
patches to add the Python API should rebase on this series with only a
few minor merge conflicts.  I think this work is a nice cleanup in its
own right, so worth posting, and trying to get merged.  I have some
other work I will try to get done, which should make the Python API
part a little cleaner.

Thoughts and feedback welcome,

Thanks,
Andrew

---

Andrew Burgess (1):
  gdb/mi: int to bool conversion in mi_execute_cli_command

Jan Vrany (4):
  gdb/mi: rename mi_lookup to mi_cmd_lookup
  gdb/mi: use std::map for MI commands in mi-cmds.c
  gdb/mi: use separate classes for different types of MI command
  gdb/mi: rename mi_cmd to mi_command

 gdb/mi/mi-cmd-info.c |   4 +-
 gdb/mi/mi-cmds.c     | 549 +++++++++++++++++++++++--------------------
 gdb/mi/mi-cmds.h     |  66 ++++--
 gdb/mi/mi-main.c     |  51 +---
 gdb/mi/mi-main.h     |  12 +
 gdb/mi/mi-parse.c    |  20 +-
 gdb/mi/mi-parse.h    |   6 +-
 7 files changed, 375 insertions(+), 333 deletions(-)

-- 
2.25.4

[PATCH 1/5] gdb/mi: rename mi_lookup to mi_cmd_lookup

[Andrew Burgess]

From: Jan Vrany <jan.vrany@labware.com>

Lets give this function a more descriptive name.  I've also improved
the comments in the header and source files.

There should be no user visible changes after this commit.
---
 gdb/mi/mi-cmd-info.c | 2 +-
 gdb/mi/mi-cmds.c     | 5 +++--
 gdb/mi/mi-cmds.h     | 5 +++--
 gdb/mi/mi-parse.c    | 2 +-
 4 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/gdb/mi/mi-cmd-info.c b/gdb/mi/mi-cmd-info.c
index 78377dc32e7..c2858519a4c 100644
--- a/gdb/mi/mi-cmd-info.c
+++ b/gdb/mi/mi-cmd-info.c
@@ -82,7 +82,7 @@ mi_cmd_info_gdb_mi_command (const char *command, char **argv, int argc)
   if (cmd_name[0] == '-')
     cmd_name++;
 
-  cmd = mi_lookup (cmd_name);
+  cmd = mi_cmd_lookup (cmd_name);
 
   ui_out_emit_tuple tuple_emitter (uiout, "command");
   uiout->field_string ("exists", cmd != NULL ? "true" : "false");
diff --git a/gdb/mi/mi-cmds.c b/gdb/mi/mi-cmds.c
index 1ed8b6f9126..8899fdd3a1e 100644
--- a/gdb/mi/mi-cmds.c
+++ b/gdb/mi/mi-cmds.c
@@ -211,9 +211,10 @@ enum
     MI_TABLE_SIZE = 227
   };
 
-/* Exported function used to obtain info from the table.  */
+/* See mi-cmds.h.  */
+
 struct mi_cmd *
-mi_lookup (const char *command)
+mi_cmd_lookup (const char *command)
 {
   return *lookup_table (command);
 }
diff --git a/gdb/mi/mi-cmds.h b/gdb/mi/mi-cmds.h
index 8da2e393919..e92737be8c8 100644
--- a/gdb/mi/mi-cmds.h
+++ b/gdb/mi/mi-cmds.h
@@ -164,9 +164,10 @@ struct mi_cmd
   int *suppress_notification;
 };
 
-/* Lookup a command in the MI command table.  */
+/* Lookup a command in the MI command table, returns nullptr if COMMAND is
+   not found.  */
 
-extern struct mi_cmd *mi_lookup (const char *command);
+extern struct mi_cmd *mi_cmd_lookup (const char *command);
 
 /* Debug flag */
 extern int mi_debug_p;
diff --git a/gdb/mi/mi-parse.c b/gdb/mi/mi-parse.c
index 4d6afa93e1f..b5b01cf4db0 100644
--- a/gdb/mi/mi-parse.c
+++ b/gdb/mi/mi-parse.c
@@ -272,7 +272,7 @@ mi_parse (const char *cmd, char **token)
   }
 
   /* Find the command in the MI table.  */
-  parse->cmd = mi_lookup (parse->command);
+  parse->cmd = mi_cmd_lookup (parse->command);
   if (parse->cmd == NULL)
     throw_error (UNDEFINED_COMMAND_ERROR,
 		 _("Undefined MI command: %s"), parse->command);
-- 
2.25.4

[PATCH 2/5] gdb/mi: use std::map for MI commands in mi-cmds.c

[Andrew Burgess]

From: Jan Vrany <jan.vrany@labware.com>

This changes the hashmap used in mi-cmds.c from a custom structure to
std::map.  Not only is replacing a custom container with a standard
one an improvement, but using std::map will make it easier to
dynamically add commands in a later commit where a new Python API will
be added for creating MI commands.

There should be no user visible changes after this commit.

gdb/ChangeLog:

	* mi/mi-cmds.c: Add 'map' and 'string' includes.
	(typedef mi_cmd_up): New typedef.
	(mi_cmds): Delete static global.
	(mi_table): Likewise.
	(MI_TABLE_SIZE): Delete, along with the enclosing anonymous enum.
	(struct stats): Delete.
	(lookup_table): Delete function.
	(mi_cmd_table): New static global.
	(DEF_MI_CMD_CLI_1): Delete macro.
	(DEF_MI_CMD_CLI): Delete macro.
	(DEF_MI_CMD_MI): Delete macro.
	(DEF_MI_CMD_MI_1): Delete macro.
	(insert_mi_cmd_entry): New function.
	(create_mi_cmd): New function.
	(add_mi_cmd_cli): New function.
	(add_mi_cmd_mi): New function.
	(build_table): Remove parameter, rewrite.
	(mi_lookup): Rename to ...
	(mi_cmd_lookup): this.
	(_initialize_mi_cmds): Rewrite.
---
 gdb/mi/mi-cmds.c | 476 +++++++++++++++++++++++------------------------
 1 file changed, 228 insertions(+), 248 deletions(-)

diff --git a/gdb/mi/mi-cmds.c b/gdb/mi/mi-cmds.c
index 8899fdd3a1e..1e18afc5745 100644
--- a/gdb/mi/mi-cmds.c
+++ b/gdb/mi/mi-cmds.c
@@ -22,283 +22,263 @@
 #include "top.h"
 #include "mi-cmds.h"
 #include "mi-main.h"
+#include <map>
+#include <string>
 
-struct mi_cmd;
-static struct mi_cmd **lookup_table (const char *command);
-static void build_table (struct mi_cmd *commands);
+/* A command held in the MI_CMD_TABLE.  */
 
-static struct mi_cmd mi_cmds[] =
-{
-/* Define a MI command of NAME, and its corresponding CLI command is
-   CLI_NAME.  */
-#define DEF_MI_CMD_CLI_1(NAME, CLI_NAME, ARGS_P, CALLED)	\
-  { NAME, { CLI_NAME, ARGS_P}, NULL, CALLED }
-#define DEF_MI_CMD_CLI(NAME, CLI_NAME, ARGS_P) \
-  DEF_MI_CMD_CLI_1(NAME, CLI_NAME, ARGS_P, NULL)
+typedef std::unique_ptr<struct mi_cmd> mi_cmd_up;
 
-/* Define a MI command of NAME, and implemented by function MI_FUNC.  */
-#define DEF_MI_CMD_MI_1(NAME, MI_FUNC, CALLED) \
-  { NAME, {NULL, 0}, MI_FUNC, CALLED }
-#define DEF_MI_CMD_MI(NAME, MI_FUNC) DEF_MI_CMD_MI_1(NAME, MI_FUNC, NULL)
+/* MI command table (built at run time). */
 
-  DEF_MI_CMD_MI ("ada-task-info", mi_cmd_ada_task_info),
-  DEF_MI_CMD_MI ("add-inferior", mi_cmd_add_inferior),
-  DEF_MI_CMD_CLI_1 ("break-after", "ignore", 1,
-		    &mi_suppress_notification.breakpoint),
-  DEF_MI_CMD_MI_1 ("break-condition", mi_cmd_break_condition,
-		   &mi_suppress_notification.breakpoint),
-  DEF_MI_CMD_MI_1 ("break-commands", mi_cmd_break_commands,
-		   &mi_suppress_notification.breakpoint),
-  DEF_MI_CMD_CLI_1 ("break-delete", "delete breakpoint", 1,
-		    &mi_suppress_notification.breakpoint),
-  DEF_MI_CMD_CLI_1 ("break-disable", "disable breakpoint", 1,
-		    &mi_suppress_notification.breakpoint),
-  DEF_MI_CMD_CLI_1 ("break-enable", "enable breakpoint", 1,
-		     &mi_suppress_notification.breakpoint),
-  DEF_MI_CMD_CLI ("break-info", "info break", 1),
-  DEF_MI_CMD_MI_1 ("break-insert", mi_cmd_break_insert,
-		   &mi_suppress_notification.breakpoint),
-  DEF_MI_CMD_MI_1 ("dprintf-insert", mi_cmd_dprintf_insert,
-		   &mi_suppress_notification.breakpoint),
-  DEF_MI_CMD_CLI ("break-list", "info break", 0),
-  DEF_MI_CMD_MI_1 ("break-passcount", mi_cmd_break_passcount,
-		   &mi_suppress_notification.breakpoint),
-  DEF_MI_CMD_MI_1 ("break-watch", mi_cmd_break_watch,
-		   &mi_suppress_notification.breakpoint),
-  DEF_MI_CMD_MI_1 ("catch-assert", mi_cmd_catch_assert,
-		   &mi_suppress_notification.breakpoint),
-  DEF_MI_CMD_MI_1 ("catch-exception", mi_cmd_catch_exception,
-		   &mi_suppress_notification.breakpoint),
-  DEF_MI_CMD_MI_1 ("catch-handlers", mi_cmd_catch_handlers,
-		   &mi_suppress_notification.breakpoint),
-  DEF_MI_CMD_MI_1 ("catch-load", mi_cmd_catch_load,
-		   &mi_suppress_notification.breakpoint),
-  DEF_MI_CMD_MI_1 ("catch-unload", mi_cmd_catch_unload,
-		   &mi_suppress_notification.breakpoint),
-  DEF_MI_CMD_MI_1 ("catch-throw", mi_cmd_catch_throw,
-		   &mi_suppress_notification.breakpoint),
-  DEF_MI_CMD_MI_1 ("catch-rethrow", mi_cmd_catch_rethrow,
-		   &mi_suppress_notification.breakpoint),
-  DEF_MI_CMD_MI_1 ("catch-catch", mi_cmd_catch_catch,
-		   &mi_suppress_notification.breakpoint),
-  DEF_MI_CMD_MI ("complete", mi_cmd_complete),
-  DEF_MI_CMD_MI ("data-disassemble", mi_cmd_disassemble),
-  DEF_MI_CMD_MI ("data-evaluate-expression", mi_cmd_data_evaluate_expression),
-  DEF_MI_CMD_MI ("data-list-changed-registers",
-		 mi_cmd_data_list_changed_registers),
-  DEF_MI_CMD_MI ("data-list-register-names", mi_cmd_data_list_register_names),
-  DEF_MI_CMD_MI ("data-list-register-values", mi_cmd_data_list_register_values),
-  DEF_MI_CMD_MI ("data-read-memory", mi_cmd_data_read_memory),
-  DEF_MI_CMD_MI ("data-read-memory-bytes", mi_cmd_data_read_memory_bytes),
-  DEF_MI_CMD_MI_1 ("data-write-memory", mi_cmd_data_write_memory,
-		   &mi_suppress_notification.memory),
-  DEF_MI_CMD_MI_1 ("data-write-memory-bytes", mi_cmd_data_write_memory_bytes,
-		   &mi_suppress_notification.memory),
-  DEF_MI_CMD_MI ("data-write-register-values",
-		 mi_cmd_data_write_register_values),
-  DEF_MI_CMD_MI ("enable-timings", mi_cmd_enable_timings),
-  DEF_MI_CMD_MI ("enable-pretty-printing", mi_cmd_enable_pretty_printing),
-  DEF_MI_CMD_MI ("enable-frame-filters", mi_cmd_enable_frame_filters),
-  DEF_MI_CMD_MI ("environment-cd", mi_cmd_env_cd),
-  DEF_MI_CMD_MI ("environment-directory", mi_cmd_env_dir),
-  DEF_MI_CMD_MI ("environment-path", mi_cmd_env_path),
-  DEF_MI_CMD_MI ("environment-pwd", mi_cmd_env_pwd),
-  DEF_MI_CMD_CLI_1 ("exec-arguments", "set args", 1,
-		    &mi_suppress_notification.cmd_param_changed),
-  DEF_MI_CMD_MI ("exec-continue", mi_cmd_exec_continue),
-  DEF_MI_CMD_MI ("exec-finish", mi_cmd_exec_finish),
-  DEF_MI_CMD_MI ("exec-jump", mi_cmd_exec_jump),
-  DEF_MI_CMD_MI ("exec-interrupt", mi_cmd_exec_interrupt),
-  DEF_MI_CMD_MI ("exec-next", mi_cmd_exec_next),
-  DEF_MI_CMD_MI ("exec-next-instruction", mi_cmd_exec_next_instruction),
-  DEF_MI_CMD_MI ("exec-return", mi_cmd_exec_return),
-  DEF_MI_CMD_MI ("exec-run", mi_cmd_exec_run),
-  DEF_MI_CMD_MI ("exec-step", mi_cmd_exec_step),
-  DEF_MI_CMD_MI ("exec-step-instruction", mi_cmd_exec_step_instruction),
-  DEF_MI_CMD_CLI ("exec-until", "until", 1),
-  DEF_MI_CMD_CLI ("file-exec-and-symbols", "file", 1),
-  DEF_MI_CMD_CLI ("file-exec-file", "exec-file", 1),
-  DEF_MI_CMD_MI ("file-list-exec-source-file",
-		 mi_cmd_file_list_exec_source_file),
-  DEF_MI_CMD_MI ("file-list-exec-source-files",
-		 mi_cmd_file_list_exec_source_files),
-  DEF_MI_CMD_MI ("file-list-shared-libraries",
-		 mi_cmd_file_list_shared_libraries),
-  DEF_MI_CMD_CLI ("file-symbol-file", "symbol-file", 1),
-  DEF_MI_CMD_MI ("fix-multi-location-breakpoint-output",
-		 mi_cmd_fix_multi_location_breakpoint_output),
-  DEF_MI_CMD_MI ("gdb-exit", mi_cmd_gdb_exit),
-  DEF_MI_CMD_CLI_1 ("gdb-set", "set", 1,
-		    &mi_suppress_notification.cmd_param_changed),
-  DEF_MI_CMD_CLI ("gdb-show", "show", 1),
-  DEF_MI_CMD_CLI ("gdb-version", "show version", 0),
-  DEF_MI_CMD_MI ("inferior-tty-set", mi_cmd_inferior_tty_set),
-  DEF_MI_CMD_MI ("inferior-tty-show", mi_cmd_inferior_tty_show),
-  DEF_MI_CMD_MI ("info-ada-exceptions", mi_cmd_info_ada_exceptions),
-  DEF_MI_CMD_MI ("info-gdb-mi-command", mi_cmd_info_gdb_mi_command),
-  DEF_MI_CMD_MI ("info-os", mi_cmd_info_os),
-  DEF_MI_CMD_MI ("interpreter-exec", mi_cmd_interpreter_exec),
-  DEF_MI_CMD_MI ("list-features", mi_cmd_list_features),
-  DEF_MI_CMD_MI ("list-target-features", mi_cmd_list_target_features),
-  DEF_MI_CMD_MI ("list-thread-groups", mi_cmd_list_thread_groups),
-  DEF_MI_CMD_MI ("remove-inferior", mi_cmd_remove_inferior),
-  DEF_MI_CMD_MI ("stack-info-depth", mi_cmd_stack_info_depth),
-  DEF_MI_CMD_MI ("stack-info-frame", mi_cmd_stack_info_frame),
-  DEF_MI_CMD_MI ("stack-list-arguments", mi_cmd_stack_list_args),
-  DEF_MI_CMD_MI ("stack-list-frames", mi_cmd_stack_list_frames),
-  DEF_MI_CMD_MI ("stack-list-locals", mi_cmd_stack_list_locals),
-  DEF_MI_CMD_MI ("stack-list-variables", mi_cmd_stack_list_variables),
-  DEF_MI_CMD_MI_1 ("stack-select-frame", mi_cmd_stack_select_frame,
-		   &mi_suppress_notification.user_selected_context),
-  DEF_MI_CMD_MI ("symbol-list-lines", mi_cmd_symbol_list_lines),
-  DEF_MI_CMD_MI ("symbol-info-functions", mi_cmd_symbol_info_functions),
-  DEF_MI_CMD_MI ("symbol-info-variables", mi_cmd_symbol_info_variables),
-  DEF_MI_CMD_MI ("symbol-info-types", mi_cmd_symbol_info_types),
-  DEF_MI_CMD_MI ("symbol-info-modules", mi_cmd_symbol_info_modules),
-  DEF_MI_CMD_MI ("symbol-info-module-functions",
-		 mi_cmd_symbol_info_module_functions),
-  DEF_MI_CMD_MI ("symbol-info-module-variables",
-		 mi_cmd_symbol_info_module_variables),
-  DEF_MI_CMD_CLI ("target-attach", "attach", 1),
-  DEF_MI_CMD_MI ("target-detach", mi_cmd_target_detach),
-  DEF_MI_CMD_CLI ("target-disconnect", "disconnect", 0),
-  DEF_MI_CMD_CLI ("target-download", "load", 1),
-  DEF_MI_CMD_MI ("target-file-delete", mi_cmd_target_file_delete),
-  DEF_MI_CMD_MI ("target-file-get", mi_cmd_target_file_get),
-  DEF_MI_CMD_MI ("target-file-put", mi_cmd_target_file_put),
-  DEF_MI_CMD_MI ("target-flash-erase", mi_cmd_target_flash_erase),
-  DEF_MI_CMD_CLI ("target-select", "target", 1),
-  DEF_MI_CMD_MI ("thread-info", mi_cmd_thread_info),
-  DEF_MI_CMD_MI ("thread-list-ids", mi_cmd_thread_list_ids),
-  DEF_MI_CMD_MI_1 ("thread-select", mi_cmd_thread_select,
-		   &mi_suppress_notification.user_selected_context),
-  DEF_MI_CMD_MI ("trace-define-variable", mi_cmd_trace_define_variable),
-  DEF_MI_CMD_MI_1 ("trace-find", mi_cmd_trace_find,
-		   &mi_suppress_notification.traceframe),
-  DEF_MI_CMD_MI ("trace-frame-collected",
-		 mi_cmd_trace_frame_collected),
-  DEF_MI_CMD_MI ("trace-list-variables", mi_cmd_trace_list_variables),
-  DEF_MI_CMD_MI ("trace-save", mi_cmd_trace_save),
-  DEF_MI_CMD_MI ("trace-start", mi_cmd_trace_start),
-  DEF_MI_CMD_MI ("trace-status", mi_cmd_trace_status),
-  DEF_MI_CMD_MI ("trace-stop", mi_cmd_trace_stop),
-  DEF_MI_CMD_MI ("var-assign", mi_cmd_var_assign),
-  DEF_MI_CMD_MI ("var-create", mi_cmd_var_create),
-  DEF_MI_CMD_MI ("var-delete", mi_cmd_var_delete),
-  DEF_MI_CMD_MI ("var-evaluate-expression", mi_cmd_var_evaluate_expression),
-  DEF_MI_CMD_MI ("var-info-path-expression", mi_cmd_var_info_path_expression),
-  DEF_MI_CMD_MI ("var-info-expression", mi_cmd_var_info_expression),
-  DEF_MI_CMD_MI ("var-info-num-children", mi_cmd_var_info_num_children),
-  DEF_MI_CMD_MI ("var-info-type", mi_cmd_var_info_type),
-  DEF_MI_CMD_MI ("var-list-children", mi_cmd_var_list_children),
-  DEF_MI_CMD_MI ("var-set-format", mi_cmd_var_set_format),
-  DEF_MI_CMD_MI ("var-set-frozen", mi_cmd_var_set_frozen),
-  DEF_MI_CMD_MI ("var-set-update-range", mi_cmd_var_set_update_range),
-  DEF_MI_CMD_MI ("var-set-visualizer", mi_cmd_var_set_visualizer),
-  DEF_MI_CMD_MI ("var-show-attributes", mi_cmd_var_show_attributes),
-  DEF_MI_CMD_MI ("var-show-format", mi_cmd_var_show_format),
-  DEF_MI_CMD_MI ("var-update", mi_cmd_var_update),
-  { NULL, }
-};
+static std::map<std::string, mi_cmd_up> mi_cmd_table;
 
-/* Pointer to the mi command table (built at run time). */
+/* Insert a new mi-command into the command table.  Return true if
+   insertion was successful.  */
 
-static struct mi_cmd **mi_table;
+static bool
+insert_mi_cmd_entry (mi_cmd_up command)
+{
+  gdb_assert (command != nullptr);
+  gdb_assert (command->name != nullptr);
 
-/* A prime large enough to accomodate the entire command table.  */
-enum
-  {
-    MI_TABLE_SIZE = 227
-  };
+  std::string name (command->name);
 
-/* See mi-cmds.h.  */
+  if (mi_cmd_table.find (name) != mi_cmd_table.end ())
+    return false;
 
-struct mi_cmd *
-mi_cmd_lookup (const char *command)
+  mi_cmd_table[name] = std::move (command);
+  return true;
+}
+
+/* Create an mi_cmd structure with name NAME.  */
+
+static mi_cmd_up
+create_mi_cmd (const char *name)
 {
-  return *lookup_table (command);
+  mi_cmd_up cmd (new mi_cmd ());
+  cmd->name = name;
+  return cmd;
 }
 
-/* Used for collecting hash hit/miss statistics.  */
+/* Create and register a new MI command with a pure MI implementation.
+   NAME must name an MI command that does not already exist, otherwise an
+   assertion will trigger.  */
 
-static struct
+static void
+add_mi_cmd_mi (const char *name, mi_cmd_argv_ftype function,
+	       int *suppress_notification = nullptr)
 {
-  int hit;
-  int miss;
-  int rehash;
-} stats;
+  mi_cmd_up cmd_up = create_mi_cmd (name);
+
+  cmd_up->cli.cmd = nullptr;
+  cmd_up->cli.args_p = 0;
+  cmd_up->argv_func = function;
+  cmd_up->suppress_notification = suppress_notification;
 
-/* Look up a command.  */
+  bool success = insert_mi_cmd_entry (std::move (cmd_up));
+  gdb_assert (success);
+}
+
+/* Create and register a new MI command implemented on top of a CLI
+   command.  NAME must name an MI command that does not already exist,
+   otherwise an assertion will trigger.  */
 
-static struct mi_cmd **
-lookup_table (const char *command)
+static void
+add_mi_cmd_cli (const char *name, const char *cli_name, int args_p,
+		int *suppress_notification = nullptr)
 {
-  const char *chp;
-  unsigned int index = 0;
+  mi_cmd_up cmd_up = create_mi_cmd (name);
 
-  /* Compute our hash.  */
-  for (chp = command; *chp; chp++)
-    {
-      /* We use a somewhat arbitrary formula.  */
-      index = ((index << 6) + (unsigned int) *chp) % MI_TABLE_SIZE;
-    }
+  cmd_up->cli.cmd = cli_name;
+  cmd_up->cli.args_p = args_p;
+  cmd_up->argv_func = nullptr;
+  cmd_up->suppress_notification = suppress_notification;
 
-  while (1)
-    {
-      struct mi_cmd **entry = &mi_table[index];
-      if ((*entry) == 0)
-	{
-	  /* not found, return pointer to next free. */
-	  stats.miss++;
-	  return entry;
-	}
-      if (strcmp (command, (*entry)->name) == 0)
-	{
-	  stats.hit++;
-	  return entry;		/* found */
-	}
-      index = (index + 1) % MI_TABLE_SIZE;
-      stats.rehash++;
-    }
+  bool success = insert_mi_cmd_entry (std::move (cmd_up));
+  gdb_assert (success);
 }
 
+/* Initialize MI_CMD_TABLE, the global map of MI commands.  */
+
 static void
-build_table (struct mi_cmd *commands)
+build_table ()
 {
-  int nr_rehash = 0;
-  int nr_entries = 0;
-  struct mi_cmd *command;
+  add_mi_cmd_mi ("ada-task-info", mi_cmd_ada_task_info);
+  add_mi_cmd_mi ("add-inferior", mi_cmd_add_inferior);
+  add_mi_cmd_cli ("break-after", "ignore", 1,
+		  &mi_suppress_notification.breakpoint);
+  add_mi_cmd_mi ("break-condition",mi_cmd_break_condition,
+		  &mi_suppress_notification.breakpoint);
+  add_mi_cmd_mi ("break-commands", mi_cmd_break_commands,
+		 &mi_suppress_notification.breakpoint);
+  add_mi_cmd_cli ("break-delete", "delete breakpoint", 1,
+		  &mi_suppress_notification.breakpoint);
+  add_mi_cmd_cli ("break-disable", "disable breakpoint", 1,
+		  &mi_suppress_notification.breakpoint);
+  add_mi_cmd_cli ("break-enable", "enable breakpoint", 1,
+		  &mi_suppress_notification.breakpoint);
+  add_mi_cmd_cli ("break-info", "info break", 1);
+  add_mi_cmd_mi ("break-insert", mi_cmd_break_insert,
+		 &mi_suppress_notification.breakpoint);
+  add_mi_cmd_mi ("dprintf-insert", mi_cmd_dprintf_insert,
+		 &mi_suppress_notification.breakpoint);
+  add_mi_cmd_cli ("break-list", "info break", 0);
+  add_mi_cmd_mi ("break-passcount", mi_cmd_break_passcount,
+		 &mi_suppress_notification.breakpoint);
+  add_mi_cmd_mi ("break-watch", mi_cmd_break_watch,
+		 &mi_suppress_notification.breakpoint);
+  add_mi_cmd_mi ("catch-assert", mi_cmd_catch_assert,
+		 &mi_suppress_notification.breakpoint);
+  add_mi_cmd_mi ("catch-exception", mi_cmd_catch_exception,
+		 &mi_suppress_notification.breakpoint);
+  add_mi_cmd_mi ("catch-handlers", mi_cmd_catch_handlers,
+		 &mi_suppress_notification.breakpoint);
+  add_mi_cmd_mi ("catch-load", mi_cmd_catch_load,
+		 &mi_suppress_notification.breakpoint);
+  add_mi_cmd_mi ("catch-unload", mi_cmd_catch_unload,
+		 &mi_suppress_notification.breakpoint);
+  add_mi_cmd_mi ("catch-throw", mi_cmd_catch_throw,
+                 &mi_suppress_notification.breakpoint),
+  add_mi_cmd_mi ("catch-rethrow", mi_cmd_catch_rethrow,
+                 &mi_suppress_notification.breakpoint),
+  add_mi_cmd_mi ("catch-catch", mi_cmd_catch_catch,
+                 &mi_suppress_notification.breakpoint),
+  add_mi_cmd_mi ("complete", mi_cmd_complete);
+  add_mi_cmd_mi ("data-disassemble", mi_cmd_disassemble);
+  add_mi_cmd_mi ("data-evaluate-expression", mi_cmd_data_evaluate_expression);
+  add_mi_cmd_mi ("data-list-changed-registers",
+		 mi_cmd_data_list_changed_registers);
+  add_mi_cmd_mi ("data-list-register-names", mi_cmd_data_list_register_names);
+  add_mi_cmd_mi ("data-list-register-values",
+		 mi_cmd_data_list_register_values);
+  add_mi_cmd_mi ("data-read-memory", mi_cmd_data_read_memory);
+  add_mi_cmd_mi ("data-read-memory-bytes", mi_cmd_data_read_memory_bytes);
+  add_mi_cmd_mi ("data-write-memory", mi_cmd_data_write_memory,
+		 &mi_suppress_notification.memory);
+  add_mi_cmd_mi ("data-write-memory-bytes", mi_cmd_data_write_memory_bytes,
+		 &mi_suppress_notification.memory);
+  add_mi_cmd_mi ("data-write-register-values",
+		 mi_cmd_data_write_register_values);
+  add_mi_cmd_mi ("enable-timings", mi_cmd_enable_timings);
+  add_mi_cmd_mi ("enable-pretty-printing", mi_cmd_enable_pretty_printing);
+  add_mi_cmd_mi ("enable-frame-filters", mi_cmd_enable_frame_filters);
+  add_mi_cmd_mi ("environment-cd", mi_cmd_env_cd);
+  add_mi_cmd_mi ("environment-directory", mi_cmd_env_dir);
+  add_mi_cmd_mi ("environment-path", mi_cmd_env_path);
+  add_mi_cmd_mi ("environment-pwd", mi_cmd_env_pwd);
+  add_mi_cmd_cli ("exec-arguments", "set args", 1,
+		  &mi_suppress_notification.cmd_param_changed);
+  add_mi_cmd_mi ("exec-continue", mi_cmd_exec_continue);
+  add_mi_cmd_mi ("exec-finish", mi_cmd_exec_finish);
+  add_mi_cmd_mi ("exec-jump", mi_cmd_exec_jump);
+  add_mi_cmd_mi ("exec-interrupt", mi_cmd_exec_interrupt);
+  add_mi_cmd_mi ("exec-next", mi_cmd_exec_next);
+  add_mi_cmd_mi ("exec-next-instruction", mi_cmd_exec_next_instruction);
+  add_mi_cmd_mi ("exec-return", mi_cmd_exec_return);
+  add_mi_cmd_mi ("exec-run", mi_cmd_exec_run);
+  add_mi_cmd_mi ("exec-step", mi_cmd_exec_step);
+  add_mi_cmd_mi ("exec-step-instruction", mi_cmd_exec_step_instruction);
+  add_mi_cmd_cli ("exec-until", "until", 1);
+  add_mi_cmd_cli ("file-exec-and-symbols", "file", 1);
+  add_mi_cmd_cli ("file-exec-file", "exec-file", 1);
+  add_mi_cmd_mi ("file-list-exec-source-file",
+		 mi_cmd_file_list_exec_source_file);
+  add_mi_cmd_mi ("file-list-exec-source-files",
+		 mi_cmd_file_list_exec_source_files);
+  add_mi_cmd_mi ("file-list-shared-libraries",
+     mi_cmd_file_list_shared_libraries),
+  add_mi_cmd_cli ("file-symbol-file", "symbol-file", 1);
+  add_mi_cmd_mi ("fix-multi-location-breakpoint-output",
+		 mi_cmd_fix_multi_location_breakpoint_output),
+  add_mi_cmd_mi ("gdb-exit", mi_cmd_gdb_exit);
+  add_mi_cmd_cli ("gdb-set", "set", 1,
+		  &mi_suppress_notification.cmd_param_changed);
+  add_mi_cmd_cli ("gdb-show", "show", 1);
+  add_mi_cmd_cli ("gdb-version", "show version", 0);
+  add_mi_cmd_mi ("inferior-tty-set", mi_cmd_inferior_tty_set);
+  add_mi_cmd_mi ("inferior-tty-show", mi_cmd_inferior_tty_show);
+  add_mi_cmd_mi ("info-ada-exceptions", mi_cmd_info_ada_exceptions);
+  add_mi_cmd_mi ("info-gdb-mi-command", mi_cmd_info_gdb_mi_command);
+  add_mi_cmd_mi ("info-os", mi_cmd_info_os);
+  add_mi_cmd_mi ("interpreter-exec", mi_cmd_interpreter_exec);
+  add_mi_cmd_mi ("list-features", mi_cmd_list_features);
+  add_mi_cmd_mi ("list-target-features", mi_cmd_list_target_features);
+  add_mi_cmd_mi ("list-thread-groups", mi_cmd_list_thread_groups);
+  add_mi_cmd_mi ("remove-inferior", mi_cmd_remove_inferior);
+  add_mi_cmd_mi ("stack-info-depth", mi_cmd_stack_info_depth);
+  add_mi_cmd_mi ("stack-info-frame", mi_cmd_stack_info_frame);
+  add_mi_cmd_mi ("stack-list-arguments", mi_cmd_stack_list_args);
+  add_mi_cmd_mi ("stack-list-frames", mi_cmd_stack_list_frames);
+  add_mi_cmd_mi ("stack-list-locals", mi_cmd_stack_list_locals);
+  add_mi_cmd_mi ("stack-list-variables", mi_cmd_stack_list_variables);
+  add_mi_cmd_mi ("stack-select-frame", mi_cmd_stack_select_frame,
+		 &mi_suppress_notification.user_selected_context);
+  add_mi_cmd_mi ("symbol-list-lines", mi_cmd_symbol_list_lines);
+  add_mi_cmd_mi ("symbol-info-functions", mi_cmd_symbol_info_functions);
+  add_mi_cmd_mi ("symbol-info-variables", mi_cmd_symbol_info_variables);
+  add_mi_cmd_mi ("symbol-info-types", mi_cmd_symbol_info_types);
+  add_mi_cmd_mi ("symbol-info-modules", mi_cmd_symbol_info_modules);
+  add_mi_cmd_mi ("symbol-info-module-functions",
+                 mi_cmd_symbol_info_module_functions);
+  add_mi_cmd_mi ("symbol-info-module-variables",
+                 mi_cmd_symbol_info_module_variables);
+  add_mi_cmd_cli ("target-attach", "attach", 1);
+  add_mi_cmd_mi ("target-detach", mi_cmd_target_detach);
+  add_mi_cmd_cli ("target-disconnect", "disconnect", 0);
+  add_mi_cmd_cli ("target-download", "load", 1);
+  add_mi_cmd_mi ("target-file-delete", mi_cmd_target_file_delete);
+  add_mi_cmd_mi ("target-file-get", mi_cmd_target_file_get);
+  add_mi_cmd_mi ("target-file-put", mi_cmd_target_file_put);
+  add_mi_cmd_mi ("target-flash-erase", mi_cmd_target_flash_erase);
+  add_mi_cmd_cli ("target-select", "target", 1);
+  add_mi_cmd_mi ("thread-info", mi_cmd_thread_info);
+  add_mi_cmd_mi ("thread-list-ids", mi_cmd_thread_list_ids);
+  add_mi_cmd_mi ("thread-select", mi_cmd_thread_select,
+		 &mi_suppress_notification.user_selected_context);
+  add_mi_cmd_mi ("trace-define-variable", mi_cmd_trace_define_variable);
+  add_mi_cmd_mi ("trace-find", mi_cmd_trace_find,
+		 &mi_suppress_notification.traceframe);
+  add_mi_cmd_mi ("trace-frame-collected", mi_cmd_trace_frame_collected);
+  add_mi_cmd_mi ("trace-list-variables", mi_cmd_trace_list_variables);
+  add_mi_cmd_mi ("trace-save", mi_cmd_trace_save);
+  add_mi_cmd_mi ("trace-start", mi_cmd_trace_start);
+  add_mi_cmd_mi ("trace-status", mi_cmd_trace_status);
+  add_mi_cmd_mi ("trace-stop", mi_cmd_trace_stop);
+  add_mi_cmd_mi ("var-assign", mi_cmd_var_assign);
+  add_mi_cmd_mi ("var-create", mi_cmd_var_create);
+  add_mi_cmd_mi ("var-delete", mi_cmd_var_delete);
+  add_mi_cmd_mi ("var-evaluate-expression", mi_cmd_var_evaluate_expression);
+  add_mi_cmd_mi ("var-info-path-expression", mi_cmd_var_info_path_expression);
+  add_mi_cmd_mi ("var-info-expression", mi_cmd_var_info_expression);
+  add_mi_cmd_mi ("var-info-num-children", mi_cmd_var_info_num_children);
+  add_mi_cmd_mi ("var-info-type", mi_cmd_var_info_type);
+  add_mi_cmd_mi ("var-list-children", mi_cmd_var_list_children);
+  add_mi_cmd_mi ("var-set-format", mi_cmd_var_set_format);
+  add_mi_cmd_mi ("var-set-frozen", mi_cmd_var_set_frozen);
+  add_mi_cmd_mi ("var-set-update-range", mi_cmd_var_set_update_range);
+  add_mi_cmd_mi ("var-set-visualizer", mi_cmd_var_set_visualizer);
+  add_mi_cmd_mi ("var-show-attributes", mi_cmd_var_show_attributes);
+  add_mi_cmd_mi ("var-show-format", mi_cmd_var_show_format);
+  add_mi_cmd_mi ("var-update", mi_cmd_var_update);
+}
 
-  mi_table = XCNEWVEC (struct mi_cmd *, MI_TABLE_SIZE);
-  for (command = commands; command->name != 0; command++)
-    {
-      struct mi_cmd **entry = lookup_table (command->name);
+/* See mi-cmds.h.  */
+
+struct mi_cmd *
+mi_cmd_lookup (const char *command)
+{
+  gdb_assert (command != nullptr);
 
-      if (*entry)
-	internal_error (__FILE__, __LINE__,
-			_("command `%s' appears to be duplicated"),
-			command->name);
-      *entry = command;
-      /* FIXME lose these prints */
-      if (0)
-	{
-	  fprintf_unfiltered (gdb_stdlog, "%-30s %2d\n",
-			      command->name, stats.rehash - nr_rehash);
-	}
-      nr_entries++;
-      nr_rehash = stats.rehash;
-    }
-  if (0)
-    {
-      fprintf_filtered (gdb_stdlog, "Average %3.1f\n",
-			(double) nr_rehash / (double) nr_entries);
-    }
+  auto it = mi_cmd_table.find (command);
+  if (it == mi_cmd_table.end ())
+    return nullptr;
+  return it->second.get ();
 }
 
 void _initialize_mi_cmds ();
 void
 _initialize_mi_cmds ()
 {
-  build_table (mi_cmds);
-  memset (&stats, 0, sizeof (stats));
+  build_table ();
 }
-- 
2.25.4

[PATCH 3/5] gdb/mi: int to bool conversion in mi_execute_cli_command

[Andrew Burgess]

Change an argument of mi_execute_cli_command from int to bool.  Update
the callers to take this into account.  Within mi_execute_cli_command,
update a comparison of a pointer to 0 with a comparison to nullptr,
and add an assert, if we are not using the argument string then the
string should be nullptr.  Also removed a cryptic 'gdb_????' comment,
which isn't really helpful.

There should be no user visible changes after this commit.
---
 gdb/mi/mi-main.c | 22 +++++++++++++---------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/gdb/mi/mi-main.c b/gdb/mi/mi-main.c
index 44008d1c0a8..7074203d3cc 100644
--- a/gdb/mi/mi-main.c
+++ b/gdb/mi/mi-main.c
@@ -90,7 +90,7 @@ int mi_proceeded;
 
 static void mi_cmd_execute (struct mi_parse *parse);
 
-static void mi_execute_cli_command (const char *cmd, int args_p,
+static void mi_execute_cli_command (const char *cmd, bool args_p,
 				    const char *args);
 static void mi_execute_async_cli_command (const char *cli_command,
 					  char **argv, int argc);
@@ -407,7 +407,7 @@ run_one_inferior (inferior *inf, bool start_p)
 {
   const char *run_cmd = start_p ? "start" : "run";
   struct target_ops *run_target = find_run_target ();
-  int async_p = mi_async && run_target->can_async_p ();
+  bool async_p = mi_async && run_target->can_async_p ();
 
   if (inf->pid != 0)
     {
@@ -472,7 +472,7 @@ mi_cmd_exec_run (const char *command, char **argv, int argc)
     {
       const char *run_cmd = start_p ? "start" : "run";
       struct target_ops *run_target = find_run_target ();
-      int async_p = mi_async && run_target->can_async_p ();
+      bool async_p = mi_async && run_target->can_async_p ();
 
       mi_execute_cli_command (run_cmd, async_p,
 			      async_p ? "&" : NULL);
@@ -2087,8 +2087,9 @@ mi_cmd_execute (struct mi_parse *parse)
       /* FIXME: DELETE THIS. */
       /* The operation is still implemented by a cli command.  */
       /* Must be a synchronous one.  */
-      mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p,
-			      parse->args);
+      bool args_p = parse->cmd->cli.args_p != 0;
+      const char *args = args_p ? parse->args : nullptr;
+      mi_execute_cli_command (parse->cmd->cli.cmd, args_p, args);
     }
   else
     {
@@ -2108,18 +2109,21 @@ mi_cmd_execute (struct mi_parse *parse)
    Use only for synchronous commands.  */
 
 void
-mi_execute_cli_command (const char *cmd, int args_p, const char *args)
+mi_execute_cli_command (const char *cmd, bool args_p, const char *args)
 {
-  if (cmd != 0)
+  if (cmd != nullptr)
     {
-      std::string run = cmd;
+      std::string run (cmd);
 
       if (args_p)
 	run = run + " " + args;
+      else
+	gdb_assert (args == nullptr);
+
       if (mi_debug_p)
-	/* FIXME: gdb_???? */
 	fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
 			    cmd, run.c_str ());
+
       execute_command (run.c_str (), 0 /* from_tty */ );
     }
 }
-- 
2.25.4

[PATCH 4/5] gdb/mi: use separate classes for different types of MI command

[Andrew Burgess]

From: Jan Vrany <jan.vrany@labware.com>

This commit changes the infrastructure in mi-cmds.{c,h} to add new
sub-classes for the different types of MI command.  Instances of these
sub-classes are then created and added into the MI command std::map.

The existing mi_cmd class becomes the base class type, this has an
invoke method and takes care of the suppress notifications handling,
before calling a do_invoke virtual method which is implemented by all
of the sub-classes.

There's currently two different sub-classes, one of pure MI commands,
and a second for MI commands that delegate to CLI commands.

There should be no user visible changes after this commit.

gdb/ChangeLog:

	* mi/mi-cmds.c (create_mi_cmd): Remove.
	(mi_command::mi_command): New function.
	(mi_command::do_suppress_notification): New function.
	(mi_command::invoke): New function.
	(mi_command_mi::mi_command_mi): New function.
	(mi_command_mi::do_invoke): New function.
	(mi_command_cli::mi_command_cli): New function.
	(mi_command_cli::do_invoke): New function.
	(mi_cmd_lookup): Change return type.
	* mi/mi-cmds.h (struct mi_cli): Remove.
	(struct mi_cmd): Remove.
	(class mi_command): New class.
	(class mi_command_mi): New class.
	(class mi_command_cli): New class.
	(mi_cmd_loopkup): Change return type.
	* mi/mi-main.c (mi_execute_cli_command): Remove declaration.
	(mi_execute_command): Remove suppress_notification handling.
	(mi_cmd_execute): Remove call to argv_func.
	(mi_cmd_execute): Remove call to mi_execute_cli_command.
	(mi_cmd_execute): New call to mi_command::invoke.
	* mi/mi-main.h (mi_execute_cli_command): New declaration.
	* mi/mi-parse.c (mi_parse): Remove call to mi_parse_argv.
	* mi/mi-parse.h (struct mi_parse): Remove field struct mi_cmd.
	(struct mi_parse): New field class mi_command.
	(mi_parse_argv): New declaration.
---
 gdb/mi/mi-cmds.c  | 128 +++++++++++++++++++++++++++++++++++-----------
 gdb/mi/mi-cmds.h  |  63 ++++++++++++++---------
 gdb/mi/mi-main.c  |  37 ++------------
 gdb/mi/mi-main.h  |  12 +++++
 gdb/mi/mi-parse.c |  18 ++-----
 gdb/mi/mi-parse.h |   4 ++
 6 files changed, 159 insertions(+), 103 deletions(-)

diff --git a/gdb/mi/mi-cmds.c b/gdb/mi/mi-cmds.c
index 1e18afc5745..75d07dfe20f 100644
--- a/gdb/mi/mi-cmds.c
+++ b/gdb/mi/mi-cmds.c
@@ -22,6 +22,7 @@
 #include "top.h"
 #include "mi-cmds.h"
 #include "mi-main.h"
+#include "mi-parse.h"
 #include <map>
 #include <string>
 
@@ -33,6 +34,63 @@ typedef std::unique_ptr<struct mi_cmd> mi_cmd_up;
 
 static std::map<std::string, mi_cmd_up> mi_cmd_table;
 
+/* MI command with a pure MI implementation.  */
+
+struct mi_command_mi : public mi_cmd
+{
+  /* Constructor.  */
+  mi_command_mi (const char *name, mi_cmd_argv_ftype func,
+                 int *suppress_notification)
+    : mi_cmd (name, suppress_notification),
+      m_argv_function (func)
+  {
+    gdb_assert (func != nullptr);
+  }
+
+protected:
+  void do_invoke(struct mi_parse *parse) const override
+  {
+    mi_parse_argv (parse->args, parse);
+
+    if (parse->argv == nullptr)
+      error (_("Problem parsing arguments: %s %s"), parse->command,
+	     parse->args);
+
+    this->m_argv_function (parse->command, parse->argv, parse->argc);
+  }
+
+private:
+  mi_cmd_argv_ftype *m_argv_function;
+};
+
+/* MI command implemented on top of a CLI command.  */
+
+class mi_command_cli : public mi_cmd
+{
+public:
+  /* Constructor.  */
+  mi_command_cli (const char *name, const char *cli_name, bool args_p,
+                  int *suppress_notification)
+    : mi_cmd (name, suppress_notification),
+      m_cli_name (cli_name),
+      m_args_p (args_p)
+  { /* Nothing.  */ }
+
+protected:
+  void do_invoke(struct mi_parse *parse) const override
+  {
+    const char *args = m_args_p ? parse->args : nullptr;
+    mi_execute_cli_command (m_cli_name.c_str (), m_args_p ? 1 : 0,
+			    args);
+  }
+
+private:
+  /* The name of the CLI command it execute.  */
+  std::string m_cli_name;
+
+  bool m_args_p;
+};
+
 /* Insert a new mi-command into the command table.  Return true if
    insertion was successful.  */
 
@@ -40,9 +98,9 @@ static bool
 insert_mi_cmd_entry (mi_cmd_up command)
 {
   gdb_assert (command != nullptr);
-  gdb_assert (command->name != nullptr);
+  gdb_assert (!command->name ().empty ());
 
-  std::string name (command->name);
+  const std::string &name = command->name ();
 
   if (mi_cmd_table.find (name) != mi_cmd_table.end ())
     return false;
@@ -51,32 +109,16 @@ insert_mi_cmd_entry (mi_cmd_up command)
   return true;
 }
 
-/* Create an mi_cmd structure with name NAME.  */
-
-static mi_cmd_up
-create_mi_cmd (const char *name)
-{
-  mi_cmd_up cmd (new mi_cmd ());
-  cmd->name = name;
-  return cmd;
-}
-
-/* Create and register a new MI command with a pure MI implementation.
-   NAME must name an MI command that does not already exist, otherwise an
-   assertion will trigger.  */
+/* Create and register a new MI command with a pure MI implementation.  */
 
 static void
 add_mi_cmd_mi (const char *name, mi_cmd_argv_ftype function,
 	       int *suppress_notification = nullptr)
 {
-  mi_cmd_up cmd_up = create_mi_cmd (name);
+  mi_cmd_up command (new mi_command_mi (name, function,
+                                        suppress_notification));
 
-  cmd_up->cli.cmd = nullptr;
-  cmd_up->cli.args_p = 0;
-  cmd_up->argv_func = function;
-  cmd_up->suppress_notification = suppress_notification;
-
-  bool success = insert_mi_cmd_entry (std::move (cmd_up));
+  bool success = insert_mi_cmd_entry (std::move (command));
   gdb_assert (success);
 }
 
@@ -88,18 +130,42 @@ static void
 add_mi_cmd_cli (const char *name, const char *cli_name, int args_p,
 		int *suppress_notification = nullptr)
 {
-  mi_cmd_up cmd_up = create_mi_cmd (name);
-
-  cmd_up->cli.cmd = cli_name;
-  cmd_up->cli.args_p = args_p;
-  cmd_up->argv_func = nullptr;
-  cmd_up->suppress_notification = suppress_notification;
+  mi_cmd_up command (new mi_command_cli (name, cli_name, args_p != 0,
+                                         suppress_notification));
 
-  bool success = insert_mi_cmd_entry (std::move (cmd_up));
+  bool success = insert_mi_cmd_entry (std::move (command));
   gdb_assert (success);
 }
 
-/* Initialize MI_CMD_TABLE, the global map of MI commands.  */
+/* See mi-cmds.h.  */
+
+mi_cmd::mi_cmd (const char *name, int *suppress_notification)
+  : m_name (name),
+    m_suppress_notification (suppress_notification)
+{ /* Nothing.  */ }
+
+/* See mi-cmds.h.  */
+
+void
+mi_cmd::invoke (struct mi_parse *parse) const
+{
+  gdb::optional<scoped_restore_tmpl<int>> restore
+    = do_suppress_notification ();
+  this->do_invoke (parse);
+}
+
+/* See mi-cmds.h.  */
+
+gdb::optional<scoped_restore_tmpl<int>>
+mi_cmd::do_suppress_notification () const
+{
+  if (m_suppress_notification != nullptr)
+    return scoped_restore_tmpl<int> (m_suppress_notification, 1);
+  else
+    return {};
+}
+
+/* Initialize the available MI commands.  */
 
 static void
 build_table ()
@@ -265,7 +331,7 @@ build_table ()
 
 /* See mi-cmds.h.  */
 
-struct mi_cmd *
+mi_cmd *
 mi_cmd_lookup (const char *command)
 {
   gdb_assert (command != nullptr);
diff --git a/gdb/mi/mi-cmds.h b/gdb/mi/mi-cmds.h
index e92737be8c8..77982f4d491 100644
--- a/gdb/mi/mi-cmds.h
+++ b/gdb/mi/mi-cmds.h
@@ -22,6 +22,7 @@
 #ifndef MI_MI_CMDS_H
 #define MI_MI_CMDS_H
 
+#include "gdbsupport/gdb_optional.h"
 enum print_values {
    PRINT_NO_VALUES,
    PRINT_ALL_VALUES,
@@ -137,37 +138,53 @@ extern mi_cmd_argv_ftype mi_cmd_enable_frame_filters;
 extern mi_cmd_argv_ftype mi_cmd_var_set_update_range;
 extern mi_cmd_argv_ftype mi_cmd_complete;
 
-/* Description of a single command.  */
-
-struct mi_cli
-{
-  /* Corresponding CLI command.  If ARGS_P is non-zero, the MI
-     command's argument list is appended to the CLI command.  */
-  const char *cmd;
-  int args_p;
-};
+/* The virtual base class for all MI commands.  */
 
 struct mi_cmd
 {
-  /* Official name of the command.  */
-  const char *name;
-  /* The corresponding CLI command that can be used to implement this
-     MI command (if cli.lhs is non NULL).  */
-  struct mi_cli cli;
-  /* If non-null, the function implementing the MI command.  */
-  mi_cmd_argv_ftype *argv_func;
-  /* If non-null, the pointer to a field in
-     'struct mi_suppress_notification', which will be set to true by MI
-     command processor (mi-main.c:mi_cmd_execute) when this command is
-     being executed.  It will be set back to false when command has been
-     executed.  */
-  int *suppress_notification;
+  /* Constructor.  */
+  mi_cmd (const char *name, int *suppress_notification);
+
+  /* Destructor.  */
+  virtual ~mi_cmd () { /* Nothing.  */ };
+
+  /* Return the name of this command.  This is the command that the user
+     will actually type in, without any arguments.  */
+  const std::string &name () const
+  { return m_name; }
+
+  /* Execute the MI command.  Can throw an exception if something goes
+     wrong.  */
+  void invoke (struct mi_parse *parse) const;
+
+protected:
+
+  /* The core of command invocation, this needs to be overridden in each
+     base class.  */
+  virtual void do_invoke(struct mi_parse *parse) const = 0;
+
+private:
+
+  /* If this command was created with a suppress notifications pointer,
+     then this function will set the suppress flag and return a
+     gdb::optional with its value set to an object that will restore the
+     previous value of the suppress notifications flag.
+
+     If this command was created without a suppress notifications points,
+     then this function returns an empty gdb::optional.  */
+  gdb::optional<scoped_restore_tmpl<int>> do_suppress_notification () const;
+
+  /* The name of the command.  */
+  std::string m_name;
+
+  /* Pointer to integer to set during command's invocation.  */
+  int *m_suppress_notification;
 };
 
 /* Lookup a command in the MI command table, returns nullptr if COMMAND is
    not found.  */
 
-extern struct mi_cmd *mi_cmd_lookup (const char *command);
+extern mi_cmd *mi_cmd_lookup (const char *command);
 
 /* Debug flag */
 extern int mi_debug_p;
diff --git a/gdb/mi/mi-main.c b/gdb/mi/mi-main.c
index 7074203d3cc..d14d7c89195 100644
--- a/gdb/mi/mi-main.c
+++ b/gdb/mi/mi-main.c
@@ -90,8 +90,6 @@ int mi_proceeded;
 
 static void mi_cmd_execute (struct mi_parse *parse);
 
-static void mi_execute_cli_command (const char *cmd, bool args_p,
-				    const char *args);
 static void mi_execute_async_cli_command (const char *cli_command,
 					  char **argv, int argc);
 static bool register_changed_p (int regnum, readonly_detached_regcache *,
@@ -1935,11 +1933,6 @@ mi_execute_command (const char *cmd, int from_tty)
     {
       ptid_t previous_ptid = inferior_ptid;
 
-      gdb::optional<scoped_restore_tmpl<int>> restore_suppress;
-
-      if (command->cmd != NULL && command->cmd->suppress_notification != NULL)
-	restore_suppress.emplace (command->cmd->suppress_notification, 1);
-
       command->token = token;
 
       if (do_timings)
@@ -2078,35 +2071,11 @@ mi_cmd_execute (struct mi_parse *parse)
 
   current_context = parse;
 
-  if (parse->cmd->argv_func != NULL)
-    {
-      parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
-    }
-  else if (parse->cmd->cli.cmd != 0)
-    {
-      /* FIXME: DELETE THIS. */
-      /* The operation is still implemented by a cli command.  */
-      /* Must be a synchronous one.  */
-      bool args_p = parse->cmd->cli.args_p != 0;
-      const char *args = args_p ? parse->args : nullptr;
-      mi_execute_cli_command (parse->cmd->cli.cmd, args_p, args);
-    }
-  else
-    {
-      /* FIXME: DELETE THIS.  */
-      string_file stb;
-
-      stb.puts ("Undefined mi command: ");
-      stb.putstr (parse->command, '"');
-      stb.puts (" (missing implementation)");
-
-      error_stream (stb);
-    }
+  gdb_assert (parse->cmd != nullptr);
+  parse->cmd->invoke (parse);
 }
 
-/* FIXME: This is just a hack so we can get some extra commands going.
-   We don't want to channel things through the CLI, but call libgdb directly.
-   Use only for synchronous commands.  */
+/* See mi-main.h.  */
 
 void
 mi_execute_cli_command (const char *cmd, bool args_p, const char *args)
diff --git a/gdb/mi/mi-main.h b/gdb/mi/mi-main.h
index 7f986969450..064f1d587f2 100644
--- a/gdb/mi/mi-main.h
+++ b/gdb/mi/mi-main.h
@@ -54,6 +54,18 @@ struct mi_suppress_notification
 };
 extern struct mi_suppress_notification mi_suppress_notification;
 
+/* This is a hack so we can get some extra commands going, but has existed
+   within GDB for many years now.  Ideally we don't want to channel things
+   through the CLI, but implement all commands as pure MI commands with
+   their own implementation.
+
+   Execute the CLI command CMD, if ARGS_P is true then ARGS should be a
+   non-nullptr string containing arguments to add after CMD.  If ARGS_P is
+   false then ARGS must be nullptr.  */
+
+extern void mi_execute_cli_command (const char *cmd, bool args_p,
+				    const char *args);
+
 /* Implementation of -fix-multi-location-breakpoint-output.  */
 
 extern void mi_cmd_fix_multi_location_breakpoint_output (const char *command,
diff --git a/gdb/mi/mi-parse.c b/gdb/mi/mi-parse.c
index b5b01cf4db0..203024fb01c 100644
--- a/gdb/mi/mi-parse.c
+++ b/gdb/mi/mi-parse.c
@@ -106,7 +106,7 @@ mi_parse_escape (const char **string_ptr)
   return c;
 }
 
-static void
+void
 mi_parse_argv (const char *args, struct mi_parse *parse)
 {
   const char *chp = args;
@@ -363,20 +363,8 @@ mi_parse (const char *cmd, char **token)
       chp = skip_spaces (chp);
     }
 
-  /* For new argv commands, attempt to return the parsed argument
-     list.  */
-  if (parse->cmd->argv_func != NULL)
-    {
-      mi_parse_argv (chp, parse.get ());
-      if (parse->argv == NULL)
-	error (_("Problem parsing arguments: %s %s"), parse->command, chp);
-    }
-
-  /* FIXME: DELETE THIS */
-  /* For CLI commands, also return the remainder of the
-     command line as a single string. */
-  if (parse->cmd->cli.cmd != NULL)
-    parse->args = xstrdup (chp);
+  /* Save the rest of the arguments for the command.  */
+  parse->args = xstrdup (chp);
 
   /* Fully parsed, flag as an MI command.  */
   parse->op = MI_COMMAND;
diff --git a/gdb/mi/mi-parse.h b/gdb/mi/mi-parse.h
index a60ce5b3a20..1d5cc764f00 100644
--- a/gdb/mi/mi-parse.h
+++ b/gdb/mi/mi-parse.h
@@ -79,4 +79,8 @@ extern std::unique_ptr<struct mi_parse> mi_parse (const char *cmd,
 
 enum print_values mi_parse_print_values (const char *name);
 
+/* Split ARGS into argc/argv and store the result in PARSE.  */
+
+void mi_parse_argv (const char *args, struct mi_parse *parse);
+
 #endif /* MI_MI_PARSE_H */
-- 
2.25.4

[PATCH 5/5] gdb/mi: rename mi_cmd to mi_command

[Andrew Burgess]

From: Jan Vrany <jan.vrany@labware.com>

Just give this base class a new name, more inline with the name of the
sub-classes.

There should be no user visible changes after this commit.
---
 gdb/mi/mi-cmd-info.c |  2 +-
 gdb/mi/mi-cmds.c     | 18 +++++++++---------
 gdb/mi/mi-cmds.h     |  8 ++++----
 gdb/mi/mi-parse.h    |  2 +-
 4 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/gdb/mi/mi-cmd-info.c b/gdb/mi/mi-cmd-info.c
index c2858519a4c..3bfd5918ce9 100644
--- a/gdb/mi/mi-cmd-info.c
+++ b/gdb/mi/mi-cmd-info.c
@@ -67,7 +67,7 @@ void
 mi_cmd_info_gdb_mi_command (const char *command, char **argv, int argc)
 {
   const char *cmd_name;
-  struct mi_cmd *cmd;
+  mi_command *cmd;
   struct ui_out *uiout = current_uiout;
 
   /* This command takes exactly one argument.  */
diff --git a/gdb/mi/mi-cmds.c b/gdb/mi/mi-cmds.c
index 75d07dfe20f..2c9f7a1d651 100644
--- a/gdb/mi/mi-cmds.c
+++ b/gdb/mi/mi-cmds.c
@@ -28,7 +28,7 @@
 
 /* A command held in the MI_CMD_TABLE.  */
 
-typedef std::unique_ptr<struct mi_cmd> mi_cmd_up;
+typedef std::unique_ptr<struct mi_command> mi_cmd_up;
 
 /* MI command table (built at run time). */
 
@@ -36,12 +36,12 @@ static std::map<std::string, mi_cmd_up> mi_cmd_table;
 
 /* MI command with a pure MI implementation.  */
 
-struct mi_command_mi : public mi_cmd
+struct mi_command_mi : public mi_command
 {
   /* Constructor.  */
   mi_command_mi (const char *name, mi_cmd_argv_ftype func,
                  int *suppress_notification)
-    : mi_cmd (name, suppress_notification),
+    : mi_command (name, suppress_notification),
       m_argv_function (func)
   {
     gdb_assert (func != nullptr);
@@ -65,13 +65,13 @@ struct mi_command_mi : public mi_cmd
 
 /* MI command implemented on top of a CLI command.  */
 
-class mi_command_cli : public mi_cmd
+class mi_command_cli : public mi_command
 {
 public:
   /* Constructor.  */
   mi_command_cli (const char *name, const char *cli_name, bool args_p,
                   int *suppress_notification)
-    : mi_cmd (name, suppress_notification),
+    : mi_command (name, suppress_notification),
       m_cli_name (cli_name),
       m_args_p (args_p)
   { /* Nothing.  */ }
@@ -139,7 +139,7 @@ add_mi_cmd_cli (const char *name, const char *cli_name, int args_p,
 
 /* See mi-cmds.h.  */
 
-mi_cmd::mi_cmd (const char *name, int *suppress_notification)
+mi_command::mi_command (const char *name, int *suppress_notification)
   : m_name (name),
     m_suppress_notification (suppress_notification)
 { /* Nothing.  */ }
@@ -147,7 +147,7 @@ mi_cmd::mi_cmd (const char *name, int *suppress_notification)
 /* See mi-cmds.h.  */
 
 void
-mi_cmd::invoke (struct mi_parse *parse) const
+mi_command::invoke (struct mi_parse *parse) const
 {
   gdb::optional<scoped_restore_tmpl<int>> restore
     = do_suppress_notification ();
@@ -157,7 +157,7 @@ mi_cmd::invoke (struct mi_parse *parse) const
 /* See mi-cmds.h.  */
 
 gdb::optional<scoped_restore_tmpl<int>>
-mi_cmd::do_suppress_notification () const
+mi_command::do_suppress_notification () const
 {
   if (m_suppress_notification != nullptr)
     return scoped_restore_tmpl<int> (m_suppress_notification, 1);
@@ -331,7 +331,7 @@ build_table ()
 
 /* See mi-cmds.h.  */
 
-mi_cmd *
+mi_command *
 mi_cmd_lookup (const char *command)
 {
   gdb_assert (command != nullptr);
diff --git a/gdb/mi/mi-cmds.h b/gdb/mi/mi-cmds.h
index 77982f4d491..c016eb2f2b2 100644
--- a/gdb/mi/mi-cmds.h
+++ b/gdb/mi/mi-cmds.h
@@ -140,13 +140,13 @@ extern mi_cmd_argv_ftype mi_cmd_complete;
 
 /* The virtual base class for all MI commands.  */
 
-struct mi_cmd
+struct mi_command
 {
   /* Constructor.  */
-  mi_cmd (const char *name, int *suppress_notification);
+  mi_command (const char *name, int *suppress_notification);
 
   /* Destructor.  */
-  virtual ~mi_cmd () { /* Nothing.  */ };
+  virtual ~mi_command () { /* Nothing.  */ };
 
   /* Return the name of this command.  This is the command that the user
      will actually type in, without any arguments.  */
@@ -184,7 +184,7 @@ struct mi_cmd
 /* Lookup a command in the MI command table, returns nullptr if COMMAND is
    not found.  */
 
-extern mi_cmd *mi_cmd_lookup (const char *command);
+extern mi_command *mi_cmd_lookup (const char *command);
 
 /* Debug flag */
 extern int mi_debug_p;
diff --git a/gdb/mi/mi-parse.h b/gdb/mi/mi-parse.h
index 1d5cc764f00..4c51559a661 100644
--- a/gdb/mi/mi-parse.h
+++ b/gdb/mi/mi-parse.h
@@ -49,7 +49,7 @@ struct mi_parse
     enum mi_command_type op;
     char *command;
     char *token;
-    const struct mi_cmd *cmd;
+    const struct mi_command *cmd;
     struct mi_timestamp *cmd_start;
     char *args;
     char **argv;
-- 
2.25.4

Re: [PATCH 0/5] refactoring towards Python MI command API

[Jan Vrany]

Andrew
> Jan, Simon,
>
> I have also wanted Python support for creating MI commands in the
> past, so was really interested to read through your patches.
>
> To answer Simon's question about what would be needed to get this
> merged; what's needed is to get the patch series posted to the list
> (e.g. using git-format-patch / git-send-email), then the review
> process can start.
>
> That said, I took a look through the series.  The patches to actually
> add the Python API will definitely need documentation writing, I also
> had some thoughts on some minor details of the implementation, but,
in
> general I thought it looked pretty good.
>
> Given Jan mentioned that he might not have time to work on this soon,
> I thought I'd take the liberty of trying to move this work forward.

Thank you very much! I really appreciate that. I agree with you on what
has to be done, especially on the documentation part. Also, Pedro had
few comments on my last attempt back in 2019: 

https://sourceware.org/pipermail/gdb-patches/2019-June/158431.html
https://sourceware.org/pipermail/gdb-patches/2019-June/158433.html
https://sourceware.org/pipermail/gdb-patches/2019-June/158435.html
https://sourceware.org/pipermail/gdb-patches/2019-June/158437.html

>
> So, the patches below are based on the first half of Jan's branch,
> this is all the setup work before the actual Python API is added. 
The
> patches to add the Python API should rebase on this series with only
a
> few minor merge conflicts.  I think this work is a nice cleanup in
its
> own right, so worth posting, and trying to get merged.  I have some
> other work I will try to get done, which should make the Python API
> part a little cleaner.

Perfect. Once this first series is merged, I'll rebase and maybe 
improve it a bit (Dec / Jan should be less busy for me, let's hope).

Thanks a lot!

Jan

Re: Broken source view with Pygments and non-UTF-8 encoded source

[Simon Sobisch]

Hi Andrew,
just leaving a friendly ping on (note: I may missed the thread this was 
posted to GDB patches, then please be so kind and drop a reference).

Thank you for working on this and other pieces of GDB!
Simon

> * Andrew Burgess via Gdb <gdb@sourceware.org> [2021-11-26 11:16:21 +0000]:
> 
> * Simon Sobisch via Gdb <gdb@sourceware.org> [2021-11-25 20:28:18 +0100]:
>
>> I _really_ like the Pygments option, but it sadly doesn't work when the
>> source code as invalid UTF8 data in it.
>> As soon as this is the case "list" does not show a nice highlighted code any
>> more but instead Python Exception is raised (UnicodeDecodeError) and then
>> non-colored lines are shown.
>>
>> This is especially bad when you "step" through the code because you get the
>> python exception for every line.
> 
> I figured it out.  I have a fix which I'll post to gdb-patches shortly.
> 
> Thanks,
> Andrew

Re: [PATCH 0/5] refactoring towards Python MI command API

[Simon Sobisch]

Andrew, you've noted that you had some work related to this, can you 
share any information about the possibility to go on with these patches, 
possibly landing them in GDB 12?

Thanks,
Simon

Am 08.11.2021 um 22:28 schrieb Jan Vrany:
> Andrew
>> Jan, Simon,
>>
>> I have also wanted Python support for creating MI commands in the
>> past, so was really interested to read through your patches.
>>
>> To answer Simon's question about what would be needed to get this
>> merged; what's needed is to get the patch series posted to the list
>> (e.g. using git-format-patch / git-send-email), then the review
>> process can start.
>>
>> That said, I took a look through the series.  The patches to actually
>> add the Python API will definitely need documentation writing, I also
>> had some thoughts on some minor details of the implementation, but,
> in
>> general I thought it looked pretty good.
>>
>> Given Jan mentioned that he might not have time to work on this soon,
>> I thought I'd take the liberty of trying to move this work forward.
> 
> Thank you very much! I really appreciate that. I agree with you on what
> has to be done, especially on the documentation part. Also, Pedro had
> few comments on my last attempt back in 2019:
> 
> https://sourceware.org/pipermail/gdb-patches/2019-June/158431.html
> https://sourceware.org/pipermail/gdb-patches/2019-June/158433.html
> https://sourceware.org/pipermail/gdb-patches/2019-June/158435.html
> https://sourceware.org/pipermail/gdb-patches/2019-June/158437.html
> 
>>
>> So, the patches below are based on the first half of Jan's branch,
>> this is all the setup work before the actual Python API is added.
> The
>> patches to add the Python API should rebase on this series with only
> a
>> few minor merge conflicts.  I think this work is a nice cleanup in
> its
>> own right, so worth posting, and trying to get merged.  I have some
>> other work I will try to get done, which should make the Python API
>> part a little cleaner.
> 
> Perfect. Once this first series is merged, I'll rebase and maybe
> improve it a bit (Dec / Jan should be less busy for me, let's hope).
> 
> Thanks a lot!
> 
> Jan
> 
> 

Re: [PATCH 0/5] refactoring towards Python MI command API

[Jan Vrany]

Hi, 

It has already landed in GDB 12 branch, thanks to Andrew's and
Simon's massive effort.

Jan


On Wed, 2022-04-13 at 14:23 +0200, Simon Sobisch wrote:
> Andrew, you've noted that you had some work related to this, can you 
> share any information about the possibility to go on with these patches, 
> possibly landing them in GDB 12?
> 
> Thanks,
> Simon
> 
> Am 08.11.2021 um 22:28 schrieb Jan Vrany:
> > Andrew
> > > Jan, Simon,
> > > 
> > > I have also wanted Python support for creating MI commands in the
> > > past, so was really interested to read through your patches.
> > > 
> > > To answer Simon's question about what would be needed to get this
> > > merged; what's needed is to get the patch series posted to the list
> > > (e.g. using git-format-patch / git-send-email), then the review
> > > process can start.
> > > 
> > > That said, I took a look through the series.  The patches to actually
> > > add the Python API will definitely need documentation writing, I also
> > > had some thoughts on some minor details of the implementation, but,
> > in
> > > general I thought it looked pretty good.
> > > 
> > > Given Jan mentioned that he might not have time to work on this soon,
> > > I thought I'd take the liberty of trying to move this work forward.
> > 
> > Thank you very much! I really appreciate that. I agree with you on what
> > has to be done, especially on the documentation part. Also, Pedro had
> > few comments on my last attempt back in 2019:
> > 
> > https://urldefense.proofpoint.com/v2/url?u=https-3A__sourceware.org_pipermail_gdb-2Dpatches_2019-2DJune_158431.html&d=DwIDaQ&c=sPZ6DeHLiehUHQWKIrsNwWp3t7snrE-az24ztT0w7Jc&r=WpFFGgYa98Yp-c29WHTCwU1wAGFBvszA6a4RzgpMSqc&m=xCH7zk87_07WJhKdWlM0ktpiaOi1WEfFa2Ykk7l8V7o&s=yJRBnJpajqrY3ILb61rgE1ufHsO1Rr1nQaoJR2MEixg&e= 
> > https://urldefense.proofpoint.com/v2/url?u=https-3A__sourceware.org_pipermail_gdb-2Dpatches_2019-2DJune_158433.html&d=DwIDaQ&c=sPZ6DeHLiehUHQWKIrsNwWp3t7snrE-az24ztT0w7Jc&r=WpFFGgYa98Yp-c29WHTCwU1wAGFBvszA6a4RzgpMSqc&m=xCH7zk87_07WJhKdWlM0ktpiaOi1WEfFa2Ykk7l8V7o&s=fLIaEYNcBHw_w3zw0GsaB04OwG0eJI5jFQRNDZPp9J0&e= 
> > https://urldefense.proofpoint.com/v2/url?u=https-3A__sourceware.org_pipermail_gdb-2Dpatches_2019-2DJune_158435.html&d=DwIDaQ&c=sPZ6DeHLiehUHQWKIrsNwWp3t7snrE-az24ztT0w7Jc&r=WpFFGgYa98Yp-c29WHTCwU1wAGFBvszA6a4RzgpMSqc&m=xCH7zk87_07WJhKdWlM0ktpiaOi1WEfFa2Ykk7l8V7o&s=f9HTpYJBCexAHNoRyuIAZhEdCyaKHarz2Mbqd9cWdqU&e= 
> > https://urldefense.proofpoint.com/v2/url?u=https-3A__sourceware.org_pipermail_gdb-2Dpatches_2019-2DJune_158437.html&d=DwIDaQ&c=sPZ6DeHLiehUHQWKIrsNwWp3t7snrE-az24ztT0w7Jc&r=WpFFGgYa98Yp-c29WHTCwU1wAGFBvszA6a4RzgpMSqc&m=xCH7zk87_07WJhKdWlM0ktpiaOi1WEfFa2Ykk7l8V7o&s=HeiwUWz3BHFvy83gVclKnHxuv8dVIkvVfwMadVL6his&e= 
> > 
> > > 
> > > So, the patches below are based on the first half of Jan's branch,
> > > this is all the setup work before the actual Python API is added.
> > The
> > > patches to add the Python API should rebase on this series with only
> > a
> > > few minor merge conflicts.  I think this work is a nice cleanup in
> > its
> > > own right, so worth posting, and trying to get merged.  I have some
> > > other work I will try to get done, which should make the Python API
> > > part a little cleaner.
> > 
> > Perfect. Once this first series is merged, I'll rebase and maybe
> > improve it a bit (Dec / Jan should be less busy for me, let's hope).
> > 
> > Thanks a lot!
> > 
> > Jan
> > 
> >