Clean up l10ntools xml parser.

-Remove namespaces from header.
-Remove unused members (dbgcnt)
-Remove helpless methods (SetValue, copy ctr and operator,
inherited but not overriden virtual functions)
-Use prefixes for variables
-Use const where it possible
-Remove visual noise
-Correct indentation

Change-Id: I295be484dde157847cd16f260ec70d5cdb5b6fb4

3 files changed, 577 insertions, 716 deletions

diff --git a/l10ntools/inc/xmlparse.hxx b/l10ntools/inc/xmlparse.hxx
index 07b9b8758b96..306c8be8f22b 100644
--- a/l10ntools/inc/xmlparse.hxx
+++ b/l10ntools/inc/xmlparse.hxx
@@ -38,26 +38,19 @@
 class XMLParentNode;
 class XMLElement;
 
-
-using namespace ::rtl;
-using namespace std;
-
 #define XML_NODE_TYPE_FILE          0x001
 #define XML_NODE_TYPE_ELEMENT       0x002
 #define XML_NODE_TYPE_DATA          0x003
 #define XML_NODE_TYPE_COMMENT       0x004
 #define XML_NODE_TYPE_DEFAULT       0x005
 
-
-//-------------------------------------------------------------------------
-
 /** Holds data of Attributes
  */
 class XMLAttribute
 {
 private:
-    OString sName;
-    OString sValue;
+    OString m_sName;
+    OString m_sValue;
 
 public:
     /// creates an attribute
@@ -65,64 +58,50 @@ public:
         const OString &rName,    // attributes name
         const OString &rValue    // attributes data
     )
-    : sName( rName ), sValue( rValue ) {}
-
-    OString GetName() const { return sName; }
-    OString GetValue() const { return sValue; }
+    : m_sName( rName ), m_sValue( rValue ) {}
 
-    void setValue(const OString &rValue){sValue=rValue;}
+    OString GetName() const { return m_sName; }
+    OString GetValue() const { return m_sValue; }
 
-    /// returns true if two attributes are equal and have the same value
-    sal_Bool IsEqual(
-        const XMLAttribute &rAttribute  // the attribute which has to be equal
-    )
-    {
-        return (( rAttribute.sName == sName ) && ( rAttribute.sValue == sValue ));
-    }
+    void setValue( const OString &rValue ){ m_sValue = rValue; }
 };
 
-typedef std::vector< XMLAttribute* > XMLAttributeList;
 
-//-------------------------------------------------------------------------
+typedef std::vector< XMLAttribute* > XMLAttributeList;
 
 /** Virtual base to handle different kinds of XML nodes
  */
 class XMLNode
 {
 protected:
-    XMLNode() {}
+    XMLNode(){}
 
 public:
-    virtual sal_uInt16 GetNodeType() = 0;
-    virtual ~XMLNode() {}
+    virtual sal_uInt16 GetNodeType() const = 0;
+    virtual ~XMLNode(){}
 };
 
-//-------------------------------------------------------------------------
 
 /** Virtual base to handle different kinds of child nodes
  */
 class XMLChildNode : public XMLNode
 {
 private:
-    XMLParentNode *pParent;
+    XMLParentNode *m_pParent;
 
 protected:
     XMLChildNode( XMLParentNode *pPar );
-    XMLChildNode():pParent( NULL ){};
-    XMLChildNode( const XMLChildNode& obj);
-    XMLChildNode& operator=(const XMLChildNode& obj);
+    XMLChildNode(): m_pParent( NULL ){};
+    XMLChildNode( const XMLChildNode& rObj);
+    XMLChildNode& operator=(const XMLChildNode& rObj);
 public:
-    virtual sal_uInt16 GetNodeType() = 0;
-
     /// returns the parent of this node
-    XMLParentNode *GetParent() { return pParent; }
+    XMLParentNode *GetParent() { return m_pParent; }
     virtual ~XMLChildNode(){};
 };
 
 typedef std::vector< XMLChildNode* > XMLChildNodeList;
 
-//-------------------------------------------------------------------------
-
 class XMLData;
 
 /** Virtual base to handle different kinds of parent nodes
@@ -131,28 +110,21 @@ class XMLData;
 class XMLParentNode : public XMLChildNode
 {
 private:
-    XMLChildNodeList* pChildList;
-    static int dbgcnt;
+    XMLChildNodeList* m_pChildList;
 
 protected:
     XMLParentNode( XMLParentNode *pPar )
-                : XMLChildNode( pPar ), pChildList( NULL )
-              {
-              }
-    XMLParentNode(): pChildList(NULL){
-    }
+        : XMLChildNode( pPar ), m_pChildList( NULL ){}
+    XMLParentNode(): m_pChildList(NULL){}
 
     XMLParentNode( const XMLParentNode& );
 
-    XMLParentNode& operator=(const XMLParentNode& obj);
+    XMLParentNode& operator=(const XMLParentNode& rObj);
     virtual ~XMLParentNode();
 
-
 public:
-    virtual sal_uInt16 GetNodeType() = 0;
-
     /// returns child list of this node
-    XMLChildNodeList *GetChildList() { return pChildList; }
+    XMLChildNodeList *GetChildList() { return m_pChildList; }
 
     /// adds a new child
     void AddChild(
@@ -162,122 +134,103 @@ public:
     void RemoveAndDeleteAllChildren();
 };
 
-//-------------------------------------------------------------------------
-
 /// Mapping numeric Language code <-> XML Element
 typedef boost::unordered_map<OString, XMLElement*, OStringHash> LangHashMap;
 
 /// Mapping XML Element string identifier <-> Language Map
 typedef boost::unordered_map<OString, LangHashMap*, OStringHash> XMLHashMap;
 
-/// Mapping iso alpha string code <-> iso numeric code
-typedef boost::unordered_map<OString, int, OStringHash> HashMap;
-
 /// Mapping XML tag names <-> have localizable strings
 typedef boost::unordered_map<OString, sal_Bool, OStringHash> TagMap;
 
 /** Holds information of a XML file, is root node of tree
  */
-
 class XMLFile : public XMLParentNode
 {
 public:
     XMLFile(
         const OString &rFileName // the file name, empty if created from memory stream
     );
-    XMLFile( const XMLFile& obj ) ;
+    XMLFile( const XMLFile& rObj ) ;
     ~XMLFile();
 
-    void        Print( XMLNode *pCur = NULL, sal_uInt16 nLevel = 0 );
+    void Print( XMLNode *pCur = NULL, sal_uInt16 nLevel = 0 );
     virtual void SearchL10NElements( XMLParentNode *pCur, int pos = 0 );
-    void        Extract( XMLFile *pCur = NULL );
+    void Extract( XMLFile *pCur = NULL );
 
-    XMLHashMap* GetStrings(){return XMLStrings;}
+    XMLHashMap* GetStrings(){ return m_pXMLStrings; }
     void Write( OString const &rFilename );
-    sal_Bool        Write( ofstream &rStream , XMLNode *pCur = NULL );
+    sal_Bool Write( std::ofstream &rStream, XMLNode *pCur = NULL );
 
-    bool        CheckExportStatus( XMLParentNode *pCur = NULL );// , int pos = 0 );
+    bool CheckExportStatus( XMLParentNode *pCur = NULL );
 
-    XMLFile&    operator=(const XMLFile& obj);
+    XMLFile& operator=(const XMLFile& rObj);
 
-    virtual sal_uInt16  GetNodeType();
+    virtual sal_uInt16 GetNodeType() const { return XML_NODE_TYPE_FILE; }
 
     /// returns file name
-    OString GetName() const { return sFileName; }
-    void SetName( const OString &rFilename ) { sFileName = rFilename; }
-    const std::vector<OString>& getOrder() const { return order; }
+    OString GetName() const { return m_sFileName; }
+    void SetName( const OString &rFilename ) { m_sFileName = rFilename; }
+    const std::vector<OString>& getOrder() const { return m_vOrder; }
 
 protected:
 
-    void        InsertL10NElement( XMLElement* pElement);
+    void InsertL10NElement( XMLElement* pElement);
 
     // DATA
-    OString      sFileName;
+    OString m_sFileName;
 
-    TagMap      nodes_localize;
-    XMLHashMap* XMLStrings;
+    TagMap m_aNodes_localize;
+    XMLHashMap* m_pXMLStrings;
 
-    std::vector <OString> order;
+    std::vector <OString> m_vOrder;
 };
 
 /// An Utility class for XML
-class XMLUtil{
-
+class XMLUtil
+{
 public:
     /// Quot the XML characters
     static OString QuotHTML( const OString& rString );
 };
 
 
-//-------------------------------------------------------------------------
-
 /** Hold information of an element node
  */
 class XMLElement : public XMLParentNode
 {
 private:
-    OString sElementName;
-    XMLAttributeList *pAttributes;
-    OString   project,
-                 filename,
-                 id,
-                 sOldRef,
-                 resourceType,
-                 languageId;
-    int          nPos;
+    OString m_sElementName;
+    XMLAttributeList *m_pAttributes;
+    OString m_sProject;
+    OString m_sFilename;
+    OString m_sId;
+    OString m_sOldRef;
+    OString m_sResourceType;
+    OString m_sLanguageId;
+    int m_nPos;
 
 protected:
-    void Print(XMLNode *pCur, OStringBuffer& buffer , bool rootelement);
+    void Print(XMLNode *pCur, OStringBuffer& rBuffer, bool bRootelement) const;
 public:
     /// create an element node
     XMLElement(){}
     XMLElement(
         const OString &rName,    // the element name
-        XMLParentNode *Parent   // parent node of this element
-    ):          XMLParentNode( Parent ),
-                sElementName( rName ),
-                pAttributes( NULL ),
-                project(""),
-                filename(""),
-                id(""),
-                sOldRef(""),
-                resourceType(""),
-                languageId(""),
-                nPos(0)
-                   {
-                }
+        XMLParentNode *pParent   // parent node of this element
+    );
+
     ~XMLElement();
     XMLElement(const XMLElement&);
 
-    XMLElement& operator=(const XMLElement& obj);
-    /// returns node type XML_NODE_ELEMENT
-    virtual sal_uInt16 GetNodeType();
+    XMLElement& operator=(const XMLElement& rObj);
+    virtual sal_uInt16 GetNodeType() const { return XML_NODE_TYPE_ELEMENT; }
 
     /// returns element name
-    OString GetName() const { return sElementName; }
+    OString GetName() const { return m_sElementName; }
 
     /// returns list of attributes of this element
-    XMLAttributeList *GetAttributeList() { return pAttributes; }
+    XMLAttributeList *GetAttributeList() { return m_pAttributes; }
 
     /// adds a new attribute to this element, typically used by parser
     void AddAttribute( const OString &rAttribute, const OString &rValue );
@@ -287,147 +240,122 @@ public:
     /// Return a Unicode String representation of this object
     OString ToOString();
 
-    void SetProject         ( OString const & prj        ){ project = prj;        }
-    void SetFileName        ( OString const & fn         ){ filename = fn;        }
-    void SetId              ( OString const & theId      ){ id = theId;           }
-    void SetResourceType    ( OString const & rt         ){ resourceType = rt;    }
-    void SetLanguageId      ( OString const & lid        ){ languageId = lid;     }
-    void SetPos             ( int nPos_in           ){ nPos = nPos_in;       }
-    void SetOldRef          ( OString const & sOldRef_in ){ sOldRef = sOldRef_in; }
+    void SetProject         ( OString const & sPrj )        { m_sProject = sPrj; }
+    void SetFileName        ( OString const & sFileName )   { m_sFilename = sFileName; }
+    void SetId              ( OString const & sTheId )      { m_sId = sTheId; }
+    void SetResourceType    ( OString const & sResType )    { m_sResourceType = sResType; }
+    void SetLanguageId      ( OString const & sLangId )     { m_sLanguageId = sLangId; }
+    void SetPos             ( int nPos )                    { m_nPos = nPos; }
+    void SetOldRef          ( OString const & sOldRef )     { m_sOldRef = sOldRef; }
 
-    virtual int        GetPos()     { return nPos;         }
-    OString GetProject() const      { return project;      }
-    OString GetFileName() const     { return filename;     }
-    OString GetId() const           { return id;           }
-    OString GetOldref() const       { return sOldRef;      }
-    OString GetResourceType() const { return resourceType; }
-    OString GetLanguageId() const   { return languageId;   }
+    virtual int GetPos()            { return m_nPos;         }
+    OString GetProject() const      { return m_sProject;      }
+    OString GetFileName() const     { return m_sFilename;     }
+    OString GetId() const           { return m_sId;           }
+    OString GetOldref() const       { return m_sOldRef;      }
+    OString GetResourceType() const { return m_sResourceType; }
+    OString GetLanguageId() const   { return m_sLanguageId;   }
 
 
 };
-//-------------------------------------------------------------------------
-
 
 /** Holds character data
  */
 class XMLData : public XMLChildNode
 {
 private:
-    OString sData;
-    bool   isNewCreated;
+    OString m_sData;
+    bool    m_bIsNewCreated;
 
 public:
     /// create a data node
     XMLData(
         const OString &rData,    // the initial data
-        XMLParentNode *Parent   // the parent node of this data, typically a element node
+        XMLParentNode *pParent,   // the parent node of this data, typically a element node
+        bool bNewCreated = false
     )
-                : XMLChildNode( Parent ), sData( rData ) , isNewCreated ( false ){}
-    XMLData(
-        const OString &rData,    // the initial data
-        XMLParentNode *Parent,  // the parent node of this data, typically a element node
-        bool newCreated
-    )
-                : XMLChildNode( Parent ), sData( rData ) , isNewCreated ( newCreated ){}
+        : XMLChildNode( pParent ), m_sData( rData ), m_bIsNewCreated( bNewCreated ){}
 
-    XMLData(const XMLData& obj);
+    // Default copy constructor and copy operator work well.
 
-    XMLData& operator=(const XMLData& obj);
-    virtual sal_uInt16 GetNodeType();
+    virtual sal_uInt16 GetNodeType() const { return XML_NODE_TYPE_DATA; }
 
     /// returns the data
-    OString GetData() const { return sData; }
-
-    bool isNew() { return isNewCreated; }
-    /// adds new character data to the existing one
-    void AddData(
-        const OString &rData // the new data
-    );
-
+    OString GetData() const { return m_sData; }
 
+    bool isNew() const { return m_bIsNewCreated; }
 
+    /// adds new character data to the existing one
+    void AddData( const OString &rData ) { m_sData += rData; }
 };
 
-//-------------------------------------------------------------------------
-
 /** Holds comments
  */
 class XMLComment : public XMLChildNode
 {
 private:
-    OString sComment;
+    OString m_sComment;
 
 public:
     /// create a comment node
     XMLComment(
         const OString &rComment, // the comment
-        XMLParentNode *Parent   // the parent node of this comemnt, typically a element node
+        XMLParentNode *pParent   // the parent node of this comemnt, typically a element node
     )
-                : XMLChildNode( Parent ), sComment( rComment ) {}
-
-    virtual sal_uInt16 GetNodeType();
+        : XMLChildNode( pParent ), m_sComment( rComment ) {}
 
-    XMLComment( const XMLComment& obj );
+    // Default copy constructor and copy operator work well.
 
-    XMLComment& operator=(const XMLComment& obj);
+    virtual sal_uInt16 GetNodeType() const { return XML_NODE_TYPE_COMMENT; }
 
     /// returns the comment
-    OString GetComment() const  { return sComment; }
+    OString GetComment() const { return m_sComment; }
 };
 
-//-------------------------------------------------------------------------
-
 /** Holds additional file content like those for which no handler exists
  */
 class XMLDefault : public XMLChildNode
 {
 private:
-    OString sDefault;
+    OString m_sDefault;
 
 public:
     /// create a comment node
     XMLDefault(
         const OString &rDefault, // the comment
-        XMLParentNode *Parent   // the parent node of this comemnt, typically a element node
+        XMLParentNode *pParent   // the parent node of this comemnt, typically a element node
     )
-                : XMLChildNode( Parent ), sDefault( rDefault ) {}
-
-    XMLDefault(const XMLDefault& obj);
+        : XMLChildNode( pParent ), m_sDefault( rDefault ) {}
 
-    XMLDefault& operator=(const XMLDefault& obj);
+    // Default copy constructor and copy operator work well.
 
-    /// returns node type XML_NODE_TYPE_COMMENT
-    virtual sal_uInt16 GetNodeType();
+    virtual sal_uInt16 GetNodeType() const { return XML_NODE_TYPE_DEFAULT; }
 
     /// returns the comment
-    OString GetDefault() const  { return sDefault; }
+    OString GetDefault() const { return m_sDefault; }
 };
 
-//-------------------------------------------------------------------------
-
 /** struct for error information, used by class SimpleXMLParser
  */
 struct XMLError {
-    XML_Error eCode;    ///< the error code
-    std::size_t nLine; ///< error line number
-    std::size_t nColumn; ///< error column number
-    OString sMessage;    ///< readable error message
+    XML_Error m_eCode;    ///< the error code
+    std::size_t m_nLine; ///< error line number
+    std::size_t m_nColumn; ///< error column number
+    OString m_sMessage;    ///< readable error message
 };
 
-//-------------------------------------------------------------------------
-
 /** validating xml parser, creates a document tree with xml nodes
  */
 
 class SimpleXMLParser
 {
 private:
-    XML_Parser aParser;
-    XMLError aErrorInformation;
+    XML_Parser m_aParser;
+    XMLError m_aErrorInformation;
 
-    XMLFile *pXMLFile;
-    XMLParentNode *pCurNode;
-    XMLData *pCurData;
+    XMLFile *m_pXMLFile;
+    XMLParentNode *m_pCurNode;
+    XMLData *m_pCurData;
 
 
     static void StartElementHandler( void *userData, const XML_Char *name, const XML_Char **atts );
@@ -455,7 +383,7 @@ public:
     );
 
     /// returns an error struct
-    const XMLError &GetError() { return aErrorInformation; }
+    const XMLError &GetError() const { return m_aErrorInformation; }
 };
 
 #endif // BOOTSTRP_XMLPARSE_HXX
diff --git a/l10ntools/source/helpmerge.cxx b/l10ntools/source/helpmerge.cxx
index be9b8635c6d2..a8fa684ab443 100644
--- a/l10ntools/source/helpmerge.cxx
+++ b/l10ntools/source/helpmerge.cxx
@@ -88,7 +88,7 @@ bool HelpParser::CreatePO(
         printf(
             "%s: %s\n",
             sHelpFile.getStr(),
-            aParser.GetError().sMessage.getStr());
+            aParser.GetError().m_sMessage.getStr());
         exit(-1);
     }
     file->Extract();
diff --git a/l10ntools/source/xmlparse.cxx b/l10ntools/source/xmlparse.cxx
index f50325b7f11c..13a9d8fc9a92 100644
--- a/l10ntools/source/xmlparse.cxx
+++ b/l10ntools/source/xmlparse.cxx
@@ -47,58 +47,56 @@ using namespace osl;
 // class XMLChildNode
 //
 
-/*****************************************************************************/
 XMLChildNode::XMLChildNode( XMLParentNode *pPar )
-/*****************************************************************************/
-                : pParent( pPar )
+    : m_pParent( pPar )
 {
-    if ( pParent )
-        pParent->AddChild( this );
+    if ( m_pParent )
+        m_pParent->AddChild( this );
 }
 
 
-/*****************************************************************************/
-XMLChildNode::XMLChildNode( const XMLChildNode& obj)
-/*****************************************************************************/
-:   XMLNode(obj),
-    pParent(obj.pParent){}
+XMLChildNode::XMLChildNode( const XMLChildNode& rObj)
+    : XMLNode(rObj),
+      m_pParent(rObj.m_pParent)
+{
+}
 
-/*****************************************************************************/
-XMLChildNode& XMLChildNode::operator=(const XMLChildNode& obj){
-/*****************************************************************************/
-    if(this != &obj){
-        pParent=obj.pParent;
+XMLChildNode& XMLChildNode::operator=(const XMLChildNode& rObj)
+{
+    if(this != &rObj)
+    {
+        m_pParent=rObj.m_pParent;
     }
     return *this;
 }
+
 //
 // class XMLParentNode
 //
 
-
-/*****************************************************************************/
 XMLParentNode::~XMLParentNode()
-/*****************************************************************************/
 {
-    if( pChildList ){
+    if( m_pChildList )
+    {
             RemoveAndDeleteAllChildren();
-            delete pChildList;
-            pChildList = NULL;
+            delete m_pChildList;
     }
-    pChildList = NULL;
+    m_pChildList = NULL;
 }
-/*****************************************************************************/
-XMLParentNode::XMLParentNode( const XMLParentNode& obj)
-/*****************************************************************************/
-: XMLChildNode( obj )
+XMLParentNode::XMLParentNode( const XMLParentNode& rObj)
+: XMLChildNode( rObj )
 {
-    if( obj.pChildList ){
-        pChildList=new XMLChildNodeList();
+    if( rObj.m_pChildList )
+    {
+        m_pChildList=new XMLChildNodeList();
         XMLChildNode* pNode = NULL;
-        for ( size_t i = 0; i < obj.pChildList->size(); i++ ){
-            pNode = (*obj.pChildList)[ i ];
-            if( pNode != NULL){
-                switch(pNode->GetNodeType()){
+        for ( size_t i = 0; i < rObj.m_pChildList->size(); i++ )
+        {
+            pNode = (*rObj.m_pChildList)[ i ];
+            if( pNode != NULL)
+            {
+                switch(pNode->GetNodeType())
+                {
                     case XML_NODE_TYPE_ELEMENT:
                         AddChild( new XMLElement( *static_cast<XMLElement* >(pNode) ) ); break;
                     case XML_NODE_TYPE_DATA:
@@ -107,47 +105,51 @@ XMLParentNode::XMLParentNode( const XMLParentNode& obj)
                         AddChild( new XMLComment( *static_cast<XMLComment* >(pNode) ) ); break;
                     case XML_NODE_TYPE_DEFAULT:
                         AddChild( new XMLDefault( *static_cast<XMLDefault* >(pNode) ) ); break;
-                    default:    fprintf(stdout,"XMLParentNode::XMLParentNode( const XMLParentNode& obj) strange obj");
+                    default:    fprintf(stdout,"XMLParentNode::XMLParentNode( const XMLParentNode& rObj) strange obj");
                 }
             }
         }
-    }else pChildList = NULL;
+    }
+    else
+        m_pChildList = NULL;
 }
-/*****************************************************************************/
-XMLParentNode& XMLParentNode::operator=(const XMLParentNode& obj){
-/*****************************************************************************/
-    if(this!=&obj){
-        XMLChildNode::operator=(obj);
-        if( pChildList ){
+XMLParentNode& XMLParentNode::operator=(const XMLParentNode& rObj)
+{
+    if(this!=&rObj)
+    {
+        XMLChildNode::operator=(rObj);
+        if( m_pChildList )
+        {
             RemoveAndDeleteAllChildren();
-            delete pChildList;
-            pChildList = NULL;
+            delete m_pChildList;
+            m_pChildList = NULL;
+        }
+        if( rObj.m_pChildList )
+        {
+            m_pChildList=new XMLChildNodeList();
+            for ( size_t i = 0; i < rObj.m_pChildList->size(); i++ )
+                AddChild( (*rObj.m_pChildList)[ i ] );
         }
-        if( obj.pChildList ){
-            pChildList=new XMLChildNodeList();
-            for ( size_t i = 0; i < obj.pChildList->size(); i++ )
-                AddChild( (*obj.pChildList)[ i ] );
-        }else pChildList = NULL;
+        else
+            m_pChildList = NULL;
 
     }
     return *this;
 }
-/*****************************************************************************/
 void XMLParentNode::AddChild( XMLChildNode *pChild )
-/*****************************************************************************/
 {
-    if ( !pChildList )
-        pChildList = new XMLChildNodeList();
-    pChildList->push_back( pChild );
+    if ( !m_pChildList )
+        m_pChildList = new XMLChildNodeList();
+    m_pChildList->push_back( pChild );
 }
 
-/*****************************************************************************/
-void XMLParentNode::RemoveAndDeleteAllChildren(){
-/*****************************************************************************/
-    if ( pChildList ) {
-        for ( size_t i = 0; i < pChildList->size(); i++ )
-            delete (*pChildList)[ i ];
-        pChildList->clear();
+void XMLParentNode::RemoveAndDeleteAllChildren()
+{
+    if ( m_pChildList )
+    {
+        for ( size_t i = 0; i < m_pChildList->size(); i++ )
+            delete (*m_pChildList)[ i ];
+        m_pChildList->clear();
     }
 }
 
@@ -155,18 +157,12 @@ void XMLParentNode::RemoveAndDeleteAllChildren(){
 // class XMLFile
 //
 
-/*****************************************************************************/
-sal_uInt16 XMLFile::GetNodeType()
-/*****************************************************************************/
-{
-    return XML_NODE_TYPE_FILE;
-}
-
 void XMLFile::Write( OString const &aFilename )
 {
     std::ofstream s(
         aFilename.getStr(), std::ios_base::out | std::ios_base::trunc);
-    if (!s.is_open()) {
+    if (!s.is_open())
+    {
         std::cerr
             << "Error: helpex cannot create file " << aFilename.getStr()
             << '\n';
@@ -181,19 +177,23 @@ sal_Bool XMLFile::Write( ofstream &rStream , XMLNode *pCur )
     if ( !pCur )
         Write( rStream, this );
     else {
-        switch( pCur->GetNodeType()) {
-            case XML_NODE_TYPE_FILE: {
+        switch( pCur->GetNodeType())
+        {
+            case XML_NODE_TYPE_FILE:
+            {
                 if( GetChildList())
                     for ( size_t i = 0; i < GetChildList()->size(); i++ )
                         Write( rStream, (*GetChildList())[ i ] );
             }
             break;
-            case XML_NODE_TYPE_ELEMENT: {
+            case XML_NODE_TYPE_ELEMENT:
+            {
                 XMLElement *pElement = ( XMLElement * ) pCur;
                 rStream  << "<";
                 rStream << pElement->GetName().getStr();
                 if ( pElement->GetAttributeList())
-                    for ( size_t j = 0; j < pElement->GetAttributeList()->size(); j++ ) {
+                    for ( size_t j = 0; j < pElement->GetAttributeList()->size(); j++ )
+                    {
                         rStream << " ";
                         OString sData( (*pElement->GetAttributeList())[ j ]->GetName() );
                         rStream << XMLUtil::QuotHTML( sData ).getStr();
@@ -204,31 +204,34 @@ sal_Bool XMLFile::Write( ofstream &rStream , XMLNode *pCur )
                     }
                 if ( !pElement->GetChildList())
                     rStream << "/>";
-                else {
+                else
+                {
                     rStream << ">";
                     for ( size_t k = 0; k < pElement->GetChildList()->size(); k++ )
                         Write( rStream, (*pElement->GetChildList())[ k ] );
                     rStream << "</";
                     rStream << pElement->GetName().getStr();
                     rStream << ">";
-                   }
+                }
             }
             break;
-            case XML_NODE_TYPE_DATA: {
-                XMLData *pData = ( XMLData * ) pCur;
-                OString sData( pData->GetData());
+            case XML_NODE_TYPE_DATA:
+            {
+                OString sData( static_cast<const XMLData*>(pCur)->GetData());
                 rStream << XMLUtil::QuotHTML( sData ).getStr();
             }
             break;
-            case XML_NODE_TYPE_COMMENT: {
-                XMLComment *pComment = ( XMLComment * ) pCur;
+            case XML_NODE_TYPE_COMMENT:
+            {
+                const XMLComment *pComment = static_cast<const XMLComment*>(pCur);
                 rStream << "<!--";
                 rStream <<  pComment->GetComment().getStr();
                 rStream << "-->";
             }
             break;
-            case XML_NODE_TYPE_DEFAULT: {
-                XMLDefault *pDefault = ( XMLDefault * ) pCur;
+            case XML_NODE_TYPE_DEFAULT:
+            {
+                const XMLDefault *pDefault = static_cast<const XMLDefault*>(pCur);
                 rStream <<  pDefault->GetDefault().getStr();
             }
             break;
@@ -237,20 +240,23 @@ sal_Bool XMLFile::Write( ofstream &rStream , XMLNode *pCur )
     return sal_True;
 }
 
-
 void XMLFile::Print( XMLNode *pCur, sal_uInt16 nLevel )
 {
     if ( !pCur )
         Print( this );
-    else {
-        switch( pCur->GetNodeType()) {
-            case XML_NODE_TYPE_FILE: {
+    else
+    {
+        switch( pCur->GetNodeType())
+        {
+            case XML_NODE_TYPE_FILE:
+            {
                 if( GetChildList())
                     for ( size_t i = 0; i < GetChildList()->size(); i++ )
                         Print( (*GetChildList())[ i ] );
             }
             break;
-            case XML_NODE_TYPE_ELEMENT: {
+            case XML_NODE_TYPE_ELEMENT:
+            {
                 XMLElement *pElement = ( XMLElement * ) pCur;
 
                 fprintf( stdout, "<%s", pElement->GetName().getStr());
@@ -269,7 +275,8 @@ void XMLFile::Print( XMLNode *pCur, sal_uInt16 nLevel )
                 }
                 if ( !pElement->GetChildList())
                     fprintf( stdout, "/>" );
-                else {
+                else
+                {
                     fprintf( stdout, ">" );
                     for ( size_t k = 0; k < pElement->GetChildList()->size(); k++ )
                         Print( (*pElement->GetChildList())[ k ], nLevel + 1 );
@@ -277,18 +284,21 @@ void XMLFile::Print( XMLNode *pCur, sal_uInt16 nLevel )
                 }
             }
             break;
-            case XML_NODE_TYPE_DATA: {
-                XMLData *pData = ( XMLData * ) pCur;
+            case XML_NODE_TYPE_DATA:
+            {
+                const XMLData *pData = static_cast<const XMLData*>(pCur);
                 fprintf( stdout, "%s", pData->GetData().getStr());
             }
             break;
-            case XML_NODE_TYPE_COMMENT: {
-                XMLComment *pComment = ( XMLComment * ) pCur;
+            case XML_NODE_TYPE_COMMENT:
+            {
+                const XMLComment *pComment = static_cast<const XMLComment*>(pCur);
                 fprintf( stdout, "<!--%s-->", pComment->GetComment().getStr());
             }
             break;
-            case XML_NODE_TYPE_DEFAULT: {
-                XMLDefault *pDefault = ( XMLDefault * ) pCur;
+            case XML_NODE_TYPE_DEFAULT:
+            {
+                const XMLDefault *pDefault = static_cast<const XMLDefault*>(pCur);
                 fprintf( stdout, "%s", pDefault->GetDefault().getStr());
             }
             break;
@@ -297,222 +307,241 @@ void XMLFile::Print( XMLNode *pCur, sal_uInt16 nLevel )
 }
 XMLFile::~XMLFile()
 {
-    if( XMLStrings != NULL ){
-        XMLHashMap::iterator pos = XMLStrings->begin();
-        for( ; pos != XMLStrings->end() ; ++pos ){
+    if( m_pXMLStrings != NULL )
+    {
+        XMLHashMap::iterator pos = m_pXMLStrings->begin();
+        for( ; pos != m_pXMLStrings->end() ; ++pos )
+        {
             delete pos->second;             // Check and delete content also ?
         }
-        delete XMLStrings;
-        XMLStrings = NULL;
+        delete m_pXMLStrings;
+        m_pXMLStrings = NULL;
     }
 }
-/*****************************************************************************/
 XMLFile::XMLFile( const OString &rFileName ) // the file name, empty if created from memory stream
-/*****************************************************************************/
-                : XMLParentNode( NULL ),
-                  sFileName    ( rFileName ),
-                  XMLStrings   ( NULL )
-
+    : XMLParentNode( NULL )
+    , m_sFileName( rFileName )
+    , m_pXMLStrings( NULL )
 {
-    nodes_localize.insert( TagMap::value_type(OString("bookmark") , sal_True) );
-    nodes_localize.insert( TagMap::value_type(OString("variable") , sal_True) );
-    nodes_localize.insert( TagMap::value_type(OString("paragraph") , sal_True) );
-    nodes_localize.insert( TagMap::value_type(OString("alt") , sal_True) );
-    nodes_localize.insert( TagMap::value_type(OString("caption") , sal_True) );
-    nodes_localize.insert( TagMap::value_type(OString("title") , sal_True) );
-    nodes_localize.insert( TagMap::value_type(OString("link") , sal_True) );
+    m_aNodes_localize.insert( TagMap::value_type(OString("bookmark") , sal_True) );
+    m_aNodes_localize.insert( TagMap::value_type(OString("variable") , sal_True) );
+    m_aNodes_localize.insert( TagMap::value_type(OString("paragraph") , sal_True) );
+    m_aNodes_localize.insert( TagMap::value_type(OString("alt") , sal_True) );
+    m_aNodes_localize.insert( TagMap::value_type(OString("caption") , sal_True) );
+    m_aNodes_localize.insert( TagMap::value_type(OString("title") , sal_True) );
+    m_aNodes_localize.insert( TagMap::value_type(OString("link") , sal_True) );
 }
-/*****************************************************************************/
+
 void XMLFile::Extract( XMLFile *pCur )
-/*****************************************************************************/
 {
-    if( XMLStrings != NULL ) delete XMLStrings; // Elements ?
+    if( m_pXMLStrings )
+        delete m_pXMLStrings; // Elements ?
 
-    XMLStrings = new XMLHashMap();
-       if ( !pCur )
+    m_pXMLStrings = new XMLHashMap();
+    if ( !pCur )
         SearchL10NElements( this );
-    else {
-        if( pCur->GetNodeType()==XML_NODE_TYPE_FILE) {
+    else
+    {
+        if( pCur->GetNodeType() == XML_NODE_TYPE_FILE )
+        {
             SearchL10NElements(pCur);
         }
     }
 }
 
-/*****************************************************************************/
-void XMLFile::InsertL10NElement( XMLElement* pElement ){
-/*****************************************************************************/
-    OString id,language("");
-    LangHashMap* elem;
+void XMLFile::InsertL10NElement( XMLElement* pElement )
+{
+    OString sId, sLanguage("");
+    LangHashMap* pElem;
 
-    if( pElement->GetAttributeList() != NULL ){
+    if( pElement->GetAttributeList() != NULL )
+    {
         for ( size_t j = 0; j < pElement->GetAttributeList()->size(); j++ )
         {
-            const OString tmpStr((*pElement->GetAttributeList())[ j ]->GetName());
-            if (tmpStr == ID) { // Get the "id" Attribute
-                id = (*pElement->GetAttributeList())[ j ]->GetValue();
+            const OString sTempStr((*pElement->GetAttributeList())[ j ]->GetName());
+            // Get the "id" Attribute
+            if (sTempStr == ID)
+            {
+                sId = (*pElement->GetAttributeList())[ j ]->GetValue();
             }
-            if (tmpStr == XML_LANG) { // Get the "xml-lang" Attribute
-                language = (*pElement->GetAttributeList())[j]->GetValue();
+            // Get the "xml-lang" Attribute
+            if (sTempStr == XML_LANG)
+            {
+                sLanguage = (*pElement->GetAttributeList())[j]->GetValue();
             }
 
         }
-    }else{
+    }
+    else
+    {
         fprintf(stdout,"XMLFile::InsertL10NElement: No AttributeList found");
         fprintf(stdout,"++++++++++++++++++++++++++++++++++++++++++++++++++");
         Print( pElement , 0 );
         fprintf(stdout,"++++++++++++++++++++++++++++++++++++++++++++++++++");
     }
 
-    XMLHashMap::iterator pos = XMLStrings->find( id );
-    if( pos == XMLStrings->end() ){             // No instanze , create new one
-        elem = new LangHashMap();
-        (*elem)[ language ]=pElement;
-        XMLStrings->insert( XMLHashMap::value_type( id , elem ) );
-        order.push_back( id );
-    }else{                                  // Already there
-        elem=pos->second;
-        if ( (*elem)[ language ] )
+    XMLHashMap::iterator pos = m_pXMLStrings->find( sId );
+    if( pos == m_pXMLStrings->end() ) // No instanze , create new one
+    {
+        pElem = new LangHashMap();
+        (*pElem)[ sLanguage ]=pElement;
+        m_pXMLStrings->insert( XMLHashMap::value_type( sId , pElem ) );
+        m_vOrder.push_back( sId );
+    }
+    else        // Already there
+    {
+        pElem=pos->second;
+        if ( (*pElem)[ sLanguage ] )
         {
-            fprintf(stdout,"Error: Duplicated entry. ID = %s  LANG = %s in File %s\n", id.getStr(), language.getStr(), sFileName.getStr() );
+            fprintf(stdout,"Error: Duplicated entry. ID = %s  LANG = %s in File %s\n", sId.getStr(), sLanguage.getStr(), m_sFileName.getStr() );
             exit( -1 );
         }
-        (*elem)[ language ]=pElement;
+        (*pElem)[ sLanguage ]=pElement;
     }
 }
 
-XMLFile::XMLFile( const XMLFile& obj )
-/*****************************************************************************/
-                : XMLParentNode( obj ),
-                  sFileName    ( obj.sFileName ),
-                  XMLStrings   ( NULL )
+XMLFile::XMLFile( const XMLFile& rObj )
+    : XMLParentNode( rObj )
+    , m_sFileName( rObj.m_sFileName )
+    , m_pXMLStrings( 0 )
 {
-    if( this!=&obj )
+    if( this != &rObj )
     {
-        nodes_localize  =obj.nodes_localize;
-        order           =obj.order;
-
+        m_aNodes_localize = rObj.m_aNodes_localize;
+        m_vOrder = rObj.m_vOrder;
     }
 }
-/*****************************************************************************/
-XMLFile& XMLFile::operator=(const XMLFile& obj){
-/*****************************************************************************/
-    if( this!=&obj ){
 
-        XMLParentNode::operator=(obj);
+XMLFile& XMLFile::operator=(const XMLFile& rObj)
+{
+    if( this != &rObj )
+    {
+        XMLParentNode::operator=(rObj);
 
-        nodes_localize  =obj.nodes_localize;
-        order           =obj.order;
+        m_aNodes_localize = rObj.m_aNodes_localize;
+        m_vOrder = rObj.m_vOrder;
 
-        if( XMLStrings )    delete XMLStrings;
+        if( m_pXMLStrings )
+            delete m_pXMLStrings;
 
-        if( obj.XMLStrings )
+        if( rObj.m_pXMLStrings )
         {
-            XMLStrings = new XMLHashMap();
-            for( XMLHashMap::iterator pos = obj.XMLStrings->begin() ; pos != obj.XMLStrings->end() ; ++pos )
+            m_pXMLStrings = new XMLHashMap();
+            for( XMLHashMap::iterator pos = rObj.m_pXMLStrings->begin() ; pos != rObj.m_pXMLStrings->end() ; ++pos )
             {
-                LangHashMap* elem=pos->second;
-                LangHashMap* newelem = new LangHashMap();
-                for(LangHashMap::iterator pos2=elem->begin(); pos2!=elem->end();++pos2){
-                    (*newelem)[ pos2->first ] = new XMLElement( *pos2->second );
+                LangHashMap* pElem=pos->second;
+                LangHashMap* pNewelem = new LangHashMap();
+                for(LangHashMap::iterator pos2=pElem->begin(); pos2!=pElem->end();++pos2)
+                {
+                    (*pNewelem)[ pos2->first ] = new XMLElement( *pos2->second );
                 }
-                (*XMLStrings)[ pos->first ] = newelem;
+                (*m_pXMLStrings)[ pos->first ] = pNewelem;
             }
         }
     }
     return *this;
 }
 
-
-/*****************************************************************************/
-void XMLFile::SearchL10NElements( XMLParentNode *pCur , int pos)
-/*****************************************************************************/
+void XMLFile::SearchL10NElements( XMLParentNode *pCur, int nPos )
 {
-    bool bInsert    = true;
+    bool bInsert = true;
     if ( !pCur )
         SearchL10NElements( this  );
-    else {
-        switch( pCur->GetNodeType()) {
-            case XML_NODE_TYPE_FILE: {
+    else
+    {
+        switch( pCur->GetNodeType())
+        {
+            case XML_NODE_TYPE_FILE:
+            {
                 XMLChildNode* pElement;
-                if( GetChildList()){
-                    for ( size_t i = 0; i < GetChildList()->size(); i++ ){
+                if( GetChildList())
+                {
+                    for ( size_t i = 0; i < GetChildList()->size(); i++ )
+                    {
                         pElement = (*GetChildList())[ i ];
-                        if( pElement->GetNodeType() ==  XML_NODE_TYPE_ELEMENT ) SearchL10NElements( (XMLParentNode*) pElement , i);
+                        if( pElement->GetNodeType() ==  XML_NODE_TYPE_ELEMENT )
+                            SearchL10NElements( (XMLParentNode*) pElement , i);
                     }
                 }
             }
             break;
-            case XML_NODE_TYPE_ELEMENT: {
+            case XML_NODE_TYPE_ELEMENT:
+            {
                 XMLElement *pElement = ( XMLElement * ) pCur;
                 const OString sName(pElement->GetName().toAsciiLowerCase());
-                OString language,tmpStrVal,oldref;
+                OString sLanguage, sTmpStrVal, sOldref;
                 if ( pElement->GetAttributeList())
                 {
                     for ( size_t j = 0 , cnt = pElement->GetAttributeList()->size(); j < cnt && bInsert; ++j )
                     {
-                        const OString tmpStr = (*pElement->GetAttributeList())[j]->GetName();
-                        if (tmpStr == ID) {
-                            tmpStrVal=(*pElement->GetAttributeList())[ j ]->GetValue();
+                        const OString sTmpStr = (*pElement->GetAttributeList())[j]->GetName();
+                        if (sTmpStr == ID)
+                        {
+                            sTmpStrVal=(*pElement->GetAttributeList())[ j ]->GetValue();
                         }
-                        if (tmpStr == "localize") {
+                        if (sTmpStr == "localize")
+                        {
                             bInsert=false;
                         }
-                        if (tmpStr == XML_LANG) { // Get the "xml-lang" Attribute
-                            language=(*pElement->GetAttributeList())[ j ]->GetValue();
+                        if (sTmpStr == XML_LANG) // Get the "xml-lang" Attribute
+                        {
+                            sLanguage=(*pElement->GetAttributeList())[ j ]->GetValue();
                         }
-                        if (tmpStr == OLDREF) { // Get the "oldref" Attribute
-                            oldref=(*pElement->GetAttributeList())[ j ]->GetValue();
+                        if (sTmpStr == OLDREF) // Get the "oldref" Attribute
+                        {
+                            sOldref=(*pElement->GetAttributeList())[ j ]->GetValue();
                         }
                     }
-                    pElement->SetLanguageId ( language );
-                    pElement->SetId(tmpStrVal);
-                    pElement->SetOldRef     ( oldref  );
-                    pElement->SetPos( pos );
+                    pElement->SetLanguageId( sLanguage );
+                    pElement->SetId( sTmpStrVal );
+                    pElement->SetOldRef( sOldref );
+                    pElement->SetPos( nPos );
                 }
 
-                if ( bInsert && ( nodes_localize.find( sName ) != nodes_localize.end() ) )
+                if ( bInsert && ( m_aNodes_localize.find( sName ) != m_aNodes_localize.end() ) )
                     InsertL10NElement(pElement);
-                else if ( bInsert && pElement->GetChildList() ){
+                else if ( bInsert && pElement->GetChildList() )
+                {
                     for ( size_t k = 0; k < pElement->GetChildList()->size(); k++ )
                         SearchL10NElements( (XMLParentNode*)(*pElement->GetChildList())[ k ], k);
                 }
             }
             break;
-            case XML_NODE_TYPE_DATA: {
-            }
+            case XML_NODE_TYPE_DATA:
             break;
-            case XML_NODE_TYPE_COMMENT: {
-            }
+            case XML_NODE_TYPE_COMMENT:
             break;
-            case XML_NODE_TYPE_DEFAULT: {
-            }
+            case XML_NODE_TYPE_DEFAULT:
             break;
         }
     }
 }
 
-/*****************************************************************************/
 bool XMLFile::CheckExportStatus( XMLParentNode *pCur )
-/*****************************************************************************/
 {
     static bool bStatusExport = true;
 
-    bool bInsert    = true;
+    bool bInsert = true;
     if ( !pCur )
         CheckExportStatus( this );
     else {
-        switch( pCur->GetNodeType()) {
-            case XML_NODE_TYPE_FILE: {
+        switch( pCur->GetNodeType())
+        {
+            case XML_NODE_TYPE_FILE:
+            {
                 XMLParentNode* pElement;
-                if( GetChildList()){
-                    for ( size_t i = 0; i < GetChildList()->size(); i++ ){
+                if( GetChildList())
+                {
+                    for ( size_t i = 0; i < GetChildList()->size(); i++ )
+                    {
                         pElement = (XMLParentNode*)(*GetChildList())[ i ];
                         if( pElement->GetNodeType() ==  XML_NODE_TYPE_ELEMENT ) CheckExportStatus( pElement );//, i);
                     }
                 }
             }
             break;
-            case XML_NODE_TYPE_ELEMENT: {
+            case XML_NODE_TYPE_ELEMENT:
+            {
                 XMLElement *pElement = ( XMLElement * ) pCur;
                 if (pElement->GetName().equalsIgnoreAsciiCase("TOPIC"))
                 {
@@ -546,95 +575,101 @@ bool XMLFile::CheckExportStatus( XMLParentNode *pCur )
     return bStatusExport;
 }
 
-/*****************************************************************************/
-sal_uInt16 XMLElement::GetNodeType()
-/*****************************************************************************/
+XMLElement::XMLElement(
+    const OString &rName,    // the element name
+    XMLParentNode *pParent   // parent node of this element
+)
+    : XMLParentNode( pParent )
+    , m_sElementName( rName )
+    , m_pAttributes( NULL )
+    , m_sProject(OString())
+    , m_sFilename(OString())
+    , m_sId(OString())
+    , m_sOldRef(OString())
+    , m_sResourceType(OString())
+    , m_sLanguageId(OString())
+    , m_nPos(0)
 {
-    return XML_NODE_TYPE_ELEMENT;
 }
 
-/*****************************************************************************/
-XMLElement::XMLElement(const XMLElement& obj)
-/*****************************************************************************/
-    :
-                XMLParentNode   ( obj ),
-                sElementName    ( obj.sElementName ),
-                pAttributes     ( NULL ),
-                project         ( obj.project ),
-                filename        ( obj.filename ),
-                id              ( obj.id ),
-                sOldRef         ( obj.sOldRef ),
-                resourceType    ( obj.resourceType ),
-                languageId      ( obj.languageId ),
-                nPos            ( obj.nPos )
-
+XMLElement::XMLElement(const XMLElement& rObj)
+    : XMLParentNode( rObj )
+    , m_sElementName( rObj.m_sElementName )
+    , m_pAttributes( 0 )
+    , m_sProject( rObj.m_sProject )
+    , m_sFilename( rObj.m_sFilename )
+    , m_sId( rObj.m_sId )
+    , m_sOldRef( rObj.m_sOldRef )
+    , m_sResourceType( rObj.m_sResourceType )
+    , m_sLanguageId( rObj.m_sLanguageId )
+    , m_nPos( rObj.m_nPos )
 {
-    if ( obj.pAttributes ){
-        pAttributes = new XMLAttributeList();
-        for ( size_t i = 0; i < obj.pAttributes->size(); i++ )
-            AddAttribute( (*obj.pAttributes)[ i ]->GetName(), (*obj.pAttributes)[ i ]->GetValue() );
+    if ( rObj.m_pAttributes )
+    {
+        m_pAttributes = new XMLAttributeList();
+        for ( size_t i = 0; i < rObj.m_pAttributes->size(); i++ )
+            AddAttribute( (*rObj.m_pAttributes)[ i ]->GetName(), (*rObj.m_pAttributes)[ i ]->GetValue() );
     }
 }
 
-/*****************************************************************************/
-XMLElement& XMLElement::operator=(const XMLElement& obj){
-/*****************************************************************************/
-    if( this!=&obj ){
-        XMLParentNode::operator=(obj);
-        sElementName    =obj.sElementName;
-        project         =obj.project;
-        filename        =obj.filename;
-        id              =obj.id;
-        sOldRef         =obj.sOldRef;
-        resourceType    =obj.resourceType;
-        languageId      =obj.languageId;
-        nPos            =obj.nPos;
-
-        if ( pAttributes ){
-            for ( size_t i = 0; i < pAttributes->size(); i++ )
-                delete (*pAttributes)[ i ];
-            delete pAttributes;
+XMLElement& XMLElement::operator=(const XMLElement& rObj)
+{
+    if( this !=& rObj )
+    {
+        XMLParentNode::operator=(rObj);
+        m_sElementName = rObj.m_sElementName;
+        m_sProject = rObj.m_sProject;
+        m_sFilename = rObj.m_sFilename;
+        m_sId = rObj.m_sId;
+        m_sOldRef = rObj.m_sOldRef;
+        m_sResourceType = rObj.m_sResourceType;
+        m_sLanguageId = rObj.m_sLanguageId;
+        m_nPos = rObj.m_nPos;
+
+        if ( m_pAttributes )
+        {
+            for ( size_t i = 0; i < m_pAttributes->size(); i++ )
+                delete (*m_pAttributes)[ i ];
+            delete m_pAttributes;
         }
-        if ( obj.pAttributes ){
-            pAttributes         =new XMLAttributeList();
-            for ( size_t i = 0; i < obj.pAttributes->size(); i++ )
-                AddAttribute( (*obj.pAttributes)[ i ]->GetName(), (*obj.pAttributes)[ i ]->GetValue() );
+        if ( rObj.m_pAttributes )
+        {
+            m_pAttributes = new XMLAttributeList();
+            for ( size_t i = 0; i < rObj.m_pAttributes->size(); i++ )
+                AddAttribute( (*rObj.m_pAttributes)[ i ]->GetName(), (*rObj.m_pAttributes)[ i ]->GetValue() );
         }
     }
     return *this;
 }
 
-/*****************************************************************************/
 void XMLElement::AddAttribute( const OString &rAttribute, const OString &rValue )
-/*****************************************************************************/
 {
-    if ( !pAttributes )
-        pAttributes = new XMLAttributeList();
-    pAttributes->push_back( new XMLAttribute( rAttribute, rValue ) );
+    if ( !m_pAttributes )
+        m_pAttributes = new XMLAttributeList();
+    m_pAttributes->push_back( new XMLAttribute( rAttribute, rValue ) );
 }
 
-/*****************************************************************************/
 void XMLElement::ChangeLanguageTag( const OString &rValue )
 {
     SetLanguageId(rValue);
-    if ( pAttributes )
+    if ( m_pAttributes )
     {
-        for (size_t i = 0; i < pAttributes->size(); ++i)
+        for (size_t i = 0; i < m_pAttributes->size(); ++i)
         {
-            if ( (*pAttributes)[ i ]->GetName() == "xml-lang" )
-                (*pAttributes)[ i ]->setValue(rValue);
+            if ( (*m_pAttributes)[ i ]->GetName() == "xml-lang" )
+                (*m_pAttributes)[ i ]->setValue(rValue);
         }
     }
     XMLChildNode* pNode  = NULL;
     XMLElement*   pElem  = NULL;
     XMLChildNodeList* pCList = GetChildList();
 
-    if( pCList != NULL )
+    if( pCList )
     {
         for ( size_t i = 0; i < pCList->size(); i++ )
         {
             pNode = (*pCList)[ i ];
-            if( pNode != NULL && pNode->GetNodeType() == XML_NODE_TYPE_ELEMENT )
+            if( pNode && pNode->GetNodeType() == XML_NODE_TYPE_ELEMENT )
             {
                 pElem = static_cast< XMLElement* >(pNode);
                 pElem->ChangeLanguageTag( rValue );
@@ -647,197 +682,114 @@ void XMLElement::ChangeLanguageTag( const OString &rValue )
     }
 }
 
-/*****************************************************************************/
 XMLElement::~XMLElement()
-/*****************************************************************************/
 {
-    if ( pAttributes ) {
-        for ( size_t i = 0; i < pAttributes->size(); i++ )
-            delete (*pAttributes)[ i ];
+    if ( m_pAttributes )
+    {
+        for ( size_t i = 0; i < m_pAttributes->size(); i++ )
+            delete (*m_pAttributes)[ i ];
 
-        delete pAttributes;
-        pAttributes = NULL;
+        delete m_pAttributes;
+        m_pAttributes = NULL;
     }
 }
 
-/*****************************************************************************/
-OString XMLElement::ToOString(){
-/*****************************************************************************/
-    OStringBuffer* buffer = new OStringBuffer();
-    Print(this,*buffer,true);
-    OString result=buffer->makeStringAndClear();
-    OString xy(result.getStr());
-    result=OString(xy);
-    delete buffer;
-    return result;
+OString XMLElement::ToOString()
+{
+    OStringBuffer sBuffer;
+    Print(this,sBuffer,true);
+    return sBuffer.makeStringAndClear();
 }
-/*****************************************************************************/
-void XMLElement::Print(XMLNode *pCur, OStringBuffer& buffer , bool rootelement ){
-/*****************************************************************************/
-    if(pCur!=NULL){
-        if(rootelement){
-            XMLElement *pElement = ( XMLElement * ) pCur;
-            if ( pElement->GetAttributeList()){
-                if ( pElement->GetChildList()){
-                    XMLChildNode* tmp=NULL;
-                    for ( size_t k = 0; k < pElement->GetChildList()->size(); k++ ){
-                        tmp = (*pElement->GetChildList())[ k ];
-                        Print( tmp, buffer , false);
+
+void XMLElement::Print(XMLNode *pCur, OStringBuffer& rBuffer, bool bRootelement ) const
+{
+    if( pCur )
+    {
+        if( bRootelement )
+        {
+            XMLElement *pElement = static_cast<XMLElement*>(pCur);
+            if ( pElement->GetAttributeList())
+            {
+                if ( pElement->GetChildList())
+                {
+                    XMLChildNode* pTmp = 0;
+                    for ( size_t k = 0; k < pElement->GetChildList()->size(); k++ )
+                    {
+                        pTmp = (*pElement->GetChildList())[ k ];
+                        Print( pTmp, rBuffer , false);
                     }
                 }
             }
         }
-        else{
-
-        switch( pCur->GetNodeType()) {
-            case XML_NODE_TYPE_ELEMENT: {
-                XMLElement *pElement = ( XMLElement * ) pCur;
+        else
+        {
+            switch( pCur->GetNodeType())
+            {
+                case XML_NODE_TYPE_ELEMENT:
+                {
+                    XMLElement *pElement = static_cast<XMLElement*>(pCur);
 
-                if( !pElement->GetName().equalsIgnoreAsciiCase("comment") ){
-                    buffer.append( "<" );
-                    buffer.append( pElement->GetName() );
-                    if ( pElement->GetAttributeList()){
-                        for ( size_t j = 0; j < pElement->GetAttributeList()->size(); j++ ){
-
-                            const OString aAttrName( (*pElement->GetAttributeList())[ j ]->GetName() );
-                            if( !aAttrName.equalsIgnoreAsciiCase( "xml-lang" ) ) {
-                                buffer.append( " " );
-                                buffer.append( aAttrName );
-                                buffer.append( "=" );
-                                buffer.append( "\"" );
-                                buffer.append( (*pElement->GetAttributeList())[ j ]->GetValue() );
-                                buffer.append( "\"" );
+                    if( !pElement->GetName().equalsIgnoreAsciiCase("comment") )
+                    {
+                        rBuffer.append( "<" );
+                        rBuffer.append( pElement->GetName() );
+                        if ( pElement->GetAttributeList())
+                        {
+                            for ( size_t j = 0; j < pElement->GetAttributeList()->size(); j++ )
+                            {
+                                const OString aAttrName( (*pElement->GetAttributeList())[ j ]->GetName() );
+                                if( !aAttrName.equalsIgnoreAsciiCase( "xml-lang" ) )
+                                {
+                                    rBuffer.append(
+                                        " " + aAttrName + "=\"" +
+                                        (*pElement->GetAttributeList())[ j ]->GetValue() + "\"" );
+                                }
                             }
                         }
-                    }
-                    if ( !pElement->GetChildList())
-                        buffer.append( "/>" );
-                    else {
-                        buffer.append( ">" );
-                        XMLChildNode* tmp=NULL;
-                        for ( size_t k = 0; k < pElement->GetChildList()->size(); k++ ){
-                            tmp = (*pElement->GetChildList())[ k ];
-                            Print( tmp, buffer , false);
+                        if ( !pElement->GetChildList())
+                            rBuffer.append( "/>" );
+                        else
+                        {
+                            rBuffer.append( ">" );
+                            XMLChildNode* pTmp = 0;
+                            for ( size_t k = 0; k < pElement->GetChildList()->size(); k++ )
+                            {
+                                pTmp = (*pElement->GetChildList())[ k ];
+                                Print( pTmp, rBuffer , false);
+                            }
+                            rBuffer.append( "</" + pElement->GetName() + ">" );
                         }
-                        buffer.append( "</" );
-                        buffer.append( pElement->GetName() );
-                        buffer.append( ">" );
                     }
                 }
+                break;
+                case XML_NODE_TYPE_DATA:
+                {
+                    const XMLData *pData = static_cast<const XMLData*>(pCur);
+                    rBuffer.append( pData->GetData() );
+                }
+                break;
+                case XML_NODE_TYPE_COMMENT:
+                {
+                    const XMLComment *pComment = static_cast<const XMLComment*>(pCur);
+                    rBuffer.append( "<!--" + pComment->GetComment() + "-->" );
+                }
+                break;
+                case XML_NODE_TYPE_DEFAULT:
+                {
+                    const XMLDefault *pDefault = static_cast<const XMLDefault*>(pCur);
+                    rBuffer.append( pDefault->GetDefault() );
+                }
+                break;
             }
-            break;
-            case XML_NODE_TYPE_DATA: {
-                XMLData *pData = ( XMLData * ) pCur;
-                buffer.append( pData->GetData() );
-            }
-            break;
-            case XML_NODE_TYPE_COMMENT: {
-                XMLComment *pComment = ( XMLComment * ) pCur;
-                buffer.append( "<!--" );
-                buffer.append( pComment->GetComment() );
-                buffer.append( "-->" );
-            }
-            break;
-            case XML_NODE_TYPE_DEFAULT: {
-                XMLDefault *pDefault = ( XMLDefault * ) pCur;
-                buffer.append( pDefault->GetDefault() );
-            }
-            break;
         }
-        }
-    }else {
+    }
+    else
+    {
         fprintf(stdout,"\n#+------Error: NULL Pointer in XMLELement::Print------+#\n");
         return;
     }
 }
 
-
-//
-// class XMLData
-//
-/*****************************************************************************/
-XMLData::XMLData(const XMLData& obj)
-/*****************************************************************************/
-    : XMLChildNode( obj ),
-      sData( obj.sData ) ,
-      isNewCreated ( obj.isNewCreated ){}
-
-/*****************************************************************************/
-XMLData& XMLData::operator=(const XMLData& obj){
-/*****************************************************************************/
-    if( this!=&obj ){
-        XMLChildNode::operator=( obj );
-        sData           = obj.sData;
-        isNewCreated    = obj.isNewCreated;
-    }
-    return *this;
-}
-/*****************************************************************************/
-void XMLData::AddData( const OString &rData) {
-/*****************************************************************************/
-    sData += rData;
-}
-
-/*****************************************************************************/
-sal_uInt16 XMLData::GetNodeType()
-/*****************************************************************************/
-{
-    return XML_NODE_TYPE_DATA;
-}
-
-//
-// class XMLComment
-//
-
-/*****************************************************************************/
-sal_uInt16 XMLComment::GetNodeType()
-/*****************************************************************************/
-{
-    return XML_NODE_TYPE_COMMENT;
-}
-/*****************************************************************************/
-XMLComment::XMLComment(const XMLComment& obj)
-/*****************************************************************************/
-    : XMLChildNode( obj ),
-      sComment( obj.sComment ){}
-
-/*****************************************************************************/
-XMLComment& XMLComment::operator=(const XMLComment& obj){
-/*****************************************************************************/
-    if( this!=&obj ){
-        XMLChildNode::operator=( obj );
-        sComment        = obj.sComment;
-    }
-    return *this;
-}
-
-//
-// class XMLDefault
-//
-
-/*****************************************************************************/
-sal_uInt16 XMLDefault::GetNodeType()
-/*****************************************************************************/
-{
-    return XML_NODE_TYPE_DEFAULT;
-}
-/*****************************************************************************/
-XMLDefault::XMLDefault(const XMLDefault& obj)
-/*****************************************************************************/
-    : XMLChildNode( obj ),
-      sDefault( obj.sDefault){}
-
-/*****************************************************************************/
-XMLDefault& XMLDefault::operator=(const XMLDefault& obj){
-/*****************************************************************************/
-    if( this!=&obj ){
-        XMLChildNode::operator=( obj );
-        sDefault        = obj.sDefault;
-    }
-    return *this;
-}
-
-
 //
 // class SimpleXMLParser
 //
@@ -845,7 +797,8 @@ XMLDefault& XMLDefault::operator=(const XMLDefault& obj){
 namespace
 {
 
-static OUString lcl_pathnameToAbsoluteUrl(const OString& rPathname) {
+static OUString lcl_pathnameToAbsoluteUrl(const OString& rPathname)
+{
     OUString sPath = OStringToOUString(rPathname, RTL_TEXTENCODING_UTF8 );
     OUString sUrl;
     if (osl::FileBase::getFileURLFromSystemPath(sPath, sUrl)
@@ -855,7 +808,8 @@ static OUString lcl_pathnameToAbsoluteUrl(const OString& rPathname) {
         std::exit(EXIT_FAILURE);
     }
     OUString sCwd;
-    if (osl_getProcessWorkingDir(&sCwd.pData) != osl_Process_E_None) {
+    if (osl_getProcessWorkingDir(&sCwd.pData) != osl_Process_E_None)
+    {
         std::cerr << "Error: Cannot determine cwd\n";
         std::exit(EXIT_FAILURE);
     }
@@ -870,133 +824,107 @@ static OUString lcl_pathnameToAbsoluteUrl(const OString& rPathname) {
 }
 
 
-/*****************************************************************************/
 SimpleXMLParser::SimpleXMLParser()
-/*****************************************************************************/
-                : pXMLFile( NULL )
+    : m_pXMLFile( NULL )
 {
-    aParser = XML_ParserCreate( NULL );
-    XML_SetUserData( aParser, this );
-    XML_SetElementHandler( aParser, (XML_StartElementHandler) StartElementHandler, (XML_EndElementHandler) EndElementHandler );
-    XML_SetCharacterDataHandler( aParser, (XML_CharacterDataHandler) CharacterDataHandler );
-    XML_SetCommentHandler( aParser, (XML_CommentHandler) CommentHandler );
-    XML_SetDefaultHandler( aParser, (XML_DefaultHandler) DefaultHandler );
+    m_aParser = XML_ParserCreate( NULL );
+    XML_SetUserData( m_aParser, this );
+    XML_SetElementHandler( m_aParser, (XML_StartElementHandler) StartElementHandler, (XML_EndElementHandler) EndElementHandler );
+    XML_SetCharacterDataHandler( m_aParser, (XML_CharacterDataHandler) CharacterDataHandler );
+    XML_SetCommentHandler( m_aParser, (XML_CommentHandler) CommentHandler );
+    XML_SetDefaultHandler( m_aParser, (XML_DefaultHandler) DefaultHandler );
 }
 
-/*****************************************************************************/
 SimpleXMLParser::~SimpleXMLParser()
-/*****************************************************************************/
 {
-    XML_ParserFree( aParser );
+    XML_ParserFree( m_aParser );
 }
 
-/*****************************************************************************/
 void SimpleXMLParser::StartElementHandler(
     void *userData, const XML_Char *name, const XML_Char **atts )
-/*****************************************************************************/
 {
     (( SimpleXMLParser * ) userData )->StartElement( name, atts );
 }
 
-
-/*****************************************************************************/
 void SimpleXMLParser::EndElementHandler(
     void *userData, const XML_Char *name )
-/*****************************************************************************/
 {
     (( SimpleXMLParser * ) userData )->EndElement( name );
 }
 
-/*****************************************************************************/
 void SimpleXMLParser::CharacterDataHandler(
     void *userData, const XML_Char *s, int len )
-/*****************************************************************************/
 {
     (( SimpleXMLParser * ) userData )->CharacterData( s, len );
 }
 
-/*****************************************************************************/
 void SimpleXMLParser::CommentHandler(
     void *userData, const XML_Char *data )
-/*****************************************************************************/
 {
     (( SimpleXMLParser * ) userData )->Comment( data );
 }
 
-/*****************************************************************************/
 void SimpleXMLParser::DefaultHandler(
     void *userData, const XML_Char *s, int len )
-/*****************************************************************************/
 {
     (( SimpleXMLParser * ) userData )->Default( s, len );
 }
 
-/*****************************************************************************/
 void SimpleXMLParser::StartElement(
     const XML_Char *name, const XML_Char **atts )
-/*****************************************************************************/
 {
-    XMLElement *pElement = new XMLElement( OString(name), ( XMLParentNode * ) pCurNode );
-    pCurNode = pElement;
-    pCurData = NULL;
+    XMLElement *pElement = new XMLElement( OString(name), ( XMLParentNode * ) m_pCurNode );
+    m_pCurNode = pElement;
+    m_pCurData = NULL;
 
     int i = 0;
-    while( atts[i] ) {
+    while( atts[i] )
+    {
         pElement->AddAttribute( atts[ i ], atts[ i + 1 ] );
         i += 2;
     }
 }
 
-/*****************************************************************************/
 void SimpleXMLParser::EndElement( const XML_Char * /*name*/ )
-/*****************************************************************************/
 {
-    pCurNode = pCurNode->GetParent();
-    pCurData = NULL;
+    m_pCurNode = m_pCurNode->GetParent();
+    m_pCurData = NULL;
 }
 
-/*****************************************************************************/
-void SimpleXMLParser::CharacterData(
-    const XML_Char *s, int len )
-/*****************************************************************************/
+void SimpleXMLParser::CharacterData( const XML_Char *s, int len )
 {
-    if ( !pCurData ){
+    if ( !m_pCurData )
+    {
         OString x( s, len );
-        pCurData = new XMLData( helper::UnQuotHTML(x) , pCurNode );
-    }else{
+        m_pCurData = new XMLData( helper::UnQuotHTML(x) , m_pCurNode );
+    }
+    else
+    {
         OString x( s, len );
-        pCurData->AddData( helper::UnQuotHTML(x) );
+        m_pCurData->AddData( helper::UnQuotHTML(x) );
 
     }
 }
 
-/*****************************************************************************/
-void SimpleXMLParser::Comment(
-    const XML_Char *data )
-/*****************************************************************************/
+void SimpleXMLParser::Comment( const XML_Char *data )
 {
-    pCurData = NULL;
-    new XMLComment( OString( data ), pCurNode );
+    m_pCurData = NULL;
+    new XMLComment( OString( data ), m_pCurNode );
 }
 
-/*****************************************************************************/
-void SimpleXMLParser::Default(
-    const XML_Char *s, int len )
-/*****************************************************************************/
+void SimpleXMLParser::Default( const XML_Char *s, int len )
 {
-    pCurData = NULL;
-    new XMLDefault(OString( s, len ), pCurNode );
+    m_pCurData = NULL;
+    new XMLDefault(OString( s, len ), m_pCurNode );
 }
 
-/*****************************************************************************/
 XMLFile *SimpleXMLParser::Execute( const OString &rFileName, XMLFile* pXMLFileIn )
-/*****************************************************************************/
 {
-    aErrorInformation.eCode = XML_ERROR_NONE;
-    aErrorInformation.nLine = 0;
-    aErrorInformation.nColumn = 0;
-    aErrorInformation.sMessage = "ERROR: Unable to open file ";
-    aErrorInformation.sMessage += rFileName;
+    m_aErrorInformation.m_eCode = XML_ERROR_NONE;
+    m_aErrorInformation.m_nLine = 0;
+    m_aErrorInformation.m_nColumn = 0;
+    m_aErrorInformation.m_sMessage = "ERROR: Unable to open file ";
+    m_aErrorInformation.m_sMessage += rFileName;
 
     OUString aFileURL(lcl_pathnameToAbsoluteUrl(rFileName));
 
@@ -1010,124 +938,129 @@ XMLFile *SimpleXMLParser::Execute( const OString &rFileName, XMLFile* pXMLFileIn
     sal_uInt64 s;
     oslFileError e = osl_getFileSize(h, &s);
     void * p = NULL;
-    if (e == osl_File_E_None) {
+    if (e == osl_File_E_None)
+    {
         e = osl_mapFile(h, &p, s, 0, 0);
     }
-    if (e != osl_File_E_None) {
+    if (e != osl_File_E_None)
+    {
         osl_closeFile(h);
         return 0;
     }
 
-    pXMLFile = pXMLFileIn;
-    pXMLFile->SetName( rFileName );
+    m_pXMLFile = pXMLFileIn;
+    m_pXMLFile->SetName( rFileName );
 
-    pCurNode = pXMLFile;
-    pCurData = NULL;
+    m_pCurNode = m_pXMLFile;
+    m_pCurData = NULL;
 
-    aErrorInformation.eCode = XML_ERROR_NONE;
-    aErrorInformation.nLine = 0;
-    aErrorInformation.nColumn = 0;
-    if ( !pXMLFile->GetName().isEmpty()) {
-        aErrorInformation.sMessage = "File " + pXMLFile->GetName() + " parsed successfully";
+    m_aErrorInformation.m_eCode = XML_ERROR_NONE;
+    m_aErrorInformation.m_nLine = 0;
+    m_aErrorInformation.m_nColumn = 0;
+    if ( !m_pXMLFile->GetName().isEmpty())
+    {
+        m_aErrorInformation.m_sMessage = "File " + m_pXMLFile->GetName() + " parsed successfully";
     }
     else
-        aErrorInformation.sMessage = "XML-File parsed successfully";
+        m_aErrorInformation.m_sMessage = "XML-File parsed successfully";
 
-    if (!XML_Parse(aParser, reinterpret_cast< char * >(p), s, true))
+    if (!XML_Parse(m_aParser, reinterpret_cast< char * >(p), s, true))
     {
-        aErrorInformation.eCode = XML_GetErrorCode( aParser );
-        aErrorInformation.nLine = XML_GetErrorLineNumber( aParser );
-        aErrorInformation.nColumn = XML_GetErrorColumnNumber( aParser );
+        m_aErrorInformation.m_eCode = XML_GetErrorCode( m_aParser );
+        m_aErrorInformation.m_nLine = XML_GetErrorLineNumber( m_aParser );
+        m_aErrorInformation.m_nColumn = XML_GetErrorColumnNumber( m_aParser );
 
-        aErrorInformation.sMessage = "ERROR: ";
-        if ( !pXMLFile->GetName().isEmpty())
-            aErrorInformation.sMessage += pXMLFile->GetName();
+        m_aErrorInformation.m_sMessage = "ERROR: ";
+        if ( !m_pXMLFile->GetName().isEmpty())
+            m_aErrorInformation.m_sMessage += m_pXMLFile->GetName();
         else
-            aErrorInformation.sMessage += OString( "XML-File (");
-        aErrorInformation.sMessage +=
-            OString::number(sal::static_int_cast< sal_Int64 >(aErrorInformation.nLine)) + "," +
-            OString::number(sal::static_int_cast< sal_Int64 >(aErrorInformation.nColumn)) + "): ";
+            m_aErrorInformation.m_sMessage += OString( "XML-File (");
 
-        switch (aErrorInformation.eCode) {
+        m_aErrorInformation.m_sMessage +=
+            OString::number(sal::static_int_cast< sal_Int64 >(m_aErrorInformation.m_nLine)) + "," +
+            OString::number(sal::static_int_cast< sal_Int64 >(m_aErrorInformation.m_nColumn)) + "): ";
+
+        switch (m_aErrorInformation.m_eCode)
+        {
         case XML_ERROR_NO_MEMORY:
-            aErrorInformation.sMessage += "No memory";
+            m_aErrorInformation.m_sMessage += "No memory";
             break;
         case XML_ERROR_SYNTAX:
-            aErrorInformation.sMessage += "Syntax";
+            m_aErrorInformation.m_sMessage += "Syntax";
             break;
         case XML_ERROR_NO_ELEMENTS:
-            aErrorInformation.sMessage += "No elements";
+            m_aErrorInformation.m_sMessage += "No elements";
             break;
         case XML_ERROR_INVALID_TOKEN:
-            aErrorInformation.sMessage += "Invalid token";
+            m_aErrorInformation.m_sMessage += "Invalid token";
             break;
         case XML_ERROR_UNCLOSED_TOKEN:
-            aErrorInformation.sMessage += "Unclosed token";
+            m_aErrorInformation.m_sMessage += "Unclosed token";
             break;
         case XML_ERROR_PARTIAL_CHAR:
-            aErrorInformation.sMessage += "Partial char";
+            m_aErrorInformation.m_sMessage += "Partial char";
             break;
         case XML_ERROR_TAG_MISMATCH:
-            aErrorInformation.sMessage += "Tag mismatch";
+            m_aErrorInformation.m_sMessage += "Tag mismatch";
             break;
         case XML_ERROR_DUPLICATE_ATTRIBUTE:
-            aErrorInformation.sMessage += "Dublicat attribute";
+            m_aErrorInformation.m_sMessage += "Dublicat attribute";
             break;
         case XML_ERROR_JUNK_AFTER_DOC_ELEMENT:
-            aErrorInformation.sMessage += "Junk after doc element";
+            m_aErrorInformation.m_sMessage += "Junk after doc element";
             break;
         case XML_ERROR_PARAM_ENTITY_REF:
-            aErrorInformation.sMessage += "Param entity ref";
+            m_aErrorInformation.m_sMessage += "Param entity ref";
             break;
         case XML_ERROR_UNDEFINED_ENTITY:
-            aErrorInformation.sMessage += "Undefined entity";
+            m_aErrorInformation.m_sMessage += "Undefined entity";
             break;
         case XML_ERROR_RECURSIVE_ENTITY_REF:
-            aErrorInformation.sMessage += "Recursive entity ref";
+            m_aErrorInformation.m_sMessage += "Recursive entity ref";
             break;
         case XML_ERROR_ASYNC_ENTITY:
-            aErrorInformation.sMessage += "Async_entity";
+            m_aErrorInformation.m_sMessage += "Async_entity";
             break;
         case XML_ERROR_BAD_CHAR_REF:
-            aErrorInformation.sMessage += "Bad char ref";
+            m_aErrorInformation.m_sMessage += "Bad char ref";
             break;
         case XML_ERROR_BINARY_ENTITY_REF:
-            aErrorInformation.sMessage += "Binary entity";
+            m_aErrorInformation.m_sMessage += "Binary entity";
             break;
         case XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF:
-            aErrorInformation.sMessage += "Attribute external entity ref";
+            m_aErrorInformation.m_sMessage += "Attribute external entity ref";
             break;
         case XML_ERROR_MISPLACED_XML_PI:
-            aErrorInformation.sMessage += "Misplaced xml pi";
+            m_aErrorInformation.m_sMessage += "Misplaced xml pi";
             break;
         case XML_ERROR_UNKNOWN_ENCODING:
-            aErrorInformation.sMessage += "Unknown encoding";
+            m_aErrorInformation.m_sMessage += "Unknown encoding";
             break;
         case XML_ERROR_INCORRECT_ENCODING:
-            aErrorInformation.sMessage += "Incorrect encoding";
+            m_aErrorInformation.m_sMessage += "Incorrect encoding";
             break;
         case XML_ERROR_UNCLOSED_CDATA_SECTION:
-            aErrorInformation.sMessage += "Unclosed cdata section";
+            m_aErrorInformation.m_sMessage += "Unclosed cdata section";
             break;
         case XML_ERROR_EXTERNAL_ENTITY_HANDLING:
-            aErrorInformation.sMessage += "External entity handling";
+            m_aErrorInformation.m_sMessage += "External entity handling";
             break;
         case XML_ERROR_NOT_STANDALONE:
-            aErrorInformation.sMessage += "Not standalone";
+            m_aErrorInformation.m_sMessage += "Not standalone";
             break;
         case XML_ERROR_NONE:
             break;
         default:
             break;
         }
-        delete pXMLFile;
-        pXMLFile = NULL;
+        delete m_pXMLFile;
+        m_pXMLFile = NULL;
     }
 
     osl_unmapMappedFile(h, p, s);
     osl_closeFile(h);
 
-    return pXMLFile;
+    return m_pXMLFile;
 }
 
 namespace