< prev index next >

src/hotspot/share/utilities/stringUtils.cpp

Print this page
@@ -22,10 +22,11 @@
   *
   */
  
  #include "precompiled.hpp"
  #include "utilities/debug.hpp"
+ #include "utilities/ostream.hpp"
  #include "utilities/stringUtils.hpp"
  
  int StringUtils::replace_no_expand(char* string, const char* from, const char* to) {
    int replace_count = 0;
    size_t from_len = strlen(from);

@@ -63,5 +64,220 @@
      }
    }
  
    return 2.0 * (double) hit / (double) total;
  }
+ 
+ class StringMatcher {
+  public:
+   typedef int getc_function_t(const char* &source, const char* limit);
+ 
+  private:
+   // These do not get properly inlined.
+   // For full performance, this should be a template class
+   // parameterized by two function arguments.
+   getc_function_t* _pattern_getc;
+   getc_function_t* _string_getc;
+ 
+  public:
+   StringMatcher(getc_function_t pattern_getc,
+                 getc_function_t string_getc)
+     : _pattern_getc(pattern_getc),
+       _string_getc(string_getc)
+   { }
+ 
+   enum {  // special results from _pattern_getc
+     string_match_comma  = -0x100 + ',',
+     string_match_star   = -0x100 + '*',
+     string_match_eos    = -0x100 + '\0'
+   };
+ 
+  private:
+   const char*
+   skip_anchor_word(const char* match,
+                    const char* match_end,
+                    int anchor_length,
+                    const char* pattern,
+                    const char* pattern_end) {
+     assert(pattern < pattern_end && anchor_length > 0, "");
+     const char* begp = pattern;
+     int ch1 = _pattern_getc(begp, pattern_end);
+     // note that begp is now advanced over ch1
+     assert(ch1 > 0, "regular char only");
+     const char* matchp = match;
+     const char* limitp = match_end - anchor_length;
+     while (matchp <= limitp) {
+       int mch = _string_getc(matchp, match_end);
+       if (mch == ch1) {
+         const char* patp = begp;
+         const char* anchorp = matchp;
+         while (patp < pattern_end) {
+           char ch = _pattern_getc(patp, pattern_end);
+           char mch = _string_getc(anchorp, match_end);
+           if (mch != ch) {
+             anchorp = NULL;
+             break;
+           }
+         }
+         if (anchorp != NULL) {
+           return anchorp;  // Found a full copy of the anchor.
+         }
+         // That did not work, so restart the search for ch1.
+       }
+     }
+     return NULL;
+   }
+ 
+  public:
+   bool string_match(const char* pattern,
+                     const char* string) {
+     return string_match(pattern, pattern + strlen(pattern),
+                         string, string + strlen(string));
+   }
+   bool string_match(const char* pattern, const char* pattern_end,
+                     const char* string, const char* string_end) {
+     const char* patp = pattern;
+     switch (_pattern_getc(patp, pattern_end)) {
+     case string_match_eos:
+       return false;  // Empty pattern is always false.
+     case string_match_star:
+       if (patp == pattern_end) {
+         return true;   // Lone star pattern is always true.
+       }
+       break;
+     }
+     patp = pattern;  // Reset after lookahead.
+     const char* matchp = string;  // NULL if failing
+     for (;;) {
+       int ch = _pattern_getc(patp, pattern_end);
+       switch (ch) {
+       case string_match_eos:
+       case string_match_comma:
+         // End of a list item; see if it's a match.
+         if (matchp == string_end) {
+           return true;
+         }
+         if (ch == string_match_comma) {
+           // Get ready to match the next item.
+           matchp = string;
+           continue;
+         }
+         return false;  // End of all items.
+ 
+       case string_match_star:
+         if (matchp != NULL) {
+           // Wildcard:  Parse out following anchor word and look for it.
+           const char* begp = patp;
+           const char* endp = patp;
+           int anchor_len = 0;
+           for (;;) {
+             // get as many following regular characters as possible
+             endp = patp;
+             ch = _pattern_getc(patp, pattern_end);
+             if (ch <= 0) {
+               break;
+             }
+             anchor_len += 1;
+           }
+           // Anchor word [begp..endp) does not contain ch, so back up.
+           // Now do an eager match to the anchor word, and commit to it.
+           patp = endp;
+           if (ch == string_match_eos ||
+               ch == string_match_comma) {
+             // Anchor word is at end of pattern, so treat it as a fixed pattern.
+             const char* limitp = string_end - anchor_len;
+             matchp = limitp;
+             patp = begp;
+             // Resume normal scanning at the only possible match position.
+             continue;
+           }
+           // Find a floating occurrence of the anchor and continue matching.
+           // Note:  This is greedy; there is no backtrack here.  Good enough.
+           matchp = skip_anchor_word(matchp, string_end, anchor_len, begp, endp);
+         }
+         continue;
+       }
+       // Normal character.
+       if (matchp != NULL) {
+         int mch = _string_getc(matchp, string_end);
+         if (mch != ch) {
+           matchp = NULL;
+         }
+       }
+     }
+   }
+ };
+ 
+ // Match a wildcarded class list to a proposed class name (in internal form).
+ // Commas or newlines separate multiple possible matches; stars are shell-style wildcards.
+ class ClassListMatcher : public StringMatcher {
+  public:
+   ClassListMatcher()
+     : StringMatcher(pattern_list_getc, class_name_getc)
+   { }
+ 
+  private:
+   static int pattern_list_getc(const char* &pattern_ptr,
+                                const char* pattern_end) {
+     if (pattern_ptr == pattern_end) {
+       return string_match_eos;
+     }
+     int ch = (unsigned char) *pattern_ptr++;
+     switch (ch) {
+     case ' ': case '\t': case '\n': case '\r':
+     case ',':
+       // End of list item.
+       for (;;) {
+         switch (*pattern_ptr) {
+         case ' ': case '\t': case '\n': case '\r':
+         case ',':
+           pattern_ptr += 1;  // Collapse multiple commas or spaces.
+           continue;
+         }
+         break;
+       }
+       return string_match_comma;
+ 
+     case '*':
+       // Wildcard, matching any number of chars.
+       while (*pattern_ptr == '*') {
+         pattern_ptr += 1;  // Collapse multiple stars.
+       }
+       return string_match_star;
+ 
+     case '.':
+       ch = '/';   // Look for internal form of package separator
+       break;
+ 
+     case '\\':
+       // Superquote in pattern escapes * , whitespace, and itself.
+       if (pattern_ptr < pattern_end) {
+         ch = (unsigned char) *pattern_ptr++;
+       }
+       break;
+     }
+ 
+     assert(ch > 0, "regular char only");
+     return ch;
+   }
+ 
+   static int class_name_getc(const char* &name_ptr,
+                              const char* name_end) {
+     if (name_ptr == name_end) {
+       return string_match_eos;
+     }
+     int ch = (unsigned char) *name_ptr++;
+     if (ch == '.') {
+       ch = '/';   // Normalize to internal form of package separator
+     }
+     return ch;  // plain character
+   }
+ };
+ 
+ bool StringUtils::class_list_match(const char* class_pattern_list,
+                                    const char* class_name) {
+   if (class_pattern_list == NULL || class_name == NULL || class_name[0] == '\0')
+     return false;
+   ClassListMatcher clm;
+   return clm.string_match(class_pattern_list, class_name);
+ }
+ 
< prev index next >