| /************************************************************** |
| * |
| * 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 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 succesfully" ); |
| } |
| 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("<")); |
| static const String GT(String::CreateFromAscii(">")); |
| static const String QGT(String::CreateFromAscii(">")); |
| static const String QUOT(String::CreateFromAscii("\\")); |
| static const String QQUOT(String::CreateFromAscii(""")); |
| static const String APOS(String::CreateFromAscii("\"")); |
| static const String QAPOS(String::CreateFromAscii("'")); |
| static const String AMP(String::CreateFromAscii("&")); |
| static const String QAMP(String::CreateFromAscii("&")); |
| 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 += "'"; |
| 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 ) == "&" ) { |
| sReturn += "&"; |
| sString.Erase( 0, 5 ); |
| } |
| else if ( sString.Copy( 0, 4 ) == "<" ) { |
| sReturn += "<"; |
| sString.Erase( 0, 4 ); |
| } |
| else if ( sString.Copy( 0, 4 ) == ">" ) { |
| sReturn += ">"; |
| sString.Erase( 0, 4 ); |
| } |
| else if ( sString.Copy( 0, 6 ) == """ ) { |
| sReturn += "\""; |
| sString.Erase( 0, 6 ); |
| } |
| else if ( sString.Copy( 0, 6 ) == "'" ) { |
| 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 ""; |
| } |
| |
