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.112 and 1.133

version 1.112, 2005/10/17 20:51:56

version 1.133, 2008/12/01 17:49:56

Line 1

//%2005////////////////////////////////////////////////////////////////////////

//%LICENSE////////////////////////////////////////////////////////////////

// Licensed to The Open Group (TOG) under one or more contributor license

// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.

// agreements. Refer to the OpenPegasusNOTICE.txt file distributed with

// this work for additional information regarding copyright ownership.

// IBM Corp.; EMC Corporation, The Open Group.

// Each contributor licenses this file to you under the OpenPegasus Open

// Source License; you may not use this file except in compliance with the

// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

// License.

// EMC Corporation; VERITAS Software Corporation; The Open Group.

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

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

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

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

// deal in the Software without restriction, including without limitation the

// to deal in the Software without restriction, including without limitation

// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

// the rights to use, copy, modify, merge, publish, distribute, sublicense,

// sell copies of the Software, and to permit persons to whom the Software is

// and/or sell copies of the Software, and to permit persons to whom the

// furnished to do so, subject to the following conditions:

// Software is furnished to do so, subject to the following conditions:

// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN

// The above copyright notice and this permission notice shall be included

// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED

// in all copies or substantial portions of the Software.

// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT

// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR

// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

//==============================================================================

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// Author: Mike Brasher (mbrasher@austin.rr.com)

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

// Modified By:

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

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

// Josephine Eskaline Joyce, IBM (jojustin@in.ibm.com) for Bug#3297

// David Dillard, VERITAS Software Corp. (david.dillard@veritas.com)

// Mike Brasher (mike-brasher@austin.rr.com)

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

#include <cassert>

#include <Pegasus/Common/PegasusAssert.h>

#include <cstring>

#include "InternalException.h"

#include "CommonUTF.h"

#include "MessageLoader.h"

#include "StringRep.h"

#ifdef PEGASUS_HAS_ICU

# include <unicode/ures.h>

#include <unicode/ustring.h>

#include <unicode/uchar.h>

#endif

Line 54

Line 48

// Compile-time macros (undefined by default).

// PEGASUS_STRING_NO_THROW -- suppresses throwing of exceptions

// PEGASUS_STRING_NO_UTF8 -- don't generate slower UTF8 code.

//==============================================================================

Line 161

Line 153

// Rounds x up to the nearest power of two (or just returns 8 if x < 8).

static Uint32 _roundUpToPow2(Uint32 x)

{

#ifndef PEGASUS_STRING_NO_THROW

// Check for potential overflow in x

PEGASUS_CHECK_CAPACITY_OVERFLOW(x);

if (x > 0x0FFFFFFF)

throw PEGASUS_STD(bad_alloc)();

#endif

if (x < 8)

return 8;

Line 279

Line 267

return 0;

}

#ifdef PEGASUS_STRING_NO_UTF8

static int _compareNoUTF8(const Uint16* s1, const char* s2)

{

Uint16 c1;

Line 296

Line 285

return c1 - c2;

}

#endif

static int _compare(const Uint16* s1, const Uint16* s2, size_t n)

{

// This should only be called when s1 and s2 have the same length.

while (n-- && (*s1++ - *s2++) == 0)

;

return s1[-1] - s2[-1];

}

static inline void _copy(Uint16* s1, const Uint16* s2, size_t n)

{

Line 319

Line 299

inline void _checkNullPointer(const void* ptr)

{

#ifdef PEGASUS_STRING_NO_THROW

if (!ptr)

throw NullPointer();

#endif

}

static void _StringThrowBadUTF8(Uint32 index)

Line 550

Line 526

inline StringRep* StringRep::alloc(size_t cap)

{

#ifndef PEGASUS_STRING_NO_THROW

// Check for potential overflow in cap

PEGASUS_CHECK_CAPACITY_OVERFLOW(cap);

// Any string bigger than this is seriously suspect.

if (cap > 0x0FFFFFFF)

throw PEGASUS_STD(bad_alloc)();

#endif

StringRep* rep = (StringRep*)::operator new(

sizeof(StringRep) + cap * sizeof(Uint16));

Line 568

Line 539

static inline void _reserve(StringRep*& rep, Uint32 cap)

{

if (cap > rep->cap || rep->refs.value() != 1)

if (cap > rep->cap || rep->refs.get() != 1)

{

size_t n = _roundUpToPow2(cap);

StringRep* newRep = StringRep::alloc(n);

Line 606

Line 577

size_t utf8_error_index;

rep->size = _convert((Uint16*)rep->data, data, size, utf8_error_index);

#ifndef PEGASUS_STRING_NO_THROW

if (rep->size == size_t(-1))

{

StringRep::free(rep);

_StringThrowBadUTF8(utf8_error_index);

_StringThrowBadUTF8((Uint32)utf8_error_index);

}

#endif

rep->data[rep->size] = '\0';

Line 628

Line 597

while (*end++)

;

return end - str - 1;

return (Uint32)(end - str - 1);

}

//==============================================================================

Line 697

Line 666

size_t utf8_error_index;

size_t tmp = _convert((Uint16*)_rep->data + n1, s2, n2, utf8_error_index);

#ifndef PEGASUS_STRING_NO_THROW

if (tmp == size_t(-1))

{

StringRep::free(_rep);

_rep = &StringRep::_emptyRep;

_StringThrowBadUTF8(utf8_error_index);

_StringThrowBadUTF8((Uint32)utf8_error_index);

}

#endif

_rep->size = n1 + tmp;

_rep->data[_rep->size] = '\0';

Line 719

Line 686

size_t utf8_error_index;

size_t tmp = _convert((Uint16*)_rep->data, s1, n1, utf8_error_index);

#ifndef PEGASUS_STRING_NO_THROW

if (tmp == size_t(-1))

{

StringRep::free(_rep);

_rep = &StringRep::_emptyRep;

_StringThrowBadUTF8(utf8_error_index);

_StringThrowBadUTF8((Uint32)utf8_error_index);

}

#endif

_rep->size = n2 + tmp;

_copy(_rep->data + n1, s2._rep->data, n2);

Line 748

Line 713

{

_checkNullPointer(str);

if (n > _rep->cap || _rep->refs.value() != 1)

if (n > _rep->cap || _rep->refs.get() != 1)

{

StringRep::unref(_rep);

_rep = StringRep::alloc(n);

Line 765

Line 730

{

_checkNullPointer(str);

if (n > _rep->cap || _rep->refs.value() != 1)

if (n > _rep->cap || _rep->refs.get() != 1)

{

StringRep::unref(_rep);

_rep = StringRep::alloc(n);

Line 774

Line 739

size_t utf8_error_index;

_rep->size = _convert(_rep->data, str, n, utf8_error_index);

#ifndef PEGASUS_STRING_NO_THROW

if (_rep->size == size_t(-1))

{

StringRep::free(_rep);

_rep = &StringRep::_emptyRep;

_StringThrowBadUTF8(utf8_error_index);

_StringThrowBadUTF8((Uint32)utf8_error_index);

}

#endif

_rep->data[_rep->size] = 0;

Line 792

Line 755

{

if (_rep->size)

{

if (_rep->refs.value() == 1)

if (_rep->refs.get() == 1)

{

_rep->size = 0;

_rep->data[0] = '\0';

Line 826

Line 789

str[_rep->size] = '\0';

return CString(str);

#else

Uint32 n = 3 * _rep->size;

Uint32 n = (Uint32)(3 * _rep->size);

char* str = (char*)operator new(n + 1);

size_t size = _copyToUTF8(str, _rep->data, _rep->size);

str[size] = '\0';

Line 840

Line 803

size_t oldSize = _rep->size;

size_t newSize = oldSize + n;

_reserve(_rep, newSize);

_reserve(_rep, (Uint32)newSize);

_copy(_rep->data + oldSize, (Uint16*)str, n);

_rep->size = newSize;

_rep->data[newSize] = '\0';

Line 850

Line 813

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

{

return append((Char16*)str._rep->data, str._rep->size);

return append((Char16*)(&(str._rep->data[0])), (Uint32)str._rep->size);

}

String& String::append(const char* str, Uint32 size)

Line 860

Line 823

size_t oldSize = _rep->size;

size_t cap = oldSize + size;

_reserve(_rep, cap);

_reserve(_rep, (Uint32)cap);

size_t utf8_error_index;

size_t tmp = _convert(

(Uint16*)_rep->data + oldSize, str, size, utf8_error_index);

#ifndef PEGASUS_STRING_NO_THROW

if (tmp == size_t(-1))

{

StringRep::free(_rep);

_rep = &StringRep::_emptyRep;

_StringThrowBadUTF8(utf8_error_index);

_StringThrowBadUTF8((Uint32)utf8_error_index);

}

#endif

_rep->size += tmp;

_rep->data[_rep->size] = '\0';

Line 883

Line 844

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

{

if (n == PEG_NOT_FOUND)

n = _rep->size - index;

n = (Uint32)(_rep->size - index);

_checkBounds(index + n, _rep->size);

if (_rep->refs.value() != 1)

if (_rep->refs.get() != 1)

_rep = StringRep::copyOnWrite(_rep);

assert(index + n <= _rep->size);

PEGASUS_ASSERT(index + n <= _rep->size);

size_t rem = _rep->size - (index + n);

Uint16* data = _rep->data;

Line 910

Line 871

if (index < _rep->size)

{

if (n == PEG_NOT_FOUND || n > _rep->size - index)

n = _rep->size - index;

n = (Uint32)(_rep->size - index);

return String((Char16*)_rep->data + index, n);

return String((Char16*)(_rep->data + index), n);

}

return String();

Line 923

Line 884

Uint16* p = (Uint16*)_find(_rep->data, _rep->size, c);

if (p)

return p - _rep->data;

return static_cast<Uint32>(p - _rep->data);

return PEG_NOT_FOUND;

}

Line 938

Line 899

Uint16* p = (Uint16*)_find(_rep->data + index, _rep->size - index, c);

if (p)

return p - _rep->data;

return static_cast<Uint32>(p - _rep->data);

return PEG_NOT_FOUND;

}

Line 959

Line 920

break;

if (memcmp(p, s, n * sizeof(Uint16)) == 0)

return p - _rep->data;

return static_cast<Uint32>(p - _rep->data);

p++;

rem -= p - data;

Line 987

Line 948

while (q != p)

{

if (*--q == x)

return q - p;

return static_cast<Uint32>(q - p);

}

return PEG_NOT_FOUND;

Line 999

Line 960

if (InitializeICU::initICUSuccessful())

{

if (_rep->refs.value() != 1)

if (_rep->refs.get() != 1)

_rep = StringRep::copyOnWrite(_rep);

// This will do a locale-insensitive, but context-sensitive convert.

Line 1034

Line 995

#endif /* PEGASUS_HAS_ICU */

if (_rep->refs.value() != 1)

if (_rep->refs.get() != 1)

_rep = StringRep::copyOnWrite(_rep);

Uint16* p = _rep->data;

Line 1053

Line 1014

if (InitializeICU::initICUSuccessful())

{

if (_rep->refs.value() != 1)

if (_rep->refs.get() != 1)

_rep = StringRep::copyOnWrite(_rep);

// This will do a locale-insensitive, but context-sensitive convert.

Line 1089

Line 1050

#endif /* PEGASUS_HAS_ICU */

if (_rep->refs.value() != 1)

if (_rep->refs.get() != 1)

_rep = StringRep::copyOnWrite(_rep);

Uint16* p = _rep->data;

Line 1101

Line 1062

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

{

assert(n <= s1._rep->size);

const Uint16* p1 = s1._rep->data;

assert(n <= s2._rep->size);

const Uint16* p2 = s2._rep->data;

// Ignoring error in which n is greater than s1.size() or s2.size()

while (n--)

return _compare(s1._rep->data, s2._rep->data, n);

{

int r = *p1++ - *p2++;

if (r)

{

return r;

}

else if (!p1[-1])

{

// We must have encountered a null terminator in both s1 and s2

return 0;

}

return 0;

}

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

Line 1132

Line 1105

if (InitializeICU::initICUSuccessful())

{

return u_strcasecmp(

str1._rep->data, str2._rep->data, U_FOLD_CASE_DEFAULT);

(const UChar*)str1._rep->data,

(const UChar*)str2._rep->data,

U_FOLD_CASE_DEFAULT

);

}

#endif /* PEGASUS_HAS_ICU */

Line 1257

Line 1233

Boolean String::equal(const String& s1, const String& s2)

{

return s1._rep->size == s2._rep->size && memcmp(s1._rep->data,

return (s1._rep == s2._rep) ||

s2._rep->data, s1._rep->size * sizeof(Uint16)) == 0;

(s1._rep->size == s2._rep->size) &&

memcmp(s1._rep->data,

s2._rep->data,

s1._rep->size * sizeof(Uint16)) == 0;

}

Boolean String::equal(const String& s1, const char* s2)

Line 1287

Line 1266

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

{

#if defined(PEGASUS_OS_OS400)

CString cstr = str.getCString();

const char* utf8str = cstr;

os << utf8str;

return os;

#else

#if defined(PEGASUS_HAS_ICU)

if (InitializeICU::initICUSuccessful())

Line 1330

Line 1301

}

return os;

#endif // PEGASUS_OS_OS400

}

void StringAppendCharAux(StringRep*& _rep)

Line 1353

Line 1323

_rep = tmp;

}

void AssignASCII(String& s, const char* str, Uint32 n)

{

class StringLayout

{

public:

StringRep* rep;

};

StringLayout* that = reinterpret_cast<StringLayout*>(&s);

_checkNullPointer(str);

if (n > that->rep->cap || that->rep->refs.get() != 1)

{

StringRep::unref(that->rep);

that->rep = StringRep::alloc(n);

}

_copy(that->rep->data, str, n);

that->rep->size = n;

that->rep->data[that->rep->size] = 0;

}

PEGASUS_NAMESPACE_END

Line 1481

Line 1474

This avoids slower UTF8 processing when not needed.

================================================================================

TO-DO:

(+) [DONE] Use PEGASUS_USE_EXPERIMENTAL_INTERFACES

(+) [DONE] Submit BUG-2754 (Windows buffer limit).

(+) [DONE] Eliminate char versions of find() and append().

(+) [DONE] Remove PEGASUS_MAX_PRINTABLE_CHARACTER from Config.h

(+) [DONE] Change _next_pow_2() to _roundUpToPow2().

(+) [DONE] Change '99' to '2' in StringRep constructor (comment as well).

(+) [DONE] Comment StringRep allocation layout.

(+) [DONE] Conceal private inline functions.

(+) [DONE] Shorten inclusion of StringInline.h in String.h.

(+) [DONE] Change USE_INTERNAL_INLINE TO DISABLE_INTERNAL_INLINE or get

rid of altogether.

(+) [DONE] useCamelNotationOnAllFunctionNames.

(+) [DONE] Check for overlow condition in StringRep::alloc().

(+) [DONE] Remove tabs (used vim ":set expandtab" and ":retab").

(+) [DONE] Fix throw-related memory leak.

(+) [DONE] Look at PEP223 for coding security guidelines.

(+) [DONE] Use old AtomicInt for now (new AtomicInt part of bug #4250).

(+) [DONE] Removed appendASCII() and the ASCII form of the constructor.

(+) DOC++ String.h - will open new bug?

(+) Added PEGASUS_DISABLE_INTERNAL_INLINES macro (to permit suppression

on certain platforms).

================================================================================

Legend:

Removed from v.1.112
changed lines
	Added in v.1.133

No CVS admin address has been configured