(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.115 and 1.129.2.1

version 1.115, 2005/11/27 03:11:36 version 1.129.2.1, 2007/11/08 09:15:06
Line 1 
Line 1 
 //%2005////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems. // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
Line 8 
Line 8 
 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
 // EMC Corporation; VERITAS Software Corporation; The Open Group. // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec 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 copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 27 
Line 29 
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Mike Brasher (mbrasher@austin.rr.com)  
 //  
 // 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 <Pegasus/Common/PegasusAssert.h> #include <Pegasus/Common/PegasusAssert.h>
Line 55 
Line 49 
 // //
 // Compile-time macros (undefined by default). // Compile-time macros (undefined by default).
 // //
 //     PEGASUS_STRING_NO_THROW -- suppresses throwing of exceptions  
 //  
 //     PEGASUS_STRING_NO_UTF8 -- don't generate slower UTF8 code. //     PEGASUS_STRING_NO_UTF8 -- don't generate slower UTF8 code.
 // //
 //============================================================================== //==============================================================================
Line 162 
Line 154 
 // Rounds x up to the nearest power of two (or just returns 8 if x < 8). // Rounds x up to the nearest power of two (or just returns 8 if x < 8).
 static Uint32 _roundUpToPow2(Uint32 x) 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)     if (x < 8)
         return 8;         return 8;
Line 298 
Line 286 
     return c1 - c2;     return c1 - c2;
 } }
  
 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) static inline void _copy(Uint16* s1, const Uint16* s2, size_t n)
 { {
     memcpy(s1, s2, n * sizeof(Uint16));     memcpy(s1, s2, n * sizeof(Uint16));
Line 320 
Line 298 
  
 inline void _checkNullPointer(const void* ptr) inline void _checkNullPointer(const void* ptr)
 { {
 #ifdef PEGASUS_STRING_NO_THROW  
   
     if (!ptr)     if (!ptr)
         throw NullPointer();         throw NullPointer();
   
 #endif  
 } }
  
 static void _StringThrowBadUTF8(Uint32 index) static void _StringThrowBadUTF8(Uint32 index)
Line 551 
Line 525 
  
 inline StringRep* StringRep::alloc(size_t cap) 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(     StringRep* rep = (StringRep*)::operator new(
         sizeof(StringRep) + cap * sizeof(Uint16));         sizeof(StringRep) + cap * sizeof(Uint16));
Line 607 
Line 576 
     size_t utf8_error_index;     size_t utf8_error_index;
     rep->size = _convert((Uint16*)rep->data, data, size, 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))     if (rep->size == size_t(-1))
     {     {
         StringRep::free(rep);         StringRep::free(rep);
         _StringThrowBadUTF8(utf8_error_index);          _StringThrowBadUTF8((Uint32)utf8_error_index);
     }     }
 #endif  
  
     rep->data[rep->size] = '\0';     rep->data[rep->size] = '\0';
  
Line 629 
Line 596 
     while (*end++)     while (*end++)
         ;         ;
  
     return end - str - 1;      return (Uint32)(end - str - 1);
 } }
  
 //============================================================================== //==============================================================================
Line 698 
Line 665 
     size_t utf8_error_index;     size_t utf8_error_index;
     size_t tmp = _convert((Uint16*)_rep->data + n1, s2, n2, 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))     if (tmp == size_t(-1))
     {     {
         StringRep::free(_rep);         StringRep::free(_rep);
         _rep = &StringRep::_emptyRep;         _rep = &StringRep::_emptyRep;
         _StringThrowBadUTF8(utf8_error_index);          _StringThrowBadUTF8((Uint32)utf8_error_index);
     }     }
 #endif  
  
     _rep->size = n1 + tmp;     _rep->size = n1 + tmp;
     _rep->data[_rep->size] = '\0';     _rep->data[_rep->size] = '\0';
Line 720 
Line 685 
     size_t utf8_error_index;     size_t utf8_error_index;
     size_t tmp = _convert((Uint16*)_rep->data, s1, n1, 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))     if (tmp ==  size_t(-1))
     {     {
         StringRep::free(_rep);         StringRep::free(_rep);
         _rep = &StringRep::_emptyRep;         _rep = &StringRep::_emptyRep;
         _StringThrowBadUTF8(utf8_error_index);          _StringThrowBadUTF8((Uint32)utf8_error_index);
     }     }
 #endif  
  
     _rep->size = n2 + tmp;     _rep->size = n2 + tmp;
     _copy(_rep->data + n1, s2._rep->data, n2);     _copy(_rep->data + n1, s2._rep->data, n2);
Line 775 
Line 738 
     size_t utf8_error_index;     size_t utf8_error_index;
     _rep->size = _convert(_rep->data, str, n, utf8_error_index);     _rep->size = _convert(_rep->data, str, n, utf8_error_index);
  
 #ifndef PEGASUS_STRING_NO_THROW  
     if (_rep->size ==  size_t(-1))     if (_rep->size ==  size_t(-1))
     {     {
         StringRep::free(_rep);         StringRep::free(_rep);
         _rep = &StringRep::_emptyRep;         _rep = &StringRep::_emptyRep;
         _StringThrowBadUTF8(utf8_error_index);          _StringThrowBadUTF8((Uint32)utf8_error_index);
     }     }
 #endif  
  
     _rep->data[_rep->size] = 0;     _rep->data[_rep->size] = 0;
  
Line 827 
Line 788 
     str[_rep->size] = '\0';     str[_rep->size] = '\0';
     return CString(str);     return CString(str);
 #else #else
     Uint32 n = 3 * _rep->size;      Uint32 n = (Uint32)(3 * _rep->size);
     char* str = (char*)operator new(n + 1);     char* str = (char*)operator new(n + 1);
     size_t size = _copyToUTF8(str, _rep->data, _rep->size);     size_t size = _copyToUTF8(str, _rep->data, _rep->size);
     str[size] = '\0';     str[size] = '\0';
Line 841 
Line 802 
  
     size_t oldSize = _rep->size;     size_t oldSize = _rep->size;
     size_t newSize = oldSize + n;     size_t newSize = oldSize + n;
     _reserve(_rep, newSize);      _reserve(_rep, (Uint32)newSize);
     _copy(_rep->data + oldSize, (Uint16*)str, n);     _copy(_rep->data + oldSize, (Uint16*)str, n);
     _rep->size = newSize;     _rep->size = newSize;
     _rep->data[newSize] = '\0';     _rep->data[newSize] = '\0';
Line 851 
Line 812 
  
 String& String::append(const String& str) 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) String& String::append(const char* str, Uint32 size)
Line 861 
Line 822 
     size_t oldSize = _rep->size;     size_t oldSize = _rep->size;
     size_t cap = oldSize + size;     size_t cap = oldSize + size;
  
     _reserve(_rep, cap);      _reserve(_rep, (Uint32)cap);
     size_t utf8_error_index;     size_t utf8_error_index;
     size_t tmp = _convert(     size_t tmp = _convert(
         (Uint16*)_rep->data + oldSize, str, size, utf8_error_index);         (Uint16*)_rep->data + oldSize, str, size, utf8_error_index);
  
 #ifndef PEGASUS_STRING_NO_THROW  
     if (tmp ==  size_t(-1))     if (tmp ==  size_t(-1))
     {     {
         StringRep::free(_rep);         StringRep::free(_rep);
         _rep = &StringRep::_emptyRep;         _rep = &StringRep::_emptyRep;
         _StringThrowBadUTF8(utf8_error_index);          _StringThrowBadUTF8((Uint32)utf8_error_index);
     }     }
 #endif  
  
     _rep->size += tmp;     _rep->size += tmp;
     _rep->data[_rep->size] = '\0';     _rep->data[_rep->size] = '\0';
Line 884 
Line 843 
 void String::remove(Uint32 index, Uint32 n) void String::remove(Uint32 index, Uint32 n)
 { {
     if (n == PEG_NOT_FOUND)     if (n == PEG_NOT_FOUND)
         n = _rep->size - index;          n = (Uint32)(_rep->size - index);
  
     _checkBounds(index + n, _rep->size);     _checkBounds(index + n, _rep->size);
  
Line 911 
Line 870 
     if (index < _rep->size)     if (index < _rep->size)
     {     {
         if (n == PEG_NOT_FOUND || n > _rep->size - index)         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();     return String();
Line 924 
Line 883 
     Uint16* p = (Uint16*)_find(_rep->data, _rep->size, c);     Uint16* p = (Uint16*)_find(_rep->data, _rep->size, c);
  
     if (p)     if (p)
         return p - _rep->data;          return static_cast<Uint32>(p - _rep->data);
  
     return PEG_NOT_FOUND;     return PEG_NOT_FOUND;
 } }
Line 939 
Line 898 
     Uint16* p = (Uint16*)_find(_rep->data + index, _rep->size - index, c);     Uint16* p = (Uint16*)_find(_rep->data + index, _rep->size - index, c);
  
     if (p)     if (p)
         return p - _rep->data;          return static_cast<Uint32>(p - _rep->data);
  
     return PEG_NOT_FOUND;     return PEG_NOT_FOUND;
 } }
Line 960 
Line 919 
             break;             break;
  
         if (memcmp(p, s, n * sizeof(Uint16)) == 0)         if (memcmp(p, s, n * sizeof(Uint16)) == 0)
             return p - _rep->data;              return static_cast<Uint32>(p - _rep->data);
  
         p++;         p++;
         rem -= p - data;         rem -= p - data;
Line 988 
Line 947 
     while (q != p)     while (q != p)
     {     {
         if (*--q == x)         if (*--q == x)
             return q - p;              return static_cast<Uint32>(q - p);
     }     }
  
     return PEG_NOT_FOUND;     return PEG_NOT_FOUND;
Line 1102 
Line 1061 
  
 int String::compare(const String& s1, const String& s2, Uint32 n) int String::compare(const String& s1, const String& s2, Uint32 n)
 { {
     PEGASUS_ASSERT(n <= s1._rep->size);      const Uint16* p1 = s1._rep->data;
     PEGASUS_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) int String::compare(const String& s1, const String& s2)
Line 1133 
Line 1104 
     if (InitializeICU::initICUSuccessful())     if (InitializeICU::initICUSuccessful())
     {     {
         return  u_strcasecmp(         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 */ #endif /* PEGASUS_HAS_ICU */
Line 1258 
Line 1232 
  
 Boolean String::equal(const String& s1, const String& s2) 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) Boolean String::equal(const String& s1, const char* s2)
Line 1288 
Line 1265 
  
 PEGASUS_STD(ostream)& operator<<(PEGASUS_STD(ostream)& os, const String& str) 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 defined(PEGASUS_HAS_ICU)
  
     if (InitializeICU::initICUSuccessful())     if (InitializeICU::initICUSuccessful())
Line 1331 
Line 1300 
     }     }
  
     return os;     return os;
 #endif // PEGASUS_OS_OS400  
 } }
  
 void StringAppendCharAux(StringRep*& _rep) void StringAppendCharAux(StringRep*& _rep)
Line 1354 
Line 1322 
     _rep = tmp;     _rep = tmp;
 } }
  
   void AssignASCII(String& s, const char* str, Uint32 n)
   {
       class StringLayout
       {
       public:
           StringRep* rep;
       };
   
       StringLayout* that = (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 PEGASUS_NAMESPACE_END
  
 /* /*
Line 1482 
Line 1473 
         This avoids slower UTF8 processing when not needed.         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.115  
changed lines
  Added in v.1.129.2.1
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2