(file) Return to String.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/String.cpp between version 1.35 and 1.36

version 1.35, 2002/04/19 02:27:30 version 1.36, 2002/04/22 09:56:44
Line 592 
Line 592 
     static Array<String> tmp;     static Array<String> tmp;
     return tmp;     return tmp;
 } }
   //#define NEWMATCHFUNCTION
 #if 0 // Wildcard String matching function that may be useful in the future  #if defined NEWMATCHFUNCTION
    // Wildcard String matching function that may be useful in the future
 // The following code was provided by Bob Blair. // The following code was provided by Bob Blair.
 // This code needs to be converted to work on Strings instead of const char*'s.  
  
 // Match two paths which may contain DOS-type wild-cards.  /* _StringMatch Match input MatchString against a GLOB style pattern
 static const unsigned char *         Note that MatchChar is the char type so that this source
 matchrange(const unsigned char *range, unsigned char c) {         in portable to different string types. This is an internal function
   const unsigned char *p = range;  
   const unsigned char *rstart = range + 1;    Results: The return value is 1 if string matches pattern, and
   const unsigned char *rend = 0;          0 otherwise.  The matching operation permits the following
   unsigned char compchar;          special characters in the pattern: *?\[] (see the manual
           entry for details on what these mean).
   
     Side effects: None.
    */
   
   /* MatchChar defined as a separate entity because this function source used
       elsewhere was an unsigned char *. Here we use Uint16 to  maintain 16 bit
       size.
   */
   typedef Uint16 MatchChar;
   
   inline Uint16 _ToLower(Uint16 ch)
   {
   #ifdef PEGASUS_HAS_EBCDIC
       return ch <= 255 ? tolower(char(ch)) : ch;
   #else
       return ch <= 127 ? tolower(char(ch)) : ch;
   #endif
   }
   
   inline Boolean _Equal(MatchChar ch1, MatchChar ch2, int nocase)
   {
       if (nocase)
           return _ToLower(ch1) == _ToLower(ch2);
       else
           return ch1 == ch2;
   }
   
   
   static const MatchChar *
   _matchrange(const MatchChar *range, MatchChar c, int nocase)
   {
     const MatchChar *p = range;
     const MatchChar *rstart = range + 1;
     const MatchChar *rend = 0;
     MatchChar compchar;
   
   for (rend = rstart; *rend && *rend != ']'; rend++);   for (rend = rstart; *rend && *rend != ']'; rend++);
   if (*rend == ']') {  // if there is an end to this thing    if (*rend == ']') {  // if there is an end to this pattern
     for (compchar = *rstart; rstart != rend; rstart++) {     for (compchar = *rstart; rstart != rend; rstart++) {
       if (*rstart == c)        if (_Equal(*rstart, c, nocase))
         return ++rend;         return ++rend;
       if (*rstart == '-') {       if (*rstart == '-') {
         rstart++;         rstart++;
Line 616 
Line 653 
       }       }
     }     }
   }   }
   return (const unsigned char *)0;    return (const MatchChar *)0;
 } }
  
 static int static int
 matchem(const unsigned char *thePattern, const unsigned char *theTest) {  _StringMatch(
       const MatchChar *testString,
       const MatchChar *pattern,
       int nocase )                /* Ignore case if this is true */
   {
     const MatchChar *pat = pattern;
     const MatchChar *str = testString;
   unsigned int done = 0;   unsigned int done = 0;
   unsigned int res = 0;  // the result: 1 == match   unsigned int res = 0;  // the result: 1 == match
   const unsigned char *pat = thePattern;  
   const unsigned char *str = theTest;  
  
   while (!done) { // main loop walks through pattern and test string   while (!done) { // main loop walks through pattern and test string
     //cerr << "Comparing <" << *pat << "> and <" << *str << ">" << endl;     //cerr << "Comparing <" << *pat << "> and <" << *str << ">" << endl;
Line 644 
Line 685 
             res = 1;                                     //  and match             res = 1;                                     //  and match
           } else {                                       //if it doesn't end           } else {                                       //if it doesn't end
             while (!done) {                              //  until we're done             while (!done) {                              //  until we're done
               if (matchem(pat, str)) {                   //  we recurse                if (_StringMatch(str, pat, nocase)) {      //  we recurse
                 done = 1;                                //if it recurses true                 done = 1;                                //if it recurses true
                 res = 1;                                 //  we done and match                 res = 1;                                 //  we done and match
               } else {                                   //it recurses false               } else {                                   //it recurses false
Line 659 
Line 700 
           if (*pat == '?') {                             //pattern is 'any'           if (*pat == '?') {                             //pattern is 'any'
             pat++, str++;                                //  so move along             pat++, str++;                                //  so move along
           } else if (*pat == '[') {                      //see if it's a range           } else if (*pat == '[') {                      //see if it's a range
             pat = matchrange(pat, *str);                 // and is a match              pat = _matchrange(pat, *str, nocase);         // and is a match
             if (!pat) {                                  //It is not a match             if (!pat) {                                  //It is not a match
               done = 1;                                  //  we're done               done = 1;                                  //  we're done
               res = 1;                                   //  no match               res = 1;                                   //  no match
Line 667 
Line 708 
               str++, pat++;                              //  keep going               str++, pat++;                              //  keep going
             }             }
           } else {               // only case left is individual characters           } else {               // only case left is individual characters
             if (*pat++ != *str++)                        // if they don't match              if (!_Equal(*pat++, *str++, nocase))         // if they don't match
               done = 1;                                  //   bail.               done = 1;                                  //   bail.
           }           }
         }  // end ("pattern is not ambiguous (*)" logic         }  // end ("pattern is not ambiguous (*)" logic
Line 677 
Line 718 
   return res;   return res;
 } }
  
 int  #else
 Match::compare() {  ////////////////////////////////////////////////////////////////////////////////
   if (!_pattern || !_test)  //
   // String matching routines borrowed from Tcl 8.0:
   //
   ////////////////////////////////////////////////////////////////////////////////
   
   ////////////////////////////////////////////////////////////////////////////////
   //
   // This software is copyrighted by the Regents of the University of
   // California, Sun Microsystems, Inc., and other parties.  The following
   // terms apply to all files associated with the software unless explicitly
   // disclaimed in individual files.
   //
   // The authors hereby grant permission to use, copy, modify, distribute,
   // and license this software and its documentation for any purpose, provided
   // that existing copyright notices are retained in all copies and that this
   // notice is included verbatim in any distributions. No written agreement,
   // license, or royalty fee is required for any of the authorized uses.
   // Modifications to this software may be copyrighted by their authors
   // and need not follow the licensing terms described here, provided that
   // the new terms are clearly indicated on the first page of each file where
   // they apply.
   //
   // IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY
   // FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
   // ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
   // DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
   // POSSIBILITY OF SUCH DAMAGE.
   //
   // THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
   // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
   // FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.  THIS SOFTWARE
   // IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE
   // NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
   // MODIFICATIONS.
   //
   // GOVERNMENT USE: If you are acquiring this software on behalf of the
   // U.S. government, the Government shall have only "Restricted Rights"
   // in the software and related documentation as defined in the Federal
   // Acquisition Regulations (FARs) in Clause 52.227.19 (c) (2).  If you
   // are acquiring the software on behalf of the Department of Defense, the
   // software shall be classified as "Commercial Computer Software" and the
   // Government shall have only "Restricted Rights" as defined in Clause
   // 252.227-7013 (c) (1) of DFARs.  Notwithstanding the foregoing, the
   // authors grant the U.S. Government and others acting in its behalf
   // permission to use and distribute the software in accordance with the
   // terms specified in this license.
   //
   ////////////////////////////////////////////////////////////////////////////////
   
   
   /*
    *----------------------------------------------------------------------
    *
    * Tcl_StringMatch --
    *
    *      See if a particular string matches a particular pattern.
    *
    * Results:
    *      The return value is 1 if string matches pattern, and
    *      0 otherwise.  The matching operation permits the following
    *      special characters in the pattern: *?\[] (see the manual
    *      entry for details on what these mean).
    *
    * Side effects:
    *      None.
    *
    *----------------------------------------------------------------------
    */
   
   typedef Uint16 MatchChar;
   
   inline Uint16 _ToLower(Uint16 ch)
   {
   #ifdef PEGASUS_HAS_EBCDIC
       return ch <= 255 ? tolower(char(ch)) : ch;
   #else
       return ch <= 127 ? tolower(char(ch)) : ch;
   #endif
   }
   
   inline Boolean _Equal(Uint16 ch1, Uint16 ch2, int nocase)
   {
       if (nocase)
           return _ToLower(ch1) == _ToLower(ch2);
       else
           return ch1 == ch2;
   }
   
   int _StringMatch(
       MatchChar *string,          /* String. */
       MatchChar *pattern,         /* Pattern, which may contain special
                                    * characters. */
       int nocase)                 /* Ignore case if this is true */
   {
       MatchChar c2;
   
       while (1) {
           /* See if we're at the end of both the pattern and the string.
            * If so, we succeeded.  If we're at the end of the pattern
            * but not at the end of the string, we failed.
            */
   
           if (*pattern == 0) {
               if (*string == 0) {
                   return 1;
               } else {
     return 0;     return 0;
   return matchem(_pattern, _test);              }
           }
           if ((*string == 0) && (*pattern != '*')) {
               return 0;
           }
   
           /* Check for a "*" as the next pattern character.  It matches
            * any substring.  We handle this by calling ourselves
            * recursively for each postfix of string, until either we
            * match or we reach the end of the string.
            */
   
           if (*pattern == '*') {
               pattern += 1;
               if (*pattern == 0) {
                   return 1;
               }
               while (1) {
                   if (_StringMatch(string, pattern, nocase)) {
                       return 1;
                   }
                   if (*string == 0) {
                       return 0;
                   }
                   string += 1;
               }
           }
   
           /* Check for a "?" as the next pattern character.  It matches
            * any single character.
            */
   
           if (*pattern == '?') {
               goto thisCharOK;
           }
   
           /* Check for a "[" as the next pattern character.  It is followed
            * by a list of characters that are acceptable, or by a range
            * (two characters separated by "-").
            */
   
           if (*pattern == '[') {
               pattern += 1;
               while (1) {
                   if ((*pattern == ']') || (*pattern == 0)) {
                       return 0;
                   }
                   if (_Equal(*pattern, *string, nocase)) {
                       break;
                   }
                   if (pattern[1] == '-') {
                       c2 = pattern[2];
                       if (c2 == 0) {
                           return 0;
                       }
                       if ((*pattern <= *string) && (c2 >= *string)) {
                           break;
                       }
                       if ((*pattern >= *string) && (c2 <= *string)) {
                           break;
                       }
                       pattern += 2;
                   }
                   pattern += 1;
               }
               while (*pattern != ']') {
                   if (*pattern == 0) {
                       pattern--;
                       break;
                   }
                   pattern += 1;
               }
               goto thisCharOK;
           }
   
           /* If the next pattern character is '/', just strip off the '/'
            * so we do exact matching on the character that follows.
            */
   
           if (*pattern == '\\') {
               pattern += 1;
               if (*pattern == 0) {
                   return 0;
               }
           }
   
           /* There's no special character.  Just make sure that the next
            * characters of each string match.
            */
   
           if (!_Equal(*pattern, *string, nocase)) {
               return 0;
           }
   
           thisCharOK: pattern += 1;
           string += 1;
       }
 } }
 #endif #endif
   Boolean String::match(const String& str, const String& pattern)
   {
       return _StringMatch(
           (Uint16*)str.getData(), (Uint16*)pattern.getData(), 0) != 0;
   }
   
   Boolean String::matchNoCase(const String& str, const String& pattern)
   {
       return _StringMatch(
           (Uint16*)str.getData(), (Uint16*)pattern.getData(), 1) != 0;
   }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

Legend:
Removed from v.1.35  
changed lines
  Added in v.1.36
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2