|
version 1.41, 2002/06/01 00:56:38
|
version 1.42, 2002/06/03 20:31:25
|
|
|
|
| return true; | return true; |
| } | } |
| | |
| //#define NEWMATCHFUNCTION |
|
| #if defined NEWMATCHFUNCTION |
// ATTN-RK-P3-20020603: This code is not completely correct |
| // Wildcard String matching function that may be useful in the future | // 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. |
| | |
|
|
|
| pat = _matchrange(pat, *str, nocase); // 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 = 0; // no match |
| } else { //Range matches | } else { //Range matches |
| str++, pat++; // keep going | str++, pat++; // keep going |
| } | } |
|
|
|
| return res; | return res; |
| } | } |
| | |
| #else |
|
| //////////////////////////////////////////////////////////////////////////////// |
|
| // |
|
| // 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; |
|
| } |
|
| } |
|
| 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 |
|
| | |
| Boolean String::match(const String& str, const String& pattern) | Boolean String::match(const String& str, const String& pattern) |
| { | { |
Return to
String.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common