*** empty log message ***

[deliverable/binutils-gdb.git] / gdb / utils.c

diff --git a/gdb/utils.c b/gdb/utils.c
index 11c34bf7bd9e7e82c55d9d3094294437320805ca..6fd220a6059bbaf9bcd32dcff20619f782eb6074 100644 (file)
--- a/gdb/utils.c
+++ b/gdb/utils.c
@@ -431,6 +431,39 @@ make_cleanup_restore_ui_file (struct ui_file **variable)
   return make_cleanup_dtor (do_restore_ui_file, (void *) c, xfree);
 }
 
+/* Helper for make_cleanup_value_free_to_mark.  */
+
+static void
+do_value_free_to_mark (void *value)
+{
+  value_free_to_mark ((struct value *) value);
+}
+
+/* Free all values allocated since MARK was obtained by value_mark
+   (except for those released) when the cleanup is run.  */
+
+struct cleanup *
+make_cleanup_value_free_to_mark (struct value *mark)
+{
+  return make_my_cleanup (&cleanup_chain, do_value_free_to_mark, mark);
+}
+
+/* Helper for make_cleanup_value_free.  */
+
+static void
+do_value_free (void *value)
+{
+  value_free (value);
+}
+
+/* Free VALUE.  */
+
+struct cleanup *
+make_cleanup_value_free (struct value *value)
+{
+  return make_my_cleanup (&cleanup_chain, do_value_free, value);
+}
+
 struct cleanup *
 make_my_cleanup2 (struct cleanup **pmy_chain, make_cleanup_ftype *function,
                  void *arg,  void (*free_arg) (void *))
@@ -2974,10 +3007,12 @@ strcmp_iw (const char *string1, const char *string2)
        {
          string2++;
        }
-      if (*string1 != *string2)
-       {
-         break;
-       }
+      if (case_sensitivity == case_sensitive_on && *string1 != *string2)
+       break;
+      if (case_sensitivity == case_sensitive_off
+         && (tolower ((unsigned char) *string1)
+             != tolower ((unsigned char) *string2)))
+       break;
       if (*string1 != '\0')
        {
          string1++;
@@ -2998,6 +3033,10 @@ strcmp_iw (const char *string1, const char *string2)
    strcmp_iw(LIST_ELT, NAME), then the place to start looking is right
    where this function would put NAME.
 
+   This function must be neutral to the CASE_SENSITIVITY setting as the user
+   may choose it during later lookup.  Therefore this function always sorts
+   primarily case-insensitively and secondarily case-sensitively.
+
    Here are some examples of why using strcmp to sort is a bad idea:
 
    Whitespace example:
@@ -3023,47 +3062,78 @@ strcmp_iw (const char *string1, const char *string2)
 int
 strcmp_iw_ordered (const char *string1, const char *string2)
 {
-  while ((*string1 != '\0') && (*string2 != '\0'))
+  const char *saved_string1 = string1, *saved_string2 = string2;
+  enum case_sensitivity case_pass = case_sensitive_off;
+
+  for (;;)
     {
-      while (isspace (*string1))
-       {
-         string1++;
-       }
-      while (isspace (*string2))
-       {
-         string2++;
-       }
-      if (*string1 != *string2)
+      /* C1 and C2 are valid only if *string1 != '\0' && *string2 != '\0'.
+        Provide stub characters if we are already at the end of one of the
+        strings.  */
+      char c1 = 'X', c2 = 'X';
+
+      while (*string1 != '\0' && *string2 != '\0')
        {
-         break;
+         while (isspace (*string1))
+           string1++;
+         while (isspace (*string2))
+           string2++;
+
+         switch (case_pass)
+         {
+           case case_sensitive_off:
+             c1 = tolower ((unsigned char) *string1);
+             c2 = tolower ((unsigned char) *string2);
+             break;
+           case case_sensitive_on:
+             c1 = *string1;
+             c2 = *string2;
+             break;
+         }
+         if (c1 != c2)
+           break;
+
+         if (*string1 != '\0')
+           {
+             string1++;
+             string2++;
+           }
        }
-      if (*string1 != '\0')
+
+      switch (*string1)
        {
-         string1++;
-         string2++;
+         /* Characters are non-equal unless they're both '\0'; we want to
+            make sure we get the comparison right according to our
+            comparison in the cases where one of them is '\0' or '('.  */
+       case '\0':
+         if (*string2 == '\0')
+           break;
+         else
+           return -1;
+       case '(':
+         if (*string2 == '\0')
+           return 1;
+         else
+           return -1;
+       default:
+         if (*string2 == '\0' || *string2 == '(')
+           return 1;
+         else if (c1 > c2)
+           return 1;
+         else if (c1 < c2)
+           return -1;
+         /* PASSTHRU */
        }
-    }
 
-  switch (*string1)
-    {
-      /* Characters are non-equal unless they're both '\0'; we want to
-        make sure we get the comparison right according to our
-        comparison in the cases where one of them is '\0' or '('.  */
-    case '\0':
-      if (*string2 == '\0')
+      if (case_pass == case_sensitive_on)
        return 0;
-      else
-       return -1;
-    case '(':
-      if (*string2 == '\0')
-       return 1;
-      else
-       return -1;
-    default:
-      if (*string2 == '(')
-       return 1;
-      else
-       return *string1 - *string2;
+      
+      /* Otherwise the strings were equal in case insensitive way, make
+        a more fine grained comparison in a case sensitive way.  */
+
+      case_pass = case_sensitive_on;
+      string1 = saved_string1;
+      string2 = saved_string2;
     }
 }