[PATCH 13/40] Introduce strncmp_iw

[Pedro Alves <palves@redhat.com>]

The explicit locations completer patch will need a strncmp_iw
function, that to strcmp_iw like strncmp is to strcmp.  This patch
implements it.

(Unit tests added a bit further down in this series will exercise
this.)

gdb/ChangeLog:
yyyy-mm-dd  Pedro Alves  <palves@redhat.com>

	* utils.c (enum class strncmp_iw_mode): New.
	(strcmp_iw): Rename to ...
	(strncmp_iw_with_mode): ... this.  Add string2_len and mode
	parameters.  Handle them.
	(strncmp_iw): New.
	(strcmp_iw): Reimplement as wrapper around strncmp_iw_with_mode.
	* utils.h (strncmp_iw): Declare.
	(strcmp_iw): Move describing comments here.
---
 gdb/utils.c | 77 +++++++++++++++++++++++++++++++++++++++++++------------------
 gdb/utils.h | 16 +++++++++++++
 2 files changed, 70 insertions(+), 23 deletions(-)

diff --git a/gdb/utils.c b/gdb/utils.c
index 00b1bbb..9f1c83a 100644
--- a/gdb/utils.c
+++ b/gdb/utils.c
@@ -2418,41 +2418,72 @@ fprintf_symbol_filtered (struct ui_file *stream, const char *name,
     }
 }
 
-/* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
-   differences in whitespace.  Returns 0 if they match, non-zero if they
-   don't (slightly different than strcmp()'s range of return values).
+/* Modes of operation for strncmp_iw_with_mode.  */
 
-   As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
-   This "feature" is useful when searching for matching C++ function names
-   (such as if the user types 'break FOO', where FOO is a mangled C++
-   function).  */
+enum class strncmp_iw_mode
+{
+  /* Work like strncmp, while ignoring whitespace.  */
+  NORMAL,
 
-int
-strcmp_iw (const char *string1, const char *string2)
+  /* Like NORMAL, but also apply the strcmp_iw hack.  I.e.,
+     string1=="FOO(PARAMS)" matches string2=="FOO".  */
+  MATCH_PARAMS,
+};
+
+/* Helper for strncmp_iw and strcmp_iw.  */
+
+static int
+strncmp_iw_with_mode (const char *string1, const char *string2,
+		      size_t string2_len, strncmp_iw_mode mode)
 {
-  while ((*string1 != '\0') && (*string2 != '\0'))
+  const char *end_str2 = string2 + string2_len;
+
+  while (1)
     {
       while (isspace (*string1))
-	{
-	  string1++;
-	}
-      while (isspace (*string2))
-	{
-	  string2++;
-	}
+	string1++;
+      while (string2 < end_str2 && isspace (*string2))
+	string2++;
+      if (*string1 == '\0' || string2 == end_str2)
+	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++;
-	  string2++;
-	}
+
+      string1++;
+      string2++;
     }
-  return (*string1 != '\0' && *string1 != '(') || (*string2 != '\0');
+
+  if (string2 == end_str2)
+    {
+      if (mode == strncmp_iw_mode::NORMAL)
+	return 0;
+      else
+	return (*string1 != '\0' && *string1 != '(');
+    }
+  else
+    return 1;
+}
+
+/* See utils.h.  */
+
+int
+strncmp_iw (const char *string1, const char *string2, size_t string2_len)
+{
+  return strncmp_iw_with_mode (string1, string2, string2_len,
+			       strncmp_iw_mode::NORMAL);
+}
+
+/* See utils.h.  */
+
+int
+strcmp_iw (const char *string1, const char *string2)
+{
+  return strncmp_iw_with_mode (string1, string2, strlen (string2),
+			       strncmp_iw_mode::MATCH_PARAMS);
 }
 
 /* This is like strcmp except that it ignores whitespace and treats
diff --git a/gdb/utils.h b/gdb/utils.h
index 3347c23..2396dcd 100644
--- a/gdb/utils.h
+++ b/gdb/utils.h
@@ -31,6 +31,22 @@ extern void initialize_utils (void);
 
 extern int sevenbit_strings;
 
+/* Do a strncmp() type operation on STRING1 and STRING2, ignoring any
+   differences in whitespace.  STRING2_LEN is STRING2's length.
+   Returns 0 if STRING1 matches STRING2_LEN characters of STRING2,
+   non-zero otherwise (slightly different than strncmp()'s range of
+   return values).  */
+extern int strncmp_iw (const char *, const char *, size_t);
+
+/* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
+   differences in whitespace.  Returns 0 if they match, non-zero if
+   they don't (slightly different than strcmp()'s range of return
+   values).
+
+   As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
+   This "feature" is useful when searching for matching C++ function
+   names (such as if the user types 'break FOO', where FOO is a
+   mangled C++ function).  */
 extern int strcmp_iw (const char *, const char *);
 
 extern int strcmp_iw_ordered (const char *, const char *);
-- 
2.5.5