ByteString->rtl::OString

9 files changed, 137 insertions, 163 deletions

diff --git a/l10ntools/inc/cfgmerge.hxx b/l10ntools/inc/cfgmerge.hxx
index 23bd45089415..8a09881c2068 100644
--- a/l10ntools/inc/cfgmerge.hxx
+++ b/l10ntools/inc/cfgmerge.hxx
@@ -46,21 +46,22 @@ friend class CfgParser;
 friend class CfgExport;
 friend class CfgMerge;
 private:
-    ByteString sTagType;
-    ByteString sIdentifier;
+    rtl::OString sTagType;
+    rtl::OString sIdentifier;
 
-    ByteString sResTyp;
+    rtl::OString sResTyp;
 
-    ByteString sTextTag;
-    ByteString sEndTextTag;
+    rtl::OString sTextTag;
+    rtl::OString sEndTextTag;
 
     ByteStringHashMap sText;
 public:
-    CfgStackData( const ByteString &rTag, const ByteString &rId )
-            : sTagType( rTag ), sIdentifier( rId ) {};
+    CfgStackData(const rtl::OString &rTag, const rtl::OString &rId)
+        : sTagType( rTag ), sIdentifier( rId )
+    {}
 
-    ByteString &GetTagType() { return sTagType; }
-    ByteString &GetIdentifier() { return sIdentifier; }
+    const rtl::OString &GetTagType() { return sTagType; }
+    const rtl::OString &GetIdentifier() { return sIdentifier; }
 
 };
 
@@ -79,18 +80,19 @@ public:
     CfgStack() {}
     ~CfgStack();
 
-    CfgStackData *Push( const ByteString &rTag, const ByteString &rId );
+    CfgStackData *Push(const rtl::OString &rTag, const rtl::OString &rId);
     CfgStackData *Pop()
-        {
-            if ( maList.empty() ) return NULL;
-            CfgStackData* temp = maList.back();
-            maList.pop_back();
-            return temp;
-        }
+    {
+        if (maList.empty())
+            return NULL;
+        CfgStackData* temp = maList.back();
+        maList.pop_back();
+        return temp;
+    }
 
     CfgStackData *GetStackData( size_t nPos = LIST_APPEND );
 
-    ByteString GetAccessPath( size_t nPos = LIST_APPEND );
+    rtl::OString GetAccessPath( size_t nPos = LIST_APPEND );
 
     size_t size() const { return maList.size(); }
 };
@@ -102,11 +104,11 @@ public:
 class CfgParser
 {
 protected:
-    ByteString sCurrentResTyp;
-    ByteString sCurrentIsoLang;
+    rtl::OString sCurrentResTyp;
+    rtl::OString sCurrentIsoLang;
     ByteString sCurrentText;
 
-    ByteString sLastWhitespace;
+    rtl::OString sLastWhitespace;
 
     CfgStack aStack;
     CfgStackData *pStackData;
@@ -115,11 +117,11 @@ protected:
 
     virtual void WorkOnText(
         ByteString &rText,
-        const ByteString &nLangIndex )=0;
+        const rtl::OString &rLangIndex )=0;
 
     virtual void WorkOnRessourceEnd()=0;
 
-    virtual void Output( const ByteString& rOutput )=0;
+    virtual void Output(const rtl::OString & rOutput)=0;
 
     void Error( const ByteString &rError );
 
@@ -131,7 +133,7 @@ private:
         const ByteString &rIsoLang,
         const ByteString &rResTyp );
 
-sal_Bool IsTokenClosed( const ByteString &rToken );
+    sal_Bool IsTokenClosed(const rtl::OString &rToken);
 
 public:
     CfgParser();
@@ -164,13 +166,13 @@ private:
     ByteString sPath;
     std::vector<ByteString> aLanguages;
 protected:
-    void WorkOnText(
+    virtual void WorkOnText(
         ByteString &rText,
-        const ByteString &rIsoLang
+        const rtl::OString &rIsoLang
         );
 
     void WorkOnRessourceEnd();
-    void Output( const ByteString& rOutput );
+    void Output(const rtl::OString& rOutput);
 public:
     CfgExport(
         const ByteString &rOutputFile,
@@ -191,23 +193,18 @@ private:
     std::vector<ByteString> aLanguages;
     ResData *pResData;
 
-    ByteString sFilename;
+    rtl::OString sFilename;
     sal_Bool bEnglish;
 
 protected:
-    void WorkOnText(
-        ByteString &rText,
-        const ByteString &nLangIndex );
+    virtual void WorkOnText(ByteString &rText, const rtl::OString &rLangIndex);
 
     void WorkOnRessourceEnd();
 
-    void Output( const ByteString& rOutput );
+    void Output(const rtl::OString& rOutput);
 public:
-    CfgMerge(
-        const ByteString &rMergeSource,
-        const ByteString &rOutputFile,
-        ByteString &rFilename
-    );
+    CfgMerge(const rtl::OString &rMergeSource,
+        const rtl::OString &rOutputFile, const rtl::OString &rFilename);
     ~CfgMerge();
 };
 
diff --git a/l10ntools/source/cfgmerge.cxx b/l10ntools/source/cfgmerge.cxx
index a6fdb98611e7..30c894228bcb 100644
--- a/l10ntools/source/cfgmerge.cxx
+++ b/l10ntools/source/cfgmerge.cxx
@@ -64,8 +64,8 @@ ByteString sPrjRoot;
 ByteString sInputFileName;
 ByteString sActFileName;
 ByteString sFullEntry;
-ByteString sOutputFile;
-ByteString sMergeSrc;
+rtl::OString sOutputFile;
+rtl::OString sMergeSrc;
 String sUsedTempFile;
 
 CfgParser *pParser;
@@ -145,7 +145,7 @@ extern char *GetOutputFile( int argc, char* argv[])
                 }
                 break;
                 case STATE_MERGESRC: {
-                    sMergeSrc = ByteString( argv[ i ]);
+                    sMergeSrc = rtl::OString(argv[i]);
                     bMergeMode = sal_True; // activate merge mode, cause merge database found
                 }
                 break;
@@ -160,26 +160,25 @@ extern char *GetOutputFile( int argc, char* argv[])
     if ( bInput ) {
         // command line is valid
         bEnableExport = sal_True;
-        char *pReturn = new char[ sOutputFile.Len() + 1 ];
-        strcpy( pReturn, sOutputFile.GetBuffer());  // #100211# - checked
+        char *pReturn = new char[ sOutputFile.getLength() + 1 ];
+        strcpy( pReturn, sOutputFile.getStr());  // #100211# - checked
         return pReturn;
     }
 
     // command line is not valid
     return NULL;
 }
-/*****************************************************************************/
+
 int InitCfgExport( char *pOutput , char* pFilename )
-/*****************************************************************************/
 {
     // instanciate Export
-    ByteString sOutput( pOutput );
+    rtl::OString sOutput( pOutput );
     ByteString sFilename( pFilename );
     Export::InitLanguages();
 
     if ( bMergeMode )
         pParser = new CfgMerge( sMergeSrc, sOutputFile, sFilename );
-      else if ( sOutputFile.Len())
+    else if ( sOutputFile.getLength())
         pParser = new CfgExport( sOutputFile, sPrj, sActFileName );
 
     return 1;
@@ -283,7 +282,7 @@ int GetError()
 // class CfgStackData
 //
 
-CfgStackData* CfgStack::Push( const ByteString &rTag, const ByteString &rId )
+CfgStackData* CfgStack::Push(const rtl::OString &rTag, const rtl::OString &rId)
 {
     CfgStackData *pD = new CfgStackData( rTag, rId );
     maList.push_back( pD );
@@ -303,21 +302,20 @@ CfgStack::~CfgStack()
     maList.clear();
 }
 
-/*****************************************************************************/
-ByteString CfgStack::GetAccessPath( size_t nPos )
-/*****************************************************************************/
+rtl::OString CfgStack::GetAccessPath( size_t nPos )
 {
     if ( nPos == LIST_APPEND )
         nPos = maList.size() - 1;
 
-    ByteString sReturn;
-    for ( size_t i = 0; i <= nPos; i++ ) {
-        if ( i )
-            sReturn += ".";
-        sReturn += GetStackData( i )->GetIdentifier();
+    rtl::OStringBuffer sReturn;
+    for (size_t i = 0; i <= nPos; ++i)
+    {
+        if (i)
+            sReturn.append('.');
+        sReturn.append(GetStackData( i )->GetIdentifier());
     }
 
-    return sReturn;
+    return sReturn.makeStringAndClear();
 }
 
 /*****************************************************************************/
@@ -347,18 +345,13 @@ CfgParser::CfgParser()
 {
 }
 
-/*****************************************************************************/
 CfgParser::~CfgParser()
-/*****************************************************************************/
 {
 }
 
-
-/*****************************************************************************/
-sal_Bool CfgParser::IsTokenClosed( const ByteString &rToken )
-/*****************************************************************************/
+sal_Bool CfgParser::IsTokenClosed(const rtl::OString &rToken)
 {
-    return rToken.GetChar( rToken.Len() - 2 ) == '/';
+    return rToken[rToken.getLength() - 2] == '/';
 }
 
 /*****************************************************************************/
@@ -392,7 +385,7 @@ int CfgParser::ExecuteAnalyzedToken( int nToken, char *pToken )
     if ( sToken == " " || sToken == "\t" )
         sLastWhitespace += sToken;
 
-    ByteString sTokenName;
+    rtl::OString sTokenName;
     ByteString sTokenId;
 
     sal_Bool bOutput = sal_True;
@@ -484,13 +477,15 @@ int CfgParser::ExecuteAnalyzedToken( int nToken, char *pToken )
         break;
         case CFG_CLOSETAG:
             sTokenName = getToken(getToken(getToken(sToken, 1, '/'), 0, '>'), 0, ' ');
-               if ( aStack.GetStackData() && ( aStack.GetStackData()->GetTagType() == sTokenName )) {
-                if ( ! sCurrentText.Len())
+            if ( aStack.GetStackData() && ( aStack.GetStackData()->GetTagType() == sTokenName ))
+            {
+                if (!sCurrentText.Len())
                     WorkOnRessourceEnd();
                 aStack.Pop();
                 pStackData = aStack.GetStackData();
             }
-            else {
+            else
+            {
                 ByteString sError( "Misplaced close tag: " );
                 ByteString sInFile(" in file ");
                 sError += sToken;
@@ -511,7 +506,8 @@ int CfgParser::ExecuteAnalyzedToken( int nToken, char *pToken )
         break;
     }
 
-    if ( sCurrentText.Len() && nToken != CFG_TEXTCHAR ) {
+    if ( sCurrentText.Len() && nToken != CFG_TEXTCHAR )
+    {
         AddText( sCurrentText, sCurrentIsoLang, sCurrentResTyp );
         Output( sCurrentText );
         sCurrentText = "";
@@ -527,12 +523,8 @@ int CfgParser::ExecuteAnalyzedToken( int nToken, char *pToken )
     return 1;
 }
 
-/*****************************************************************************/
-void CfgExport::Output( const ByteString& rOutput )
-/*****************************************************************************/
+void CfgExport::Output(const rtl::OString&)
 {
-    // Dummy operation to suppress warnings caused by poor class design
-    ByteString a( rOutput );
 }
 
 /*****************************************************************************/
@@ -681,14 +673,12 @@ void CfgExport::WorkOnRessourceEnd()
     }
 }
 
-/*****************************************************************************/
 void CfgExport::WorkOnText(
     ByteString &rText,
-    const ByteString &rIsoLang
+    const rtl::OString &rIsoLang
 )
-/*****************************************************************************/
 {
-    if( rIsoLang.Len() ) Export::UnquotHTML( rText );
+    if( rIsoLang.getLength() ) Export::UnquotHTML( rText );
 }
 
 
@@ -696,18 +686,16 @@ void CfgExport::WorkOnText(
 // class CfgMerge
 //
 
-/*****************************************************************************/
 CfgMerge::CfgMerge(
-    const ByteString &rMergeSource, const ByteString &rOutputFile,
-    ByteString &rFilename )
-/*****************************************************************************/
+    const rtl::OString &rMergeSource, const rtl::OString &rOutputFile,
+    const rtl::OString &rFilename)
                 : CfgOutputParser( rOutputFile ),
                 pMergeDataFile( NULL ),
                 pResData( NULL ),
                 sFilename( rFilename ),
                 bEnglish( sal_False )
 {
-    if (rMergeSource.Len())
+    if (rMergeSource.getLength())
     {
         pMergeDataFile = new MergeDataFile(
         rMergeSource, sInputFileName, bErrorLog, true );
@@ -730,12 +718,7 @@ CfgMerge::~CfgMerge()
     delete pResData;
 }
 
-/*****************************************************************************/
-void CfgMerge::WorkOnText(
-    ByteString &rText,
-    const ByteString& nLangIndex
-)
-/*****************************************************************************/
+void CfgMerge::WorkOnText(ByteString &rText, const rtl::OString& rLangIndex)
 {
 
     if ( pMergeDataFile && bLocalize ) {
@@ -757,15 +740,15 @@ void CfgMerge::WorkOnText(
             pResData->sResTyp = pStackData->sResTyp;
         }
 
-        if (( nLangIndex.EqualsIgnoreCaseAscii("en-US") ))
+        if (rLangIndex.equalsIgnoreAsciiCaseL(RTL_CONSTASCII_STRINGPARAM("en-US")))
             bEnglish = sal_True;
 
         PFormEntrys *pEntrys = pMergeDataFile->GetPFormEntrysCaseSensitive( pResData );
         if ( pEntrys ) {
             ByteString sContent;
-            pEntrys->GetText( sContent, STRING_TYP_TEXT, nLangIndex );
+            pEntrys->GetText( sContent, STRING_TYP_TEXT, rLangIndex );
 
-            if ( Export::isAllowed( nLangIndex ) &&
+            if ( Export::isAllowed( rLangIndex ) &&
                 ( sContent != "-" ) && ( sContent.Len()))
             {
                 Export::QuotHTML( rText );
@@ -774,12 +757,10 @@ void CfgMerge::WorkOnText(
     }
 }
 
-/*****************************************************************************/
-void CfgMerge::Output( const ByteString& rOutput )
-/*****************************************************************************/
+void CfgMerge::Output(const rtl::OString& rOutput)
 {
-    if ( pOutputStream )
-        pOutputStream->Write( rOutput.GetBuffer(), rOutput.Len());
+    if (pOutputStream)
+        pOutputStream->Write(rOutput.getStr(), rOutput.getLength());
 }
 
 /*****************************************************************************/
diff --git a/rsc/inc/rscrsc.hxx b/rsc/inc/rscrsc.hxx
index 7a14792dd101..09a91ffb2481 100644
--- a/rsc/inc/rscrsc.hxx
+++ b/rsc/inc/rscrsc.hxx
@@ -97,14 +97,14 @@ private:
     void            Append( const rtl::OString& rOutputSrs, const rtl::OString& rTmpFile );
 
     bool            GetImageFilePath( const RscCmdLine::OutputFile& rOutputFile,
-                                       const WriteRcContext& rContext,
-                                    const ByteString& rBaseFileName,
-                                    ByteString& rImagePath,
-                                    FILE* pSysListFile );
+                                      const WriteRcContext& rContext,
+                                      const rtl::OString& rBaseFileName,
+                                      ByteString& rImagePath,
+                                      FILE* pSysListFile );
     void            PreprocessSrsFile( const RscCmdLine::OutputFile& rOutputFile,
-                                          const WriteRcContext& rContext,
-                                         const DirEntry& rSrsInPath,
-                                         const DirEntry& rSrsOutPath );
+                                       const WriteRcContext& rContext,
+                                       const DirEntry& rSrsInPath,
+                                       const DirEntry& rSrsOutPath );
 
 public:
     RscTypCont*     pTC;        // String und Id-Verwalter
diff --git a/rsc/source/parser/rscibas.cxx b/rsc/source/parser/rscibas.cxx
index 4e2ba9f30080..e4cc72a2d561 100644
--- a/rsc/source/parser/rscibas.cxx
+++ b/rsc/source/parser/rscibas.cxx
@@ -147,19 +147,19 @@ void RscLangEnum::Init( RscNameTable& rNames )
     rtl::OString aEnvIsoTokens = getenv( "RSC_LANG_ISO" );
     if ( aEnvIsoTokens.getLength() )
     {
-        ByteString aIsoToken;
+        rtl::OString aIsoToken;
         sal_uInt16 nTokenCounter = 0;
         sal_Bool bOneMore = 1;
         while ( bOneMore )
         {
             aIsoToken = comphelper::string::getToken(aEnvIsoTokens, nTokenCounter, ' ');
-            if ( aIsoToken.Len() )
+            if ( aIsoToken.getLength() )
             {
-                SetConstant( rNames.Put( aIsoToken.GetBuffer(), CONSTNAME, mnLangId ), mnLangId );
+                SetConstant( rNames.Put( aIsoToken.getStr(), CONSTNAME, mnLangId ), mnLangId );
                 if ( ! GetLangId( aIsoToken ))
                     ULong_Iso_map[ aIsoToken ] = mnLangId;
 #if OSL_DEBUG_LEVEL > 2
-                fprintf( stderr, "Env ISO Language out: %s 0x%lx\n", aIsoToken.GetBuffer(), mnLangId );
+                fprintf( stderr, "Env ISO Language out: %s 0x%lx\n", aIsoToken.getStr(), mnLangId );
 #endif
                 mnLangId++;
             }
diff --git a/rsc/source/parser/rsclex.cxx b/rsc/source/parser/rsclex.cxx
index df388d9c63c0..0edbb549238b 100644
--- a/rsc/source/parser/rsclex.cxx
+++ b/rsc/source/parser/rsclex.cxx
@@ -381,7 +381,7 @@ void IncludeParser( RscFileInst * pFileInst )
                 }
                 else if( INCLUDE_STRING == nToken ){
                     lKey = pTypCon->aFileTab.NewIncFile( aYYSType.string,
-                                                         ByteString() );
+                                                         rtl::OString() );
                     pFName->InsertDependFile( lKey, ULONG_MAX );
                 };
             };
diff --git a/rsc/source/parser/rscyacc.y b/rsc/source/parser/rscyacc.y
index 6c401d55d66a..4ba11f4b5a9b 100644
--- a/rsc/source/parser/rscyacc.y
+++ b/rsc/source/parser/rscyacc.y
@@ -504,13 +504,13 @@ type
   {
 	if( $1 )
 	{
-		ByteString aTypeName = pHS->getString( $1->GetId() );
-		aTypeName += "[]";
-		$$ = pTC->SearchType( pHS->getID( aTypeName.GetBuffer(), true ) );
+		rtl::OString aTypeName = rtl::OStringBuffer(pHS->getString($1->GetId())).
+                    append("[]").makeStringAndClear();
+		$$ = pTC->SearchType( pHS->getID( aTypeName.getStr(), true ) );
 		if( !$$ )
 		{
 			RscCont * pCont;
-			pCont = new RscCont( pHS->getID( aTypeName.GetBuffer() ), RSC_NOTYPE );
+			pCont = new RscCont( pHS->getID( aTypeName.getStr() ), RSC_NOTYPE );
 			pCont->SetTypeClass( $1 );
 			pTC->InsertType( pCont );
 			$$ = pCont;
diff --git a/rsc/source/prj/start.cxx b/rsc/source/prj/start.cxx
index aeddeb767621..08672ba515ab 100644
--- a/rsc/source/prj/start.cxx
+++ b/rsc/source/prj/start.cxx
@@ -62,22 +62,21 @@ int rsc2_main(int, char**);
 |*
 |*    Beschreibung
 *************************************************************************/
-static sal_Bool CallPrePro( const ByteString& rInput,
-                        const ByteString& rOutput,
-                        RscPtrPtr * pCmdLine,
-                        sal_Bool bResponse )
+static sal_Bool CallPrePro( const rtl::OString& rInput,
+    const rtl::OString& rOutput, RscPtrPtr * pCmdLine,
+    sal_Bool bResponse )
 {
     RscPtrPtr       aNewCmdL;   // Kommandozeile
     RscPtrPtr       aRespCmdL;   // Kommandozeile
     RscPtrPtr *     pCmdL = &aNewCmdL;
     int             i, nRet;
     FILE*           fRspFile = NULL;
-    ByteString      aRspFileName;
+    rtl::OString    aRspFileName;
 
     if( bResponse )
     {
         aRspFileName = ::GetTmpFileName();
-        fRspFile = fopen( aRspFileName.GetBuffer(), "w" );
+        fRspFile = fopen( aRspFileName.getStr(), "w" );
     }
 
     if( !fRspFile )
@@ -100,8 +99,8 @@ static sal_Bool CallPrePro( const ByteString& rInput,
         }
     }
 
-    aNewCmdL.Append( rsc_strdup( rInput.GetBuffer() ) );
-    aNewCmdL.Append( rsc_strdup( rOutput.GetBuffer() ) );
+    aNewCmdL.Append( rsc_strdup( rInput.getStr() ) );
+    aNewCmdL.Append( rsc_strdup( rOutput.getStr() ) );
     aNewCmdL.Append( (void *)0 );
 
     if ( bVerbose )
@@ -145,11 +144,13 @@ static sal_Bool CallPrePro( const ByteString& rInput,
     nRet = rscpp_main( pCmdL->GetCount()-1, (char**)pCmdL->GetBlock() );
 
     if ( fRspFile )
+    {
         #if OSL_DEBUG_LEVEL > 5
-        fprintf( stderr, "leaving response file %s\n", aRspFileName.GetBuffer() );
+        fprintf( stderr, "leaving response file %s\n", aRspFileName.getStr() );
         #else
-        unlink( aRspFileName.GetBuffer() );
+        unlink( aRspFileName.getStr() );
         #endif
+    }
     if ( nRet )
         return sal_False;
 
@@ -163,8 +164,7 @@ static sal_Bool CallPrePro( const ByteString& rInput,
 |*    Beschreibung
 *************************************************************************/
 static sal_Bool CallRsc2( RscStrList * pInputList,
-                      ByteString aSrsName,
-                      RscPtrPtr * pCmdLine )
+    const rtl::OString &rSrsName, RscPtrPtr * pCmdLine )
 {
     int nRet;
     rtl::OString*  pString;
@@ -200,7 +200,7 @@ static sal_Bool CallRsc2( RscStrList * pInputList,
             aNewCmdL.Append( rsc_strdup( (char *)pCmdLine->GetEntry( i ) ) );
     };
 
-    aNewCmdL.Append( rsc_strdup( aSrsName.GetBuffer() ) );
+    aNewCmdL.Append( rsc_strdup( rSrsName.getStr() ) );
 
     for ( size_t i = 0, n = pInputList->size(); i < n; ++i )
     {
@@ -232,12 +232,12 @@ static sal_Bool CallRsc2( RscStrList * pInputList,
 *************************************************************************/
 SAL_IMPLEMENT_MAIN_WITH_ARGS(argc, argv)
 {
-    sal_Bool            bPrePro  = sal_True;
-    sal_Bool            bHelp    = sal_False;
-    sal_Bool            bError   = sal_False;
-    sal_Bool            bResponse = sal_False;
-    ByteString      aSrsName;
-    ByteString      aResName;
+    sal_Bool        bPrePro  = sal_True;
+    sal_Bool        bHelp    = sal_False;
+    sal_Bool        bError   = sal_False;
+    sal_Bool        bResponse = sal_False;
+    rtl::OString    aSrsName;
+    rtl::OString    aResName;
     RscStrList      aInputList;
     RscStrList      aTmpList;
     char *          pStr;
@@ -296,12 +296,12 @@ SAL_IMPLEMENT_MAIN_WITH_ARGS(argc, argv)
     if( !aInputList.empty() )
     {
         /* build the output file names          */
-        if( ! aResName.Len() )
+        if (!aResName.getLength())
             aResName = OutputFile( *aInputList[ 0 ], "res" );
         if( ! bSetSrs )
         {
-            aSrsName = "-fp=";
-            aSrsName += OutputFile( *aInputList[ 0 ], "srs" );
+            aSrsName = rtl::OStringBuffer("-fp=").append(OutputFile(*aInputList[0], "srs")).
+                makeStringAndClear();
         }
     };
 
@@ -309,7 +309,7 @@ SAL_IMPLEMENT_MAIN_WITH_ARGS(argc, argv)
         bPrePro = sal_False;
     if( bPrePro && !aInputList.empty() )
     {
-        ByteString aTmpName;
+        rtl::OString aTmpName;
 
         for ( size_t k = 0, n = aInputList.size(); k < n; ++k )
         {
diff --git a/rsc/source/res/rscmgr.cxx b/rsc/source/res/rscmgr.cxx
index 078be90c5658..77dbee0973c0 100644
--- a/rsc/source/res/rscmgr.cxx
+++ b/rsc/source/res/rscmgr.cxx
@@ -311,12 +311,12 @@ ERRTYPE RscMgr::WriteRc( const RSCINST &, RscWriteRc &,
 }
 
 
-static rtl::OString MakeSmartName( const ByteString & rDefName )
+static rtl::OString MakeSmartName( const rtl::OString& rDefName )
 {
     rtl::OStringBuffer aSmartName;
-    if( rDefName.Len() )
+    if( rDefName.getStr() )
     {
-        char * pStr = (char *)rDefName.GetBuffer();
+        char * pStr = (char *)rDefName.getStr();
         aSmartName.append(static_cast<sal_Char>(toupper(*pStr)));
         while( *++pStr )
         {
@@ -335,10 +335,10 @@ static rtl::OString MakeSmartName( const ByteString & rDefName )
 }
 
 static rtl::OString MakeName( RscTypCont * pTypCon, RscTop * pClass,
-                            const ByteString & rName )
+                            const rtl::OString& rName )
 {
     rtl::OStringBuffer aRet;
-    if( !pTypCon->IsSmart() || isdigit( rName.GetChar(0) ) )
+    if( !pTypCon->IsSmart() || isdigit( rName[0] ) )
     {
         aRet.append(pHS->getString( pClass->GetId() ).getStr());
         aRet.append(rName);
diff --git a/rsc/source/rsc/rsc.cxx b/rsc/source/rsc/rsc.cxx
index a638a2ca3f3f..8aef412fc190 100644
--- a/rsc/source/rsc/rsc.cxx
+++ b/rsc/source/rsc/rsc.cxx
@@ -856,11 +856,11 @@ ERRTYPE RscCompiler::Link()
             pTC->SetSourceCharSet( RTL_TEXTENCODING_UTF8 );
             pTC->ClearSysNames();
             rtl::OStringBuffer aSysSearchPath(it->aLangSearchPath);
-            xub_StrLen nIndex = 0;
-            ByteString aSearchPath = pTC->GetSearchPath();
-            while( nIndex != STRING_NOTFOUND )
+            sal_Int32 nIndex = 0;
+            rtl::OString aSearchPath = pTC->GetSearchPath();
+            do
             {
-                ByteString aToken = aSearchPath.GetToken( 0, cSearchDelim, nIndex );
+                rtl::OString aToken = aSearchPath.getToken( 0, cSearchDelim, nIndex );
                 if (aSysSearchPath.getLength())
                     aSysSearchPath.append(cSearchDelim);
                 aSysSearchPath.append(aToken);
@@ -869,6 +869,7 @@ ERRTYPE RscCompiler::Link()
                 aSysSearchPath.append(cSearchDelim);
                 aSysSearchPath.append(aToken);
             }
+            while ( nIndex >= 0 );
             OSL_TRACE( "setting search path for language %s: %s", it->aLangName.GetBuffer(), aSysSearchPath.getStr() );
             pTC->SetSysSearchPath(aSysSearchPath.makeStringAndClear());
 
@@ -975,12 +976,12 @@ ERRTYPE RscCompiler::Link()
 
         pTC->pEH->StdOut( "Generating .cxx file\n" );
 
-        ByteString aHxx = pCL->aOutputHxx;
-        if( !aHxx.Len() )
+        rtl::OString aHxx = pCL->aOutputHxx;
+        if( !aHxx.getLength() )
         {
             UniString aUniOutputCxx( pCL->aOutputCxx, RTL_TEXTENCODING_ASCII_US );
-            aHxx = rtl::OUStringToOString(DirEntry( aUniOutputCxx ).GetBase(), RTL_TEXTENCODING_ASCII_US);
-            aHxx += ".hxx";
+            aHxx = rtl::OStringBuffer(rtl::OUStringToOString(DirEntry(aUniOutputCxx).GetBase(),
+                RTL_TEXTENCODING_ASCII_US)).append(".hxx").makeStringAndClear();
         }
 
         // Schreibe Datei
@@ -1050,20 +1051,17 @@ void RscCompiler::Append( const rtl::OString& rOutputSrs,
 
 bool RscCompiler::GetImageFilePath( const RscCmdLine::OutputFile& rOutputFile,
                                     const WriteRcContext& rContext,
-                                    const ByteString& rBaseFileName,
+                                    const rtl::OString& rBaseFileName,
                                     ByteString& rImagePath,
                                     FILE* pSysListFile )
 {
-    ::std::list< ByteString >                   aFileNames;
-    bool                                        bFound = false;
+    ::std::list< rtl::OString >  aFileNames;
+    bool bFound = false;
 
-    ByteString  aFileName( rBaseFileName );
-    aFileNames.push_back( aFileName += ".png" );
+    aFileNames.push_back( rBaseFileName + rtl::OString(".png") );
+    aFileNames.push_back( rBaseFileName + rtl::OString(".bmp") );
 
-    aFileName = rBaseFileName;
-    aFileNames.push_back( aFileName += ".bmp" );
-
-    ::std::list< ByteString >::iterator aFileIter( aFileNames.begin() );
+    ::std::list< rtl::OString >::iterator aFileIter( aFileNames.begin() );
 
     while( ( aFileIter != aFileNames.end() ) && !bFound )
     {
@@ -1090,11 +1088,9 @@ bool RscCompiler::GetImageFilePath( const RscCmdLine::OutputFile& rOutputFile,
 
                 while( ( aReplIter != rContext.pCmdLine->m_aReplacements.end() ) && !bFound )
                 {
-                    ByteString aSearch( aReplIter->second );
-                    aSearch.ToLowerAscii();
-                    ByteString aSearchIn( aRelPathStr );
-                    aSearchIn.ToLowerAscii();
-                    if( aSearchIn.Search( aSearch ) == 0 )
+                    rtl::OString aSearch(aReplIter->second.toAsciiLowerCase());
+                    rtl::OString aSearchIn(aRelPathStr.toAsciiLowerCase());
+                    if( aSearchIn.indexOf(aSearch) == 0 )
                     {
                         sal_Int32       nCopyPos = aReplIter->second.getLength(), nLength = aRelPathStr.getLength();
                         const sal_Char* pChars = aRelPathStr.getStr();
@@ -1145,7 +1141,7 @@ void RscCompiler::PreprocessSrsFile( const RscCmdLine::OutputFile& rOutputFile,
 {
     SvFileStream                aIStm( rSrsInPath.GetFull(), STREAM_READ );
     SvFileStream                aOStm( rSrsOutPath.GetFull(), STREAM_WRITE | STREAM_TRUNC );
-    ::std::vector< ByteString > aMissingImages;
+    ::std::vector< rtl::OString > aMissingImages;
     FILE*                       pSysListFile = rContext.aOutputSysList.getLength() ? fopen( rContext.aOutputSysList.getStr(), "ab" ) : NULL;
 
     if( !aIStm.GetError() && !aOStm.GetError() )
@@ -1183,7 +1179,7 @@ void RscCompiler::PreprocessSrsFile( const RscCmdLine::OutputFile& rOutputFile,
                     }
                     while( aLine.Search( "Prefix" ) == STRING_NOTFOUND );
 
-                    const ByteString aPrefix( getToken(aLine, 1, '"') );
+                    const rtl::OString aPrefix( getToken(aLine, 1, '"') );
                     aIStm.Seek( nImgListStartPos );
 
                     do