/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/


// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_l10ntools.hxx"
#include <iterator> /* std::iterator*/

#include <stdio.h>
#include <sal/alloca.h>

#include "xmlparse.hxx"
#include <fstream>
#include <iostream>
#include <osl/mutex.hxx>
#include <osl/thread.hxx>
#ifdef __MINGW32__
#include <tools/prewin.h>
#include <tools/postwin.h>
#endif
using namespace std;
using namespace osl;

//
// class XMLChildNode
//

/*****************************************************************************/
XMLChildNode::XMLChildNode( XMLParentNode *pPar )
/*****************************************************************************/
				: pParent( pPar )
{
	if ( pParent )
		pParent->AddChild( this );
}


/*****************************************************************************/
XMLChildNode::XMLChildNode( const XMLChildNode& obj)
/*****************************************************************************/
:   XMLNode(obj),
    pParent(obj.pParent){}

/*****************************************************************************/
XMLChildNode& XMLChildNode::operator=(const XMLChildNode& obj){
/*****************************************************************************/
	if(this != &obj){
        pParent=obj.pParent;
    }
    return *this;
}
//
// class XMLParentNode
//


/*****************************************************************************/
XMLParentNode::~XMLParentNode()
/*****************************************************************************/
{
	if( pChildList ){
            RemoveAndDeleteAllChilds();
            delete pChildList;
			pChildList = NULL;
    }
	pChildList = NULL;
}
/*****************************************************************************/
XMLParentNode::XMLParentNode( const XMLParentNode& obj)
/*****************************************************************************/
: XMLChildNode( obj )
{
	if( obj.pChildList ){
        pChildList=new XMLChildNodeList();
        XMLChildNode* pNode = NULL;
        for ( sal_uLong i = 0; i < obj.pChildList->Count(); i++ ){
			pNode = obj.pChildList->GetObject( 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:
                        AddChild( new XMLData   ( *static_cast<XMLData* >   (pNode) ) ); break;
                    case XML_NODE_TYPE_COMMENT:
                        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");
                }
            }
        }
    }else pChildList = NULL;
}
/*****************************************************************************/
XMLParentNode& XMLParentNode::operator=(const XMLParentNode& obj){
/*****************************************************************************/
	if(this!=&obj){
        XMLChildNode::operator=(obj);
        if( pChildList ){
            RemoveAndDeleteAllChilds();
            delete pChildList;
			pChildList = NULL;
        }
        if( obj.pChildList ){
            pChildList=new XMLChildNodeList();
            for ( sal_uLong i = 0; i < obj.pChildList->Count(); i++ )
			    AddChild( obj.pChildList->GetObject( i ) );
        }else pChildList = NULL;

    }
    return *this;
}
/*****************************************************************************/
void XMLParentNode::AddChild( XMLChildNode *pChild )
/*****************************************************************************/
{
	if ( !pChildList )
		pChildList = new XMLChildNodeList();
	pChildList->Insert( pChild, LIST_APPEND );
}

/*****************************************************************************/
void XMLParentNode::AddChild( XMLChildNode *pChild , int pos )
/*****************************************************************************/
{
	if ( !pChildList )
		pChildList = new XMLChildNodeList();
    pChildList->Insert( pChild, pos );
}

/*****************************************************************************/
int XMLParentNode::GetPosition( ByteString id ){
/*****************************************************************************/
    XMLElement* a;

    static const ByteString sEnusStr = ByteString(String::CreateFromAscii(ENGLISH_US_ISO).ToLowerAscii() , RTL_TEXTENCODING_ASCII_US ).ToLowerAscii();
    static const ByteString sDeStr   = ByteString(String::CreateFromAscii(GERMAN_ISO2).ToLowerAscii()    , RTL_TEXTENCODING_ASCII_US ).ToLowerAscii();

    if ( pChildList ){
        for ( sal_uLong i = 0; i < pChildList->Count(); i++ ) {
		    XMLChildNode *pChild = pChildList->GetObject( i );
            if ( pChild->GetNodeType() == XML_NODE_TYPE_ELEMENT ){
			    a = static_cast<XMLElement* >(pChild);
                ByteString elemid( a->GetId() );
                elemid.ToLowerAscii();
                if (   elemid.Equals( id.ToLowerAscii() ) ){
                    ByteString elemLID( a->GetLanguageId() );
                    elemLID.ToLowerAscii();
                    if( elemLID.Equals( sEnusStr) ) {
                        return i;
                    }
                    else if( elemLID.Equals( sDeStr) ) {
                        return i;
                    }
                }
            }
        }
    }
    return -1;
}

/*****************************************************************************/
int XMLParentNode::RemoveChild( XMLElement *pRefElement )
/*****************************************************************************/
{
    XMLElement* a;
    if ( pChildList ){
        for ( sal_uLong i = 0; i < pChildList->Count(); i++ ) {
		    XMLChildNode *pChild = pChildList->GetObject( i );
            if ( pChild->GetNodeType() == XML_NODE_TYPE_ELEMENT ){
			    a = static_cast<XMLElement* >(pChild);
                ByteString elemid( a->GetId() );
                elemid.ToLowerAscii();
                ByteString elemLID( a->GetLanguageId() );
                elemLID.ToLowerAscii();
                ByteString pRefLID( pRefElement->GetLanguageId() );
                pRefLID.ToLowerAscii();
                if ( elemid.Equals(pRefElement->GetId())
                    && elemLID.Equals( pRefLID ) )
			    {
                    if( pRefElement->ToOString().compareTo( a->ToOString() )==0 ){
						pChildList->Remove( i );
                        delete a; // Test
                        return i;
                    }
                }
            }

        }
    }
    return -1;
}

/*****************************************************************************/
void XMLParentNode::RemoveAndDeleteAllChilds(){
/*****************************************************************************/
	if ( pChildList ) {
		for ( sal_uLong i = 0; i < pChildList->Count(); i++ )
			delete pChildList->GetObject( i );
		pChildList->Clear();
	}
}

/*****************************************************************************/
XMLElement *XMLParentNode::GetChildElement( XMLElement *pRefElement )
/*****************************************************************************/
{
	for ( sal_uLong i = 0; i < pChildList->Count(); i++ ) {
		XMLChildNode *pChild = pChildList->GetObject( i );
		if ( pChild->GetNodeType() == XML_NODE_TYPE_ELEMENT )
			if ((( XMLElement * ) pChild )->GetName() ==
				pRefElement->GetName())
			{
				XMLAttributeList *pList = pRefElement->GetAttributeList();
				if ( !pList )
					return ( XMLElement * ) pChild;

				sal_Bool bMatch = sal_False;
				for ( sal_uLong j = 0; j < pList->Count() && bMatch; j++ ) {
					XMLAttribute *pAttribute = pList->GetObject( j );
					XMLAttribute *pCandidate =
						(( XMLElement * ) pChild )->GetAttribute(
							*pAttribute );
					if ( !pCandidate || !pAttribute->IsEqual( *pCandidate ))
						bMatch = sal_False;
				}
				if ( bMatch )
					return ( XMLElement * ) pChild;
			}
	}
	return NULL;
}

//
// class XMLFile
//

/*****************************************************************************/
sal_uInt16 XMLFile::GetNodeType()
/*****************************************************************************/
{
	return XML_NODE_TYPE_FILE;
}

/*****************************************************************************/
sal_Bool XMLFile::Write( ByteString &aFilename )
/*****************************************************************************/
{

    if ( aFilename.Len()) {
		// retry harder if there is a NFS problem,
        for( int x = 1 ; x < 3 ; x++ ){	// this looks strange...yes!
			ofstream aFStream( aFilename.GetBuffer() , ios::out | ios::trunc );

            if( !aFStream )		// From time to time the stream can not be opened the first time on NFS volumes,
			{					// I wasn't able to track this down. I think this is an NFS issue .....
                //cerr << "ERROR: - helpex - Can't write to tempfile " << aFilename.GetBuffer() << " No#" << x << "\n";
                TimeValue aTime;
                aTime.Seconds = 3;
                aTime.Nanosec = 0;

                osl::Thread::wait( aTime );
            }
            else
            {
                // write out
				Write( aFStream );
                aFStream.close();

				// check!
				DirEntry aTarget( aFilename );
                FileStat aFileStat( aTarget );

				if( aFileStat.GetSize() < 1 )
				{
                    //retry
					//cerr << "WARNING: - helpex - Can't create file " << aFilename.GetBuffer() << " No#" << x << "\n";
                    aTarget.Kill();
                }
				else
				{
                    //everything ok!
					return true;
                }
            }
	    }
		cerr << "ERROR: - helpex - Can't create file " << aFilename.GetBuffer() << "\nPossible reason: Disk full ? Mounted NFS volume broken ? Wrong permissions ?\n";
        exit( -1 );
    }
    cerr << "ERROR: - helpex - Empty file name\n";
    exit( -1 );
}


void XMLFile::WriteString( ofstream &rStream, const String &sString )
{
	ByteString sText( sString, RTL_TEXTENCODING_UTF8 );
	rStream << sText.GetBuffer();
}


sal_Bool XMLFile::Write( ofstream &rStream , XMLNode *pCur )
{
    XMLUtil& xmlutil = XMLUtil::Instance();
    (void) xmlutil;

    if ( !pCur )
		Write( rStream, this );
	else {
		switch( pCur->GetNodeType()) {
			case XML_NODE_TYPE_FILE: {
				if( GetChildList())
					for ( sal_uLong i = 0; i < GetChildList()->Count(); i++ )
						Write( rStream, GetChildList()->GetObject( i ));
			}
			break;
			case XML_NODE_TYPE_ELEMENT: {
				XMLElement *pElement = ( XMLElement * ) pCur;
				rStream  << "<";
				WriteString( rStream, pElement->GetName());
				if ( pElement->GetAttributeList())
					for ( sal_uLong j = 0; j < pElement->GetAttributeList()->Count(); j++ ) {
						rStream << " ";
						String sData(*pElement->GetAttributeList()->GetObject( j ));
						xmlutil.QuotHTML( sData );
						WriteString( rStream , sData );
						rStream << "=\"";
						sData=pElement->GetAttributeList()->GetObject( j )->GetValue();
						xmlutil.QuotHTML(  sData );
						WriteString( rStream , sData  );
						rStream << "\"";
					}
				if ( !pElement->GetChildList())
					rStream << "/>";
				else {
					rStream << ">";
					for ( sal_uLong k = 0; k < pElement->GetChildList()->Count(); k++ )
						Write( rStream, pElement->GetChildList()->GetObject( k ));
					rStream << "</";
					WriteString( rStream, pElement->GetName());
					rStream << ">";
   				}
			}
			break;
			case XML_NODE_TYPE_DATA: {
				XMLData *pData = ( XMLData * ) pCur;
				String sData( pData->GetData());
                xmlutil.QuotHTML( sData );
				WriteString( rStream, sData );
			}
			break;
			case XML_NODE_TYPE_COMMENT: {
				XMLComment *pComment = ( XMLComment * ) pCur;
				rStream << "<!--";
				WriteString( rStream, pComment->GetComment());
				rStream << "-->";
			}
			break;
			case XML_NODE_TYPE_DEFAULT: {
				XMLDefault *pDefault = ( XMLDefault * ) pCur;
				WriteString( rStream, pDefault->GetDefault());
			}
			break;
		}
	}
	return sal_True;
}


void XMLFile::Print( XMLNode *pCur, sal_uInt16 nLevel )
{

	if ( !pCur )
		Print( this );
	else {
		switch( pCur->GetNodeType()) {
			case XML_NODE_TYPE_FILE: {
				if( GetChildList())
					for ( sal_uLong i = 0; i < GetChildList()->Count(); i++ )
						Print( GetChildList()->GetObject( i ));
			}
			break;
			case XML_NODE_TYPE_ELEMENT: {
				XMLElement *pElement = ( XMLElement * ) pCur;

				fprintf( stdout, "<%s", ByteString( pElement->GetName(), RTL_TEXTENCODING_UTF8 ).GetBuffer());
				if ( pElement->GetAttributeList())
					for ( sal_uLong j = 0; j < pElement->GetAttributeList()->Count(); j++ ){
						ByteString aAttrName( *pElement->GetAttributeList()->GetObject( j ), RTL_TEXTENCODING_UTF8 );
                        if( !aAttrName.EqualsIgnoreCaseAscii( XML_LANG ) ) {
                            fprintf( stdout, " %s=\"%s\"",
                                aAttrName.GetBuffer(),
							    ByteString( pElement->GetAttributeList()->GetObject( j )->GetValue(),
								    RTL_TEXTENCODING_UTF8 ).GetBuffer());
                        }
                    }
				if ( !pElement->GetChildList())
					fprintf( stdout, "/>" );
				else {
					fprintf( stdout, ">" );
					for ( sal_uLong k = 0; k < pElement->GetChildList()->Count(); k++ )
						Print( pElement->GetChildList()->GetObject( k ), nLevel + 1 );
					fprintf( stdout, "</%s>", ByteString( pElement->GetName(), RTL_TEXTENCODING_UTF8 ).GetBuffer());
				}
			}
			break;
			case XML_NODE_TYPE_DATA: {
				XMLData *pData = ( XMLData * ) pCur;
				String sData = pData->GetData();
				fprintf( stdout, "%s", ByteString( sData, RTL_TEXTENCODING_UTF8 ).GetBuffer());
			}
			break;
			case XML_NODE_TYPE_COMMENT: {
				XMLComment *pComment = ( XMLComment * ) pCur;
				fprintf( stdout, "<!--%s-->", ByteString( pComment->GetComment(), RTL_TEXTENCODING_UTF8 ).GetBuffer());
			}
			break;
			case XML_NODE_TYPE_DEFAULT: {
				XMLDefault *pDefault = ( XMLDefault * ) pCur;
				fprintf( stdout, "%s", ByteString( pDefault->GetDefault(), RTL_TEXTENCODING_UTF8 ).GetBuffer());
			}
			break;
		}
	}
}
XMLFile::~XMLFile()
{
	if( XMLStrings != NULL ){
		XMLHashMap::iterator pos = XMLStrings->begin();
		for( ; pos != XMLStrings->end() ; ++pos ){
			delete pos->second;				// Check and delete content also ?
		}
		delete XMLStrings;
		XMLStrings = NULL;
	}
}
/*****************************************************************************/
XMLFile::XMLFile( const String &rFileName ) // the file name, empty if created from memory stream
/*****************************************************************************/
				: XMLParentNode( NULL ),
				  sFileName    ( rFileName ),
				  ID           ( "id" ),
                  OLDREF       ( "oldref" ),
				  XML_LANG     ( "xml-lang" ),
				  XMLStrings   ( NULL )

{
//	nodes_localize.insert( TagMap::value_type(ByteString(String::CreateFromAscii("bookmark_value"),RTL_TEXTENCODING_ASCII_US) , sal_True) );
	nodes_localize.insert( TagMap::value_type(ByteString(String::CreateFromAscii("bookmark"),RTL_TEXTENCODING_ASCII_US) , sal_True) );
    nodes_localize.insert( TagMap::value_type(ByteString(String::CreateFromAscii("variable"),RTL_TEXTENCODING_ASCII_US) , sal_True) );
	nodes_localize.insert( TagMap::value_type(ByteString(String::CreateFromAscii("paragraph"),RTL_TEXTENCODING_ASCII_US) , sal_True) );
	nodes_localize.insert( TagMap::value_type(ByteString(String::CreateFromAscii("alt"),RTL_TEXTENCODING_ASCII_US) , sal_True) );
	nodes_localize.insert( TagMap::value_type(ByteString(String::CreateFromAscii("caption"),RTL_TEXTENCODING_ASCII_US) , sal_True) );
	nodes_localize.insert( TagMap::value_type(ByteString(String::CreateFromAscii("title"),RTL_TEXTENCODING_ASCII_US) , sal_True) );
	nodes_localize.insert( TagMap::value_type(ByteString(String::CreateFromAscii("link"),RTL_TEXTENCODING_ASCII_US) , sal_True) );
}
/*****************************************************************************/
void XMLFile::Extract( XMLFile *pCur )
/*****************************************************************************/
{
	if( XMLStrings != NULL ) delete XMLStrings; // Elements ?

	XMLStrings = new XMLHashMap();
   	if ( !pCur )
        SearchL10NElements( this );
	else {
		if( pCur->GetNodeType()==XML_NODE_TYPE_FILE) {
            SearchL10NElements(pCur);
		}
	}
}

/*****************************************************************************/
void XMLFile::View(){
/*****************************************************************************/
	XMLElement* cur;
	for(XMLHashMap::iterator pos=XMLStrings->begin(); pos!=XMLStrings->end();++pos){
		fprintf(stdout,"\nid=%s\n",(pos->first).GetBuffer());
		LangHashMap* elem=pos->second;
		for(LangHashMap::iterator pos2=elem->begin(); pos2!=elem->end();++pos2){
			fprintf( stdout,"\nlanguage=%s\n",(pos2->first).GetBuffer() );
			cur=pos2->second;
			fprintf(stdout,"\n%s\n",((XMLElement*)cur)->ToOString().getStr());

		}
	}
}

/*****************************************************************************/
void XMLFile::InsertL10NElement( XMLElement* pElement ){
/*****************************************************************************/
	ByteString tmpStr,id,oldref,language("");
	LangHashMap* elem;

    if( pElement->GetAttributeList() != NULL ){
        for ( sal_uLong j = 0; j < pElement->GetAttributeList()->Count(); j++ ){
		    tmpStr=ByteString( *pElement->GetAttributeList()->GetObject( j ),RTL_TEXTENCODING_UTF8 );
		    if( tmpStr.CompareTo(ID)==COMPARE_EQUAL  ){	// Get the "id" Attribute
			    id = ByteString( pElement->GetAttributeList()->GetObject( j )->GetValue(),RTL_TEXTENCODING_UTF8 );
		    }
		    if( tmpStr.CompareTo( XML_LANG ) == COMPARE_EQUAL ){	// Get the "xml-lang" Attribute
			    language = ByteString( pElement->GetAttributeList()->GetObject( j )->GetValue(),RTL_TEXTENCODING_UTF8 );
		    }

	    }
    }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 ] )
        {
            fprintf(stdout,"Error: Duplicated entry. ID = %s  LANG = %s in File %s\n", id.GetBuffer(), language.GetBuffer(), ByteString( sFullName,RTL_TEXTENCODING_ASCII_US ).GetBuffer() );
            exit( -1 );
        }
        (*elem)[ language ]=pElement;
	}
}
/*****************************************************************************/
void XMLFile::showType(XMLParentNode* node){
/*****************************************************************************/
	switch (node->GetNodeType()){
		case XML_NODE_TYPE_ELEMENT: fprintf(stdout,"ELEMENT\n") ;break;
		case XML_NODE_TYPE_FILE:    fprintf(stdout,"FILE\n")    ;break;
		case XML_NODE_TYPE_COMMENT: fprintf(stdout,"COMMENT\n") ;break;
		case XML_NODE_TYPE_DATA:    fprintf(stdout,"DATA\n")    ;break;
		case XML_NODE_TYPE_DEFAULT: fprintf(stdout,"DEFAULT\n") ;break;
		default: break;
	}
}
XMLFile::XMLFile()
/*****************************************************************************/
				: XMLParentNode( NULL ),
				  ID           ( "id" ),
                  OLDREF       ( "oldref" ),
				  XML_LANG     ( "xml-lang" ),
				  XMLStrings   ( NULL ){};


XMLFile::XMLFile( const XMLFile& obj )
/*****************************************************************************/
				: XMLParentNode( obj ),
				  sFileName    ( obj.sFileName ),
				  ID           ( "id" ),
                  OLDREF       ( "oldref" ),
				  XML_LANG     ( "xml-lang" ),
				  XMLStrings   ( NULL )
{
	if( this!=&obj )
	{
        nodes_localize  =obj.nodes_localize;
        order           =obj.order;

	}
}
/*****************************************************************************/
XMLFile& XMLFile::operator=(const XMLFile& obj){
/*****************************************************************************/
    if( this!=&obj ){

        XMLParentNode::operator=(obj);

        nodes_localize  =obj.nodes_localize;
        order           =obj.order;

		if( XMLStrings )    delete XMLStrings;

		if( obj.XMLStrings )
        {
            XMLStrings = new XMLHashMap();
	        for( XMLHashMap::iterator pos = obj.XMLStrings->begin() ; pos != obj.XMLStrings->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 );
                    printf("*");
		        }
                (*XMLStrings)[ pos->first ] = newelem;
            }
        }
    }
    printf("done!\n");
    return *this;
}


/*****************************************************************************/
void XMLFile::SearchL10NElements( XMLParentNode *pCur , int pos)
/*****************************************************************************/
{
	static const ByteString LOCALIZE("localize");
	static const ByteString THEID("id");
	bool bInsert	= true;
	if ( !pCur )
		SearchL10NElements( this  );
	else {
		switch( pCur->GetNodeType()) {
			case XML_NODE_TYPE_FILE: {
                XMLParentNode* pElement;
                if( GetChildList()){
                    for ( sal_uLong i = 0; i < GetChildList()->Count(); i++ ){
                        pElement = (XMLParentNode*) GetChildList()->GetObject( i );
                        if( pElement->GetNodeType() ==  XML_NODE_TYPE_ELEMENT ) SearchL10NElements( pElement , i);
                    }
                }
            }
			break;
			case XML_NODE_TYPE_ELEMENT: {
				XMLElement *pElement = ( XMLElement * ) pCur;
        		ByteString sName(pElement->GetName(),RTL_TEXTENCODING_ASCII_US);
                ByteString language,tmpStrVal,oldref;
				if ( pElement->GetAttributeList()){
					for ( sal_uLong j = 0 , cnt = pElement->GetAttributeList()->Count(); j < cnt && bInsert; j++ ){
						const ByteString tmpStr( *pElement->GetAttributeList()->GetObject( j ),RTL_TEXTENCODING_UTF8 );
						if( tmpStr.CompareTo(THEID)==COMPARE_EQUAL  ){	// Get the "id" Attribute
							tmpStrVal=ByteString( pElement->GetAttributeList()->GetObject( j )->GetValue(),RTL_TEXTENCODING_UTF8 );
                            //printf("Checking id = %s\n",tmpStrVal.GetBuffer() );
						}
						if( tmpStr.CompareTo(LOCALIZE)==COMPARE_EQUAL  ){	// Get the "localize" Attribute
							bInsert=false;
						}
						if( tmpStr.CompareTo(XML_LANG)==COMPARE_EQUAL ){	// Get the "xml-lang" Attribute
							language=ByteString( pElement->GetAttributeList()->GetObject( j )->GetValue(),RTL_TEXTENCODING_UTF8 );
						}
                        if( tmpStr.CompareTo(OLDREF)==COMPARE_EQUAL ){	// Get the "oldref" Attribute
		                    oldref=ByteString( pElement->GetAttributeList()->GetObject( j )->GetValue(),RTL_TEXTENCODING_UTF8 );
		                }
					}
					pElement->SetLanguageId ( language );
					pElement->SetId         ( tmpStrVal.GetBuffer() );
                    pElement->SetOldRef     ( oldref  );
                    pElement->SetPos( pos );
				}

				if ( bInsert && ( nodes_localize.find( sName.ToLowerAscii() ) != nodes_localize.end() ) )
					InsertL10NElement(pElement);
				else if ( bInsert && pElement->GetChildList() ){
					for ( sal_uLong k = 0; k < pElement->GetChildList()->Count(); k++ )
						SearchL10NElements( (XMLParentNode*) pElement->GetChildList()->GetObject( k ) , k);
				}
            }
			break;
			case XML_NODE_TYPE_DATA: {
			}
			break;
			case XML_NODE_TYPE_COMMENT: {
			}
			break;
			case XML_NODE_TYPE_DEFAULT: {
			}
			break;
		}
	}
}

/*****************************************************************************/
bool XMLFile::CheckExportStatus( XMLParentNode *pCur )
/*****************************************************************************/
{
    static bool bStatusExport = true;
    const ByteString LOCALIZE("localize");
    const ByteString STATUS("status");
    const ByteString PUBLISH("PUBLISH");
    const ByteString DEPRECATED("DEPRECATED");

    const ByteString TOPIC("topic");
	bool bInsert	= true;
	if ( !pCur )
		CheckExportStatus( this );
	else {
        switch( pCur->GetNodeType()) {
			case XML_NODE_TYPE_FILE: {
                XMLParentNode* pElement;
                if( GetChildList()){
                    for ( sal_uLong i = 0; i < GetChildList()->Count(); i++ ){
                        pElement = (XMLParentNode*) GetChildList()->GetObject( i );
                        if( pElement->GetNodeType() ==  XML_NODE_TYPE_ELEMENT ) CheckExportStatus( pElement );//, i);
                    }
                }
            }
			break;
			case XML_NODE_TYPE_ELEMENT: {
				XMLElement *pElement = ( XMLElement * ) pCur;
        		ByteString sName(pElement->GetName(),RTL_TEXTENCODING_ASCII_US);
                if( sName.EqualsIgnoreCaseAscii( TOPIC ) ){
				    if ( pElement->GetAttributeList()){
					    for ( sal_uLong j = 0 , cnt = pElement->GetAttributeList()->Count(); j < cnt && bInsert; j++ ){
						    const ByteString tmpStr( *pElement->GetAttributeList()->GetObject( j ),RTL_TEXTENCODING_UTF8 );
                            if( tmpStr.EqualsIgnoreCaseAscii( STATUS ) ){
							    ByteString tmpStrVal=ByteString( pElement->GetAttributeList()->GetObject( j )->GetValue(),RTL_TEXTENCODING_UTF8 );
                                if( !tmpStrVal.EqualsIgnoreCaseAscii( PUBLISH )  &&
                                    !tmpStrVal.EqualsIgnoreCaseAscii( DEPRECATED )){
                                    bStatusExport = false;
                                }
						    }

                        }
                    }
                }
				else if ( pElement->GetChildList() ){
					for ( sal_uLong k = 0; k < pElement->GetChildList()->Count(); k++ )
						CheckExportStatus( (XMLParentNode*) pElement->GetChildList()->GetObject( k ) );//, k);
				}
            }
			break;
		}
	}
    return bStatusExport;
}

/*****************************************************************************/
sal_uInt16 XMLElement::GetNodeType()
/*****************************************************************************/
{
	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 )

{
    if ( obj.pAttributes ){
        pAttributes = new XMLAttributeList();
        for ( sal_uLong i = 0; i < obj.pAttributes->Count(); i++ )
			AddAttribute( *obj.pAttributes->GetObject( i ) , obj.pAttributes->GetObject( 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 ( sal_uLong i = 0; i < pAttributes->Count(); i++ )
			    delete pAttributes->GetObject( i );
	        delete pAttributes;
	    }
        if ( obj.pAttributes ){
            pAttributes         =new XMLAttributeList();
            for ( sal_uLong i = 0; i < obj.pAttributes->Count(); i++ )
			    AddAttribute( *obj.pAttributes->GetObject( i ) , obj.pAttributes->GetObject( i )->GetValue() );
        }
    }
    return *this;
}

/*****************************************************************************/
void XMLElement::AddAttribute( const String &rAttribute, const String &rValue )
/*****************************************************************************/
{
	if ( !pAttributes )
		pAttributes = new XMLAttributeList();
	pAttributes->Insert( new XMLAttribute( rAttribute, rValue ), LIST_APPEND );
}

/*****************************************************************************/
void XMLElement::ChangeLanguageTag( const String &rValue ){
/*****************************************************************************/
    static const String rName = String::CreateFromAscii("xml-lang");
    SetLanguageId( ByteString(rValue,RTL_TEXTENCODING_UTF8) );
    if ( pAttributes ){
        for ( sal_uLong i = 0; i < pAttributes->Count(); i++ ){
            if ( *pAttributes->GetObject( i ) == rName ){
                pAttributes->GetObject( i )->setValue(rValue);
            }
        }
    }
    XMLChildNode* pNode  = NULL;
    XMLElement*   pElem  = NULL;
    XMLChildNodeList* pCList = GetChildList();

    if( pCList != NULL ){
        for ( sal_uLong i = 0; i < pCList->Count(); i++ ){
			pNode = pCList->GetObject( i );
            if( pNode != NULL && pNode->GetNodeType() == XML_NODE_TYPE_ELEMENT ){
                pElem = static_cast< XMLElement* >(pNode);
                pElem->ChangeLanguageTag( rValue );
                pElem->SetLanguageId( ByteString(rValue,RTL_TEXTENCODING_UTF8) );
                pElem  = NULL;
                pNode  = NULL;
            }
        }
        pCList = NULL;
    }
}
/*****************************************************************************/
XMLAttribute *XMLElement::GetAttribute( const String &rName	)
/*****************************************************************************/
{
	if ( pAttributes )
		for ( sal_uLong i = 0; i < pAttributes->Count(); i++ )
			if ( *pAttributes->GetObject( i ) == rName )
				return pAttributes->GetObject( i );

	return NULL;
}

/*****************************************************************************/
XMLElement::~XMLElement()
/*****************************************************************************/
{
	if ( pAttributes ) {
		for ( sal_uLong i = 0; i < pAttributes->Count(); i++ )
			delete pAttributes->GetObject( i );

		delete pAttributes;
		pAttributes = NULL;
	}
}
/*****************************************************************************/
bool	XMLElement::Equals(OUString refStr){
/*****************************************************************************/
	return  refStr.equals( ToOUString() );
}

/*****************************************************************************/
OString XMLElement::ToOString(){
/*****************************************************************************/
    OUString ouEmpty;

	OUStringBuffer* buffer = new OUStringBuffer();
	Print( this, *buffer , true );

	OString result( (sal_Unicode* )buffer->getStr(), buffer->getLength() , RTL_TEXTENCODING_UTF8 );
	delete buffer;
	return result;
}
/*****************************************************************************/
OUString XMLElement::ToOUString(){
/*****************************************************************************/
	OUStringBuffer* buffer = new OUStringBuffer();
	Print(this,*buffer,true);
	OUString result=buffer->makeStringAndClear();
	String xy(result.getStr());
    result=OUString(xy);
	delete buffer;
	return result;
}
/*****************************************************************************/
void XMLElement::Print(XMLNode *pCur, OUStringBuffer& buffer , bool rootelement ){
/*****************************************************************************/
    //YD FIXME somewhere COMMENT is defined as 4!
    static const String _COMMENT = String::CreateFromAscii("comment");
    static const OUString XML_LANG ( OUString::createFromAscii("xml-lang") );

    if(pCur!=NULL){
        if(rootelement){
            XMLElement *pElement = ( XMLElement * ) pCur;
            if ( pElement->GetAttributeList()){
                if ( pElement->GetChildList()){
                    XMLChildNode* tmp=NULL;
                    for ( sal_uLong k = 0; k < pElement->GetChildList()->Count(); k++ ){
				        tmp=pElement->GetChildList()->GetObject( k );
                        Print( tmp, buffer , false);
                    }
				}
			}
        }
        else{

        switch( pCur->GetNodeType()) {
			case XML_NODE_TYPE_ELEMENT: {
				XMLElement *pElement = ( XMLElement * ) pCur;

                if(  !pElement->GetName().EqualsIgnoreCaseAscii( _COMMENT ) ){
                    buffer.append( OUString::createFromAscii("\\<") );
				    buffer.append( pElement->GetName() );
				    if ( pElement->GetAttributeList()){
					    for ( sal_uLong j = 0; j < pElement->GetAttributeList()->Count(); j++ ){

                            OUString aAttrName( *pElement->GetAttributeList()->GetObject( j ) );
                            if( !aAttrName.equalsIgnoreAsciiCase( XML_LANG ) ) {
                                buffer.append( OUString::createFromAscii(" ") );
                                buffer.append( aAttrName );
                                buffer.append( OUString::createFromAscii("=") );
						        buffer.append( OUString::createFromAscii("\\\"") );
					            buffer.append( pElement->GetAttributeList()->GetObject( j )->GetValue() );
						        buffer.append( OUString::createFromAscii("\\\"") );
                            }
					    }
                    }
				    if ( !pElement->GetChildList())
					    buffer.append( OUString::createFromAscii("/\\>") );
				    else {
					    buffer.append( OUString::createFromAscii("\\>") );
                        XMLChildNode* tmp=NULL;
                        for ( sal_uLong k = 0; k < pElement->GetChildList()->Count(); k++ ){
						    tmp=pElement->GetChildList()->GetObject( k );
                            Print( tmp, buffer , false);
                        }
					    buffer.append( OUString::createFromAscii("\\</") );
				        buffer.append( pElement->GetName() );
                        buffer.append( OUString::createFromAscii("\\>") );
	                }
                }
			}
			break;
			case XML_NODE_TYPE_DATA: {
				XMLData *pData = ( XMLData * ) pCur;
				String sData = pData->GetData();
                buffer.append( sData );
			}
			break;
			case XML_NODE_TYPE_COMMENT: {
				XMLComment *pComment = ( XMLComment * ) pCur;
				buffer.append( OUString::createFromAscii("<!--") );
			    buffer.append( pComment->GetComment() );
			    buffer.append( OUString::createFromAscii("-->") );
			}
			break;
			case XML_NODE_TYPE_DEFAULT: {
				XMLDefault *pDefault = ( XMLDefault * ) pCur;
				buffer.append( pDefault->GetDefault() );
			}
			break;
		}
        }
    }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 String &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
//

#define XML_CHAR_TO_OUSTRING(x) OStringToOUString(OString(x), RTL_TEXTENCODING_UTF8)
#define XML_CHAR_N_TO_OUSTRING(x,n) OStringToOUString(OString(x,n), RTL_TEXTENCODING_UTF8 )


/*****************************************************************************/
SimpleXMLParser::SimpleXMLParser()
/*****************************************************************************/
				: 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 );
}

/*****************************************************************************/
SimpleXMLParser::~SimpleXMLParser()
/*****************************************************************************/
{
	XML_ParserFree( 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 )
/*****************************************************************************/
{
	String sElementName = String( XML_CHAR_TO_OUSTRING( name ));
	XMLElement *pElement = new XMLElement( sElementName, ( XMLParentNode * ) pCurNode );
	pCurNode = pElement;
	pCurData = NULL;

	int i = 0;
	while( atts[i] ) {
		pElement->AddAttribute(
			String( XML_CHAR_TO_OUSTRING( atts[ i ] )),
			String( XML_CHAR_TO_OUSTRING( atts[ i + 1 ] )));
		i += 2;
	}
}

/*****************************************************************************/
void SimpleXMLParser::EndElement( const XML_Char *name )
/*****************************************************************************/
{
	// This variable is not used at all, but the sax C interface can't be changed
    // To prevent warnings this dummy assignment is used
    // +++
    (void) name;

    pCurNode = pCurNode->GetParent();
	pCurData = NULL;
}

/*****************************************************************************/
void SimpleXMLParser::CharacterData(
	const XML_Char *s, int len )
/*****************************************************************************/
{
	if ( !pCurData ){
		String x=String( XML_CHAR_N_TO_OUSTRING( s, len ));
		XMLUtil::UnQuotHTML(x);
		pCurData = new XMLData( x , pCurNode );
	}else{
		String x=String( XML_CHAR_N_TO_OUSTRING( s, len ));
		XMLUtil::UnQuotHTML(x);
		pCurData->AddData( x );

	}
}

/*****************************************************************************/
void SimpleXMLParser::Comment(
	const XML_Char *data )
/*****************************************************************************/
{
	pCurData = NULL;
		new XMLComment( String( XML_CHAR_TO_OUSTRING( data )), pCurNode );
}

/*****************************************************************************/
void SimpleXMLParser::Default(
	const XML_Char *s, int len )
/*****************************************************************************/
{
	pCurData = NULL;
	new XMLDefault(
		String( XML_CHAR_N_TO_OUSTRING( s, len )), pCurNode );
}

/*****************************************************************************/
XMLFile *SimpleXMLParser::Execute( const String &rFullFileName , const String &rFileName, XMLFile* pXMLFileIn )
/*****************************************************************************/
{
//	printf("DBG: SimpleXMLParser::Execute( %s )", ByteString( rFileName , RTL_TEXTENCODING_ASCII_US ).GetBuffer() );
    aErrorInformation.eCode = XML_ERROR_NONE;
	aErrorInformation.nLine = 0;
	aErrorInformation.nColumn = 0;
	aErrorInformation.sMessage = String::CreateFromAscii( "ERROR: Unable to open file " );
	aErrorInformation.sMessage += rFileName;

	SvFileStream aStream( rFileName, STREAM_STD_READ );

	if ( !aStream.IsOpen())
		return NULL;

	SvMemoryStream aMemStream;
	aStream >> aMemStream;
	aMemStream.Seek( 0 );

	aStream.Close();

    pXMLFile = pXMLFileIn;
    pXMLFile->SetName( rFileName );
    pXMLFile->SetFullName( rFullFileName );

	return Execute( &aMemStream );
}

/*****************************************************************************/
XMLFile *SimpleXMLParser::Execute( SvMemoryStream *pStream )
/*****************************************************************************/
{
	if ( !pXMLFile )
		pXMLFile = new XMLFile( String());

	pCurNode = pXMLFile;
	pCurData = NULL;

	sal_uLong nPos = pStream->Tell();
	pStream->Seek( STREAM_SEEK_TO_END );

	aErrorInformation.eCode = XML_ERROR_NONE;
	aErrorInformation.nLine = 0;
	aErrorInformation.nColumn = 0;
	if ( pXMLFile->GetName().Len()) {
		aErrorInformation.sMessage = String::CreateFromAscii( "File " );
		aErrorInformation.sMessage += pXMLFile->GetName();
		aErrorInformation.sMessage += String::CreateFromAscii( " parsed successfully" );
	}
	else
		aErrorInformation.sMessage = String::CreateFromAscii( "XML-File parsed successfully" );

	if ( !XML_Parse(
		aParser, ( char * ) pStream->GetData() + nPos, pStream->Tell() - nPos, sal_True ))
	{
		aErrorInformation.eCode = XML_GetErrorCode( aParser );
		aErrorInformation.nLine = XML_GetErrorLineNumber( aParser );
		aErrorInformation.nColumn = XML_GetErrorColumnNumber( aParser );

		aErrorInformation.sMessage = String::CreateFromAscii( "ERROR: " );
		if ( pXMLFile->GetName().Len())
			aErrorInformation.sMessage += pXMLFile->GetName();
		else
			aErrorInformation.sMessage += String::CreateFromAscii( "XML-File" );
		aErrorInformation.sMessage += String::CreateFromAscii( " (" );
		aErrorInformation.sMessage += String::CreateFromInt64( aErrorInformation.nLine );
		aErrorInformation.sMessage += String::CreateFromAscii( "," );
		aErrorInformation.sMessage += String::CreateFromInt64( aErrorInformation.nColumn );
		aErrorInformation.sMessage += String::CreateFromAscii( "): " );

		switch( aErrorInformation.eCode ) {
  			case XML_ERROR_NO_MEMORY: aErrorInformation.sMessage += String::CreateFromAscii( "No memory" ); break;
  			case XML_ERROR_SYNTAX: aErrorInformation.sMessage += String::CreateFromAscii( "Syntax" ); break;
  			case XML_ERROR_NO_ELEMENTS: aErrorInformation.sMessage += String::CreateFromAscii( "No elements" ); break;
  			case XML_ERROR_INVALID_TOKEN: aErrorInformation.sMessage += String::CreateFromAscii( "Invalid token" ); break;
  			case XML_ERROR_UNCLOSED_TOKEN: aErrorInformation.sMessage += String::CreateFromAscii( "Unclosed token" ); break;
  			case XML_ERROR_PARTIAL_CHAR: aErrorInformation.sMessage += String::CreateFromAscii( "Partial char" ); break;
  			case XML_ERROR_TAG_MISMATCH: aErrorInformation.sMessage += String::CreateFromAscii( "Tag mismatch" ); break;
  			case XML_ERROR_DUPLICATE_ATTRIBUTE: aErrorInformation.sMessage += String::CreateFromAscii( "Dublicat attribute" ); break;
  			case XML_ERROR_JUNK_AFTER_DOC_ELEMENT: aErrorInformation.sMessage += String::CreateFromAscii( "Junk after doc element" ); break;
  			case XML_ERROR_PARAM_ENTITY_REF: aErrorInformation.sMessage += String::CreateFromAscii( "Param entity ref" ); break;
  			case XML_ERROR_UNDEFINED_ENTITY: aErrorInformation.sMessage += String::CreateFromAscii( "Undefined entity" ); break;
  			case XML_ERROR_RECURSIVE_ENTITY_REF: aErrorInformation.sMessage += String::CreateFromAscii( "Recursive entity ref" ); break;
  			case XML_ERROR_ASYNC_ENTITY: aErrorInformation.sMessage += String::CreateFromAscii( "Async_entity" ); break;
  			case XML_ERROR_BAD_CHAR_REF: aErrorInformation.sMessage += String::CreateFromAscii( "Bad char ref" ); break;
  			case XML_ERROR_BINARY_ENTITY_REF: aErrorInformation.sMessage += String::CreateFromAscii( "Binary entity" ); break;
  			case XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF: aErrorInformation.sMessage += String::CreateFromAscii( "Attribute external entity ref" ); break;
  			case XML_ERROR_MISPLACED_XML_PI: aErrorInformation.sMessage += String::CreateFromAscii( "Misplaced xml pi" ); break;
  			case XML_ERROR_UNKNOWN_ENCODING: aErrorInformation.sMessage += String::CreateFromAscii( "Unknown encoding" ); break;
  			case XML_ERROR_INCORRECT_ENCODING: aErrorInformation.sMessage += String::CreateFromAscii( "Incorrect encoding" ); break;
  			case XML_ERROR_UNCLOSED_CDATA_SECTION: aErrorInformation.sMessage += String::CreateFromAscii( "Unclosed cdata section" ); break;
  			case XML_ERROR_EXTERNAL_ENTITY_HANDLING: aErrorInformation.sMessage += String::CreateFromAscii( "External entity handling" ); break;
  			case XML_ERROR_NOT_STANDALONE: aErrorInformation.sMessage += String::CreateFromAscii( "Not standalone" ); break;
            case XML_ERROR_NONE: break;
            default:
                break;

		}
		delete pXMLFile;
		pXMLFile = NULL;
	}
	pStream->Seek( nPos );

	return pXMLFile;
}

/*****************************************************************************/
void XMLUtil::QuotHTML( String &rString )
/*****************************************************************************/
{
	OUStringBuffer sReturn;
	static const String LT(String::CreateFromAscii("<"));
	static const String QLT(String::CreateFromAscii("&lt;"));
	static const String GT(String::CreateFromAscii(">"));
	static const String QGT(String::CreateFromAscii("&gt;"));
	static const String QUOT(String::CreateFromAscii("\\"));
	static const String QQUOT(String::CreateFromAscii("&quot;"));
	static const String APOS(String::CreateFromAscii("\""));
	static const String QAPOS(String::CreateFromAscii("&apos;"));
	static const String AMP(String::CreateFromAscii("&"));
	static const String QAMP(String::CreateFromAscii("&amp;"));
	static const String SLASH(String::CreateFromAscii("\\"));

	for ( sal_uInt16 i = 0; i < rString.Len(); i++) {
		if ( i < rString.Len()) {
			switch ( rString.GetChar( i )) {
				case '\\': if( i+1 <= rString.Len() ){
							switch( rString.GetChar( i+1 ) ){
                             case '<':  sReturn.append( LT );i++;break;
                             case '>':  sReturn.append( GT );i++;break;
                             case '\\': sReturn.append( QUOT );i++;break;
                             case '\"': sReturn.append( APOS );i++;break;
                             //case '\'': sReturn += "\'";i++;break;
                             //case '&' : sRetrun += "&";i++;break;
                             default:   sReturn.append( SLASH );break;

                           }
                          }
                        break;

                case '<':
                    sReturn.append( QLT );
					break;

				case '>':
                    sReturn.append( QGT );
					break;

				case '\"':
                    sReturn.append( QQUOT );
					break;

/*				case '\'':
                    sReturn += "&apos;";
					break;
*/
				case '&':
					if (
						  ( ( i + 4 ) < rString.Len()) &&
						  ( String( rString.Copy( i, 5 ) ).Equals( QAMP ) )
					   )
						sReturn.append( rString.GetChar( i ) );
					else
						sReturn.append( QAMP );
				break;

				default:
					sReturn.append( rString.GetChar( i ) );
				break;
			}
		}
	}
	rString = String( sReturn.makeStringAndClear() );
}

void XMLUtil::UnQuotHTML( String &rString ){
    UnQuotData( rString );
}

void XMLUtil::UnQuotData( String &rString_in ){
	ByteString sReturn;
    ByteString sString( rString_in , RTL_TEXTENCODING_UTF8 );
	while ( sString.Len()) {
	    if ( sString.Copy( 0, 1 ) == "\\" ) {
			sReturn += "\\\\";
			sString.Erase( 0, 1 );
		}
		else if ( sString.Copy( 0, 5 ) == "&amp;" ) {
			sReturn += "&";
			sString.Erase( 0, 5 );
		}
		else if ( sString.Copy( 0, 4 ) == "&lt;" ) {
			sReturn += "<";
			sString.Erase( 0, 4 );
		}
		else if ( sString.Copy( 0, 4 ) == "&gt;" ) {
			sReturn += ">";
			sString.Erase( 0, 4 );
		}
		else if ( sString.Copy( 0, 6 ) == "&quot;" ) {
			sReturn += "\"";
			sString.Erase( 0, 6 );
		}
		else if ( sString.Copy( 0, 6 ) == "&apos;" ) {
			sReturn += "\'";
			sString.Erase( 0, 6 );
		}
		else {
			sReturn += sString.GetChar( 0 );
			sString.Erase( 0, 1 );
		}
	}
    rString_in = String(sReturn , RTL_TEXTENCODING_UTF8 );


}

XMLUtil::XMLUtil(){
}


/*****************************************************************************/
void XMLUtil::dump(){
/*****************************************************************************/
	int cnt=1;
    printf("size=%lu\n",static_cast<unsigned long>(lMap.size()));
    for(HashMap::iterator pos = lMap.begin(); pos != lMap.end() ; ++pos){
        fprintf(stdout,"key=%s , value=%d , no=%d\n",pos->first.GetBuffer(),pos->second,cnt++);
    }
}
/*****************************************************************************/
XMLUtil&  XMLUtil::Instance(){
/*****************************************************************************/
	static XMLUtil instance;
	return instance;
}
/*****************************************************************************/
XMLUtil::~XMLUtil(){}
/*****************************************************************************/
/*****************************************************************************/
ByteString XMLUtil::GetIsoLangByIndex( sal_uInt16 nIndex )
/*****************************************************************************/
{
	if(nIndex > 0 && MAX_LANGUAGES >= nIndex )
		return isoArray[nIndex];
	return "";
}