1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_l10ntools.hxx" 26 #include <iterator> /* std::iterator*/ 27 28 #include <stdio.h> 29 #include <sal/alloca.h> 30 31 #include "xmlparse.hxx" 32 #include <fstream> 33 #include <iostream> 34 #include <osl/mutex.hxx> 35 #include <osl/thread.hxx> 36 #ifdef __MINGW32__ 37 #include <tools/prewin.h> 38 #include <tools/postwin.h> 39 #endif 40 using namespace std; 41 using namespace osl; 42 43 // 44 // class XMLChildNode 45 // 46 47 /*****************************************************************************/ 48 XMLChildNode::XMLChildNode( XMLParentNode *pPar ) 49 /*****************************************************************************/ 50 : pParent( pPar ) 51 { 52 if ( pParent ) 53 pParent->AddChild( this ); 54 } 55 56 57 /*****************************************************************************/ 58 XMLChildNode::XMLChildNode( const XMLChildNode& obj) 59 /*****************************************************************************/ 60 : XMLNode(obj), 61 pParent(obj.pParent){} 62 63 /*****************************************************************************/ 64 XMLChildNode& XMLChildNode::operator=(const XMLChildNode& obj){ 65 /*****************************************************************************/ 66 if(this != &obj){ 67 pParent=obj.pParent; 68 } 69 return *this; 70 } 71 // 72 // class XMLParentNode 73 // 74 75 76 /*****************************************************************************/ 77 XMLParentNode::~XMLParentNode() 78 /*****************************************************************************/ 79 { 80 if( pChildList ){ 81 RemoveAndDeleteAllChilds(); 82 delete pChildList; 83 pChildList = NULL; 84 } 85 pChildList = NULL; 86 } 87 /*****************************************************************************/ 88 XMLParentNode::XMLParentNode( const XMLParentNode& obj) 89 /*****************************************************************************/ 90 : XMLChildNode( obj ) 91 { 92 if( obj.pChildList ){ 93 pChildList=new XMLChildNodeList(); 94 XMLChildNode* pNode = NULL; 95 for ( sal_uLong i = 0; i < obj.pChildList->Count(); i++ ){ 96 pNode = obj.pChildList->GetObject( i ); 97 if( pNode != NULL){ 98 switch(pNode->GetNodeType()){ 99 case XML_NODE_TYPE_ELEMENT: 100 AddChild( new XMLElement( *static_cast<XMLElement* >(pNode) ) ); break; 101 case XML_NODE_TYPE_DATA: 102 AddChild( new XMLData ( *static_cast<XMLData* > (pNode) ) ); break; 103 case XML_NODE_TYPE_COMMENT: 104 AddChild( new XMLComment( *static_cast<XMLComment* >(pNode) ) ); break; 105 case XML_NODE_TYPE_DEFAULT: 106 AddChild( new XMLDefault( *static_cast<XMLDefault* >(pNode) ) ); break; 107 default: fprintf(stdout,"XMLParentNode::XMLParentNode( const XMLParentNode& obj) strange obj"); 108 } 109 } 110 } 111 }else pChildList = NULL; 112 } 113 /*****************************************************************************/ 114 XMLParentNode& XMLParentNode::operator=(const XMLParentNode& obj){ 115 /*****************************************************************************/ 116 if(this!=&obj){ 117 XMLChildNode::operator=(obj); 118 if( pChildList ){ 119 RemoveAndDeleteAllChilds(); 120 delete pChildList; 121 pChildList = NULL; 122 } 123 if( obj.pChildList ){ 124 pChildList=new XMLChildNodeList(); 125 for ( sal_uLong i = 0; i < obj.pChildList->Count(); i++ ) 126 AddChild( obj.pChildList->GetObject( i ) ); 127 }else pChildList = NULL; 128 129 } 130 return *this; 131 } 132 /*****************************************************************************/ 133 void XMLParentNode::AddChild( XMLChildNode *pChild ) 134 /*****************************************************************************/ 135 { 136 if ( !pChildList ) 137 pChildList = new XMLChildNodeList(); 138 pChildList->Insert( pChild, LIST_APPEND ); 139 } 140 141 /*****************************************************************************/ 142 void XMLParentNode::AddChild( XMLChildNode *pChild , int pos ) 143 /*****************************************************************************/ 144 { 145 if ( !pChildList ) 146 pChildList = new XMLChildNodeList(); 147 pChildList->Insert( pChild, pos ); 148 } 149 150 /*****************************************************************************/ 151 int XMLParentNode::GetPosition( ByteString id ){ 152 /*****************************************************************************/ 153 XMLElement* a; 154 155 static const ByteString sEnusStr = ByteString(String::CreateFromAscii(ENGLISH_US_ISO).ToLowerAscii() , RTL_TEXTENCODING_ASCII_US ).ToLowerAscii(); 156 static const ByteString sDeStr = ByteString(String::CreateFromAscii(GERMAN_ISO2).ToLowerAscii() , RTL_TEXTENCODING_ASCII_US ).ToLowerAscii(); 157 158 if ( pChildList ){ 159 for ( sal_uLong i = 0; i < pChildList->Count(); i++ ) { 160 XMLChildNode *pChild = pChildList->GetObject( i ); 161 if ( pChild->GetNodeType() == XML_NODE_TYPE_ELEMENT ){ 162 a = static_cast<XMLElement* >(pChild); 163 ByteString elemid( a->GetId() ); 164 elemid.ToLowerAscii(); 165 if ( elemid.Equals( id.ToLowerAscii() ) ){ 166 ByteString elemLID( a->GetLanguageId() ); 167 elemLID.ToLowerAscii(); 168 if( elemLID.Equals( sEnusStr) ) { 169 return i; 170 } 171 else if( elemLID.Equals( sDeStr) ) { 172 return i; 173 } 174 } 175 } 176 } 177 } 178 return -1; 179 } 180 181 /*****************************************************************************/ 182 int XMLParentNode::RemoveChild( XMLElement *pRefElement ) 183 /*****************************************************************************/ 184 { 185 XMLElement* a; 186 if ( pChildList ){ 187 for ( sal_uLong i = 0; i < pChildList->Count(); i++ ) { 188 XMLChildNode *pChild = pChildList->GetObject( i ); 189 if ( pChild->GetNodeType() == XML_NODE_TYPE_ELEMENT ){ 190 a = static_cast<XMLElement* >(pChild); 191 ByteString elemid( a->GetId() ); 192 elemid.ToLowerAscii(); 193 ByteString elemLID( a->GetLanguageId() ); 194 elemLID.ToLowerAscii(); 195 ByteString pRefLID( pRefElement->GetLanguageId() ); 196 pRefLID.ToLowerAscii(); 197 if ( elemid.Equals(pRefElement->GetId()) 198 && elemLID.Equals( pRefLID ) ) 199 { 200 if( pRefElement->ToOString().compareTo( a->ToOString() )==0 ){ 201 pChildList->Remove( i ); 202 delete a; // Test 203 return i; 204 } 205 } 206 } 207 208 } 209 } 210 return -1; 211 } 212 213 /*****************************************************************************/ 214 void XMLParentNode::RemoveAndDeleteAllChilds(){ 215 /*****************************************************************************/ 216 if ( pChildList ) { 217 for ( sal_uLong i = 0; i < pChildList->Count(); i++ ) 218 delete pChildList->GetObject( i ); 219 pChildList->Clear(); 220 } 221 } 222 223 /*****************************************************************************/ 224 XMLElement *XMLParentNode::GetChildElement( XMLElement *pRefElement ) 225 /*****************************************************************************/ 226 { 227 for ( sal_uLong i = 0; i < pChildList->Count(); i++ ) { 228 XMLChildNode *pChild = pChildList->GetObject( i ); 229 if ( pChild->GetNodeType() == XML_NODE_TYPE_ELEMENT ) 230 if ((( XMLElement * ) pChild )->GetName() == 231 pRefElement->GetName()) 232 { 233 XMLAttributeList *pList = pRefElement->GetAttributeList(); 234 if ( !pList ) 235 return ( XMLElement * ) pChild; 236 237 sal_Bool bMatch = sal_False; 238 for ( sal_uLong j = 0; j < pList->Count() && bMatch; j++ ) { 239 XMLAttribute *pAttribute = pList->GetObject( j ); 240 XMLAttribute *pCandidate = 241 (( XMLElement * ) pChild )->GetAttribute( 242 *pAttribute ); 243 if ( !pCandidate || !pAttribute->IsEqual( *pCandidate )) 244 bMatch = sal_False; 245 } 246 if ( bMatch ) 247 return ( XMLElement * ) pChild; 248 } 249 } 250 return NULL; 251 } 252 253 // 254 // class XMLFile 255 // 256 257 /*****************************************************************************/ 258 sal_uInt16 XMLFile::GetNodeType() 259 /*****************************************************************************/ 260 { 261 return XML_NODE_TYPE_FILE; 262 } 263 264 /*****************************************************************************/ 265 sal_Bool XMLFile::Write( ByteString &aFilename ) 266 /*****************************************************************************/ 267 { 268 269 if ( aFilename.Len()) { 270 // retry harder if there is a NFS problem, 271 for( int x = 1 ; x < 3 ; x++ ){ // this looks strange...yes! 272 ofstream aFStream( aFilename.GetBuffer() , ios::out | ios::trunc ); 273 274 if( !aFStream ) // From time to time the stream can not be opened the first time on NFS volumes, 275 { // I wasn't able to track this down. I think this is an NFS issue ..... 276 //cerr << "ERROR: - helpex - Can't write to tempfile " << aFilename.GetBuffer() << " No#" << x << "\n"; 277 TimeValue aTime; 278 aTime.Seconds = 3; 279 aTime.Nanosec = 0; 280 281 osl::Thread::wait( aTime ); 282 } 283 else 284 { 285 // write out 286 Write( aFStream ); 287 aFStream.close(); 288 289 // check! 290 DirEntry aTarget( aFilename ); 291 FileStat aFileStat( aTarget ); 292 293 if( aFileStat.GetSize() < 1 ) 294 { 295 //retry 296 //cerr << "WARNING: - helpex - Can't create file " << aFilename.GetBuffer() << " No#" << x << "\n"; 297 aTarget.Kill(); 298 } 299 else 300 { 301 //everything ok! 302 return true; 303 } 304 } 305 } 306 cerr << "ERROR: - helpex - Can't create file " << aFilename.GetBuffer() << "\nPossible reason: Disk full ? Mounted NFS volume broken ? Wrong permissions ?\n"; 307 exit( -1 ); 308 } 309 cerr << "ERROR: - helpex - Empty file name\n"; 310 exit( -1 ); 311 } 312 313 314 315 void XMLFile::WriteString( ofstream &rStream, const String &sString ) 316 { 317 ByteString sText( sString, RTL_TEXTENCODING_UTF8 ); 318 rStream << sText.GetBuffer(); 319 } 320 321 322 sal_Bool XMLFile::Write( ofstream &rStream , XMLNode *pCur ) 323 { 324 XMLUtil& xmlutil = XMLUtil::Instance(); 325 (void) xmlutil; 326 327 if ( !pCur ) 328 Write( rStream, this ); 329 else { 330 switch( pCur->GetNodeType()) { 331 case XML_NODE_TYPE_FILE: { 332 if( GetChildList()) 333 for ( sal_uLong i = 0; i < GetChildList()->Count(); i++ ) 334 Write( rStream, GetChildList()->GetObject( i )); 335 } 336 break; 337 case XML_NODE_TYPE_ELEMENT: { 338 XMLElement *pElement = ( XMLElement * ) pCur; 339 rStream << "<"; 340 WriteString( rStream, pElement->GetName()); 341 if ( pElement->GetAttributeList()) 342 for ( sal_uLong j = 0; j < pElement->GetAttributeList()->Count(); j++ ) { 343 rStream << " "; 344 String sData(*pElement->GetAttributeList()->GetObject( j )); 345 xmlutil.QuotHTML( sData ); 346 WriteString( rStream , sData ); 347 rStream << "=\""; 348 sData=pElement->GetAttributeList()->GetObject( j )->GetValue(); 349 xmlutil.QuotHTML( sData ); 350 WriteString( rStream , sData ); 351 rStream << "\""; 352 } 353 if ( !pElement->GetChildList()) 354 rStream << "/>"; 355 else { 356 rStream << ">"; 357 for ( sal_uLong k = 0; k < pElement->GetChildList()->Count(); k++ ) 358 Write( rStream, pElement->GetChildList()->GetObject( k )); 359 rStream << "</"; 360 WriteString( rStream, pElement->GetName()); 361 rStream << ">"; 362 } 363 } 364 break; 365 case XML_NODE_TYPE_DATA: { 366 XMLData *pData = ( XMLData * ) pCur; 367 String sData( pData->GetData()); 368 xmlutil.QuotHTML( sData ); 369 WriteString( rStream, sData ); 370 } 371 break; 372 case XML_NODE_TYPE_COMMENT: { 373 XMLComment *pComment = ( XMLComment * ) pCur; 374 rStream << "<!--"; 375 WriteString( rStream, pComment->GetComment()); 376 rStream << "-->"; 377 } 378 break; 379 case XML_NODE_TYPE_DEFAULT: { 380 XMLDefault *pDefault = ( XMLDefault * ) pCur; 381 WriteString( rStream, pDefault->GetDefault()); 382 } 383 break; 384 } 385 } 386 return sal_True; 387 } 388 389 390 void XMLFile::Print( XMLNode *pCur, sal_uInt16 nLevel ) 391 { 392 393 if ( !pCur ) 394 Print( this ); 395 else { 396 switch( pCur->GetNodeType()) { 397 case XML_NODE_TYPE_FILE: { 398 if( GetChildList()) 399 for ( sal_uLong i = 0; i < GetChildList()->Count(); i++ ) 400 Print( GetChildList()->GetObject( i )); 401 } 402 break; 403 case XML_NODE_TYPE_ELEMENT: { 404 XMLElement *pElement = ( XMLElement * ) pCur; 405 406 fprintf( stdout, "<%s", ByteString( pElement->GetName(), RTL_TEXTENCODING_UTF8 ).GetBuffer()); 407 if ( pElement->GetAttributeList()) 408 for ( sal_uLong j = 0; j < pElement->GetAttributeList()->Count(); j++ ){ 409 ByteString aAttrName( *pElement->GetAttributeList()->GetObject( j ), RTL_TEXTENCODING_UTF8 ); 410 if( !aAttrName.EqualsIgnoreCaseAscii( XML_LANG ) ) { 411 fprintf( stdout, " %s=\"%s\"", 412 aAttrName.GetBuffer(), 413 ByteString( pElement->GetAttributeList()->GetObject( j )->GetValue(), 414 RTL_TEXTENCODING_UTF8 ).GetBuffer()); 415 } 416 } 417 if ( !pElement->GetChildList()) 418 fprintf( stdout, "/>" ); 419 else { 420 fprintf( stdout, ">" ); 421 for ( sal_uLong k = 0; k < pElement->GetChildList()->Count(); k++ ) 422 Print( pElement->GetChildList()->GetObject( k ), nLevel + 1 ); 423 fprintf( stdout, "</%s>", ByteString( pElement->GetName(), RTL_TEXTENCODING_UTF8 ).GetBuffer()); 424 } 425 } 426 break; 427 case XML_NODE_TYPE_DATA: { 428 XMLData *pData = ( XMLData * ) pCur; 429 String sData = pData->GetData(); 430 fprintf( stdout, "%s", ByteString( sData, RTL_TEXTENCODING_UTF8 ).GetBuffer()); 431 } 432 break; 433 case XML_NODE_TYPE_COMMENT: { 434 XMLComment *pComment = ( XMLComment * ) pCur; 435 fprintf( stdout, "<!--%s-->", ByteString( pComment->GetComment(), RTL_TEXTENCODING_UTF8 ).GetBuffer()); 436 } 437 break; 438 case XML_NODE_TYPE_DEFAULT: { 439 XMLDefault *pDefault = ( XMLDefault * ) pCur; 440 fprintf( stdout, "%s", ByteString( pDefault->GetDefault(), RTL_TEXTENCODING_UTF8 ).GetBuffer()); 441 } 442 break; 443 } 444 } 445 } 446 XMLFile::~XMLFile() 447 { 448 if( XMLStrings != NULL ){ 449 XMLHashMap::iterator pos = XMLStrings->begin(); 450 for( ; pos != XMLStrings->end() ; ++pos ){ 451 delete pos->second; // Check and delete content also ? 452 } 453 delete XMLStrings; 454 XMLStrings = NULL; 455 } 456 } 457 /*****************************************************************************/ 458 XMLFile::XMLFile( const String &rFileName ) // the file name, empty if created from memory stream 459 /*****************************************************************************/ 460 : XMLParentNode( NULL ), 461 sFileName ( rFileName ), 462 ID ( "id" ), 463 OLDREF ( "oldref" ), 464 XML_LANG ( "xml-lang" ), 465 XMLStrings ( NULL ) 466 467 { 468 // nodes_localize.insert( TagMap::value_type(ByteString(String::CreateFromAscii("bookmark_value"),RTL_TEXTENCODING_ASCII_US) , sal_True) ); 469 nodes_localize.insert( TagMap::value_type(ByteString(String::CreateFromAscii("bookmark"),RTL_TEXTENCODING_ASCII_US) , sal_True) ); 470 nodes_localize.insert( TagMap::value_type(ByteString(String::CreateFromAscii("variable"),RTL_TEXTENCODING_ASCII_US) , sal_True) ); 471 nodes_localize.insert( TagMap::value_type(ByteString(String::CreateFromAscii("paragraph"),RTL_TEXTENCODING_ASCII_US) , sal_True) ); 472 nodes_localize.insert( TagMap::value_type(ByteString(String::CreateFromAscii("alt"),RTL_TEXTENCODING_ASCII_US) , sal_True) ); 473 nodes_localize.insert( TagMap::value_type(ByteString(String::CreateFromAscii("caption"),RTL_TEXTENCODING_ASCII_US) , sal_True) ); 474 nodes_localize.insert( TagMap::value_type(ByteString(String::CreateFromAscii("title"),RTL_TEXTENCODING_ASCII_US) , sal_True) ); 475 nodes_localize.insert( TagMap::value_type(ByteString(String::CreateFromAscii("link"),RTL_TEXTENCODING_ASCII_US) , sal_True) ); 476 } 477 /*****************************************************************************/ 478 void XMLFile::Extract( XMLFile *pCur ) 479 /*****************************************************************************/ 480 { 481 if( XMLStrings != NULL ) delete XMLStrings; // Elements ? 482 483 XMLStrings = new XMLHashMap(); 484 if ( !pCur ) 485 SearchL10NElements( this ); 486 else { 487 if( pCur->GetNodeType()==XML_NODE_TYPE_FILE) { 488 SearchL10NElements(pCur); 489 } 490 } 491 } 492 493 /*****************************************************************************/ 494 void XMLFile::View(){ 495 /*****************************************************************************/ 496 XMLElement* cur; 497 for(XMLHashMap::iterator pos=XMLStrings->begin(); pos!=XMLStrings->end();++pos){ 498 fprintf(stdout,"\nid=%s\n",(pos->first).GetBuffer()); 499 LangHashMap* elem=pos->second; 500 for(LangHashMap::iterator pos2=elem->begin(); pos2!=elem->end();++pos2){ 501 fprintf( stdout,"\nlanguage=%s\n",(pos2->first).GetBuffer() ); 502 cur=pos2->second; 503 fprintf(stdout,"\n%s\n",((XMLElement*)cur)->ToOString().getStr()); 504 505 } 506 } 507 } 508 509 /*****************************************************************************/ 510 void XMLFile::InsertL10NElement( XMLElement* pElement ){ 511 /*****************************************************************************/ 512 ByteString tmpStr,id,oldref,language(""); 513 LangHashMap* elem; 514 515 if( pElement->GetAttributeList() != NULL ){ 516 for ( sal_uLong j = 0; j < pElement->GetAttributeList()->Count(); j++ ){ 517 tmpStr=ByteString( *pElement->GetAttributeList()->GetObject( j ),RTL_TEXTENCODING_UTF8 ); 518 if( tmpStr.CompareTo(ID)==COMPARE_EQUAL ){ // Get the "id" Attribute 519 id = ByteString( pElement->GetAttributeList()->GetObject( j )->GetValue(),RTL_TEXTENCODING_UTF8 ); 520 } 521 if( tmpStr.CompareTo( XML_LANG ) == COMPARE_EQUAL ){ // Get the "xml-lang" Attribute 522 language = ByteString( pElement->GetAttributeList()->GetObject( j )->GetValue(),RTL_TEXTENCODING_UTF8 ); 523 } 524 525 } 526 }else{ 527 fprintf(stdout,"XMLFile::InsertL10NElement: No AttributeList found"); 528 fprintf(stdout,"++++++++++++++++++++++++++++++++++++++++++++++++++"); 529 Print( pElement , 0 ); 530 fprintf(stdout,"++++++++++++++++++++++++++++++++++++++++++++++++++"); 531 } 532 533 XMLHashMap::iterator pos = XMLStrings->find( id ); 534 if( pos == XMLStrings->end() ){ // No instanze , create new one 535 elem = new LangHashMap(); 536 (*elem)[ language ]=pElement; 537 XMLStrings->insert( XMLHashMap::value_type( id , elem ) ); 538 order.push_back( id ); 539 }else{ // Already there 540 elem=pos->second; 541 if ( (*elem)[ language ] ) 542 { 543 fprintf(stdout,"Error: Duplicated entry. ID = %s LANG = %s in File %s\n", id.GetBuffer(), language.GetBuffer(), ByteString( sFullName,RTL_TEXTENCODING_ASCII_US ).GetBuffer() ); 544 exit( -1 ); 545 } 546 (*elem)[ language ]=pElement; 547 } 548 } 549 /*****************************************************************************/ 550 void XMLFile::showType(XMLParentNode* node){ 551 /*****************************************************************************/ 552 switch (node->GetNodeType()){ 553 case XML_NODE_TYPE_ELEMENT: fprintf(stdout,"ELEMENT\n") ;break; 554 case XML_NODE_TYPE_FILE: fprintf(stdout,"FILE\n") ;break; 555 case XML_NODE_TYPE_COMMENT: fprintf(stdout,"COMMENT\n") ;break; 556 case XML_NODE_TYPE_DATA: fprintf(stdout,"DATA\n") ;break; 557 case XML_NODE_TYPE_DEFAULT: fprintf(stdout,"DEFAULT\n") ;break; 558 default: break; 559 } 560 } 561 XMLFile::XMLFile() 562 /*****************************************************************************/ 563 : XMLParentNode( NULL ), 564 ID ( "id" ), 565 OLDREF ( "oldref" ), 566 XML_LANG ( "xml-lang" ), 567 XMLStrings ( NULL ){}; 568 569 570 XMLFile::XMLFile( const XMLFile& obj ) 571 /*****************************************************************************/ 572 : XMLParentNode( obj ), 573 sFileName ( obj.sFileName ), 574 ID ( "id" ), 575 OLDREF ( "oldref" ), 576 XML_LANG ( "xml-lang" ), 577 XMLStrings ( NULL ) 578 { 579 if( this!=&obj ) 580 { 581 nodes_localize =obj.nodes_localize; 582 order =obj.order; 583 584 } 585 } 586 /*****************************************************************************/ 587 XMLFile& XMLFile::operator=(const XMLFile& obj){ 588 /*****************************************************************************/ 589 if( this!=&obj ){ 590 591 XMLParentNode::operator=(obj); 592 593 nodes_localize =obj.nodes_localize; 594 order =obj.order; 595 596 if( XMLStrings ) delete XMLStrings; 597 598 if( obj.XMLStrings ) 599 { 600 XMLStrings = new XMLHashMap(); 601 for( XMLHashMap::iterator pos = obj.XMLStrings->begin() ; pos != obj.XMLStrings->end() ; ++pos ) 602 { 603 LangHashMap* elem=pos->second; 604 LangHashMap* newelem = new LangHashMap(); 605 for(LangHashMap::iterator pos2=elem->begin(); pos2!=elem->end();++pos2){ 606 (*newelem)[ pos2->first ] = new XMLElement( *pos2->second ); 607 printf("*"); 608 } 609 (*XMLStrings)[ pos->first ] = newelem; 610 } 611 } 612 } 613 printf("done!\n"); 614 return *this; 615 } 616 617 618 /*****************************************************************************/ 619 void XMLFile::SearchL10NElements( XMLParentNode *pCur , int pos) 620 /*****************************************************************************/ 621 { 622 static const ByteString LOCALIZE("localize"); 623 static const ByteString THEID("id"); 624 bool bInsert = true; 625 if ( !pCur ) 626 SearchL10NElements( this ); 627 else { 628 switch( pCur->GetNodeType()) { 629 case XML_NODE_TYPE_FILE: { 630 XMLParentNode* pElement; 631 if( GetChildList()){ 632 for ( sal_uLong i = 0; i < GetChildList()->Count(); i++ ){ 633 pElement = (XMLParentNode*) GetChildList()->GetObject( i ); 634 if( pElement->GetNodeType() == XML_NODE_TYPE_ELEMENT ) SearchL10NElements( pElement , i); 635 } 636 } 637 } 638 break; 639 case XML_NODE_TYPE_ELEMENT: { 640 XMLElement *pElement = ( XMLElement * ) pCur; 641 ByteString sName(pElement->GetName(),RTL_TEXTENCODING_ASCII_US); 642 ByteString language,tmpStrVal,oldref; 643 if ( pElement->GetAttributeList()){ 644 for ( sal_uLong j = 0 , cnt = pElement->GetAttributeList()->Count(); j < cnt && bInsert; j++ ){ 645 const ByteString tmpStr( *pElement->GetAttributeList()->GetObject( j ),RTL_TEXTENCODING_UTF8 ); 646 if( tmpStr.CompareTo(THEID)==COMPARE_EQUAL ){ // Get the "id" Attribute 647 tmpStrVal=ByteString( pElement->GetAttributeList()->GetObject( j )->GetValue(),RTL_TEXTENCODING_UTF8 ); 648 //printf("Checking id = %s\n",tmpStrVal.GetBuffer() ); 649 } 650 if( tmpStr.CompareTo(LOCALIZE)==COMPARE_EQUAL ){ // Get the "localize" Attribute 651 bInsert=false; 652 } 653 if( tmpStr.CompareTo(XML_LANG)==COMPARE_EQUAL ){ // Get the "xml-lang" Attribute 654 language=ByteString( pElement->GetAttributeList()->GetObject( j )->GetValue(),RTL_TEXTENCODING_UTF8 ); 655 } 656 if( tmpStr.CompareTo(OLDREF)==COMPARE_EQUAL ){ // Get the "oldref" Attribute 657 oldref=ByteString( pElement->GetAttributeList()->GetObject( j )->GetValue(),RTL_TEXTENCODING_UTF8 ); 658 } 659 } 660 pElement->SetLanguageId ( language ); 661 pElement->SetId ( tmpStrVal.GetBuffer() ); 662 pElement->SetOldRef ( oldref ); 663 pElement->SetPos( pos ); 664 } 665 666 if ( bInsert && ( nodes_localize.find( sName.ToLowerAscii() ) != nodes_localize.end() ) ) 667 InsertL10NElement(pElement); 668 else if ( bInsert && pElement->GetChildList() ){ 669 for ( sal_uLong k = 0; k < pElement->GetChildList()->Count(); k++ ) 670 SearchL10NElements( (XMLParentNode*) pElement->GetChildList()->GetObject( k ) , k); 671 } 672 } 673 break; 674 case XML_NODE_TYPE_DATA: { 675 } 676 break; 677 case XML_NODE_TYPE_COMMENT: { 678 } 679 break; 680 case XML_NODE_TYPE_DEFAULT: { 681 } 682 break; 683 } 684 } 685 } 686 687 /*****************************************************************************/ 688 bool XMLFile::CheckExportStatus( XMLParentNode *pCur ) 689 /*****************************************************************************/ 690 { 691 static bool bStatusExport = true; 692 const ByteString LOCALIZE("localize"); 693 const ByteString STATUS("status"); 694 const ByteString PUBLISH("PUBLISH"); 695 const ByteString DEPRECATED("DEPRECATED"); 696 697 const ByteString TOPIC("topic"); 698 bool bInsert = true; 699 if ( !pCur ) 700 CheckExportStatus( this ); 701 else { 702 switch( pCur->GetNodeType()) { 703 case XML_NODE_TYPE_FILE: { 704 XMLParentNode* pElement; 705 if( GetChildList()){ 706 for ( sal_uLong i = 0; i < GetChildList()->Count(); i++ ){ 707 pElement = (XMLParentNode*) GetChildList()->GetObject( i ); 708 if( pElement->GetNodeType() == XML_NODE_TYPE_ELEMENT ) CheckExportStatus( pElement );//, i); 709 } 710 } 711 } 712 break; 713 case XML_NODE_TYPE_ELEMENT: { 714 XMLElement *pElement = ( XMLElement * ) pCur; 715 ByteString sName(pElement->GetName(),RTL_TEXTENCODING_ASCII_US); 716 if( sName.EqualsIgnoreCaseAscii( TOPIC ) ){ 717 if ( pElement->GetAttributeList()){ 718 for ( sal_uLong j = 0 , cnt = pElement->GetAttributeList()->Count(); j < cnt && bInsert; j++ ){ 719 const ByteString tmpStr( *pElement->GetAttributeList()->GetObject( j ),RTL_TEXTENCODING_UTF8 ); 720 if( tmpStr.EqualsIgnoreCaseAscii( STATUS ) ){ 721 ByteString tmpStrVal=ByteString( pElement->GetAttributeList()->GetObject( j )->GetValue(),RTL_TEXTENCODING_UTF8 ); 722 if( !tmpStrVal.EqualsIgnoreCaseAscii( PUBLISH ) && 723 !tmpStrVal.EqualsIgnoreCaseAscii( DEPRECATED )){ 724 bStatusExport = false; 725 } 726 } 727 728 } 729 } 730 } 731 else if ( pElement->GetChildList() ){ 732 for ( sal_uLong k = 0; k < pElement->GetChildList()->Count(); k++ ) 733 CheckExportStatus( (XMLParentNode*) pElement->GetChildList()->GetObject( k ) );//, k); 734 } 735 } 736 break; 737 } 738 } 739 return bStatusExport; 740 } 741 742 /*****************************************************************************/ 743 sal_uInt16 XMLElement::GetNodeType() 744 /*****************************************************************************/ 745 { 746 return XML_NODE_TYPE_ELEMENT; 747 } 748 749 /*****************************************************************************/ 750 XMLElement::XMLElement(const XMLElement& obj) 751 /*****************************************************************************/ 752 : 753 XMLParentNode ( obj ), 754 sElementName ( obj.sElementName ), 755 pAttributes ( NULL ), 756 project ( obj.project ), 757 filename ( obj.filename ), 758 id ( obj.id ), 759 sOldRef ( obj.sOldRef ), 760 resourceType ( obj.resourceType ), 761 languageId ( obj.languageId ), 762 nPos ( obj.nPos ) 763 764 { 765 if ( obj.pAttributes ){ 766 pAttributes = new XMLAttributeList(); 767 for ( sal_uLong i = 0; i < obj.pAttributes->Count(); i++ ) 768 AddAttribute( *obj.pAttributes->GetObject( i ) , obj.pAttributes->GetObject( i )->GetValue() ); 769 } 770 } 771 772 /*****************************************************************************/ 773 XMLElement& XMLElement::operator=(const XMLElement& obj){ 774 /*****************************************************************************/ 775 if( this!=&obj ){ 776 XMLParentNode::operator=(obj); 777 sElementName =obj.sElementName; 778 project =obj.project; 779 filename =obj.filename; 780 id =obj.id; 781 sOldRef =obj.sOldRef; 782 resourceType =obj.resourceType; 783 languageId =obj.languageId; 784 nPos =obj.nPos; 785 786 if ( pAttributes ){ 787 for ( sal_uLong i = 0; i < pAttributes->Count(); i++ ) 788 delete pAttributes->GetObject( i ); 789 delete pAttributes; 790 } 791 if ( obj.pAttributes ){ 792 pAttributes =new XMLAttributeList(); 793 for ( sal_uLong i = 0; i < obj.pAttributes->Count(); i++ ) 794 AddAttribute( *obj.pAttributes->GetObject( i ) , obj.pAttributes->GetObject( i )->GetValue() ); 795 } 796 } 797 return *this; 798 } 799 800 /*****************************************************************************/ 801 void XMLElement::AddAttribute( const String &rAttribute, const String &rValue ) 802 /*****************************************************************************/ 803 { 804 if ( !pAttributes ) 805 pAttributes = new XMLAttributeList(); 806 pAttributes->Insert( new XMLAttribute( rAttribute, rValue ), LIST_APPEND ); 807 } 808 809 /*****************************************************************************/ 810 void XMLElement::ChangeLanguageTag( const String &rValue ){ 811 /*****************************************************************************/ 812 static const String rName = String::CreateFromAscii("xml-lang"); 813 SetLanguageId( ByteString(rValue,RTL_TEXTENCODING_UTF8) ); 814 if ( pAttributes ){ 815 for ( sal_uLong i = 0; i < pAttributes->Count(); i++ ){ 816 if ( *pAttributes->GetObject( i ) == rName ){ 817 pAttributes->GetObject( i )->setValue(rValue); 818 } 819 } 820 } 821 XMLChildNode* pNode = NULL; 822 XMLElement* pElem = NULL; 823 XMLChildNodeList* pCList = GetChildList(); 824 825 if( pCList != NULL ){ 826 for ( sal_uLong i = 0; i < pCList->Count(); i++ ){ 827 pNode = pCList->GetObject( i ); 828 if( pNode != NULL && pNode->GetNodeType() == XML_NODE_TYPE_ELEMENT ){ 829 pElem = static_cast< XMLElement* >(pNode); 830 pElem->ChangeLanguageTag( rValue ); 831 pElem->SetLanguageId( ByteString(rValue,RTL_TEXTENCODING_UTF8) ); 832 pElem = NULL; 833 pNode = NULL; 834 } 835 } 836 pCList = NULL; 837 } 838 } 839 /*****************************************************************************/ 840 XMLAttribute *XMLElement::GetAttribute( const String &rName ) 841 /*****************************************************************************/ 842 { 843 if ( pAttributes ) 844 for ( sal_uLong i = 0; i < pAttributes->Count(); i++ ) 845 if ( *pAttributes->GetObject( i ) == rName ) 846 return pAttributes->GetObject( i ); 847 848 return NULL; 849 } 850 851 /*****************************************************************************/ 852 XMLElement::~XMLElement() 853 /*****************************************************************************/ 854 { 855 if ( pAttributes ) { 856 for ( sal_uLong i = 0; i < pAttributes->Count(); i++ ) 857 delete pAttributes->GetObject( i ); 858 859 delete pAttributes; 860 pAttributes = NULL; 861 } 862 } 863 /*****************************************************************************/ 864 bool XMLElement::Equals(OUString refStr){ 865 /*****************************************************************************/ 866 return refStr.equals( ToOUString() ); 867 } 868 869 /*****************************************************************************/ 870 OString XMLElement::ToOString(){ 871 /*****************************************************************************/ 872 OUString ouEmpty; 873 874 OUStringBuffer* buffer = new OUStringBuffer(); 875 Print( this, *buffer , true ); 876 877 OString result( (sal_Unicode* )buffer->getStr(), buffer->getLength() , RTL_TEXTENCODING_UTF8 ); 878 delete buffer; 879 return result; 880 } 881 /*****************************************************************************/ 882 OUString XMLElement::ToOUString(){ 883 /*****************************************************************************/ 884 OUStringBuffer* buffer = new OUStringBuffer(); 885 Print(this,*buffer,true); 886 OUString result=buffer->makeStringAndClear(); 887 String xy(result.getStr()); 888 result=OUString(xy); 889 delete buffer; 890 return result; 891 } 892 /*****************************************************************************/ 893 void XMLElement::Print(XMLNode *pCur, OUStringBuffer& buffer , bool rootelement ){ 894 /*****************************************************************************/ 895 //YD FIXME somewhere COMMENT is defined as 4! 896 static const String _COMMENT = String::CreateFromAscii("comment"); 897 static const OUString XML_LANG ( OUString::createFromAscii("xml-lang") ); 898 899 if(pCur!=NULL){ 900 if(rootelement){ 901 XMLElement *pElement = ( XMLElement * ) pCur; 902 if ( pElement->GetAttributeList()){ 903 if ( pElement->GetChildList()){ 904 XMLChildNode* tmp=NULL; 905 for ( sal_uLong k = 0; k < pElement->GetChildList()->Count(); k++ ){ 906 tmp=pElement->GetChildList()->GetObject( k ); 907 Print( tmp, buffer , false); 908 } 909 } 910 } 911 } 912 else{ 913 914 switch( pCur->GetNodeType()) { 915 case XML_NODE_TYPE_ELEMENT: { 916 XMLElement *pElement = ( XMLElement * ) pCur; 917 918 if( !pElement->GetName().EqualsIgnoreCaseAscii( _COMMENT ) ){ 919 buffer.append( OUString::createFromAscii("\\<") ); 920 buffer.append( pElement->GetName() ); 921 if ( pElement->GetAttributeList()){ 922 for ( sal_uLong j = 0; j < pElement->GetAttributeList()->Count(); j++ ){ 923 924 OUString aAttrName( *pElement->GetAttributeList()->GetObject( j ) ); 925 if( !aAttrName.equalsIgnoreAsciiCase( XML_LANG ) ) { 926 buffer.append( OUString::createFromAscii(" ") ); 927 buffer.append( aAttrName ); 928 buffer.append( OUString::createFromAscii("=") ); 929 buffer.append( OUString::createFromAscii("\\\"") ); 930 buffer.append( pElement->GetAttributeList()->GetObject( j )->GetValue() ); 931 buffer.append( OUString::createFromAscii("\\\"") ); 932 } 933 } 934 } 935 if ( !pElement->GetChildList()) 936 buffer.append( OUString::createFromAscii("/\\>") ); 937 else { 938 buffer.append( OUString::createFromAscii("\\>") ); 939 XMLChildNode* tmp=NULL; 940 for ( sal_uLong k = 0; k < pElement->GetChildList()->Count(); k++ ){ 941 tmp=pElement->GetChildList()->GetObject( k ); 942 Print( tmp, buffer , false); 943 } 944 buffer.append( OUString::createFromAscii("\\</") ); 945 buffer.append( pElement->GetName() ); 946 buffer.append( OUString::createFromAscii("\\>") ); 947 } 948 } 949 } 950 break; 951 case XML_NODE_TYPE_DATA: { 952 XMLData *pData = ( XMLData * ) pCur; 953 String sData = pData->GetData(); 954 buffer.append( sData ); 955 } 956 break; 957 case XML_NODE_TYPE_COMMENT: { 958 XMLComment *pComment = ( XMLComment * ) pCur; 959 buffer.append( OUString::createFromAscii("<!--") ); 960 buffer.append( pComment->GetComment() ); 961 buffer.append( OUString::createFromAscii("-->") ); 962 } 963 break; 964 case XML_NODE_TYPE_DEFAULT: { 965 XMLDefault *pDefault = ( XMLDefault * ) pCur; 966 buffer.append( pDefault->GetDefault() ); 967 } 968 break; 969 } 970 } 971 }else { 972 fprintf(stdout,"\n#+------Error: NULL Pointer in XMLELement::Print------+#\n"); 973 return; 974 } 975 } 976 977 978 // 979 // class XMLData 980 // 981 /*****************************************************************************/ 982 XMLData::XMLData(const XMLData& obj) 983 /*****************************************************************************/ 984 : XMLChildNode( obj ), 985 sData( obj.sData ) , 986 isNewCreated ( obj.isNewCreated ){} 987 988 /*****************************************************************************/ 989 XMLData& XMLData::operator=(const XMLData& obj){ 990 /*****************************************************************************/ 991 if( this!=&obj ){ 992 XMLChildNode::operator=( obj ); 993 sData = obj.sData; 994 isNewCreated = obj.isNewCreated; 995 } 996 return *this; 997 } 998 /*****************************************************************************/ 999 void XMLData::AddData( const String &rData) { 1000 /*****************************************************************************/ 1001 sData += rData; 1002 } 1003 1004 /*****************************************************************************/ 1005 sal_uInt16 XMLData::GetNodeType() 1006 /*****************************************************************************/ 1007 { 1008 return XML_NODE_TYPE_DATA; 1009 } 1010 1011 // 1012 // class XMLComment 1013 // 1014 1015 /*****************************************************************************/ 1016 sal_uInt16 XMLComment::GetNodeType() 1017 /*****************************************************************************/ 1018 { 1019 return XML_NODE_TYPE_COMMENT; 1020 } 1021 /*****************************************************************************/ 1022 XMLComment::XMLComment(const XMLComment& obj) 1023 /*****************************************************************************/ 1024 : XMLChildNode( obj ), 1025 sComment( obj.sComment ){} 1026 1027 /*****************************************************************************/ 1028 XMLComment& XMLComment::operator=(const XMLComment& obj){ 1029 /*****************************************************************************/ 1030 if( this!=&obj ){ 1031 XMLChildNode::operator=( obj ); 1032 sComment = obj.sComment; 1033 } 1034 return *this; 1035 } 1036 1037 // 1038 // class XMLDefault 1039 // 1040 1041 /*****************************************************************************/ 1042 sal_uInt16 XMLDefault::GetNodeType() 1043 /*****************************************************************************/ 1044 { 1045 return XML_NODE_TYPE_DEFAULT; 1046 } 1047 /*****************************************************************************/ 1048 XMLDefault::XMLDefault(const XMLDefault& obj) 1049 /*****************************************************************************/ 1050 : XMLChildNode( obj ), 1051 sDefault( obj.sDefault){} 1052 1053 /*****************************************************************************/ 1054 XMLDefault& XMLDefault::operator=(const XMLDefault& obj){ 1055 /*****************************************************************************/ 1056 if( this!=&obj ){ 1057 XMLChildNode::operator=( obj ); 1058 sDefault = obj.sDefault; 1059 } 1060 return *this; 1061 } 1062 1063 1064 // 1065 // class SimpleXMLParser 1066 // 1067 1068 #define XML_CHAR_TO_OUSTRING(x) OStringToOUString(OString(x), RTL_TEXTENCODING_UTF8) 1069 #define XML_CHAR_N_TO_OUSTRING(x,n) OStringToOUString(OString(x,n), RTL_TEXTENCODING_UTF8 ) 1070 1071 1072 /*****************************************************************************/ 1073 SimpleXMLParser::SimpleXMLParser() 1074 /*****************************************************************************/ 1075 : pXMLFile( NULL ) 1076 { 1077 aParser = XML_ParserCreate( NULL ); 1078 XML_SetUserData( aParser, this ); 1079 XML_SetElementHandler( aParser, (XML_StartElementHandler) StartElementHandler, (XML_EndElementHandler) EndElementHandler ); 1080 XML_SetCharacterDataHandler( aParser, (XML_CharacterDataHandler) CharacterDataHandler ); 1081 XML_SetCommentHandler( aParser, (XML_CommentHandler) CommentHandler ); 1082 XML_SetDefaultHandler( aParser, (XML_DefaultHandler) DefaultHandler ); 1083 } 1084 1085 /*****************************************************************************/ 1086 SimpleXMLParser::~SimpleXMLParser() 1087 /*****************************************************************************/ 1088 { 1089 XML_ParserFree( aParser ); 1090 } 1091 1092 /*****************************************************************************/ 1093 void SimpleXMLParser::StartElementHandler( 1094 void *userData, const XML_Char *name, const XML_Char **atts ) 1095 /*****************************************************************************/ 1096 { 1097 (( SimpleXMLParser * ) userData )->StartElement( name, atts ); 1098 } 1099 1100 1101 /*****************************************************************************/ 1102 void SimpleXMLParser::EndElementHandler( 1103 void *userData, const XML_Char *name ) 1104 /*****************************************************************************/ 1105 { 1106 (( SimpleXMLParser * ) userData )->EndElement( name ); 1107 } 1108 1109 /*****************************************************************************/ 1110 void SimpleXMLParser::CharacterDataHandler( 1111 void *userData, const XML_Char *s, int len ) 1112 /*****************************************************************************/ 1113 { 1114 (( SimpleXMLParser * ) userData )->CharacterData( s, len ); 1115 } 1116 1117 /*****************************************************************************/ 1118 void SimpleXMLParser::CommentHandler( 1119 void *userData, const XML_Char *data ) 1120 /*****************************************************************************/ 1121 { 1122 (( SimpleXMLParser * ) userData )->Comment( data ); 1123 } 1124 1125 /*****************************************************************************/ 1126 void SimpleXMLParser::DefaultHandler( 1127 void *userData, const XML_Char *s, int len ) 1128 /*****************************************************************************/ 1129 { 1130 (( SimpleXMLParser * ) userData )->Default( s, len ); 1131 } 1132 1133 /*****************************************************************************/ 1134 void SimpleXMLParser::StartElement( 1135 const XML_Char *name, const XML_Char **atts ) 1136 /*****************************************************************************/ 1137 { 1138 String sElementName = String( XML_CHAR_TO_OUSTRING( name )); 1139 XMLElement *pElement = new XMLElement( sElementName, ( XMLParentNode * ) pCurNode ); 1140 pCurNode = pElement; 1141 pCurData = NULL; 1142 1143 int i = 0; 1144 while( atts[i] ) { 1145 pElement->AddAttribute( 1146 String( XML_CHAR_TO_OUSTRING( atts[ i ] )), 1147 String( XML_CHAR_TO_OUSTRING( atts[ i + 1 ] ))); 1148 i += 2; 1149 } 1150 } 1151 1152 /*****************************************************************************/ 1153 void SimpleXMLParser::EndElement( const XML_Char *name ) 1154 /*****************************************************************************/ 1155 { 1156 // This variable is not used at all, but the the sax C interface can't be changed 1157 // To prevent warnings this dummy assignment is used 1158 // +++ 1159 (void) name; 1160 1161 pCurNode = pCurNode->GetParent(); 1162 pCurData = NULL; 1163 } 1164 1165 /*****************************************************************************/ 1166 void SimpleXMLParser::CharacterData( 1167 const XML_Char *s, int len ) 1168 /*****************************************************************************/ 1169 { 1170 if ( !pCurData ){ 1171 String x=String( XML_CHAR_N_TO_OUSTRING( s, len )); 1172 XMLUtil::UnQuotHTML(x); 1173 pCurData = new XMLData( x , pCurNode ); 1174 }else{ 1175 String x=String( XML_CHAR_N_TO_OUSTRING( s, len )); 1176 XMLUtil::UnQuotHTML(x); 1177 pCurData->AddData( x ); 1178 1179 } 1180 } 1181 1182 /*****************************************************************************/ 1183 void SimpleXMLParser::Comment( 1184 const XML_Char *data ) 1185 /*****************************************************************************/ 1186 { 1187 pCurData = NULL; 1188 new XMLComment( String( XML_CHAR_TO_OUSTRING( data )), pCurNode ); 1189 } 1190 1191 /*****************************************************************************/ 1192 void SimpleXMLParser::Default( 1193 const XML_Char *s, int len ) 1194 /*****************************************************************************/ 1195 { 1196 pCurData = NULL; 1197 new XMLDefault( 1198 String( XML_CHAR_N_TO_OUSTRING( s, len )), pCurNode ); 1199 } 1200 1201 /*****************************************************************************/ 1202 XMLFile *SimpleXMLParser::Execute( const String &rFullFileName , const String &rFileName, XMLFile* pXMLFileIn ) 1203 /*****************************************************************************/ 1204 { 1205 // printf("DBG: SimpleXMLParser::Execute( %s )", ByteString( rFileName , RTL_TEXTENCODING_ASCII_US ).GetBuffer() ); 1206 aErrorInformation.eCode = XML_ERROR_NONE; 1207 aErrorInformation.nLine = 0; 1208 aErrorInformation.nColumn = 0; 1209 aErrorInformation.sMessage = String::CreateFromAscii( "ERROR: Unable to open file " ); 1210 aErrorInformation.sMessage += rFileName; 1211 1212 SvFileStream aStream( rFileName, STREAM_STD_READ ); 1213 1214 if ( !aStream.IsOpen()) 1215 return NULL; 1216 1217 SvMemoryStream aMemStream; 1218 aStream >> aMemStream; 1219 aMemStream.Seek( 0 ); 1220 1221 aStream.Close(); 1222 1223 pXMLFile = pXMLFileIn; 1224 pXMLFile->SetName( rFileName ); 1225 pXMLFile->SetFullName( rFullFileName ); 1226 1227 return Execute( &aMemStream ); 1228 } 1229 1230 /*****************************************************************************/ 1231 XMLFile *SimpleXMLParser::Execute( SvMemoryStream *pStream ) 1232 /*****************************************************************************/ 1233 { 1234 if ( !pXMLFile ) 1235 pXMLFile = new XMLFile( String()); 1236 1237 pCurNode = pXMLFile; 1238 pCurData = NULL; 1239 1240 sal_uLong nPos = pStream->Tell(); 1241 pStream->Seek( STREAM_SEEK_TO_END ); 1242 1243 aErrorInformation.eCode = XML_ERROR_NONE; 1244 aErrorInformation.nLine = 0; 1245 aErrorInformation.nColumn = 0; 1246 if ( pXMLFile->GetName().Len()) { 1247 aErrorInformation.sMessage = String::CreateFromAscii( "File " ); 1248 aErrorInformation.sMessage += pXMLFile->GetName(); 1249 aErrorInformation.sMessage += String::CreateFromAscii( " parsed succesfully" ); 1250 } 1251 else 1252 aErrorInformation.sMessage = String::CreateFromAscii( "XML-File parsed successfully" ); 1253 1254 if ( !XML_Parse( 1255 aParser, ( char * ) pStream->GetData() + nPos, pStream->Tell() - nPos, sal_True )) 1256 { 1257 aErrorInformation.eCode = XML_GetErrorCode( aParser ); 1258 aErrorInformation.nLine = XML_GetErrorLineNumber( aParser ); 1259 aErrorInformation.nColumn = XML_GetErrorColumnNumber( aParser ); 1260 1261 aErrorInformation.sMessage = String::CreateFromAscii( "ERROR: " ); 1262 if ( pXMLFile->GetName().Len()) 1263 aErrorInformation.sMessage += pXMLFile->GetName(); 1264 else 1265 aErrorInformation.sMessage += String::CreateFromAscii( "XML-File" ); 1266 aErrorInformation.sMessage += String::CreateFromAscii( " (" ); 1267 aErrorInformation.sMessage += String::CreateFromInt64( aErrorInformation.nLine ); 1268 aErrorInformation.sMessage += String::CreateFromAscii( "," ); 1269 aErrorInformation.sMessage += String::CreateFromInt64( aErrorInformation.nColumn ); 1270 aErrorInformation.sMessage += String::CreateFromAscii( "): " ); 1271 1272 switch( aErrorInformation.eCode ) { 1273 case XML_ERROR_NO_MEMORY: aErrorInformation.sMessage += String::CreateFromAscii( "No memory" ); break; 1274 case XML_ERROR_SYNTAX: aErrorInformation.sMessage += String::CreateFromAscii( "Syntax" ); break; 1275 case XML_ERROR_NO_ELEMENTS: aErrorInformation.sMessage += String::CreateFromAscii( "No elements" ); break; 1276 case XML_ERROR_INVALID_TOKEN: aErrorInformation.sMessage += String::CreateFromAscii( "Invalid token" ); break; 1277 case XML_ERROR_UNCLOSED_TOKEN: aErrorInformation.sMessage += String::CreateFromAscii( "Unclosed token" ); break; 1278 case XML_ERROR_PARTIAL_CHAR: aErrorInformation.sMessage += String::CreateFromAscii( "Partial char" ); break; 1279 case XML_ERROR_TAG_MISMATCH: aErrorInformation.sMessage += String::CreateFromAscii( "Tag mismatch" ); break; 1280 case XML_ERROR_DUPLICATE_ATTRIBUTE: aErrorInformation.sMessage += String::CreateFromAscii( "Dublicat attribute" ); break; 1281 case XML_ERROR_JUNK_AFTER_DOC_ELEMENT: aErrorInformation.sMessage += String::CreateFromAscii( "Junk after doc element" ); break; 1282 case XML_ERROR_PARAM_ENTITY_REF: aErrorInformation.sMessage += String::CreateFromAscii( "Param entity ref" ); break; 1283 case XML_ERROR_UNDEFINED_ENTITY: aErrorInformation.sMessage += String::CreateFromAscii( "Undefined entity" ); break; 1284 case XML_ERROR_RECURSIVE_ENTITY_REF: aErrorInformation.sMessage += String::CreateFromAscii( "Recursive entity ref" ); break; 1285 case XML_ERROR_ASYNC_ENTITY: aErrorInformation.sMessage += String::CreateFromAscii( "Async_entity" ); break; 1286 case XML_ERROR_BAD_CHAR_REF: aErrorInformation.sMessage += String::CreateFromAscii( "Bad char ref" ); break; 1287 case XML_ERROR_BINARY_ENTITY_REF: aErrorInformation.sMessage += String::CreateFromAscii( "Binary entity" ); break; 1288 case XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF: aErrorInformation.sMessage += String::CreateFromAscii( "Attribute external entity ref" ); break; 1289 case XML_ERROR_MISPLACED_XML_PI: aErrorInformation.sMessage += String::CreateFromAscii( "Misplaced xml pi" ); break; 1290 case XML_ERROR_UNKNOWN_ENCODING: aErrorInformation.sMessage += String::CreateFromAscii( "Unknown encoding" ); break; 1291 case XML_ERROR_INCORRECT_ENCODING: aErrorInformation.sMessage += String::CreateFromAscii( "Incorrect encoding" ); break; 1292 case XML_ERROR_UNCLOSED_CDATA_SECTION: aErrorInformation.sMessage += String::CreateFromAscii( "Unclosed cdata section" ); break; 1293 case XML_ERROR_EXTERNAL_ENTITY_HANDLING: aErrorInformation.sMessage += String::CreateFromAscii( "External entity handling" ); break; 1294 case XML_ERROR_NOT_STANDALONE: aErrorInformation.sMessage += String::CreateFromAscii( "Not standalone" ); break; 1295 case XML_ERROR_NONE: break; 1296 default: 1297 break; 1298 1299 } 1300 delete pXMLFile; 1301 pXMLFile = NULL; 1302 } 1303 pStream->Seek( nPos ); 1304 1305 return pXMLFile; 1306 } 1307 1308 /*****************************************************************************/ 1309 void XMLUtil::QuotHTML( String &rString ) 1310 /*****************************************************************************/ 1311 { 1312 OUStringBuffer sReturn; 1313 static const String LT(String::CreateFromAscii("<")); 1314 static const String QLT(String::CreateFromAscii("<")); 1315 static const String GT(String::CreateFromAscii(">")); 1316 static const String QGT(String::CreateFromAscii(">")); 1317 static const String QUOT(String::CreateFromAscii("\\")); 1318 static const String QQUOT(String::CreateFromAscii(""")); 1319 static const String APOS(String::CreateFromAscii("\"")); 1320 static const String QAPOS(String::CreateFromAscii("'")); 1321 static const String AMP(String::CreateFromAscii("&")); 1322 static const String QAMP(String::CreateFromAscii("&")); 1323 static const String SLASH(String::CreateFromAscii("\\")); 1324 1325 for ( sal_uInt16 i = 0; i < rString.Len(); i++) { 1326 if ( i < rString.Len()) { 1327 switch ( rString.GetChar( i )) { 1328 case '\\': if( i+1 <= rString.Len() ){ 1329 switch( rString.GetChar( i+1 ) ){ 1330 case '<': sReturn.append( LT );i++;break; 1331 case '>': sReturn.append( GT );i++;break; 1332 case '\\': sReturn.append( QUOT );i++;break; 1333 case '\"': sReturn.append( APOS );i++;break; 1334 //case '\'': sReturn += "\'";i++;break; 1335 //case '&' : sRetrun += "&";i++;break; 1336 default: sReturn.append( SLASH );break; 1337 1338 } 1339 } 1340 break; 1341 1342 case '<': 1343 sReturn.append( QLT ); 1344 break; 1345 1346 case '>': 1347 sReturn.append( QGT ); 1348 break; 1349 1350 case '\"': 1351 sReturn.append( QQUOT ); 1352 break; 1353 1354 /* case '\'': 1355 sReturn += "'"; 1356 break; 1357 */ 1358 case '&': 1359 if ( 1360 ( ( i + 4 ) < rString.Len()) && 1361 ( String( rString.Copy( i, 5 ) ).Equals( QAMP ) ) 1362 ) 1363 sReturn.append( rString.GetChar( i ) ); 1364 else 1365 sReturn.append( QAMP ); 1366 break; 1367 1368 default: 1369 sReturn.append( rString.GetChar( i ) ); 1370 break; 1371 } 1372 } 1373 } 1374 rString = String( sReturn.makeStringAndClear() ); 1375 } 1376 1377 void XMLUtil::UnQuotHTML( String &rString ){ 1378 UnQuotData( rString ); 1379 } 1380 1381 void XMLUtil::UnQuotData( String &rString_in ){ 1382 ByteString sReturn; 1383 ByteString sString( rString_in , RTL_TEXTENCODING_UTF8 ); 1384 while ( sString.Len()) { 1385 if ( sString.Copy( 0, 1 ) == "\\" ) { 1386 sReturn += "\\\\"; 1387 sString.Erase( 0, 1 ); 1388 } 1389 else if ( sString.Copy( 0, 5 ) == "&" ) { 1390 sReturn += "&"; 1391 sString.Erase( 0, 5 ); 1392 } 1393 else if ( sString.Copy( 0, 4 ) == "<" ) { 1394 sReturn += "<"; 1395 sString.Erase( 0, 4 ); 1396 } 1397 else if ( sString.Copy( 0, 4 ) == ">" ) { 1398 sReturn += ">"; 1399 sString.Erase( 0, 4 ); 1400 } 1401 else if ( sString.Copy( 0, 6 ) == """ ) { 1402 sReturn += "\""; 1403 sString.Erase( 0, 6 ); 1404 } 1405 else if ( sString.Copy( 0, 6 ) == "'" ) { 1406 sReturn += "\'"; 1407 sString.Erase( 0, 6 ); 1408 } 1409 else { 1410 sReturn += sString.GetChar( 0 ); 1411 sString.Erase( 0, 1 ); 1412 } 1413 } 1414 rString_in = String(sReturn , RTL_TEXTENCODING_UTF8 ); 1415 1416 1417 } 1418 1419 XMLUtil::XMLUtil(){ 1420 } 1421 1422 1423 /*****************************************************************************/ 1424 void XMLUtil::dump(){ 1425 /*****************************************************************************/ 1426 int cnt=1; 1427 printf("size=%lu\n",static_cast<unsigned long>(lMap.size())); 1428 for(HashMap::iterator pos = lMap.begin(); pos != lMap.end() ; ++pos){ 1429 fprintf(stdout,"key=%s , value=%d , no=%d\n",pos->first.GetBuffer(),pos->second,cnt++); 1430 } 1431 } 1432 /*****************************************************************************/ 1433 XMLUtil& XMLUtil::Instance(){ 1434 /*****************************************************************************/ 1435 static XMLUtil instance; 1436 return instance; 1437 } 1438 /*****************************************************************************/ 1439 XMLUtil::~XMLUtil(){} 1440 /*****************************************************************************/ 1441 /*****************************************************************************/ 1442 ByteString XMLUtil::GetIsoLangByIndex( sal_uInt16 nIndex ) 1443 /*****************************************************************************/ 1444 { 1445 if(nIndex > 0 && MAX_LANGUAGES >= nIndex ) 1446 return isoArray[nIndex]; 1447 return ""; 1448 } 1449 1450