Rename "wild_match" parameter in ada-lang.c:symbol_completion_add...

[deliverable/binutils-gdb.git] / gdb / ada-lang.c

diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index c063683867cb2de311c466e92b1462b234f89505..092ee269a6d2bc981242e17ee5fd06bebf18aadf 100644 (file)
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -5198,19 +5198,19 @@ ada_iterate_over_symbols (const struct block *block,
    to 1, but choosing the first symbol found if there are multiple
    choices.
 
-   The result is stored in *SYMBOL_INFO, which must be non-NULL.
-   If no match is found, SYMBOL_INFO->SYM is set to NULL.  */
+   The result is stored in *INFO, which must be non-NULL.
+   If no match is found, INFO->SYM is set to NULL.  */
 
 void
 ada_lookup_encoded_symbol (const char *name, const struct block *block,
                           domain_enum namespace,
-                          struct ada_symbol_info *symbol_info)
+                          struct ada_symbol_info *info)
 {
   struct ada_symbol_info *candidates;
   int n_candidates;
 
-  gdb_assert (symbol_info != NULL);
-  memset (symbol_info, 0, sizeof (struct ada_symbol_info));
+  gdb_assert (info != NULL);
+  memset (info, 0, sizeof (struct ada_symbol_info));
 
   n_candidates = ada_lookup_symbol_list (name, block, namespace, &candidates,
                                         1);
@@ -5218,8 +5218,8 @@ ada_lookup_encoded_symbol (const char *name, const struct block *block,
   if (n_candidates == 0)
     return;
 
-  *symbol_info = candidates[0];
-  symbol_info->sym = fixup_symbol_section (symbol_info->sym, NULL);
+  *info = candidates[0];
+  info->sym = fixup_symbol_section (info->sym, NULL);
 }
 
 /* Return a symbol in DOMAIN matching NAME, in BLOCK0 and enclosing
@@ -5232,14 +5232,14 @@ struct symbol *
 ada_lookup_symbol (const char *name, const struct block *block0,
                    domain_enum namespace, int *is_a_field_of_this)
 {
-  struct ada_symbol_info symbol_info;
+  struct ada_symbol_info info;
 
   if (is_a_field_of_this != NULL)
     *is_a_field_of_this = 0;
 
   ada_lookup_encoded_symbol (ada_encode (ada_fold_name (name)),
-                            block0, namespace, &symbol_info);
-  return symbol_info.sym;
+                            block0, namespace, &info);
+  return info.sym;
 }
 
 static struct symbol *
@@ -5640,14 +5640,14 @@ ada_add_block_symbols (struct obstack *obstackp,
    does not need to be deallocated, but is only good until the next call.
 
    TEXT_LEN is equal to the length of TEXT.
-   Perform a wild match if WILD_MATCH is set.
-   ENCODED should be set if TEXT represents the start of a symbol name
+   Perform a wild match if WILD_MATCH_P is set.
+   ENCODED_P should be set if TEXT represents the start of a symbol name
    in its encoded form.  */
 
 static const char *
 symbol_completion_match (const char *sym_name,
                          const char *text, int text_len,
-                         int wild_match, int encoded)
+                         int wild_match_p, int encoded_p)
 {
   const int verbatim_match = (text[0] == '<');
   int match = 0;
@@ -5664,7 +5664,7 @@ symbol_completion_match (const char *sym_name,
   if (strncmp (sym_name, text, text_len) == 0)
     match = 1;
 
-  if (match && !encoded)
+  if (match && !encoded_p)
     {
       /* One needed check before declaring a positive match is to verify
          that iff we are doing a verbatim match, the decoded version
@@ -5695,7 +5695,7 @@ symbol_completion_match (const char *sym_name,
 
   /* Second: Try wild matching...  */
 
-  if (!match && wild_match)
+  if (!match && wild_match_p)
     {
       /* Since we are doing wild matching, this means that TEXT
          may represent an unqualified symbol name.  We therefore must
@@ -5714,7 +5714,7 @@ symbol_completion_match (const char *sym_name,
   if (verbatim_match)
     sym_name = add_angle_brackets (sym_name);
 
-  if (!encoded)
+  if (!encoded_p)
     sym_name = ada_decode (sym_name);
 
   return sym_name;
@@ -5730,7 +5730,7 @@ symbol_completion_match (const char *sym_name,
    completion should be performed.  These two parameters are used to
    determine which part of the symbol name should be added to the
    completion vector.
-   if WILD_MATCH is set, then wild matching is performed.
+   if WILD_MATCH_P is set, then wild matching is performed.
    ENCODED should be set if TEXT represents a symbol name in its
    encoded formed (in which case the completion should also be
    encoded).  */
@@ -5740,10 +5740,10 @@ symbol_completion_add (VEC(char_ptr) **sv,
                        const char *sym_name,
                        const char *text, int text_len,
                        const char *orig_text, const char *word,
-                       int wild_match, int encoded)
+                       int wild_match_p, int encoded)
 {
   const char *match = symbol_completion_match (sym_name, text, text_len,
-                                               wild_match, encoded);
+                                               wild_match_p, encoded);
   char *completion;
 
   if (match == NULL)