Reduced tools/string usage further

l10ntools/inc/gsicheck.hxx

@@ -71,7 +71,7 @@ public:
     rtl::OString  const GetQuickHelpText() const { return aQuickHelpText; }
     rtl::OString  const GetTitle()      const    { return aTitle; }
 
-    void SetUText( String &aNew ) { aText = rtl::OUStringToOString(aNew, RTL_TEXTENCODING_UTF8); ReassembleLine(); }
+    void SetUText( rtl::OUString const &aNew ) { aText = rtl::OUStringToOString(aNew, RTL_TEXTENCODING_UTF8); ReassembleLine(); }
     void        SetText( rtl::OString const &aNew ) { aText = aNew; ReassembleLine(); }
     void        SetQuickHelpText( rtl::OString const &aNew ) { aQuickHelpText = aNew; ReassembleLine(); }
     void        SetTitle( rtl::OString const &aNew ) { aTitle = aNew; ReassembleLine(); }
@@ -109,7 +109,7 @@ private:
 
     sal_Bool bHasBlockError;
 
-    sal_Bool IsUTF8( const rtl::OString &aTestee, sal_Bool bFixTags, sal_uInt16 &nErrorPos, rtl::OString &aErrorMsg, sal_Bool &bHasBeenFixed, rtl::OString &aFixed ) const;
+    sal_Bool IsUTF8( const rtl::OString &aTestee, sal_Bool bFixTags, sal_Int32 &nErrorPos, rtl::OString &aErrorMsg, sal_Bool &bHasBeenFixed, rtl::OString &aFixed ) const;
     sal_Bool TestUTF8( GSILine* pTestee, sal_Bool bFixTags );
     sal_Bool HasSuspiciousChars( GSILine* pTestee, GSILine* pSource );
 

l10ntools/inc/tagtest.hxx

@@ -29,7 +29,6 @@
 #ifndef _TAGTEST_HXX_
 #define _TAGTEST_HXX_
 
-#include <tools/string.hxx>
 #include <boost/unordered_map.hpp>
 #include <vector>
 
@@ -44,14 +43,14 @@ typedef ::std::vector< ParserMessage* > Impl_ParserMessageList;
 
 class ParserMessageList;
 
-typedef boost::unordered_map<rtl::OString, String, rtl::OStringHash> StringHashMap;
+typedef boost::unordered_map<rtl::OString, rtl::OUString, rtl::OStringHash> StringHashMap;
 
 class TokenInfo
 {
 private:
     void SplitTag( ParserMessageList &rErrorList );
 
-    String aTagName;
+    rtl::OUString aTagName;
     StringHashMap aProperties;
     sal_Bool bClosed;    // tag is closed  <sdnf/>
     sal_Bool bCloseTag;  // tag is close Tag  </sdnf>
@@ -63,29 +62,29 @@ private:
 
 public:
 
-    String aTokenString;
+    rtl::OUString aTokenString;
     TokenId nId;
     sal_uInt16 nPos;            // Position in String
 
     TokenInfo():bClosed(sal_False),bCloseTag(sal_False),bIsBroken(sal_False),bHasBeenFixed(sal_False),bDone(sal_False),nId( 0 ){;}
 explicit    TokenInfo( TokenId pnId, sal_uInt16 nP ):bClosed(sal_False),bCloseTag(sal_False),bIsBroken(sal_False),bHasBeenFixed(sal_False),bDone(sal_False),nId( pnId ),nPos(nP){;}
-explicit    TokenInfo( TokenId pnId, sal_uInt16 nP, String paStr ):bClosed(sal_False),bCloseTag(sal_False),bIsBroken(sal_False),bHasBeenFixed(sal_False),bDone(sal_False),aTokenString( paStr ),nId( pnId ),nPos(nP) {;}
-explicit    TokenInfo( TokenId pnId, sal_uInt16 nP, String paStr, ParserMessageList &rErrorList );
+    explicit    TokenInfo( TokenId pnId, sal_uInt16 nP, rtl::OUString const & paStr ):bClosed(sal_False),bCloseTag(sal_False),bIsBroken(sal_False),bHasBeenFixed(sal_False),bDone(sal_False),aTokenString( paStr ),nId( pnId ),nPos(nP) {;}
+    explicit    TokenInfo( TokenId pnId, sal_uInt16 nP, rtl::OUString const & paStr, ParserMessageList &rErrorList );
 
-    String GetTagName() const;
+    rtl::OUString GetTagName() const;
 
-    String MakeTag() const;
+    rtl::OUString MakeTag() const;
 
     /**
         Is the property to be ignored or does it have the default value anyways
     **/
-    sal_Bool IsPropertyRelevant( const rtl::OString &rName, const String &rValue ) const;
-    sal_Bool IsPropertyValueValid( const rtl::OString &rName, const String &rValue ) const;
+    sal_Bool IsPropertyRelevant( const rtl::OString &rName, const rtl::OUString &rValue ) const;
+    sal_Bool IsPropertyValueValid( const rtl::OString &rName, const rtl::OUString &rValue ) const;
     /**
         Does the property contain the same value for all languages
         e.g.: the href in a link tag
     **/
-    sal_Bool IsPropertyInvariant( const rtl::OString &rName, const String &rValue ) const;
+    sal_Bool IsPropertyInvariant( const rtl::OString &rName, const rtl::OUString &rValue ) const;
     /**
         a subset of IsPropertyInvariant but containing only those that are fixable
         we dont wat to fix e.g.: ahelp :: visibility
@@ -284,19 +283,19 @@ class SimpleParser
 {
 private:
     sal_uInt16 nPos;
-    String aSource;
-    String aLastToken;
+    rtl::OUString aSource;
+    rtl::OUString aLastToken;
     TokenList aTokenList;
 
     TokenInfo aNextTag;     // to store closetag in case of combined tags like <br/>
 
-    String GetNextTokenString( ParserMessageList &rErrorList, sal_uInt16 &rTokeStartPos );
+    rtl::OUString GetNextTokenString( ParserMessageList &rErrorList, sal_uInt16 &rTokeStartPos );
 
 public:
     SimpleParser();
-    void Parse( String PaSource );
+    void Parse( rtl::OUString const & PaSource );
     TokenInfo GetNextToken( ParserMessageList &rErrorList );
-    static String GetLexem( TokenInfo const &aToken );
+    static rtl::OUString GetLexem( TokenInfo const &aToken );
     TokenList& GetTokenList(){ return aTokenList; }
 };
 
@@ -328,7 +327,7 @@ class TokenParser
 
 public:
     TokenParser();
-    void Parse( const String &aCode, ParserMessageList* pList );
+    void Parse( const rtl::OUString &aCode, ParserMessageList* pList );
     TokenList& GetTokenList(){ return aParser.GetTokenList(); }
 };
 
@@ -340,7 +339,7 @@ private:
     ParserMessageList aCompareWarningList;
     void CheckTags( TokenList &aReference, TokenList &aTestee, sal_Bool bFixTags );
     sal_Bool IsTagMandatory( TokenInfo const &aToken, TokenId &aMetaTokens );
-    String aFixedTestee;
+    rtl::OUString aFixedTestee;
 public:
     void CheckReference( GSILine *aReference );
     void CheckTestee( GSILine *aTestee, sal_Bool bHasSourceLine, sal_Bool bFixTags );
@@ -348,7 +347,7 @@ public:
     ParserMessageList& GetCompareWarnings(){ return aCompareWarningList; }
     sal_Bool HasCompareWarnings(){ return ( !aCompareWarningList.empty() ); }
 
-    String GetFixedTestee(){ return aFixedTestee; }
+    rtl::OUString GetFixedTestee(){ return aFixedTestee; }
 };
 
 #endif

l10ntools/inc/xmlparse.hxx

@@ -33,7 +33,6 @@
 #include <expat.h>
 #include <rtl/ustring.hxx>
 #include <rtl/ustrbuf.hxx>
-#include <tools/string.hxx>
 #include <tools/stream.hxx>
 #include "export.hxx"
 #include "xmlutil.hxx"
@@ -224,23 +223,20 @@ public:
     virtual sal_uInt16  GetNodeType();
 
     /// returns file name
-    const String &GetName() { return sFileName; }
-    void          SetName( const String &rFilename ) { sFileName = rFilename; }
-    void          SetFullName( const String &rFullFilename ) { sFullName = rFullFilename; }
+    rtl::OUString GetName() { return sFileName; }
+    void          SetName( const rtl::OUString &rFilename ) { sFileName = rFilename; }
+    void          SetFullName( const rtl::OUString &rFullFilename ) { sFullName = rFullFilename; }
     const std::vector<rtl::OString> getOrder(){ return order; }
 
 protected:
     // writes a string as UTF8 with dos line ends to a given stream
-    void        WriteString( ofstream &rStream, const String &sString );
-
-    // quotes the given text for writing to a file
-    void        QuotHTML( String &rString );
+    void        WriteString( ofstream &rStream, const rtl::OUString &sString );
 
     void        InsertL10NElement( XMLElement* pElement);
 
     // DATA
-    String      sFileName;
-    String      sFullName;
+    rtl::OUString      sFileName;
+    rtl::OUString      sFullName;
 
     const rtl::OString ID, OLDREF, XML_LANG;
 
@@ -256,13 +252,10 @@ class XMLUtil{
 
 public:
     /// Quot the XML characters and replace \n \t
-    static void         QuotHTML( String &rString );
+    static void         QuotHTML( rtl::OUString &rString );
 
     /// UnQuot the XML characters and restore \n \t
-    static void         UnQuotHTML  ( String &rString );
-private:
-    static void UnQuotData( String &rString );
-    static void UnQuotTags( String &rString );
+    static void         UnQuotHTML  ( rtl::OUString &rString );
 };
 
 
@@ -274,7 +267,7 @@ private:
 class XMLElement : public XMLParentNode
 {
 private:
-    String sElementName;
+    rtl::OUString sElementName;
     XMLAttributeList *pAttributes;
     rtl::OString   project,
                  filename,
@@ -290,7 +283,7 @@ public:
     /// create a element node
     XMLElement(){}
     XMLElement(
-        const String &rName,    // the element name
+        const rtl::OUString &rName,    // the element name
         XMLParentNode *Parent   // parent node of this element
     ):          XMLParentNode( Parent ),
                 sElementName( rName ),
@@ -312,15 +305,15 @@ public:
     virtual sal_uInt16 GetNodeType();
 
     /// returns element name
-    const String &GetName() { return sElementName; }
+    rtl::OUString GetName() { return sElementName; }
 
     /// returns list of attributes of this element
     XMLAttributeList *GetAttributeList() { return pAttributes; }
 
     /// adds a new attribute to this element, typically used by parser
-    void AddAttribute( const String &rAttribute, const String &rValue );
+    void AddAttribute( const rtl::OUString &rAttribute, const rtl::OUString &rValue );
 
-    void ChangeLanguageTag( const String &rValue );
+    void ChangeLanguageTag( const rtl::OUString &rValue );
     // Return a ASCII String representation of this object
     OString ToOString();
 
@@ -359,18 +352,18 @@ public:
 class XMLData : public XMLChildNode
 {
 private:
-    String sData;
+    rtl::OUString sData;
     bool   isNewCreated;
 
 public:
     /// create a data node
     XMLData(
-        const String &rData,    // the initial data
+        const rtl::OUString &rData,    // the initial data
         XMLParentNode *Parent   // the parent node of this data, typically a element node
     )
                 : XMLChildNode( Parent ), sData( rData ) , isNewCreated ( false ){}
     XMLData(
-        const String &rData,    // the initial data
+        const rtl::OUString &rData,    // the initial data
         XMLParentNode *Parent,  // the parent node of this data, typically a element node
         bool newCreated
     )
@@ -382,12 +375,12 @@ public:
     virtual sal_uInt16 GetNodeType();
 
     /// returns the data
-    const String &GetData() { return sData; }
+    rtl::OUString GetData() { return sData; }
 
     bool isNew() { return isNewCreated; }
     /// adds new character data to the existing one
     void AddData(
-        const String &rData // the new data
+        const rtl::OUString &rData // the new data
     );
 
 
@@ -401,12 +394,12 @@ public:
 class XMLComment : public XMLChildNode
 {
 private:
-    String sComment;
+    rtl::OUString sComment;
 
 public:
     /// create a comment node
     XMLComment(
-        const String &rComment, // the comment
+        const rtl::OUString &rComment, // the comment
         XMLParentNode *Parent   // the parent node of this comemnt, typically a element node
     )
                 : XMLChildNode( Parent ), sComment( rComment ) {}
@@ -418,7 +411,7 @@ public:
     XMLComment& operator=(const XMLComment& obj);
 
     /// returns the comment
-    const String &GetComment()  { return sComment; }
+    rtl::OUString GetComment()  { return sComment; }
 };
 
 //-------------------------------------------------------------------------
@@ -428,12 +421,12 @@ public:
 class XMLDefault : public XMLChildNode
 {
 private:
-    String sDefault;
+    rtl::OUString sDefault;
 
 public:
     /// create a comment node
     XMLDefault(
-        const String &rDefault, // the comment
+        const rtl::OUString &rDefault, // the comment
         XMLParentNode *Parent   // the parent node of this comemnt, typically a element node
     )
                 : XMLChildNode( Parent ), sDefault( rDefault ) {}
@@ -446,7 +439,7 @@ public:
     virtual sal_uInt16 GetNodeType();
 
     /// returns the comment
-    const String &GetDefault()  { return sDefault; }
+    rtl::OUString GetDefault()  { return sDefault; }
 };
 
 //-------------------------------------------------------------------------
@@ -457,7 +450,7 @@ struct XMLError {
     XML_Error eCode;    // the error code
     sal_uLong nLine;        // error line number
     sal_uLong nColumn;      // error column number
-    String sMessage;    // readable error message
+    rtl::OUString sMessage;    // readable error message
 };
 
 //-------------------------------------------------------------------------
@@ -498,8 +491,8 @@ public:
 
     /// parse a file, returns NULL on criticall errors
     XMLFile *Execute(
-        const String &rFullFileName,
-        const String &rFileName,    // the file name
+        const rtl::OUString &rFullFileName,
+        const rtl::OUString &rFileName,    // the file name
         XMLFile *pXMLFileIn         // the XMLFile
     );
 

l10ntools/inc/xrmmerge.hxx

@@ -26,9 +26,6 @@
  *
  ************************************************************************/
 
-// global includes
-#include <tools/string.hxx>
-
 //
 // XRMResParser
 //
@@ -36,42 +33,42 @@
 class XRMResParser
 {
 private:
-    ByteString sGID;
-    ByteString sLID;
+    rtl::OString sGID;
+    rtl::OString sLID;
 
     sal_Bool bError;
     sal_Bool bText;
 
     bool sLocalized;
 
-    ByteString sCurrentOpenTag;
-    ByteString sCurrentCloseTag;
-    ByteString sCurrentText;
+    rtl::OString sCurrentOpenTag;
+    rtl::OString sCurrentCloseTag;
+    rtl::OString sCurrentText;
     std::vector<rtl::OString> aLanguages;
 
 protected:
-    ByteString GetAttribute( const ByteString &rToken, const ByteString &rAttribute );
-    void Error( const ByteString &rError );
+    rtl::OString GetAttribute( const rtl::OString &rToken, const rtl::OString &rAttribute );
+    void Error( const rtl::OString &rError );
 
-    virtual void Output( const ByteString& rOutput )=0;
+    virtual void Output( const rtl::OString& rOutput )=0;
     virtual void WorkOnDesc(
-        const ByteString &rOpenTag,
-        ByteString &rText
+        const rtl::OString &rOpenTag,
+        rtl::OString &rText
     )=0;
     virtual void WorkOnText(
-        const ByteString &rOpenTag,
-        ByteString &rText
+        const rtl::OString &rOpenTag,
+        rtl::OString &rText
     )=0;
     virtual void EndOfText(
-        const ByteString &rOpenTag,
-        const ByteString &rCloseTag
+        const rtl::OString &rOpenTag,
+        const rtl::OString &rCloseTag
     )=0;
 
-    ByteString GetGID() { return sGID; }
-    ByteString GetLID() { return sLID; }
+    rtl::OString GetGID() { return sGID; }
+    rtl::OString GetLID() { return sLID; }
 
-    void ConvertStringToDBFormat( ByteString &rString );
-    void ConvertStringToXMLFormat( ByteString &rString );
+    void ConvertStringToDBFormat( rtl::OString &rString );
+    void ConvertStringToXMLFormat( rtl::OString &rString );
 
 public:
     XRMResParser();
@@ -94,7 +91,7 @@ private:
 protected:
     SvFileStream *pOutputStream;
 public:
-    XRMResOutputParser ( const ByteString &rOutputFile );
+    XRMResOutputParser ( const rtl::OString &rOutputFile );
     virtual ~XRMResOutputParser();
 };
 
@@ -106,30 +103,30 @@ class XRMResExport : public XRMResOutputParser
 {
 private:
     ResData *pResData;
-    ByteString sPrj;
-    ByteString sPath;
+    rtl::OString sPrj;
+    rtl::OString sPath;
     std::vector<rtl::OString> aLanguages;
 
 protected:
     void WorkOnDesc(
-        const ByteString &rOpenTag,
-        ByteString &rText
+        const rtl::OString &rOpenTag,
+        rtl::OString &rText
     );
     void WorkOnText(
-        const ByteString &rOpenTag,
-        ByteString &rText
+        const rtl::OString &rOpenTag,
+        rtl::OString &rText
     );
     void EndOfText(
-        const ByteString &rOpenTag,
-        const ByteString &rCloseTag
+        const rtl::OString &rOpenTag,
+        const rtl::OString &rCloseTag
     );
-    void Output( const ByteString& rOutput );
+    void Output( const rtl::OString& rOutput );
 
 public:
     XRMResExport(
-        const ByteString &rOutputFile,
-        const ByteString &rProject,
-        const ByteString &rFilePath
+        const rtl::OString &rOutputFile,
+        const rtl::OString &rProject,
+        const rtl::OString &rFilePath
     );
     virtual ~XRMResExport();
 };
@@ -142,29 +139,29 @@ class XRMResMerge : public XRMResOutputParser
 {
 private:
     MergeDataFile *pMergeDataFile;
-    ByteString sFilename;
+    rtl::OString sFilename;
     ResData *pResData;
     std::vector<rtl::OString> aLanguages;
 
 protected:
     void WorkOnDesc(
-        const ByteString &rOpenTag,
-        ByteString &rText
+        const rtl::OString &rOpenTag,
+        rtl::OString &rText
     );
     void WorkOnText(
-        const ByteString &rOpenTag,
-        ByteString &rText
+        const rtl::OString &rOpenTag,
+        rtl::OString &rText
     );
     void EndOfText(
-        const ByteString &rOpenTag,
-        const ByteString &rCloseTag
+        const rtl::OString &rOpenTag,
+        const rtl::OString &rCloseTag
     );
-    void Output( const ByteString& rOutput );
+    void Output( const rtl::OString& rOutput );
 public:
     XRMResMerge(
-        const ByteString &rMergeSource,
-        const ByteString &rOutputFile,
-        ByteString &rFilename
+        const rtl::OString &rMergeSource,
+        const rtl::OString &rOutputFile,
+        const rtl::OString &rFilename
     );
     virtual ~XRMResMerge();
 };

l10ntools/source/export2.cxx

@@ -114,9 +114,9 @@ void Export::DumpMap(const rtl::OString& rMapName,
         return;
     for(OStringHashMap::const_iterator idbg = aMap.begin(); idbg != aMap.end(); ++idbg)
     {
-        ByteString a( idbg->first );
-        ByteString b( idbg->second );
-        printf("[%s]= %s",a.GetBuffer(),b.GetBuffer());
+        rtl::OString a( idbg->first );
+        rtl::OString b( idbg->second );
+        printf("[%s]= %s",a.getStr(),b.getStr());
         printf("\n");
     }
     printf("\n");
@@ -343,7 +343,7 @@ void Export::InitLanguages( bool bMergeMode ){
 /*****************************************************************************/
     if( !isInitialized )
     {
-        ByteString sTmp;
+        rtl::OString sTmp;
         OStringBoolHashMap aEnvLangs;
 
         sal_Int32 nIndex = 0;
@@ -353,7 +353,7 @@ void Export::InitLanguages( bool bMergeMode ){
             sTmp = getToken(aToken, 0, '=');
             sTmp = comphelper::string::strip(sTmp, ' ');
             if( bMergeMode && !isAllowed( sTmp ) ){}
-            else if( !( (sTmp.GetChar(0)=='x' || sTmp.GetChar(0)=='X') && sTmp.GetChar(1)=='-' ) ){
+            else if( !( (sTmp[0]=='x' || sTmp[0]=='X') && sTmp[1]=='-' ) ){
                 aLanguages.push_back( sTmp );
             }
         }
@@ -366,7 +366,7 @@ void Export::InitLanguages( bool bMergeMode ){
 /*****************************************************************************/
 void Export::InitForcedLanguages( bool bMergeMode ){
 /*****************************************************************************/
-    ByteString sTmp;
+    rtl::OString sTmp;
     OStringBoolHashMap aEnvLangs;
 
     sal_Int32 nIndex = 0;
@@ -377,7 +377,7 @@ void Export::InitForcedLanguages( bool bMergeMode ){
         sTmp = getToken(aToken, 0, '=');
         sTmp = comphelper::string::strip(sTmp, ' ');
         if( bMergeMode && isAllowed( sTmp ) ){}
-        else if( !( (sTmp.GetChar(0)=='x' || sTmp.GetChar(0)=='X') && sTmp.GetChar(1)=='-' ) )
+        else if( !( (sTmp[0]=='x' || sTmp[0]=='X') && sTmp[1]=='-' ) )
             aForcedLanguages.push_back( sTmp );
     }
     while ( nIndex >= 0 );
@@ -399,8 +399,8 @@ sal_Bool Export::ConvertLineEnds(
     rtl::OString const & sSource, rtl::OString const & sDestination )
 /*****************************************************************************/
 {
-    String sSourceFile( sSource, RTL_TEXTENCODING_ASCII_US );
-    String sDestinationFile( sDestination, RTL_TEXTENCODING_ASCII_US );
+    rtl::OUString sSourceFile(rtl::OStringToOUString(sSource, RTL_TEXTENCODING_ASCII_US));
+    rtl::OUString sDestinationFile(rtl::OStringToOUString(sDestination, RTL_TEXTENCODING_ASCII_US));
 
     SvFileStream aSource( sSourceFile, STREAM_READ );
     if ( !aSource.IsOpen())
@@ -512,10 +512,10 @@ DirEntry Export::GetTempFile()
     int nRC = osl::FileBase::createTempFile( 0 , 0 , sTempFilename );
     if( nRC ) printf(" osl::FileBase::createTempFile RC = %d",nRC);
 
-    String strTmp( *sTempFilename  );
+    rtl::OUString strTmp( *sTempFilename  );
 
     INetURLObject::DecodeMechanism eMechanism = INetURLObject::DECODE_TO_IURI;
-    String sDecodedStr = INetURLObject::decode( strTmp , '%' , eMechanism );
+    rtl::OUString sDecodedStr = INetURLObject::decode( strTmp , '%' , eMechanism );
     rtl::OString sTmp(rtl::OUStringToOString(sDecodedStr , RTL_TEXTENCODING_UTF8));
 
 #if defined(WNT)

l10ntools/source/helper.hxx

@@ -56,6 +56,21 @@ inline sal_Int32 searchAndReplace(
     return i;
 }
 
+inline void searchAndReplaceAll(
+    rtl::OString * text, rtl::OString const & search,
+    rtl::OString const & replace)
+{
+    assert(text != 0);
+    for (sal_Int32 i = 0;;) {
+        i = text->indexOf(search, i);
+        if (i == -1) {
+            break;
+        }
+        *text = text->replaceAt(i, search.getLength(), replace);
+        i += replace.getLength();
+    }
+}
+
 inline rtl::OString getToken(
     rtl::OString const & text, sal_Int32 token, char separator)
 {
@@ -63,6 +78,23 @@ inline rtl::OString getToken(
     return text.getToken(token, separator, i);
 }
 
+inline sal_Int32 indexOfAnyAsciiL(
+    rtl::OUString const & text, char const * chars, sal_Int32 charsLen,
+    sal_Int32 index = 0)
+{
+    for (; index != text.getLength(); ++index) {
+        sal_Unicode c = text[index];
+        if (c <= 0x7F
+            && (rtl_str_indexOfChar_WithLength(
+                    chars, charsLen, static_cast< char >(c))
+                != -1))
+        {
+            return index;
+        }
+    }
+    return -1;
+}
+
 }
 
 #endif

l10ntools/source/helpmerge.cxx

@@ -57,7 +57,7 @@ void HelpParser::Dump(XMLHashMap* rElem_in)
 
 void HelpParser::Dump(LangHashMap* rElem_in,const rtl::OString & sKey_in)
 {
-    ByteString x;
+    rtl::OString x;
     OString y;
     fprintf(stdout,"+------------%s-----------+\n",sKey_in.getStr() );
     for(LangHashMap::iterator posn=rElem_in->begin();posn!=rElem_in->end();++posn)
@@ -111,15 +111,13 @@ bool HelpParser::CreateSDF(
         sXmlFile = String( sHelpFile , RTL_TEXTENCODING_ASCII_US );
     }
 
-//    ByteString fullFilePath;
-    //DirEntry aFile( sXmlFile );
-    //makeAbsolutePath( sHelpFile , rRoot_in);
-    ByteString fullFilePath = rPrj_in;
-    fullFilePath.Append( "\\" );
-    fullFilePath.Append( makeAbsolutePath( sHelpFile , rRoot_in ) );
-    fullFilePath.SearchAndReplaceAll( "\\", "/" );
+    rtl::OString fullFilePath = rPrj_in;
+    fullFilePath += "\\";
+    fullFilePath += makeAbsolutePath( sHelpFile , rRoot_in );
+    fullFilePath = fullFilePath.replace('\\', '/');
 
-    String strFullPath( fullFilePath.GetBuffer() , RTL_TEXTENCODING_ASCII_US );
+    rtl::OUString strFullPath(
+        rtl::OStringToOUString(fullFilePath, RTL_TEXTENCODING_ASCII_US));
 
     //printf( "%s\n", fullFilePath.GetBuffer() );
     std::auto_ptr <XMLFile> file ( aParser.Execute( strFullPath , sXmlFile, pXmlFile ) );
@@ -147,8 +145,9 @@ bool HelpParser::CreateSDF(
     LangHashMap* pElem;
     XMLElement*  pXMLElement  = NULL;
 
-    ByteString sTimeStamp( Export::GetTimeStamp() );
-    OUString sOUTimeStamp( sTimeStamp.GetBuffer() , sTimeStamp.Len() , RTL_TEXTENCODING_ASCII_US );
+    OUString sOUTimeStamp(
+        rtl::OStringToOUString(
+            Export::GetTimeStamp(), RTL_TEXTENCODING_ASCII_US));
 
     OUStringBuffer sBuffer;
     const OUString sOUPrj( rPrj_in.getStr() , rPrj_in.getLength() , RTL_TEXTENCODING_ASCII_US );

l10ntools/source/xrmmerge.cxx

@@ -33,6 +33,7 @@
 
 // local includes
 #include "export.hxx"
+#include "helper.hxx"
 #include "xrmmerge.hxx"
 #include "tokens.h"
 #include <iostream>
@@ -302,7 +303,7 @@ int XRMResParser::Execute( int nToken, char * pToken )
 
     switch ( nToken ) {
         case XRM_TEXT_START:{
-                ByteString sNewLID = GetAttribute( rToken, "id" );
+                rtl::OString sNewLID = GetAttribute( rToken, "id" );
                 if ( sNewLID != sLID ) {
                     sLID = sNewLID;
                 }
@@ -404,7 +405,7 @@ int XRMResParser::Execute( int nToken, char * pToken )
 }
 
 /*****************************************************************************/
-ByteString XRMResParser::GetAttribute( const ByteString &rToken, const ByteString &rAttribute )
+rtl::OString XRMResParser::GetAttribute( const rtl::OString &rToken, const rtl::OString &rAttribute )
 /*****************************************************************************/
 {
     ByteString sTmp( rToken );
@@ -426,17 +427,17 @@ ByteString XRMResParser::GetAttribute( const ByteString &rToken, const ByteStrin
 
 
 /*****************************************************************************/
-void XRMResParser::Error( const ByteString &rError )
+void XRMResParser::Error( const rtl::OString &rError )
 /*****************************************************************************/
 {
-    yyerror(( char * ) rError.GetBuffer());
+    yyerror(( char * ) rError.getStr());
 }
 
 /*****************************************************************************/
-void XRMResParser::ConvertStringToDBFormat( ByteString &rString )
+void XRMResParser::ConvertStringToDBFormat( rtl::OString &rString )
 /*****************************************************************************/
 {
-    ByteString sResult;
+    rtl::OString sResult;
     do {
         sResult = rString;
         rString = comphelper::string::stripStart(rString, _LF);
@@ -444,14 +445,14 @@ void XRMResParser::ConvertStringToDBFormat( ByteString &rString )
         rString = comphelper::string::stripEnd(rString, '\t');
     } while ( sResult != rString );
 
-    rString.SearchAndReplaceAll( "\t", "\\t" );
+    helper::searchAndReplaceAll(&rString, "\t", "\\t");
 }
 
 /*****************************************************************************/
-void XRMResParser::ConvertStringToXMLFormat( ByteString &rString )
+void XRMResParser::ConvertStringToXMLFormat( rtl::OString &rString )
 /*****************************************************************************/
 {
-    rString.SearchAndReplaceAll( "\\t", "\t" );
+    helper::searchAndReplaceAll(&rString, "\\t", "\t");
 }
 
 
@@ -461,7 +462,7 @@ void XRMResParser::ConvertStringToXMLFormat( ByteString &rString )
 //
 
 /*****************************************************************************/
-XRMResOutputParser::XRMResOutputParser ( const ByteString &rOutputFile )
+XRMResOutputParser::XRMResOutputParser ( const rtl::OString &rOutputFile )
 /*****************************************************************************/
 {
     aLanguages = Export::GetLanguages();
@@ -496,8 +497,8 @@ XRMResOutputParser::~XRMResOutputParser()
 
 /*****************************************************************************/
 XRMResExport::XRMResExport(
-    const ByteString &rOutputFile, const ByteString &rProject,
-    const ByteString &rFilePath )
+    const rtl::OString &rOutputFile, const rtl::OString &rProject,
+    const rtl::OString &rFilePath )
 /*****************************************************************************/
                 : XRMResOutputParser( rOutputFile ),
                 pResData( NULL ),
@@ -514,16 +515,12 @@ XRMResExport::~XRMResExport()
     delete pResData;
 }
 
-void XRMResExport::Output( const ByteString& rOutput )
-{
-    // Dummy to suppress warnings caused by poor class design
-    (void) rOutput;
-}
+void XRMResExport::Output( const rtl::OString& ) {}
 
 /*****************************************************************************/
 void XRMResExport::WorkOnDesc(
-    const ByteString &rOpenTag,
-    ByteString &rText
+    const rtl::OString &rOpenTag,
+    rtl::OString &rText
 )
 /*****************************************************************************/
 {
@@ -543,7 +540,7 @@ void XRMResExport::WorkOnDesc(
         file.close();
         memblock[size] = '\0';
         rText = ByteString(memblock);
-        rText.SearchAndReplaceAll( "\n", "\\n" );
+        helper::searchAndReplaceAll(&rText, "\n", "\\n");
         delete[] memblock;
      }
     WorkOnText( rOpenTag, rText );
@@ -552,8 +549,8 @@ void XRMResExport::WorkOnDesc(
 
 //*****************************************************************************/
 void XRMResExport::WorkOnText(
-    const ByteString &rOpenTag,
-    ByteString &rText
+    const rtl::OString &rOpenTag,
+    rtl::OString &rText
 )
 /*****************************************************************************/
 {
@@ -566,22 +563,18 @@ void XRMResExport::WorkOnText(
         pResData->sId = GetLID();
     }
 
-    ByteString sText(rText);
+    rtl::OString sText(rText);
     ConvertStringToDBFormat(sText);
     pResData->sText[sLang] = sText;
 }
 
 /*****************************************************************************/
 void XRMResExport::EndOfText(
-    const ByteString &rOpenTag,
-    const ByteString &rCloseTag
+    const rtl::OString &,
+    const rtl::OString &
 )
 /*****************************************************************************/
 {
-
-    (void) rOpenTag;        // FIXME
-    (void) rCloseTag;       // FIXME
-
     if ( pResData && pOutputStream )
     {
         ByteString sTimeStamp( Export::GetTimeStamp());
@@ -627,15 +620,15 @@ void XRMResExport::EndOfText(
 
 /*****************************************************************************/
 XRMResMerge::XRMResMerge(
-    const ByteString &rMergeSource, const ByteString &rOutputFile,
-    ByteString &rFilename)
+    const rtl::OString &rMergeSource, const rtl::OString &rOutputFile,
+    const rtl::OString &rFilename)
 /*****************************************************************************/
                 : XRMResOutputParser( rOutputFile ),
                 pMergeDataFile( NULL ),
                 sFilename( rFilename ) ,
                 pResData( NULL )
 {
-    if ( rMergeSource.Len())
+    if (!rMergeSource.isEmpty())
         pMergeDataFile = new MergeDataFile(
             rMergeSource, sInputFileName, bErrorLog);
     if( Export::sLanguages.equalsIgnoreAsciiCaseL(RTL_CONSTASCII_STRINGPARAM("ALL")))
@@ -657,8 +650,8 @@ XRMResMerge::~XRMResMerge()
 
 /*****************************************************************************/
 void XRMResMerge::WorkOnDesc(
-    const ByteString &rOpenTag,
-    ByteString &rText
+    const rtl::OString &rOpenTag,
+    rtl::OString &rText
 )
 /*****************************************************************************/
 {
@@ -721,8 +714,8 @@ void XRMResMerge::WorkOnDesc(
 
 /*****************************************************************************/
 void XRMResMerge::WorkOnText(
-    const ByteString &rOpenTag,
-    ByteString &rText
+    const rtl::OString &rOpenTag,
+    rtl::OString &rText
 )
 /*****************************************************************************/
 {
@@ -753,18 +746,18 @@ void XRMResMerge::WorkOnText(
 }
 
 /*****************************************************************************/
-void XRMResMerge::Output( const ByteString& rOutput )
+void XRMResMerge::Output( const rtl::OString& rOutput )
 /*****************************************************************************/
 {
     //printf("W: %s\n",rOutput.GetBuffer());
-    if ( pOutputStream && rOutput.Len() > 0 )
-        pOutputStream->Write( rOutput.GetBuffer(), rOutput.Len());
+    if ( pOutputStream && !rOutput.isEmpty() )
+        pOutputStream->Write( rOutput.getStr(), rOutput.getLength());
 }
 
 /*****************************************************************************/
 void XRMResMerge::EndOfText(
-    const ByteString &rOpenTag,
-    const ByteString &rCloseTag
+    const rtl::OString &rOpenTag,
+    const rtl::OString &rCloseTag
 )
 /*****************************************************************************/
 {