Aren/haiku
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Cleanup.

Browse Source 
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@19731 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Axel Dörfler 2007-01-06 18:06:38 +00:00
parent 955dc88f0c
commit 43cca04a9a
2 changed files with 420 additions and 506 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

359
headers/os/support/String.h
View File

@ -1,191 +1,153 @@
//------------------------------------------------------------------------------ /*
// Copyright (c) 2001-2003, OpenBeOS * Copyright 2001-2007, Haiku Inc. All Rights Reserved.
// * Distributed under the terms of the MIT License.
// Permission is hereby granted, free of charge, to any person obtaining a */
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "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.
//
// File Name: String.h
// Author(s): Stefano Ceccherini (burton666@libero.it)
// Description: String class supporting common string operations.
//------------------------------------------------------------------------------
#ifndef __BSTRING__ #ifndef __BSTRING__
#define __BSTRING__ #define __BSTRING__
#include <BeBuild.h> #include <BeBuild.h>
#include <SupportDefs.h> #include <SupportDefs.h>
#include <string.h> #include <string.h>
class BString { class BString {
public: public:
BString(); BString();
BString(const char *); BString(const char* string);
BString(const BString &); BString(const BString& string);
BString(const char *, int32 maxLength); BString(const char* string, int32 maxLength);
~BString(); ~BString();
/*---- Access --------------------------------------------------------------*/ // Access
const char* String() const; const char* String() const;
/* returns null-terminated string */
int32 Length() const; int32 Length() const;
/* length of corresponding string */ // length of corresponding string
int32 CountChars() const; int32 CountChars() const;
/* returns number of UTF8 characters in string */ // returns number of UTF8 characters in string
/*---- Assignment ----------------------------------------------------------*/
BString &operator=(const BString &);
BString &operator=(const char *);
BString &operator=(char);
BString &SetTo(const char *); // Assignment
BString &SetTo(const char *, int32 length); BString& operator=(const BString& string);
BString& operator=(const char* string);
BString& operator=(char c);
BString &SetTo(const BString &from); BString& SetTo(const char* string);
BString& SetTo(const char* string, int32 maxLength);
BString& SetTo(const BString& string);
BString& Adopt(BString& from); BString& Adopt(BString& from);
/* leaves <from> empty, avoiding a copy */
BString &SetTo(const BString &, int32 length); BString& SetTo(const BString& string, int32 maxLength);
BString &Adopt(BString &from, int32 length); BString& Adopt(BString& from, int32 maxLength);
/* leaves <from> empty, avoiding a copy */
BString &SetTo(char, int32 count); BString& SetTo(char c, int32 count);
/*---- Substring copying ---------------------------------------------------*/ // Substring copying
BString& CopyInto(BString& into, int32 fromOffset, BString& CopyInto(BString& into, int32 fromOffset,
int32 length) const; int32 length) const;
/* returns <into> ref as it's result; doesn't do
* anything if <into> is <this>
*/
void CopyInto(char* into, int32 fromOffset, void CopyInto(char* into, int32 fromOffset,
int32 length) const; int32 length) const;
/* caller guarantees that <into> is large enough */
/*---- Appending -----------------------------------------------------------*/ // Appending
BString &operator+=(const BString &); BString& operator+=(const BString& string);
BString &operator+=(const char *); BString& operator+=(const char* string);
BString &operator+=(char); BString& operator+=(char c);
BString &Append(const BString &); BString& Append(const BString& string);
BString &Append(const char *); BString& Append(const char* string);
BString &Append(const BString &, int32 length); BString& Append(const BString& string, int32 length);
BString &Append(const char *, int32 length); BString& Append(const char* string, int32 length);
BString &Append(char, int32 count); BString& Append(char c, int32 count);
/*---- Prepending ----------------------------------------------------------*/ // Prepending
BString &Prepend(const char *); BString& Prepend(const char* string);
BString &Prepend(const BString &); BString& Prepend(const BString& string);
BString &Prepend(const char *, int32); BString& Prepend(const char* string, int32 length);
BString &Prepend(const BString &, int32); BString& Prepend(const BString& string, int32 length);
BString &Prepend(char, int32 count); BString& Prepend(char c, int32 count);
/*---- Inserting ----------------------------------------------------------*/ // Inserting
BString &Insert(const char *, int32 pos); BString& Insert(const char* string, int32 pos);
BString &Insert(const char *, int32 length, int32 pos); BString& Insert(const char* string, int32 length, int32 pos);
BString &Insert(const char *, int32 fromOffset, BString& Insert(const char* string, int32 fromOffset,
int32 length, int32 pos); int32 length, int32 pos);
BString &Insert(const BString &, int32 pos); BString& Insert(const BString& string, int32 pos);
BString &Insert(const BString &, int32 length, int32 pos); BString& Insert(const BString& string, int32 length, int32 pos);
BString &Insert(const BString &, int32 fromOffset, BString& Insert(const BString& string, int32 fromOffset,
int32 length, int32 pos); int32 length, int32 pos);
BString& Insert(char, int32 count, int32 pos); BString& Insert(char, int32 count, int32 pos);
/*---- Removing -----------------------------------------------------------*/ // Removing
BString& Truncate(int32 newLength, bool lazy = true); BString& Truncate(int32 newLength, bool lazy = true);
/* pass false in <lazy> to ensure freeing up the
* truncated memory
*/
BString& Remove(int32 from, int32 length); BString& Remove(int32 from, int32 length);
BString &RemoveFirst(const BString &); BString& RemoveFirst(const BString& string);
BString &RemoveLast(const BString &); BString& RemoveLast(const BString& string);
BString &RemoveAll(const BString &); BString& RemoveAll(const BString& string);
BString &RemoveFirst(const char *); BString& RemoveFirst(const char* string);
BString &RemoveLast(const char *); BString& RemoveLast(const char* string);
BString &RemoveAll(const char *); BString& RemoveAll(const char* string);
BString& RemoveSet(const char* setOfCharsToRemove); BString& RemoveSet(const char* setOfCharsToRemove);
BString& MoveInto(BString& into, int32 from, int32 length); BString& MoveInto(BString& into, int32 from, int32 length);
void MoveInto(char* into, int32 from, int32 length); void MoveInto(char* into, int32 from, int32 length);
/* caller guarantees that <into> is large enough */
// Compare functions
bool operator<(const BString& string) const;
bool operator<=(const BString& string) const;
bool operator==(const BString& string) const;
bool operator>=(const BString& string) const;
bool operator>(const BString& string) const;
bool operator!=(const BString& string) const;
/*---- Compare functions ---------------------------------------------------*/ bool operator<(const char* string) const;
bool operator<(const BString &) const; bool operator<=(const char* string) const;
bool operator<=(const BString &) const; bool operator==(const char* string) const;
bool operator==(const BString &) const; bool operator>=(const char* string) const;
bool operator>=(const BString &) const; bool operator>(const char* string) const;
bool operator>(const BString &) const; bool operator!=(const char* string) const;
bool operator!=(const BString &) const;
bool operator<(const char *) const; // strcmp()-style compare functions
bool operator<=(const char *) const; int Compare(const BString& string) const;
bool operator==(const char *) const; int Compare(const char* string) const;
bool operator>=(const char *) const; int Compare(const BString& string, int32 length) const;
bool operator>(const char *) const; int Compare(const char* string, int32 length) const;
bool operator!=(const char *) const; int ICompare(const BString& string) const;
int ICompare(const char* string) const;
int ICompare(const BString& string, int32 length) const;
int ICompare(const char* string, int32 length) const;
/*---- strcmp-style compare functions --------------------------------------*/ // Searching
int Compare(const BString &) const; int32 FindFirst(const BString& string) const;
int Compare(const char *) const; int32 FindFirst(const char* string) const;
int Compare(const BString &, int32 n) const; int32 FindFirst(const BString& string, int32 fromOffset) const;
int Compare(const char *, int32 n) const; int32 FindFirst(const char* string, int32 fromOffset) const;
int ICompare(const BString &) const; int32 FindFirst(char c) const;
int ICompare(const char *) const; int32 FindFirst(char c, int32 fromOffset) const;
int ICompare(const BString &, int32 n) const;
int ICompare(const char *, int32 n) const;
/*---- Searching -----------------------------------------------------------*/ int32 FindLast(const BString& string) const;
int32 FindFirst(const BString &) const; int32 FindLast(const char* string) const;
int32 FindFirst(const char *) const; int32 FindLast(const BString& string, int32 beforeOffset) const;
int32 FindFirst(const BString &, int32 fromOffset) const; int32 FindLast(const char* string, int32 beforeOffset) const;
int32 FindFirst(const char *, int32 fromOffset) const; int32 FindLast(char c) const;
int32 FindFirst(char) const; int32 FindLast(char c, int32 beforeOffset) const;
int32 FindFirst(char, int32 fromOffset) const;
int32 FindLast(const BString &) const; int32 IFindFirst(const BString& string) const;
int32 FindLast(const char *) const; int32 IFindFirst(const char* string) const;
int32 FindLast(const BString &, int32 beforeOffset) const; int32 IFindFirst(const BString& string, int32 fromOffset) const;
int32 FindLast(const char *, int32 beforeOffset) const; int32 IFindFirst(const char* string, int32 fromOffset) const;
int32 FindLast(char) const;
int32 FindLast(char, int32 beforeOffset) const;
int32 IFindFirst(const BString &) const; int32 IFindLast(const BString& string) const;
int32 IFindFirst(const char *) const; int32 IFindLast(const char* string) const;
int32 IFindFirst(const BString &, int32 fromOffset) const; int32 IFindLast(const BString& string, int32 beforeOffset) const;
int32 IFindFirst(const char *, int32 fromOffset) const; int32 IFindLast(const char* string, int32 beforeOffset) const;
int32 IFindLast(const BString &) const;
int32 IFindLast(const char *) const;
int32 IFindLast(const BString &, int32 beforeOffset) const;
int32 IFindLast(const char *, int32 beforeOffset) const;
/*---- Replacing -----------------------------------------------------------*/
// Replacing
BString& ReplaceFirst(char replaceThis, char withThis); BString& ReplaceFirst(char replaceThis, char withThis);
BString& ReplaceLast(char replaceThis, char withThis); BString& ReplaceLast(char replaceThis, char withThis);
BString& ReplaceAll(char replaceThis, char withThis, BString& ReplaceAll(char replaceThis, char withThis,
@ -218,81 +180,47 @@ public:
BString& ReplaceSet(const char* setOfChars, char with); BString& ReplaceSet(const char* setOfChars, char with);
BString& ReplaceSet(const char* setOfChars, const char *with); BString& ReplaceSet(const char* setOfChars, const char *with);
/*---- Unchecked char access -----------------------------------------------*/
// Unchecked char access
char operator[](int32 index) const; char operator[](int32 index) const;
char& operator[](int32 index); char& operator[](int32 index);
/*---- Checked char access -------------------------------------------------*/ // Checked char access
char ByteAt(int32 index) const; char ByteAt(int32 index) const;
/*---- Fast low-level manipulation -----------------------------------------*/ // Fast low-level manipulation
char* LockBuffer(int32 maxLength); char* LockBuffer(int32 maxLength);
/* Make room for characters to be added by C-string like manipulation.
* Returns the equivalent of String(), <maxLength> includes space for
* trailing zero while used as C-string, it is illegal to call other
* BString routines that rely on data/length consistency until
* UnlockBuffer sets things up again.
*/
BString& UnlockBuffer(int32 length = -1); BString& UnlockBuffer(int32 length = -1);
/* Finish using BString as C-string, adjusting length. If no length // Upercase <-> Lowercase
* passed in, strlen of internal data is used to determine it.
* BString is in consistent state after this.
*/
/*---- Upercase<->Lowercase ------------------------------------------------*/
BString& ToLower(); BString& ToLower();
BString& ToUpper(); BString& ToUpper();
BString& Capitalize(); BString& Capitalize();
/* Converts first character to upper-case, rest to
* lower-case
*/
BString& CapitalizeEachWord(); BString& CapitalizeEachWord();
/* Converts first character in each
* non-alphabethycal-character-separated // Escaping and De-escaping
* word to upper-case, rest to lower-case
*/
/*----- Escaping and Deescaping --------------------------------------------*/
BString& CharacterEscape(const char* original, BString& CharacterEscape(const char* original,
const char* setOfCharsToEscape, char escapeWith); const char* setOfCharsToEscape, char escapeWith);
/* copies original into <this>, escaping characters
* specified in <setOfCharsToEscape> by prepending
* them with <escapeWith>
*/
BString& CharacterEscape(const char* setOfCharsToEscape, BString& CharacterEscape(const char* setOfCharsToEscape,
char escapeWith); char escapeWith);
/* escapes characters specified in <setOfCharsToEscape>
* by prepending them with <escapeWith>
*/
BString& CharacterDeescape(const char* original, char escapeChar); BString& CharacterDeescape(const char* original, char escapeChar);
/* copy <original> into the string removing the escaping
* characters <escapeChar>
*/
BString& CharacterDeescape(char escapeChar); BString& CharacterDeescape(char escapeChar);
/* remove the escaping characters <escapeChar> from
* the string
*/
/*---- Simple sprintf replacement calls ------------------------------------*/ // Slower than sprintf() but type and overflow safe
/*---- Slower than sprintf but type and overflow safe ----------------------*/ BString& operator<<(const char* string);
BString &operator<<(const char *); BString& operator<<(const BString& string);
BString &operator<<(const BString &); BString& operator<<(char c);
BString &operator<<(char); BString& operator<<(int value);
BString &operator<<(int); BString& operator<<(unsigned int value);
BString &operator<<(unsigned int); BString& operator<<(uint32 value);
BString &operator<<(uint32); BString& operator<<(int32 value);
BString &operator<<(int32); BString& operator<<(uint64 value);
BString &operator<<(uint64); BString& operator<<(int64 value);
BString &operator<<(int64); BString& operator<<(float value);
BString &operator<<(float); // float output hardcodes %.2f style formatting
/* float output hardcodes %.2f style formatting */
/*----- Private or reserved ------------------------------------------------*/
private: private:
void _Init(const char *, int32); void _Init(const char *, int32);
void _DoAssign(const char *, int32); void _DoAssign(const char *, int32);
@ -319,42 +247,35 @@ private:
void _AssertNotUsingAsCString() const {} void _AssertNotUsingAsCString() const {}
#endif #endif
char *_Alloc( int32); char* _Alloc(int32 size);
struct PosVect; class PosVect;
void _ReplaceAtPositions(const PosVect* positions, void _ReplaceAtPositions(const PosVect* positions,
int32 searchLen, int32 searchLength, const char* with, int32 withLen);
const char* with,
int32 withLen);
protected: protected:
char *_privateData; char* fPrivateData;
}; };
/*----- Comutative compare operators --------------------------------------*/ // Commutative compare operators
bool operator<(const char *, const BString &); bool operator<(const char* a, const BString& b);
bool operator<=(const char *, const BString &); bool operator<=(const char* a, const BString& b);
bool operator==(const char *, const BString &); bool operator==(const char* a, const BString& b);
bool operator>(const char *, const BString &); bool operator>(const char* a, const BString& b);
bool operator>=(const char *, const BString &); bool operator>=(const char* a, const BString& b);
bool operator!=(const char *, const BString &); bool operator!=(const char* a, const BString& b);
/*----- Non-member compare for sorting, etc. ------------------------------*/ // Non-member compare for sorting, etc.
int Compare(const BString &, const BString &); int Compare(const BString& a, const BString& b);
int ICompare(const BString &, const BString &); int ICompare(const BString& a, const BString& b);
int Compare(const BString *, const BString *); int Compare(const BString* a, const BString* b);
int ICompare(const BString *, const BString *); int ICompare(const BString* a, const BString* b);
/*-------------------------------------------------------------------------*/
/*---- No user serviceable parts after this -------------------------------*/
inline int32 inline int32
BString::Length() const BString::Length() const
{ {
return _privateData ? (*((int32 *)_privateData - 1) & 0x7fffffff) : 0; return fPrivateData ? (*((int32 *)fPrivateData - 1) & 0x7fffffff) : 0;
/* the most significant bit is reserved; accessing /* the most significant bit is reserved; accessing
* it in any way will cause the computer to explode * it in any way will cause the computer to explode
*/ */
@ -363,29 +284,29 @@ BString::Length() const
inline const char * inline const char *
BString::String() const BString::String() const
{ {
if (!_privateData) if (!fPrivateData)
return ""; return "";
return _privateData; return fPrivateData;
} }
inline BString & inline BString &
BString::SetTo(const char *str) BString::SetTo(const char *string)
{ {
return operator=(str); return operator=(string);
} }
inline char inline char
BString::operator[](int32 index) const BString::operator[](int32 index) const
{ {
return _privateData[index]; return fPrivateData[index];
} }
inline char inline char
BString::ByteAt(int32 index) const BString::ByteAt(int32 index) const
{ {
if (!_privateData || index < 0 || index > Length()) if (!fPrivateData || index < 0 || index > Length())
return 0; return 0;
return _privateData[index]; return fPrivateData[index];
} }
inline BString & inline BString &

399
src/kits/support/String.cpp
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2001-2006, Haiku, Inc. All Rights Reserved. * Copyright 2001-2007, Haiku, Inc. All Rights Reserved.
* Distributed under the terms of the MIT License. * Distributed under the terms of the MIT License.
* *
* Authors: * Authors:
@ -31,86 +31,6 @@
#define REPLACE_ALL 0x7FFFFFFF #define REPLACE_ALL 0x7FFFFFFF
const char *B_EMPTY_STRING = "";
// helper function, returns minimum of two given values (but clamps to 0):
static inline int32
min_clamp0(int32 num1, int32 num2)
{
if (num1 < num2)
return num1 > 0 ? num1 : 0;
return num2 > 0 ? num2 : 0;
}
// helper function, returns length of given string (but clamps to given maximum):
static inline int32
strlen_clamp(const char* str, int32 max)
{ // this should yield 0 for max<0:
int32 len=0;
while( len<max && *str++)
len++;
return len;
}
// helper function, massages given pointer into a legal c-string:
static inline const char *
safestr(const char* str)
{
return str ? str : "";
}
// helper class for BString::_ReplaceAtPositions():
struct
BString::PosVect {
PosVect()
:
size(0),
bufSize(20),
buf(NULL)
{
}
~PosVect()
{
free(buf);
}
bool Add(int32 pos)
{
if (!buf || size == bufSize) {
if (buf)
bufSize *= 2;
int32 *newBuf = (int32 *)realloc(buf, bufSize * sizeof(int32));
if (!newBuf)
return false;
buf = newBuf;
}
buf[size++] = pos;
return true;
}
inline int32 ItemAt(int32 idx) const
{
return buf[idx];
}
inline int32 CountItems() const
{
return size;
}
private:
int32 size;
int32 bufSize;
int32 *buf;
};
// helper macro that is used to fall into debugger if a given param check fails: // helper macro that is used to fall into debugger if a given param check fails:
#ifdef DEBUG #ifdef DEBUG
#define CHECK_PARAM( expr, msg) \ #define CHECK_PARAM( expr, msg) \
@ -137,65 +57,147 @@ private:
#endif #endif
//! helper class for BString::_ReplaceAtPositions():
class BString::PosVect {
public:
PosVect();
~PosVect();
bool Add(int32 pos);
inline int32 ItemAt(int32 index) const
{ return fBuffer[index]; }
inline int32 CountItems() const
{ return fSize; }
private:
int32 fSize;
int32 fBufferSize;
int32* fBuffer;
};
const char *B_EMPTY_STRING = "";
// helper function, returns minimum of two given values (but clamps to 0):
static inline int32
min_clamp0(int32 num1, int32 num2)
{
if (num1 < num2)
return num1 > 0 ? num1 : 0;
return num2 > 0 ? num2 : 0;
}
//! helper function, returns length of given string (but clamps to given maximum):
static inline int32
strlen_clamp(const char* str, int32 max)
{
// this should yield 0 for max<0:
int32 length = 0;
while (length < max && *str++) {
length++;
}
return length;
}
//! helper function, massages given pointer into a legal c-string:
static inline const char *
safestr(const char* str)
{
return str ? str : "";
}
// #pragma mark - // #pragma mark -
BString::PosVect::PosVect()
:
fSize(0),
fBufferSize(20),
fBuffer(NULL)
{
}
BString::PosVect::~PosVect()
{
free(fBuffer);
}
bool
BString::PosVect::Add(int32 pos)
{
if (fBuffer == NULL || fSize == fBufferSize) {
if (fBuffer != NULL)
fBufferSize *= 2;
int32* newBuffer = (int32 *)realloc(fBuffer, fBufferSize * sizeof(int32));
if (newBuffer == NULL)
return false;
fBuffer = newBuffer;
}
fBuffer[fSize++] = pos;
return true;
}
// #pragma mark - BString
// constructor
BString::BString() BString::BString()
: _privateData(NULL) : fPrivateData(NULL)
{ {
} }
// constructor BString::BString(const char* string)
BString::BString(const char* str) : fPrivateData(NULL)
: _privateData(NULL)
{ {
if (str != NULL) if (string != NULL)
_Init(str, strlen(str)); _Init(string, strlen(string));
} }
// copy constructor
BString::BString(const BString &string) BString::BString(const BString &string)
: _privateData(NULL) : fPrivateData(NULL)
{ {
_Init(string.String(), string.Length()); _Init(string.String(), string.Length());
} }
// constructor BString::BString(const char *string, int32 maxLength)
BString::BString(const char *str, int32 maxLength) : fPrivateData(NULL)
: _privateData(NULL)
{ {
if (str != NULL) if (string != NULL)
_Init(str, strlen_clamp(str, maxLength)); _Init(string, strlen_clamp(string, maxLength));
} }
// destructor
BString::~BString() BString::~BString()
{ {
if (_privateData) if (fPrivateData)
free(_privateData - sizeof(int32)); free(fPrivateData - sizeof(int32));
} }
/*---- Access --------------------------------------------------------------*/ // #pragma mark - Access
// String, implemented inline in the header
// Length, implemented inline in the header
// CountChars
int32 int32
BString::CountChars() const BString::CountChars() const
{ {
int32 count = 0; int32 count = 0;
const char *start = _privateData; const char *start = fPrivateData;
const char *end = _privateData + Length(); const char *end = fPrivateData + Length();
while (start++ != end) { while (start++ != end) {
count++; count++;
@ -208,8 +210,9 @@ BString::CountChars() const
} }
/*---- Assignment ----------------------------------------------------------*/ // #pragma mark - Assignment
// equal operator
BString& BString&
BString::operator=(const BString &string) BString::operator=(const BString &string)
{ {
@ -219,7 +222,6 @@ BString::operator=(const BString &string)
} }
// equal operator
BString& BString&
BString::operator=(const char *str) BString::operator=(const char *str)
{ {
@ -232,7 +234,6 @@ BString::operator=(const char *str)
} }
// equal operator
BString& BString&
BString::operator=(char c) BString::operator=(char c)
{ {
@ -241,7 +242,6 @@ BString::operator=(char c)
} }
// SetTo
BString& BString&
BString::SetTo(const char *str, int32 maxLength) BString::SetTo(const char *str, int32 maxLength)
{ {
@ -254,17 +254,17 @@ BString::SetTo(const char *str, int32 maxLength)
} }
// SetTo
BString& BString&
BString::SetTo(const BString &from) BString::SetTo(const BString &from)
{ {
if (&from != this) // Avoid auto-assignment if (&from != this) {
// Avoid auto-assignment
_DoAssign(from.String(), from.Length()); _DoAssign(from.String(), from.Length());
}
return *this; return *this;
} }
// Adopt
BString& BString&
BString::Adopt(BString &from) BString::Adopt(BString &from)
{ {
@ -273,18 +273,17 @@ BString::Adopt(BString &from)
return *this; return *this;
} }
if (_privateData) if (fPrivateData)
free(_privateData - sizeof(int32)); free(fPrivateData - sizeof(int32));
/* "steal" the data from the given BString */ /* "steal" the data from the given BString */
_privateData = from._privateData; fPrivateData = from.fPrivateData;
from._privateData = NULL; from.fPrivateData = NULL;
return *this; return *this;
} }
// SetTo
BString& BString&
BString::SetTo(const BString &string, int32 length) BString::SetTo(const BString &string, int32 length)
{ {
@ -294,7 +293,6 @@ BString::SetTo(const BString &string, int32 length)
} }
// Adopt
BString& BString&
BString::Adopt(BString &from, int32 length) BString::Adopt(BString &from, int32 length)
{ {
@ -303,12 +301,12 @@ BString::Adopt(BString &from, int32 length)
int32 len = min_clamp0(length, from.Length()); int32 len = min_clamp0(length, from.Length());
if (_privateData) if (fPrivateData)
free(_privateData - sizeof(int32)); free(fPrivateData - sizeof(int32));
/* "steal" the data from the given BString */ /* "steal" the data from the given BString */
_privateData = from._privateData; fPrivateData = from.fPrivateData;
from._privateData = NULL; from.fPrivateData = NULL;
if (len < Length()) if (len < Length())
_Alloc(len); _Alloc(len);
@ -317,7 +315,6 @@ BString::Adopt(BString &from, int32 length)
} }
// SetTo
BString& BString&
BString::SetTo(char c, int32 count) BString::SetTo(char c, int32 count)
{ {
@ -326,14 +323,14 @@ BString::SetTo(char c, int32 count)
int32 curLen = Length(); int32 curLen = Length();
if (curLen == count || _GrowBy(count - curLen)) if (curLen == count || _GrowBy(count - curLen))
memset(_privateData, c, count); memset(fPrivateData, c, count);
return *this; return *this;
} }
/*---- Substring copying ---------------------------------------------------*/ // #pragma mark - Substring copying
// CopyInto
BString & BString &
BString::CopyInto(BString &into, int32 fromOffset, int32 length) const BString::CopyInto(BString &into, int32 fromOffset, int32 length) const
{ {
@ -348,7 +345,6 @@ BString::CopyInto(BString &into, int32 fromOffset, int32 length) const
} }
// CopyInto
void void
BString::CopyInto(char *into, int32 fromOffset, int32 length) const BString::CopyInto(char *into, int32 fromOffset, int32 length) const
{ {
@ -356,13 +352,14 @@ BString::CopyInto(char *into, int32 fromOffset, int32 length) const
CHECK_PARAM_VOID(fromOffset >= 0, "'fromOffset' must not be negative!"); CHECK_PARAM_VOID(fromOffset >= 0, "'fromOffset' must not be negative!");
CHECK_PARAM_VOID(fromOffset <= Length(), "'fromOffset' exceeds length!"); CHECK_PARAM_VOID(fromOffset <= Length(), "'fromOffset' exceeds length!");
int32 len = min_clamp0(length, Length() - fromOffset); int32 len = min_clamp0(length, Length() - fromOffset);
memcpy(into, _privateData + fromOffset, len); memcpy(into, fPrivateData + fromOffset, len);
} }
} }
/*---- Appending -----------------------------------------------------------*/ // #pragma mark - Appending
// plus operator
BString& BString&
BString::operator+=(const char *str) BString::operator+=(const char *str)
{ {
@ -372,7 +369,6 @@ BString::operator+=(const char *str)
} }
// plus operator
BString& BString&
BString::operator+=(char c) BString::operator+=(char c)
{ {
@ -381,7 +377,6 @@ BString::operator+=(char c)
} }
// Append
BString& BString&
BString::Append(const BString &string, int32 length) BString::Append(const BString &string, int32 length)
{ {
@ -390,7 +385,6 @@ BString::Append(const BString &string, int32 length)
} }
// Append
BString& BString&
BString::Append(const char *str, int32 length) BString::Append(const char *str, int32 length)
{ {
@ -402,13 +396,12 @@ BString::Append(const char *str, int32 length)
} }
// Append
BString& BString&
BString::Append(char c, int32 count) BString::Append(char c, int32 count)
{ {
int32 len = Length(); int32 len = Length();
if (count > 0 && _GrowBy(count)) if (count > 0 && _GrowBy(count))
memset(_privateData + len, c, count); memset(fPrivateData + len, c, count);
return *this; return *this;
} }
@ -463,7 +456,7 @@ BString&
BString::Prepend(char c, int32 count) BString::Prepend(char c, int32 count)
{ {
if (count > 0 && _OpenAtBy(0, count)) if (count > 0 && _OpenAtBy(0, count))
memset(_privateData, c, count); memset(fPrivateData, c, count);
return *this; return *this;
} }
@ -486,7 +479,7 @@ BString::Insert(const char *str, int32 pos)
} else } else
pos = min_clamp0(pos, Length()); pos = min_clamp0(pos, Length());
if (_OpenAtBy(pos, len)) if (_OpenAtBy(pos, len))
memcpy(_privateData + pos, str, len); memcpy(fPrivateData + pos, str, len);
} }
return *this; return *this;
} }
@ -507,7 +500,7 @@ BString::Insert(const char *str, int32 length, int32 pos)
} else } else
pos = min_clamp0(pos, Length()); pos = min_clamp0(pos, Length());
if (_OpenAtBy(pos, len)) if (_OpenAtBy(pos, len))
memcpy(_privateData + pos, str, len); memcpy(fPrivateData + pos, str, len);
} }
return *this; return *this;
} }
@ -566,7 +559,7 @@ BString::Insert(char c, int32 count, int32 pos)
pos = min_clamp0(pos, Length()); pos = min_clamp0(pos, Length());
if (count > 0 && _OpenAtBy(pos, count)) if (count > 0 && _OpenAtBy(pos, count))
memset(_privateData + pos, c, count); memset(fPrivateData + pos, c, count);
return *this; return *this;
} }
@ -587,7 +580,7 @@ BString::Truncate(int32 newLength, bool lazy)
if (lazy) { if (lazy) {
// don't free memory yet, just set new length // don't free memory yet, just set new length
_SetLength(newLength); _SetLength(newLength);
_privateData[newLength] = '\0'; fPrivateData[newLength] = '\0';
} else } else
_Alloc(newLength); _Alloc(newLength);
} }
@ -699,8 +692,8 @@ BString::MoveInto(BString &into, int32 from, int32 length)
if (&into == this) { if (&into == this) {
/* TODO: [zooey]: to be activated later (>R1): /* TODO: [zooey]: to be activated later (>R1):
// strings are identical, just move the data: // strings are identical, just move the data:
if (from>0 && _privateData) if (from>0 && fPrivateData)
memmove( _privateData, _privateData+from, len); memmove( fPrivateData, fPrivateData+from, len);
Truncate( len); Truncate( len);
*/ */
return *this; return *this;
@ -1088,7 +1081,7 @@ BString::ReplaceFirst(char replaceThis, char withThis)
{ {
int32 pos = FindFirst(replaceThis); int32 pos = FindFirst(replaceThis);
if (pos >= 0) if (pos >= 0)
_privateData[pos] = withThis; fPrivateData[pos] = withThis;
return *this; return *this;
} }
@ -1099,7 +1092,7 @@ BString::ReplaceLast(char replaceThis, char withThis)
{ {
int32 pos = FindLast(replaceThis); int32 pos = FindLast(replaceThis);
if (pos >= 0) if (pos >= 0)
_privateData[pos] = withThis; fPrivateData[pos] = withThis;
return *this; return *this;
} }
@ -1113,7 +1106,7 @@ BString::ReplaceAll(char replaceThis, char withThis, int32 fromOffset)
pos = FindFirst(replaceThis, pos); pos = FindFirst(replaceThis, pos);
if (pos < 0) if (pos < 0)
break; break;
_privateData[pos] = withThis; fPrivateData[pos] = withThis;
} }
return *this; return *this;
@ -1130,7 +1123,7 @@ BString::Replace(char replaceThis, char withThis, int32 maxReplaceCount, int32 f
pos = FindFirst(replaceThis, pos); pos = FindFirst(replaceThis, pos);
if (pos < 0) if (pos < 0)
break; break;
_privateData[pos] = withThis; fPrivateData[pos] = withThis;
} }
} }
return *this; return *this;
@ -1164,7 +1157,7 @@ BString::ReplaceLast(const char *replaceThis, const char *withThis)
if (!_ShrinkAtBy(pos, -difference)) if (!_ShrinkAtBy(pos, -difference))
return *this; return *this;
} }
memcpy(_privateData + pos, withThis, len); memcpy(fPrivateData + pos, withThis, len);
} }
return *this; return *this;
@ -1196,7 +1189,7 @@ BString::IReplaceFirst(char replaceThis, char withThis)
int32 pos = _IFindAfter(tmp, 0, 1); int32 pos = _IFindAfter(tmp, 0, 1);
if (pos >= 0) if (pos >= 0)
_privateData[pos] = withThis; fPrivateData[pos] = withThis;
return *this; return *this;
} }
@ -1209,7 +1202,7 @@ BString::IReplaceLast(char replaceThis, char withThis)
int32 pos = _IFindBefore(tmp, Length(), 1); int32 pos = _IFindBefore(tmp, Length(), 1);
if (pos >= 0) if (pos >= 0)
_privateData[pos] = withThis; fPrivateData[pos] = withThis;
return *this; return *this;
} }
@ -1226,7 +1219,7 @@ BString::IReplaceAll(char replaceThis, char withThis, int32 fromOffset)
pos = _IFindAfter(tmp, pos, 1); pos = _IFindAfter(tmp, pos, 1);
if (pos < 0) if (pos < 0)
break; break;
_privateData[pos] = withThis; fPrivateData[pos] = withThis;
} }
return *this; return *this;
} }
@ -1239,7 +1232,7 @@ BString::IReplace(char replaceThis, char withThis, int32 maxReplaceCount, int32
char tmp[2] = { replaceThis, '\0' }; char tmp[2] = { replaceThis, '\0' };
if (_privateData == NULL) if (fPrivateData == NULL)
return *this; return *this;
for (int32 pos = min_clamp0(fromOffset,Length()); for (int32 pos = min_clamp0(fromOffset,Length());
@ -1247,7 +1240,7 @@ BString::IReplace(char replaceThis, char withThis, int32 maxReplaceCount, int32
pos = _IFindAfter(tmp, pos, 1); pos = _IFindAfter(tmp, pos, 1);
if (pos < 0) if (pos < 0)
break; break;
_privateData[pos] = withThis; fPrivateData[pos] = withThis;
} }
return *this; return *this;
} }
@ -1280,7 +1273,7 @@ BString::IReplaceLast(const char *replaceThis, const char *withThis)
if (!_ShrinkAtBy(pos, -difference)) if (!_ShrinkAtBy(pos, -difference))
return *this; return *this;
} }
memcpy(_privateData + pos, withThis, len); memcpy(fPrivateData + pos, withThis, len);
} }
return *this; return *this;
@ -1322,7 +1315,7 @@ BString::ReplaceSet(const char *setOfChars, char with)
if (offset >= length) if (offset >= length)
break; break;
_privateData[offset] = with; fPrivateData[offset] = with;
offset++; offset++;
} }
@ -1339,7 +1332,7 @@ BString::ReplaceSet(const char *setOfChars, const char *with)
return ReplaceSet(setOfChars, *with); return ReplaceSet(setOfChars, *with);
} }
if (setOfChars == NULL || _privateData == NULL) if (setOfChars == NULL || fPrivateData == NULL)
return *this; return *this;
PosVect positions; PosVect positions;
@ -1348,7 +1341,7 @@ BString::ReplaceSet(const char *setOfChars, const char *with)
int32 len = Length(); int32 len = Length();
int32 pos = 0; int32 pos = 0;
for (int32 offset = 0; offset < len; offset += (pos+searchLen)) { for (int32 offset = 0; offset < len; offset += (pos+searchLen)) {
pos = strcspn(_privateData + offset, setOfChars); pos = strcspn(fPrivateData + offset, setOfChars);
if (pos + offset >= len) if (pos + offset >= len)
break; break;
if (!positions.Add(offset + pos)) if (!positions.Add(offset + pos))
@ -1366,7 +1359,7 @@ BString::ReplaceSet(const char *setOfChars, const char *with)
char & char &
BString::operator[](int32 index) BString::operator[](int32 index)
{ {
return _privateData[index]; return fPrivateData[index];
} }
@ -1381,16 +1374,16 @@ BString::LockBuffer(int32 maxLength)
if (maxLength > len) { if (maxLength > len) {
if (!_GrowBy(maxLength - len)) if (!_GrowBy(maxLength - len))
return NULL; return NULL;
if (!len && _privateData) if (!len && fPrivateData)
// if string was empty before call to LockBuffer(), we make sure the // if string was empty before call to LockBuffer(), we make sure the
// buffer represents an empty c-string: // buffer represents an empty c-string:
*_privateData = '\0'; *fPrivateData = '\0';
} else if (!maxLength && !len) { } else if (!maxLength && !len) {
// special case for unallocated string, we return an empty c-string: // special case for unallocated string, we return an empty c-string:
return const_cast<char*>(String()); return const_cast<char*>(String());
} }
return _privateData; return fPrivateData;
} }
@ -1400,7 +1393,7 @@ BString::UnlockBuffer(int32 length)
_SetUsingAsCString(false); _SetUsingAsCString(false);
if (length < 0) if (length < 0)
length = (_privateData == NULL) ? 0 : strlen(_privateData); length = (fPrivateData == NULL) ? 0 : strlen(fPrivateData);
if (length != Length()) if (length != Length())
_GrowBy(length - Length()); _GrowBy(length - Length());
@ -1416,7 +1409,7 @@ BString::ToLower()
{ {
int32 length = Length(); int32 length = Length();
for (int32 count = 0; count < length; count++) { for (int32 count = 0; count < length; count++) {
_privateData[count] = tolower(_privateData[count]); fPrivateData[count] = tolower(fPrivateData[count]);
} }
return *this; return *this;
@ -1429,7 +1422,7 @@ BString::ToUpper()
{ {
int32 length = Length(); int32 length = Length();
for (int32 count = 0; count < length; count++) { for (int32 count = 0; count < length; count++) {
_privateData[count] = toupper(_privateData[count]); fPrivateData[count] = toupper(fPrivateData[count]);
} }
return *this; return *this;
@ -1440,14 +1433,14 @@ BString::ToUpper()
BString& BString&
BString::Capitalize() BString::Capitalize()
{ {
if (_privateData == NULL) if (fPrivateData == NULL)
return *this; return *this;
_privateData[0] = toupper(_privateData[0]); fPrivateData[0] = toupper(fPrivateData[0]);
int32 length = Length(); int32 length = Length();
for (int32 count = 1; count < length; count++) { for (int32 count = 1; count < length; count++) {
_privateData[count] = tolower(_privateData[count]); fPrivateData[count] = tolower(fPrivateData[count]);
} }
return *this; return *this;
@ -1458,7 +1451,7 @@ BString::Capitalize()
BString& BString&
BString::CapitalizeEachWord() BString::CapitalizeEachWord()
{ {
if (_privateData == NULL) if (fPrivateData == NULL)
return *this; return *this;
int32 count = 0; int32 count = 0;
@ -1467,9 +1460,9 @@ BString::CapitalizeEachWord()
do { do {
// Find the first alphabetical character... // Find the first alphabetical character...
for (; count < length; count++) { for (; count < length; count++) {
if (isalpha(_privateData[count])) { if (isalpha(fPrivateData[count])) {
// ...found! Convert it to uppercase. // ...found! Convert it to uppercase.
_privateData[count] = toupper(_privateData[count]); fPrivateData[count] = toupper(fPrivateData[count]);
count++; count++;
break; break;
} }
@ -1478,8 +1471,8 @@ BString::CapitalizeEachWord()
// Now find the first non-alphabetical character, // Now find the first non-alphabetical character,
// and meanwhile, turn to lowercase all the alphabetical ones // and meanwhile, turn to lowercase all the alphabetical ones
for (; count < length; count++) { for (; count < length; count++) {
if (isalpha(_privateData[count])) if (isalpha(fPrivateData[count]))
_privateData[count] = tolower(_privateData[count]); fPrivateData[count] = tolower(fPrivateData[count]);
else else
break; break;
} }
@ -1504,14 +1497,14 @@ BString::CharacterEscape(const char *original, const char *setOfCharsToEscape,
BString& BString&
BString::CharacterEscape(const char *setOfCharsToEscape, char escapeWith) BString::CharacterEscape(const char *setOfCharsToEscape, char escapeWith)
{ {
if (setOfCharsToEscape == NULL || _privateData == NULL) if (setOfCharsToEscape == NULL || fPrivateData == NULL)
return *this; return *this;
PosVect positions; PosVect positions;
int32 len = Length(); int32 len = Length();
int32 pos = 0; int32 pos = 0;
for (int32 offset = 0; offset < len; offset += pos + 1) { for (int32 offset = 0; offset < len; offset += pos + 1) {
if ((pos = strcspn(_privateData + offset, setOfCharsToEscape)) < len - offset) { if ((pos = strcspn(fPrivateData + offset, setOfCharsToEscape)) < len - offset) {
if (!positions.Add(offset + pos)) if (!positions.Add(offset + pos))
return *this; return *this;
} }
@ -1525,7 +1518,7 @@ BString::CharacterEscape(const char *setOfCharsToEscape, char escapeWith)
} }
int32 lastPos = 0; int32 lastPos = 0;
char* oldAdr = _privateData; char* oldAdr = fPrivateData;
char* newData = (char*)malloc(newLength + sizeof(int32) + 1); char* newData = (char*)malloc(newLength + sizeof(int32) + 1);
if (newData) { if (newData) {
newData += sizeof(int32); newData += sizeof(int32);
@ -1546,9 +1539,9 @@ BString::CharacterEscape(const char *setOfCharsToEscape, char escapeWith)
if (len > 0) if (len > 0)
memcpy(newAdr, oldAdr, len); memcpy(newAdr, oldAdr, len);
free(_privateData - sizeof(int32)); free(fPrivateData - sizeof(int32));
_privateData = newData; fPrivateData = newData;
_privateData[newLength] = 0; fPrivateData[newLength] = 0;
_SetLength( newLength); _SetLength( newLength);
} }
@ -1684,17 +1677,17 @@ BString::operator<<(float f)
char * char *
BString::_Alloc(int32 dataLength) BString::_Alloc(int32 dataLength)
{ {
char *dataPtr = _privateData ? _privateData - sizeof(int32) : NULL; char *dataPtr = fPrivateData ? fPrivateData - sizeof(int32) : NULL;
if (dataLength <= 0) { if (dataLength <= 0) {
// release buffer // release buffer
#if 0 #if 0
free(dataPtr); free(dataPtr);
_privateData = NULL; fPrivateData = NULL;
return NULL; return NULL;
#else #else
// TODO: think about removing this work-around again; it lets // TODO: think about removing this work-around again; it lets
// BeOS R5 NetPositive run on Haiku - this is obviously ignoring // BeOS R5 NetPositive run on Haiku - this is obviously ignoring
// the fact, that _privateData could be NULL at one point // the fact, that fPrivateData could be NULL at one point
// (while building the menus from resources). // (while building the menus from resources).
dataLength = 0; dataLength = 0;
#endif #endif
@ -1704,10 +1697,10 @@ BString::_Alloc(int32 dataLength)
dataPtr = (char *)realloc(dataPtr, allocLength); dataPtr = (char *)realloc(dataPtr, allocLength);
if (dataPtr) { if (dataPtr) {
dataPtr += sizeof(int32); dataPtr += sizeof(int32);
_privateData = dataPtr; fPrivateData = dataPtr;
_SetLength(dataLength); _SetLength(dataLength);
_privateData[dataLength] = '\0'; fPrivateData[dataLength] = '\0';
} }
return dataPtr; return dataPtr;
@ -1717,7 +1710,7 @@ void
BString::_Init(const char *str, int32 len) BString::_Init(const char *str, int32 len)
{ {
if (_Alloc(len)) if (_Alloc(len))
memcpy(_privateData, str, len); memcpy(fPrivateData, str, len);
} }
@ -1730,7 +1723,7 @@ BString::_DoAssign(const char *str, int32 len)
int32 curLen = Length(); int32 curLen = Length();
if (len == curLen || _GrowBy(len - curLen)) if (len == curLen || _GrowBy(len - curLen))
memcpy(_privateData, str, len); memcpy(fPrivateData, str, len);
} }
@ -1742,7 +1735,7 @@ BString::_DoAppend(const char *str, int32 len)
{ {
int32 length = Length(); int32 length = Length();
if (_GrowBy(len)) if (_GrowBy(len))
memcpy(_privateData + length, str, len); memcpy(fPrivateData + length, str, len);
} }
@ -1760,7 +1753,7 @@ BString::_OpenAtBy(int32 offset, int32 length)
char* newData = _Alloc(oldLength + length); char* newData = _Alloc(oldLength + length);
if (newData != NULL) { if (newData != NULL) {
memmove(_privateData + offset + length, _privateData + offset, memmove(fPrivateData + offset + length, fPrivateData + offset,
oldLength - offset); oldLength - offset);
} }
@ -1771,12 +1764,12 @@ BString::_OpenAtBy(int32 offset, int32 length)
char* char*
BString::_ShrinkAtBy(int32 offset, int32 length) BString::_ShrinkAtBy(int32 offset, int32 length)
{ {
if (!_privateData) if (!fPrivateData)
return NULL; return NULL;
int32 oldLength = Length(); int32 oldLength = Length();
memmove(_privateData + offset, _privateData + offset + length, memmove(fPrivateData + offset, fPrivateData + offset + length,
oldLength - offset - length); oldLength - offset - length);
// the following actually should never fail, since we are reducing the size... // the following actually should never fail, since we are reducing the size...
@ -1791,7 +1784,7 @@ void
BString::_DoPrepend(const char *str, int32 count) BString::_DoPrepend(const char *str, int32 count)
{ {
if (_OpenAtBy(0, count)) if (_OpenAtBy(0, count))
memcpy(_privateData, str, count); memcpy(fPrivateData, str, count);
} }
@ -1835,12 +1828,12 @@ BString::_ShortFindAfter(const char *str, int32 len) const
int32 int32
BString::_FindBefore(const char *str, int32 offset, int32 strlen) const BString::_FindBefore(const char *str, int32 offset, int32 strlen) const
{ {
if (_privateData) { if (fPrivateData) {
const char *ptr = _privateData + offset - strlen; const char *ptr = fPrivateData + offset - strlen;
while (ptr >= _privateData) { while (ptr >= fPrivateData) {
if (!memcmp(ptr, str, strlen)) if (!memcmp(ptr, str, strlen))
return ptr - _privateData; return ptr - fPrivateData;
ptr--; ptr--;
} }
} }
@ -1851,12 +1844,12 @@ BString::_FindBefore(const char *str, int32 offset, int32 strlen) const
int32 int32
BString::_IFindBefore(const char *str, int32 offset, int32 strlen) const BString::_IFindBefore(const char *str, int32 offset, int32 strlen) const
{ {
if (_privateData) { if (fPrivateData) {
char *ptr1 = _privateData + offset - strlen; char *ptr1 = fPrivateData + offset - strlen;
while (ptr1 >= _privateData) { while (ptr1 >= fPrivateData) {
if (!strncasecmp(ptr1, str, strlen)) if (!strncasecmp(ptr1, str, strlen))
return ptr1 - _privateData; return ptr1 - fPrivateData;
ptr1--; ptr1--;
} }
} }
@ -1908,7 +1901,7 @@ BString::_ReplaceAtPositions(const PosVect* positions,
int32 pos; int32 pos;
int32 lastPos = 0; int32 lastPos = 0;
char *oldAdr = _privateData; char *oldAdr = fPrivateData;
char *newData = (char *)malloc(newLength + sizeof(int32) + 1); char *newData = (char *)malloc(newLength + sizeof(int32) + 1);
if (newData) { if (newData) {
newData += sizeof(int32); newData += sizeof(int32);
@ -1930,9 +1923,9 @@ BString::_ReplaceAtPositions(const PosVect* positions,
if (len > 0) if (len > 0)
memcpy(newAdr, oldAdr, len); memcpy(newAdr, oldAdr, len);
free(_privateData - sizeof(int32)); free(fPrivateData - sizeof(int32));
_privateData = newData; fPrivateData = newData;
_privateData[newLength] = 0; fPrivateData[newLength] = 0;
_SetLength( newLength); _SetLength( newLength);
} }
} }
@ -1944,7 +1937,7 @@ inline
void void
BString::_SetLength(int32 length) BString::_SetLength(int32 length)
{ {
*((int32*)_privateData - 1) = length & 0x7fffffff; *((int32*)fPrivateData - 1) = length & 0x7fffffff;
} }