C++ify osdata

This patch c++ifies the osdata structure: osdata_column, osdata_item and
osdata.  char* are replaced with std::string and VEC are replaced with
std::vector.  This allows to get rid of a great deal of cleanup and
free'ing code.

I replaced the splay tree in list_available_thread_groups with an
std::map.  Unless there's a good advantage to keep using a splay tree,
I think using the standard type should make things simpler to
understand.

gdb/ChangeLog:

	* osdata.h: Include vector isntead of vec.h.
	(osdata_column_s): Remove typedef.
	(struct osdata_column): Add constructor.
	<name, value>: Change type to std::string.
	(DEF_VEC_O (osdata_column_s)): Remove.
	(osdata_item_s): Remove typedef.
	(struct osdata_item) <columns>: Change type to std::vector.
	(DEF_VEC_O (osdata_item_s)): Remove.
	(struct osdata): Add constructor.
	<type>: Change type to std::string.
	<items>: Change type to std::vector.
	(osdata_p): Remove typedef.
	(DEF_VEC_P (osdata_p)): Remove.
	(osdata_parse): Return a unique_ptr.
	(osdata_free): Remove.
	(make_cleanup_osdata_free): Remove.
	(get_osdata): Return a unique_ptr.
	(get_osdata_column): Return pointer to std::string, take a
	reference to osdata_item as parameter.
	* osdata.c (struct osdata_parsing_data) <osdata>: Change type to
	unique_ptr.
	<property_name>: Change type to std::string.
	(osdata_start_osdata): Allocate osdata with new and adjust.
	(osdata_start_item): Adjust.
	(osdata_start_column): Adjust.
	(osdata_end_column): Adjust.
	(clear_parsing_data): Remove.
	(osdata_parse): Return a unique_ptr and adjust, remove cleanup.
	(osdata_item_clear): Remove.
	(get_osdata): return a unique_ptr and adjust.
	(get_osdata_column): Return a pointer to std::string and adjust.
	(info_osdata): Adjust.
	* mi/mi-main.c: Include <map>.
	(free_vector_of_osdata_items): Remove.
	(list_available_thread_groups): Adjust, use std::map instead of
	splay tree.

1 files changed, 35 insertions, 78 deletions

diff --git a/gdb/mi/mi-main.c b/gdb/mi/mi-main.c
index d3ea13987f..c7db478434 100644
--- a/gdb/mi/mi-main.c
+++ b/gdb/mi/mi-main.c
@@ -63,6 +63,7 @@
 #include "common/rsp-low.h"
 #include <algorithm>
 #include <set>
+#include <map>
 
 enum
   {
@@ -709,88 +710,50 @@ output_cores (struct ui_out *uiout, const char *field_name, const char *xcores)
 }
 
 static void
-free_vector_of_osdata_items (splay_tree_value xvalue)
-{
-  VEC (osdata_item_s) *value = (VEC (osdata_item_s) *) xvalue;
-
-  /* We don't free the items itself, it will be done separately.  */
-  VEC_free (osdata_item_s, value);
-}
-
-static int
-splay_tree_int_comparator (splay_tree_key xa, splay_tree_key xb)
-{
-  int a = xa;
-  int b = xb;
-
-  return a - b;
-}
-
-static void
 list_available_thread_groups (const std::set<int> &ids, int recurse)
 {
-  struct osdata *data;
-  struct osdata_item *item;
-  int ix_items;
   struct ui_out *uiout = current_uiout;
-  struct cleanup *cleanup;
 
-  /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
-     The vector contains information about all threads for the given pid.
-     This is assigned an initial value to avoid "may be used uninitialized"
-     warning from gcc.  */
-  gdb_splay_tree_up tree;
+  /* This keeps a map from integer (pid) to vector of struct osdata_item.
+     The vector contains information about all threads for the given pid.  */
+  std::map<int, std::vector<osdata_item> *> tree_;
 
   /* get_osdata will throw if it cannot return data.  */
-  data = get_osdata ("processes");
-  cleanup = make_cleanup_osdata_free (data);
+  std::unique_ptr<osdata> data = get_osdata ("processes");
 
   if (recurse)
     {
-      struct osdata *threads = get_osdata ("threads");
+      std::unique_ptr<osdata> threads = get_osdata ("threads");
 
-      make_cleanup_osdata_free (threads);
-      tree.reset (splay_tree_new (splay_tree_int_comparator,
-				  NULL,
-				  free_vector_of_osdata_items));
-
-      for (ix_items = 0;
-	   VEC_iterate (osdata_item_s, threads->items,
-			ix_items, item);
-	   ix_items++)
+      for (const osdata_item &item : threads->items)
 	{
-	  const char *pid = get_osdata_column (item, "pid");
-	  int pid_i = strtoul (pid, NULL, 0);
-	  VEC (osdata_item_s) *vec = 0;
+	  const std::string *pid = get_osdata_column (item, "pid");
+	  int pid_i = strtoul (pid->c_str (), NULL, 0);
+	  std::vector<osdata_item> *vec;
 
-	  splay_tree_node n = splay_tree_lookup (tree.get (), pid_i);
-	  if (!n)
+	  auto n = tree_.find (pid_i);
+	  if (n == tree_.end ())
 	    {
-	      VEC_safe_push (osdata_item_s, vec, item);
-	      splay_tree_insert (tree.get (), pid_i, (splay_tree_value)vec);
+	      vec = new std::vector<osdata_item>;
+	      tree_[pid_i] = vec;
 	    }
 	  else
-	    {
-	      vec = (VEC (osdata_item_s) *) n->value;
-	      VEC_safe_push (osdata_item_s, vec, item);
-	      n->value = (splay_tree_value) vec;
-	    }
+	    vec = n->second;
+
+	  vec->push_back (item);
 	}
     }
 
   ui_out_emit_list list_emitter (uiout, "groups");
 
-  for (ix_items = 0;
-       VEC_iterate (osdata_item_s, data->items,
-		    ix_items, item);
-       ix_items++)
+  for (const osdata_item &item : data->items)
     {
-      const char *pid = get_osdata_column (item, "pid");
-      const char *cmd = get_osdata_column (item, "command");
-      const char *user = get_osdata_column (item, "user");
-      const char *cores = get_osdata_column (item, "cores");
+      const std::string *pid = get_osdata_column (item, "pid");
+      const std::string *cmd = get_osdata_column (item, "command");
+      const std::string *user = get_osdata_column (item, "user");
+      const std::string *cores = get_osdata_column (item, "cores");
 
-      int pid_i = strtoul (pid, NULL, 0);
+      int pid_i = strtoul (pid->c_str (), NULL, 0);
 
       /* At present, the target will return all available processes
 	 and if information about specific ones was required, we filter
@@ -800,43 +763,37 @@ list_available_thread_groups (const std::set<int> &ids, int recurse)
 
       ui_out_emit_tuple tuple_emitter (uiout, NULL);
 
-      uiout->field_fmt ("id", "%s", pid);
+      uiout->field_fmt ("id", "%s", pid->c_str ());
       uiout->field_string ("type", "process");
       if (cmd)
-	uiout->field_string ("description", cmd);
+	uiout->field_string ("description", cmd->c_str ());
       if (user)
-	uiout->field_string ("user", user);
+	uiout->field_string ("user", user->c_str ());
       if (cores)
-	output_cores (uiout, "cores", cores);
+	output_cores (uiout, "cores", cores->c_str ());
 
       if (recurse)
 	{
-	  splay_tree_node n = splay_tree_lookup (tree.get (), pid_i);
-	  if (n)
+	  auto n = tree_.find (pid_i);
+	  if (n != tree_.end ())
 	    {
-	      VEC (osdata_item_s) *children = (VEC (osdata_item_s) *) n->value;
-	      struct osdata_item *child;
-	      int ix_child;
+	      std::vector<osdata_item> *children = n->second;
 
 	      ui_out_emit_list thread_list_emitter (uiout, "threads");
 
-	      for (ix_child = 0;
-		   VEC_iterate (osdata_item_s, children, ix_child, child);
-		   ++ix_child)
+	      for (const osdata_item &child : *children)
 		{
 		  ui_out_emit_tuple tuple_emitter (uiout, NULL);
-		  const char *tid = get_osdata_column (child, "tid");
-		  const char *tcore = get_osdata_column (child, "core");
+		  const std::string *tid = get_osdata_column (child, "tid");
+		  const std::string *tcore = get_osdata_column (child, "core");
 
-		  uiout->field_string ("id", tid);
+		  uiout->field_string ("id", tid->c_str ());
 		  if (tcore)
-		    uiout->field_string ("core", tcore);
+		    uiout->field_string ("core", tcore->c_str ());
 		}
 	    }
 	}
     }
-
-  do_cleanups (cleanup);
 }
 
 void