Clean up code to remove the explicit backslash cruft.

If the backslash default is still wanted, just pass a backslash
 to MatchText() for the two-parameter callable routines.

diff --git a/src/backend/utils/adt/like.c b/src/backend/utils/adt/like.c
index 058fb1d9656655983b2a4c18aa15b9859be62286..0be559598d54a4a06a865928a947f762082b8f67 100644 (file)
--- a/src/backend/utils/adt/like.c
+++ b/src/backend/utils/adt/like.c
@@ -11,12 +11,12 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *     $Header: /cvsroot/pgsql/src/backend/utils/adt/like.c,v 1.38 2000/08/06 18:05:41 thomas Exp $
+ *     $Header: /cvsroot/pgsql/src/backend/utils/adt/like.c,v 1.39 2000/08/07 01:45:00 thomas Exp $
  *
  *-------------------------------------------------------------------------
  */
 #include "postgres.h"
-
+#include <ctype.h>
 #include "mb/pg_wchar.h"
 #include "utils/builtins.h"
 
@@ -307,59 +307,51 @@ MatchText(pg_wchar * t, int tlen, pg_wchar * p, int plen, char *e)
                        if ((plen <= 0) || (*t != *p))
                                return LIKE_FALSE;
                }
-               else
+               else if (*p == '%')
                {
-                       switch (*p)
+                       /* %% is the same as % according to the SQL standard */
+                       /* Advance past all %'s */
+                       while ((plen > 0) && (*p == '%'))
+                               NextChar(p, plen);
+                       /* Trailing percent matches everything. */
+                       if (plen <= 0)
+                               return LIKE_TRUE;
+
+                       /*
+                        * Otherwise, scan for a text position at which we can
+                        * match the rest of the pattern.
+                        */
+                       while (tlen > 0)
                        {
-                               case '\\':
-                                       /* Literal match with following character. */
-                                       NextChar(p, plen);
-                                       /* FALLTHROUGH */
-                               default:
-                                       if (*t != *p)
-                                               return LIKE_FALSE;
-                                       break;
-                               case '_':
-                                       /* Match any single character. */
-                                       break;
-                               case '%':
-                                       /* %% is the same as % according to the SQL standard */
-                                       /* Advance past all %'s */
-                                       while ((plen > 0) && (*p == '%'))
-                                               NextChar(p, plen);
-                                       /* Trailing percent matches everything. */
-                                       if (plen <= 0)
-                                               return LIKE_TRUE;
-
-                                       /*
-                                        * Otherwise, scan for a text position at which we can
-                                        * match the rest of the pattern.
-                                        */
-                                       while (tlen > 0)
-                                       {
-                                               /*
-                                                * Optimization to prevent most recursion: don't
-                                                * recurse unless first pattern char might match this
-                                                * text char.
-                                                */
-                                               if ((*t == *p) || (*p == '\\') || (*p == '_')
-                                                       || ((e != NULL) && (*p == *e)))
-                                               {
-                                                       int matched = MatchText(t, tlen, p, plen, e);
-
-                                                       if (matched != LIKE_FALSE)
-                                                               return matched;         /* TRUE or ABORT */
-                                               }
-
-                                               NextChar(t, tlen);
-                                       }
-
-                                       /*
-                                        * End of text with no match, so no point in trying later
-                                        * places to start matching this pattern.
-                                        */
-                                       return LIKE_ABORT;
+                               /*
+                                * Optimization to prevent most recursion: don't
+                                * recurse unless first pattern char might match this
+                                * text char.
+                                */
+                               if ((*t == *p) || (*p == '_')
+                                       || ((e != NULL) && (*p == *e)))
+                               {
+                                       int matched = MatchText(t, tlen, p, plen, e);
+
+                                       if (matched != LIKE_FALSE)
+                                               return matched;         /* TRUE or ABORT */
+                               }
+
+                               NextChar(t, tlen);
                        }
+
+                       /*
+                        * End of text with no match, so no point in trying later
+                        * places to start matching this pattern.
+                        */
+                       return LIKE_ABORT;
+               }
+               else if ((*p != '_') && (*t != *p))
+               {
+                       /* Not the single-character wildcard and no explicit match?
+                        * Then time to quit...
+                        */
+                       return LIKE_FALSE;
                }
 
                NextChar(t, tlen);
@@ -404,59 +396,48 @@ MatchTextLower(pg_wchar * t, int tlen, pg_wchar * p, int plen, char *e)
                        if ((plen <= 0) || (tolower(*t) != tolower(*p)))
                                return LIKE_FALSE;
                }
-               else
+               else if (*p == '%')
                {
-                       switch (*p)
+                       /* %% is the same as % according to the SQL standard */
+                       /* Advance past all %'s */
+                       while ((plen > 0) && (*p == '%'))
+                               NextChar(p, plen);
+                       /* Trailing percent matches everything. */
+                       if (plen <= 0)
+                               return LIKE_TRUE;
+
+                       /*
+                        * Otherwise, scan for a text position at which we can
+                        * match the rest of the pattern.
+                        */
+                       while (tlen > 0)
                        {
-                               case '\\':
-                                       /* Literal match with following character. */
-                                       NextChar(p, plen);
-                                       /* FALLTHROUGH */
-                               default:
-                                       if (tolower(*t) != tolower(*p))
-                                               return LIKE_FALSE;
-                                       break;
-                               case '_':
-                                       /* Match any single character. */
-                                       break;
-                               case '%':
-                                       /* %% is the same as % according to the SQL standard */
-                                       /* Advance past all %'s */
-                                       while ((plen > 0) && (*p == '%'))
-                                               NextChar(p, plen);
-                                       /* Trailing percent matches everything. */
-                                       if (plen <= 0)
-                                               return LIKE_TRUE;
-
-                                       /*
-                                        * Otherwise, scan for a text position at which we can
-                                        * match the rest of the pattern.
-                                        */
-                                       while (tlen > 0)
-                                       {
-                                               /*
-                                                * Optimization to prevent most recursion: don't
-                                                * recurse unless first pattern char might match this
-                                                * text char.
-                                                */
-                                               if ((tolower(*t) == tolower(*p)) || (*p == '\\') || (*p == '_')
-                                                       || ((e != NULL) && (tolower(*p) == tolower(*e))))
-                                               {
-                                                       int matched = MatchText(t, tlen, p, plen, e);
-
-                                                       if (matched != LIKE_FALSE)
-                                                               return matched;         /* TRUE or ABORT */
-                                               }
-
-                                               NextChar(t, tlen);
-                                       }
-
-                                       /*
-                                        * End of text with no match, so no point in trying later
-                                        * places to start matching this pattern.
-                                        */
-                                       return LIKE_ABORT;
+                               /*
+                                * Optimization to prevent most recursion: don't
+                                * recurse unless first pattern char might match this
+                                * text char.
+                                */
+                               if ((tolower(*t) == tolower(*p)) || (*p == '_')
+                                       || ((e != NULL) && (tolower(*p) == tolower(*e))))
+                               {
+                                       int matched = MatchText(t, tlen, p, plen, e);
+
+                                       if (matched != LIKE_FALSE)
+                                               return matched;         /* TRUE or ABORT */
+                               }
+
+                               NextChar(t, tlen);
                        }
+
+                       /*
+                        * End of text with no match, so no point in trying later
+                        * places to start matching this pattern.
+                        */
+                       return LIKE_ABORT;
+               }
+               else if ((*p != '_') && (tolower(*t) != tolower(*p)))
+               {
+                       return LIKE_FALSE;
                }
 
                NextChar(t, tlen);