Simplify resolve_subexp by using C++ algorithms

This changes resolve_subexp to use any_of and the erase-remove idiom
to simplify the code somewhat.  This simplifies the next patch a bit.

gdb/ChangeLog
2021-03-02  Tom Tromey  <tromey@adacore.com>

	* ada-lang.c (resolve_subexp): Use any_of and erase-remove idiom.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 8f5bc1d59b1cd5a6f19a4d5f53830d2e38ec98bb..282df4cab437a5834b4d3176848dedffd90db797 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,7 @@
+2021-03-02  Tom Tromey  <tromey@adacore.com>
+
+       * ada-lang.c (resolve_subexp): Use any_of and erase-remove idiom.
+
 2021-03-02  Tom Tromey  <tromey@adacore.com>
 
        * ada-lang.c (struct ada_symbol_cache) <cache_space>: Now an

diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index 7ab423bd23558efa6c96b5dcd05f39fbc176e7f9..c3e562c0bc90fb4debd3c37ec415d37aea863e5e 100644 (file)
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -3660,41 +3660,40 @@ resolve_subexp (expression_up *expp, int *pos, int deprocedure_p,
            ada_lookup_symbol_list (exp->elts[pc + 2].symbol->linkage_name (),
                                    exp->elts[pc + 1].block, VAR_DOMAIN,
                                    &candidates);
+         /* Paranoia.  */
+         candidates.resize (n_candidates);
 
-         if (n_candidates > 1)
+         if (std::any_of (candidates.begin (),
+                          candidates.end (),
+                          [] (block_symbol &sym)
+                          {
+                            switch (SYMBOL_CLASS (sym.symbol))
+                              {
+                              case LOC_REGISTER:
+                              case LOC_ARG:
+                              case LOC_REF_ARG:
+                              case LOC_REGPARM_ADDR:
+                              case LOC_LOCAL:
+                              case LOC_COMPUTED:
+                                return true;
+                              default:
+                                return false;
+                              }
+                          }))
            {
              /* Types tend to get re-introduced locally, so if there
                 are any local symbols that are not types, first filter
                 out all types.  */
-             int j;
-             for (j = 0; j < n_candidates; j += 1)
-               switch (SYMBOL_CLASS (candidates[j].symbol))
+             candidates.erase
+               (std::remove_if
+                (candidates.begin (),
+                 candidates.end (),
+                 [] (block_symbol &sym)
                  {
-                 case LOC_REGISTER:
-                 case LOC_ARG:
-                 case LOC_REF_ARG:
-                 case LOC_REGPARM_ADDR:
-                 case LOC_LOCAL:
-                 case LOC_COMPUTED:
-                   goto FoundNonType;
-                 default:
-                   break;
-                 }
-           FoundNonType:
-             if (j < n_candidates)
-               {
-                 j = 0;
-                 while (j < n_candidates)
-                   {
-                     if (SYMBOL_CLASS (candidates[j].symbol) == LOC_TYPEDEF)
-                       {
-                         candidates[j] = candidates[n_candidates - 1];
-                         n_candidates -= 1;
-                       }
-                     else
-                       j += 1;
-                   }
-               }
+                   return SYMBOL_CLASS (sym.symbol) == LOC_TYPEDEF;
+                 }),
+                candidates.end ());
+             n_candidates = candidates.size ();
            }
 
          if (n_candidates == 0)