pegasus/src/Pegasus/Common/String.cpp - diff

Return to String.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/String.cpp between version 1.38 and 1.71

version 1.38, 2002/05/06 06:43:38

version 1.71, 2003/08/20 17:35:53

Line 1

//%/////////////////////////////////////////////////////////////////////////////

// The Open Group, Tivoli Systems

// Permission is hereby granted, free of charge, to any person obtaining a copy

// of this software and associated documentation files (the "Software"), to

Line 22

Line 23

// Author: Mike Brasher (mbrasher@bmc.com)

// Modified By:

// Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)

//%/////////////////////////////////////////////////////////////////////////////

#include <cctype>

#include <cstring>

#include "String.h"

#include "Exception.h"

#include "Array.h"

#include "String.h"

#include "InternalException.h"

#include <iostream>

#include <fstream>

#ifndef PEGASUS_REMOVE_DEPRECATED

#include "System.h" // for strcasecmp

#endif

#include "CommonUTF.h"

#ifdef PEGASUS_HAS_ICU

#include <unistr.h>

#endif

PEGASUS_USING_STD;

PEGASUS_NAMESPACE_BEGIN

#define PEGASUS_ARRAY_T String

///////////////////////////////////////////////////////////////////////////////

#include <Pegasus/Common/ArrayImpl.h>

#undef PEGASUS_ARRAY_T

// CString

///////////////////////////////////////////////////////////////////////////////

const String String::EMPTY = String();

CString::CString()

: _rep(0)

{

}

#if 0 // Apparently dead code

CString::CString(const CString& cstr)

static inline void _SkipWhitespace(const Char16*& p)

{

while (*p && isspace(*p))

_rep = (void*)new char[strlen((char*)cstr._rep)+1];

p++;

strcpy((char*)_rep, (char*)cstr._rep);

}

#endif

CString::CString(char* cstr)

: _rep(cstr)

{

}

CString::~CString()

{

if (_rep)

delete [] (char*)_rep;

}

CString& CString::operator=(const CString& cstr)

{

_rep = (char*)new char[strlen((char*)cstr._rep)+1];

strcpy((char*)_rep, (char*)cstr._rep);

return *this;

}

CString::operator const char*() const

{

return (char*)_rep;

}

///////////////////////////////////////////////////////////////////////////////

// String

///////////////////////////////////////////////////////////////////////////////

const String String::EMPTY = String();

Uint32 _strnlen(const char* str, Uint32 n)

{

Line 83

Line 129

return n;

}

inline Uint32 StrLen(const char* str)

inline Uint32 _StrLen(const char* str)

{

if (!str)

throw NullPointer();

Line 91

Line 137

return strlen(str);

}

inline Uint32 StrLen(const Char16* str)

inline Uint32 _StrLen(const Char16* str)

{

if (!str)

throw NullPointer();

Line 104

Line 150

return n;

}

class StringRep

{

public:

StringRep()

{}

StringRep(const StringRep& r)

: c16a(r.c16a)

{}

StringRep(const Char16* str)

: c16a(str, _StrLen(str) + 1)

{}

Array<Char16> c16a;

};

String::String()

{

_rep.append('\0');

_rep = new StringRep;

_rep->c16a.append('\0');

}

String::String(const String& x) : _rep(x._rep)

String::String(const String& str)

{

if (str._rep != NULL)

{

_rep = new StringRep(*str._rep);

}

else

String::String(const String& x, Uint32 n)

{

assign(x.getData(), n);

_rep = new StringRep();

}

String::String(const Char16* x) : _rep(x, StrLen(x) + 1)

String::String(const String& str, Uint32 n)

{

_rep = new StringRep;

assign(str.getChar16Data(), n);

}

String::String(const Char16* str)

{

_rep = new StringRep(str);

}

String::String(const Char16* x, Uint32 n)

String::String(const Char16* str, Uint32 n)

{

assign(x, n);

_rep = new StringRep;

assign(str, n);

}

String::String(const char* str)

{

_rep = new StringRep;

assign(str);

}

String::String(const char* str, Uint32 n_)

String::String(const char* str, const char* utfFlag)

{

assign(str, n_);

_rep = new StringRep;

}

String& String::assign(const Char16* x)

if(!memcmp(utfFlag,STRING_FLAG_UTF8,sizeof(STRING_FLAG_UTF8)))

{

_rep.clear();

assignUTF8(str);

_rep.append(x, StrLen(x) + 1);

return *this;

}

else

String& String::assign(const Char16* str, Uint32 n)

{

_rep.clear();

assign(str);

Uint32 m = _strnlen(str, n);

}

_rep.append(str, m);

_rep.append('\0');

return *this;

}

String& String::assign(const char* x)

String::String(const char* str, Uint32 n)

{

_rep.clear();

_rep = new StringRep;

assign(str, n);

}

Uint32 n = strlen(x) + 1;

String::~String()

_rep.reserve(n);

{

delete _rep;

}

while (n--)

String& String::operator=(const String& str)

_rep.append(*x++);

{

return assign(str);

}

String& String::assign(const String& str)

{

_rep->c16a = str._rep->c16a;

return *this;

}

String& String::assign(const char* x, Uint32 n_)

String& String::assign(const Char16* str)

{

_rep.clear();

_rep->c16a.clear();

_rep->c16a.append(str, _StrLen(str) + 1);

Uint32 n = _strnlen(x, n_);

_rep.reserve(n + 1);

while (n--)

_rep.append(*x++);

_rep.append('\0');

return *this;

}

char* String::allocateCString(Uint32 extraBytes, Boolean noThrow) const

String& String::assign(const Char16* str, Uint32 n)

{

Uint32 n = size() + 1;

_rep->c16a.clear();

char* str = new char[n + extraBytes];

Uint32 m = _strnlen(str, n);

char* p = str;

_rep->c16a.append(str, m);

const Char16* q = getData();

_rep->c16a.append('\0');

return *this;

}

for (Uint32 i = 0; i < n; i++)

String& String::assign(const char* str)

{

Uint16 c = *q++;

_rep->c16a.clear();

*p++ = char(c);

if ((c & 0xff00) && !noThrow)

Uint32 n = strlen(str) + 1;

throw TruncatedCharacter();

_rep->c16a.reserveCapacity(n);

}

return str;

while (n--)

_rep->c16a.append(Uint8(*str++));

return *this;

}

void String::appendToCString(

String& String::assign(const char* str, Uint32 n)

char* str,

Uint32 length,

Boolean noThrow) const

{

if (!str)

_rep->c16a.clear();

throw NullPointer();

Uint32 n = _pegasusMin(size(), length);

char* p = str + strlen(str);

Uint32 _n = _strnlen(str, n);

const Char16* q = getData();

_rep->c16a.reserveCapacity(_n + 1);

for (Uint32 i = 0; i < n; i++)

while (_n--)

{

_rep->c16a.append(Uint8(*str++));

Uint16 c = *q++;

*p++ = char(c);

if ((c & 0xff00) && !noThrow)

_rep->c16a.append('\0');

throw TruncatedCharacter();

}

*p = '\0';

return *this;

}

Char16& String::operator[](Uint32 i)

void String::clear()

{

if (i > size())

_rep->c16a.clear();

ThrowOutOfBounds();

_rep->c16a.append('\0');

return _rep[i];

}

const Char16 String::operator[](Uint32 i) const

void String::reserveCapacity(Uint32 capacity)

{

if (i > size())

_rep->c16a.reserveCapacity(capacity + 1);

ThrowOutOfBounds();

return _rep[i];

}

String& String::append(const Char16* str, Uint32 n)

Uint32 String::size() const

{

Uint32 m = _strnlen(str, n);

return _rep->c16a.size() - 1;

_rep.reserve(_rep.size() + m);

_rep.remove(_rep.size() - 1);

_rep.append(str, m);

_rep.append('\0');

return *this;

}

void String::remove(Uint32 pos, Uint32 size)

const Char16* String::getChar16Data() const

{

if (size == PEG_NOT_FOUND)

return _rep->c16a.getData();

size = this->size() - pos;

if (pos + size > this->size())

ThrowOutOfBounds();

if (size)

_rep.remove(pos, size);

}

int String::compare(const Char16* s1, const Char16* s2, Uint32 n)

CString String::getCString() const

{

while (n--)

{

int r = *s1++ - *s2++;

Uint32 n = size() + 1;

char* str = new char[n];

if (r)

char* p = str;

return r;

const Char16* q = getChar16Data();

}

return 0;

}

int String::compareNoCase(const char* s1, const char* s2, Uint32 n)

for (Uint32 i = 0; i < n; i++)

{

while (n--)

{

int r = tolower(*s1++) - tolower(*s2++);

Uint16 c = *q++;

*p++ = char(c);

if (r)

//if (c & 0xff00)

return r;

// truncatedCharacters = true;

}

return 0;

return CString(str);

}

Boolean String::equal(const String& x, const String& y)

Char16& String::operator[](Uint32 index)

{

if (x.size() != y.size())

if (index > size())

return false;

throw IndexOutOfBoundsException();

return String::compare(x.getData(), y.getData(), x.size()) == 0;

return _rep->c16a[index];

}

Boolean String::equal(const String& x, const Char16* y)

const Char16 String::operator[](Uint32 index) const

{

if (x.size() != StrLen(y))

if (index > size())

return false;

throw IndexOutOfBoundsException();

return String::compare(x.getData(), y, x.size()) == 0;

return _rep->c16a[index];

}

Boolean String::equal(const Char16* x, const String& y)

String& String::append(const Char16& c)

{

return equal(y, x);

_rep->c16a.insert(_rep->c16a.size() - 1, c);

return *this;

}

Boolean String::equal(const String& x, const char* y)

String& String::append(const Char16* str, Uint32 n)

{

return equal(x, String(y));

Uint32 m = _strnlen(str, n);

_rep->c16a.reserveCapacity(_rep->c16a.size() + m);

_rep->c16a.remove(_rep->c16a.size() - 1);

_rep->c16a.append(str, m);

_rep->c16a.append('\0');

return *this;

}

Boolean String::equal(const char* x, const String& y)

String& String::append(const String& str)

{

return equal(String(x), y);

return append(str.getChar16Data(), str.size());

}

Boolean String::equalNoCase(const String& x, const String& y)

void String::remove(Uint32 index, Uint32 size)

{

if (x.size() != y.size())

if (size == PEG_NOT_FOUND)

return false;

size = this->size() - index;

const Char16* p = x.getData();

const Char16* q = y.getData();

Uint32 n = x.size();

while (n--)

if (index + size > this->size())

{

throw IndexOutOfBoundsException();

#ifdef PEGASUS_HAS_EBCDIC

if (*p <= 255 && *q <= 255)

#else

if (*p <= 127 && *q <= 127)

#endif

{

if (tolower(*p++) != tolower(*q++))

return false;

}

else if (*p++ != *q++)

return false;

}

return true;

if (size)

_rep->c16a.remove(index, size);

}

String String::subString(Uint32 pos, Uint32 length) const

String String::subString(Uint32 index, Uint32 length) const

{

if (pos < size())

if (index < size())

{

if (length == PEG_NOT_FOUND)

if ((length == PEG_NOT_FOUND) || (length > size() - index))

length = size() - pos;

length = size() - index;

return String(getData() + pos, length);

return String(getChar16Data() + index, length);

}

else

return String();

Line 365

Line 391

Uint32 String::find(Char16 c) const

{

const Char16* first = getData();

const Char16* first = getChar16Data();

for (const Char16* p = first; *p; p++)

{

Line 376

Line 402

return PEG_NOT_FOUND;

}

Uint32 String::find(Uint32 pos, Char16 c) const

Uint32 String::find(Uint32 index, Char16 c) const

{

const Char16* data = getData();

const Char16* data = getChar16Data();

for (Uint32 i = pos, n = size(); i < n; i++)

for (Uint32 i = index, n = size(); i < n; i++)

{

if (data[i] == c)

return i;

Line 391

Line 417

Uint32 String::find(const String& s) const

{

const Char16* pSubStr = s.getData();

const Char16* pSubStr = s.getChar16Data();

const Char16* pStr = getData();

const Char16* pStr = getChar16Data();

Uint32 subStrLen = s.size();

Uint32 strLen = size();

Line 422

Line 448

return PEG_NOT_FOUND;

}

Uint32 String::find(const char* s) const

{

return find(String(s));

}

Uint32 String::find(const Char16* s) const

{

return find(String(s));

}

Uint32 String::reverseFind(Char16 c) const

{

const Char16* first = getData();

const Char16* first = getChar16Data();

const Char16* last = getData() + size();

const Char16* last = getChar16Data() + size();

while (last != first)

{

Line 446

Line 462

return PEG_NOT_FOUND;

}

// ATTN-RK-P3-20020509: Define case-sensitivity for non-English characters

void String::toLower()

{

for (Char16* p = &_rep[0]; *p; p++)

#ifdef PEGASUS_HAS_ICU

{

Char16* utf16str;

#ifdef PEGASUS_HAS_EBCDIC

UnicodeString UniStr((const UChar *)_rep->c16a.getData(), (int32_t)size());

if (*p <= 255)

UniStr = UniStr.toLower();

utf16str = (Char16 *)UniStr.getTerminatedBuffer();

assign(utf16str);

delete utf16str;

#else

if (*p <= 127)

for (Char16* p = &_rep->c16a[0]; *p; p++)

#endif

{

if (*p <= PEGASUS_MAX_PRINTABLE_CHAR)

*p = tolower(*p);

}

#endif

}

void String::translate(Char16 fromChar, Char16 toChar)

int String::compare(const String& s1, const String& s2, Uint32 n)

{

for (Char16* p = &_rep[0]; *p; p++)

{

if (*p == fromChar)

const Char16* s1c16 = s1.getChar16Data();

*p = toChar;

const Char16* s2c16 = s2.getChar16Data();

}

int String::compare(const Char16* s1, const Char16* s2)

while (n--)

{

while (*s1 && *s2)

{

int r = *s1++ - *s2++;

int r = *s1c16++ - *s2c16++;

if (r)

return r;

}

if (*s2)

return -1;

else if (*s1)

return 1;

return 0;

}

int String::compareNoCase(const char* s1, const char* s2)

int String::compare(const String& s1, const String& s2)

{

while (*s1 && *s2)

const Char16* s1c16 = s1.getChar16Data();

const Char16* s2c16 = s2.getChar16Data();

while (*s1c16 && *s2c16)

{

int r = tolower(*s1++) - tolower(*s2++);

int r = *s1c16++ - *s2c16++;

if (r)

return r;

}

if (*s2)

if (*s2c16)

return -1;

else if (*s1)

else if (*s1c16)

return 1;

return 0;

}

PEGASUS_STD(ostream)& operator<<(PEGASUS_STD(ostream)& os, const String& x)

int String::compareNoCase(const String& s1, const String& s2)

{

for (Uint32 i = 0, n = x.size(); i < n; i++)

os << x[i];

return os;

}

void String::toLower(char* str)

{

while (*str)

#ifdef PEGASUS_HAS_ICU

tolower(*str++);

UnicodeString UniStr1((const UChar *)s1.getChar16Data(), (int32_t)s1.size());

}

UnicodeString UniStr2((const UChar *)s2.getChar16Data(), (int32_t)s2.size());

UniStr1 = UniStr1.toLower();

UniStr2 = UniStr2.toLower();

return (UniStr2.compare(UniStr1));

#else

const Char16* _s1 = s1.getChar16Data();

const Char16* _s2 = s2.getChar16Data();

String ToLower(const String& str)

while (*_s1 && *_s2)

{

String tmp(str);

int r;

for (Uint32 i = 0, n = tmp.size(); i < n; i++)

if (*_s1 <= PEGASUS_MAX_PRINTABLE_CHAR &&

*_s2 <= PEGASUS_MAX_PRINTABLE_CHAR)

{

Char16 c = tmp[i];

r = tolower(*_s1++) - tolower(*_s2++);

#ifdef PEGASUS_HAS_EBCDIC

if (c <= 255)

#else

if (c <= 127)

#endif

tmp[i] = tolower(c);

}

else

return tmp;

}

int CompareNoCase(const char* s1, const char* s2)

{

while (*s1 && *s2)

{

int r = tolower(*s1++) - tolower(*s2++);

r = *_s1++ - *_s2++;

}

if (r)

return r;

}

if (*s2)

if (*_s2)

return -1;

else if (*s1)

else if (*_s1)

return 1;

return 0;

#endif

}

Boolean GetLine(PEGASUS_STD(istream)& is, String& line)

Boolean String::equal(const String& str1, const String& str2)

{

line.clear();

return String::compare(str1, str2) == 0;

}

Boolean gotChar = false;

char c;

while (is.get(c))

Boolean String::equalNoCase(const String& str1, const String& str2)

{

gotChar = true;

#ifdef PEGASUS_HAS_ICU

UnicodeString UniStr1((const UChar *)str1.getChar16Data(), (int32_t)str1.size());

UnicodeString UniStr2((const UChar *)str2.getChar16Data(), (int32_t)str2.size());

UniStr1 = UniStr1.toLower();

UniStr2 = UniStr2.toLower();

return (UniStr1 == UniStr2);

#else

if (str1.size() != str2.size())

return false;

if (c == '\n')

const Char16* p = str1.getChar16Data();

break;

const Char16* q = str2.getChar16Data();

line.append(c);

Uint32 n = str1.size();

}

return gotChar;

}

String::~String()

while (n--)

{

if (*p <= PEGASUS_MAX_PRINTABLE_CHAR &&

*q <= PEGASUS_MAX_PRINTABLE_CHAR)

{

if (tolower(*p++) != tolower(*q++))

return false;

}

else if (*p++ != *q++)

return false;

}

String& String::assign(const String& x)

return true;

{

#endif

_rep = x._rep;

return *this;

}

String& String::append(const Char16& c)

// UTF8 specific code:

String& String::assignUTF8(const char* str)

{

_rep.insert(_rep.size() - 1, c);

_rep->c16a.clear();

Uint32 n = strlen(str) + 1;

const Uint8 *strsrc = (Uint8 *)str;

Uint8 *endsrc = (Uint8 *)&str[n-1];

Char16 *msg16 = new Char16[n];

Uint16 *strtgt = (Uint16 *)msg16;

Uint16 *endtgt = (Uint16 *)&msg16[n];

UTF8toUTF16(&strsrc,

endsrc,

&strtgt,

endtgt);

Uint32 count;

for(count = 0; ((msg16[count]) != Char16(0x00)) && (count <= n); ++count);

_rep->c16a.append(msg16, count);

_rep->c16a.append('\0');

delete [] msg16;

return *this;

}

void String::clear()

CString String::getCStringUTF8() const

{

_rep.clear();

Uint32 n = 3*size();

_rep.append('\0');

char* str = new char[n];

}

void String::print() const

const Char16* msg16 = getChar16Data();

{

cout << *this << endl;

}

void String::reserve(Uint32 capacity)

const Uint16 *strsrc = (Uint16 *)msg16;

{

Uint16 *endsrc = (Uint16 *)&msg16[size()+1];

_rep.reserve(capacity + 1);

Uint8 *strtgt = (Uint8 *)str;

Uint8 *endtgt = (Uint8 *)&str[n];

UTF16toUTF8 (&strsrc,

endsrc,

&strtgt,

endtgt);

char* str1 = new char[strlen(str)+1];

strcpy(str1,str);

delete str;

return CString(str1);

}

const Array<String>& EmptyStringArray()

Boolean String::isUTF8(const char *legal)

{

static Array<String> tmp;

return (isValid_U8((const Uint8 *)legal,

return tmp;

UTF_8_COUNT_TRAIL_BYTES(*legal)+1));

}

//#define NEWMATCHFUNCTION

#if defined NEWMATCHFUNCTION

#if 0

// ATTN-RK-P3-20020603: This code is not completely correct

// Wildcard String matching function that may be useful in the future

// The following code was provided by Bob Blair.

Line 637

Line 682

inline Uint16 _ToLower(Uint16 ch)

{

#ifdef PEGASUS_HAS_EBCDIC

// ICU_TODO: If ICU is available we should do this the correct way.

return ch <= 255 ? tolower(char(ch)) : ch;

return ch <= PEGASUS_MAX_PRINTABLE_CHAR ? tolower(char(ch)) : ch;

#else

return ch <= 127 ? tolower(char(ch)) : ch;

#endif

}

inline Boolean _Equal(MatchChar ch1, MatchChar ch2, int nocase)

{

// ICU_TODO: If ICU is available we should do this the correct way.

if (nocase)

return _ToLower(ch1) == _ToLower(ch2);

else

Line 723

Line 766

pat = _matchrange(pat, *str, nocase); // and is a match

if (!pat) { //It is not a match

done = 1; // we're done

res = 1; // no match

res = 0; // no match

} else { //Range matches

str++, pat++; // keep going

}

Line 738

Line 781

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.

////////////////////////////////////////////////////////////////////////////////

/** match matches a string against a GLOB style pattern.

Return trues if the String parameter matches the pattern. C-Shell style

glob matching is used.

@param str String to be matched against the pattern

@param pattern Pattern to use in the match

@return Boolean true if str matches pattern

The pattern definition is as follows:

<pre>

* Matches any number of any characters

? Match exactly one character

[chars] Match any character in chars

[chara-charb] Match any character in the range between chara and charb

</pre>

The literal characters *, ?, [, ] can be included in a string by

escaping them with backslash "\". Ranges of characters can be concatenated.

<pre>

examples:

Boolean result = String::match("This is a test", "*is*");

Boolean works = String::match("abcdef123", "*[0-9]");

</pre>

Boolean String::match(const String& str, const String& pattern)

{

return _StringMatch(

(Uint16*)str.getChar16Data(), (Uint16*)pattern.getChar16Data(), 0) != 0;

}

/** matchNoCase Matches a String against a GLOB style pattern independent

*----------------------------------------------------------------------

of case.

Returns true if the str parameter matches the pattern. C-Shell style

* Tcl_StringMatch --

glob matching is used. Ignore case in all comparisons. Case is

ignored in the match.

* See if a particular string matches a particular pattern.

@parm str String containing the string to be matched\

@parm pattern GLOB style patterh to use in the match.

* Results:

@return Boolean true if str matches patterh

* The return value is 1 if string matches pattern, and

@SeeAlso match

* 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.

*----------------------------------------------------------------------

Boolean String::matchNoCase(const String& str, const String& pattern)

{

return _StringMatch(

(Uint16*)str.getChar16Data(), (Uint16*)pattern.getChar16Data(), 1) != 0;

}

#endif

typedef Uint16 MatchChar;

inline Uint16 _ToLower(Uint16 ch)

///////////////////////////////////////////////////////////////////////////////

// String-related functions

///////////////////////////////////////////////////////////////////////////////

Boolean operator==(const String& str1, const String& str2)

{

#ifdef PEGASUS_HAS_EBCDIC

return String::equal(str1, str2);

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)

Boolean operator==(const String& str1, const char* str2)

{

if (nocase)

return String::equal(str1, str2);

return _ToLower(ch1) == _ToLower(ch2);

else

return ch1 == ch2;

}

int _StringMatch(

Boolean operator==(const char* str1, const String& str2)

MatchChar *string, /* String. */

MatchChar *pattern, /* Pattern, which may contain special

* characters. */

int nocase) /* Ignore case if this is true */

{

MatchChar c2;

return String::equal(str1, str2);

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;

Boolean operator!=(const String& str1, const String& str2)

{

return !String::equal(str1, str2);

}

/* Check for a "*" as the next pattern character. It matches

PEGASUS_STD(ostream)& operator<<(PEGASUS_STD(ostream)& os, const String& str)

* 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 defined(PEGASUS_OS_OS400)

CString cstr = str.getCStringUTF8();

const char* utf8str = cstr;

if (*pattern == '*') {

os << utf8str;

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

#elif defined(PEGASUS_HAS_ICU)

* any single character.

#if defined(PEGASUS_HAS_ICU)

char *buf = NULL;

UnicodeString UniStr((const UChar *)str.getChar16Data(), (int32_t)str.size());

if (*pattern == '?') {

Uint32 bufsize = UniStr.extract(0,0,buf);

goto thisCharOK;

buf = new char[bufsize+1];

}

UniStr.extract(0,bufsize,buf);

/* Check for a "[" as the next pattern character. It is followed

os << buf;

* by a list of characters that are acceptable, or by a range

* (two characters separated by "-").

if (*pattern == '[') {

delete buf;

pattern += 1;

#else

while (1) {

if ((*pattern == ']') || (*pattern == 0)) {

return 0;

for (Uint32 i = 0, n = str.size(); i < n; i++)

}

{

if (_Equal(*pattern, *string, nocase)) {

Uint16 code = str[i];

break;

}

if (code > 0 && code <= PEGASUS_MAX_PRINTABLE_CHAR)

if (pattern[1] == '-') {

{

c2 = pattern[2];

os << char(code);

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;

else

{

// Print in hex format:

char buffer[8];

sprintf(buffer, "\\x%04X", code);

os << buffer;

}

goto thisCharOK;

}

#endif // End of PEGASUS_HAS_ICU #else leg.

/* If the next pattern character is '/', just strip off the '/'

return os;

* 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

String operator+(const String& str1, const String& str2)

* characters of each string match.

{

return String(str1).append(str2);

}

if (!_Equal(*pattern, *string, nocase)) {

Boolean operator<(const String& str1, const String& str2)

return 0;

{

return String::compare(str1, str2) < 0;

}

thisCharOK: pattern += 1;

Boolean operator<=(const String& str1, const String& str2)

string += 1;

{

return String::compare(str1, str2) <= 0;

}

Boolean operator>(const String& str1, const String& str2)

{

return String::compare(str1, str2) > 0;

}

#endif

Boolean String::match(const String& str, const String& pattern)

Boolean operator>=(const String& str1, const String& str2)

{

return _StringMatch(

return String::compare(str1, str2) >= 0;

(Uint16*)str.getData(), (Uint16*)pattern.getData(), 0) != 0;

}

Boolean String::matchNoCase(const String& str, const String& pattern)

#ifndef PEGASUS_REMOVE_DEPRECATED

int CompareNoCase(const char* s1, const char* s2)

{

return _StringMatch(

return System::strcasecmp(s1, s2);

(Uint16*)str.getData(), (Uint16*)pattern.getData(), 1) != 0;

}

#endif

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.38
changed lines
	Added in v.1.71

No CVS admin address has been configured