Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 : #include "sal/config.h"
20 :
21 : #include <iterator> /* std::iterator*/
22 :
23 : #include <cassert>
24 : #include <stdio.h>
25 : #include <sal/alloca.h>
26 :
27 : #include "helper.hxx"
28 : #include "common.hxx"
29 : #include "xmlparse.hxx"
30 : #include <fstream>
31 : #include <iostream>
32 : #include <osl/mutex.hxx>
33 : #include <osl/thread.hxx>
34 : #include <osl/process.h>
35 : #include <rtl/strbuf.hxx>
36 : #include <unicode/regex.h>
37 :
38 : using namespace U_ICU_NAMESPACE;
39 : using namespace std;
40 : using namespace osl;
41 :
42 : //
43 : // class XMLChildNode
44 : //
45 :
46 : /*****************************************************************************/
47 0 : XMLChildNode::XMLChildNode( XMLParentNode *pPar )
48 : /*****************************************************************************/
49 0 : : pParent( pPar )
50 : {
51 0 : if ( pParent )
52 0 : pParent->AddChild( this );
53 0 : }
54 :
55 :
56 : /*****************************************************************************/
57 0 : XMLChildNode::XMLChildNode( const XMLChildNode& obj)
58 : /*****************************************************************************/
59 : : XMLNode(obj),
60 0 : pParent(obj.pParent){}
61 :
62 : /*****************************************************************************/
63 0 : XMLChildNode& XMLChildNode::operator=(const XMLChildNode& obj){
64 : /*****************************************************************************/
65 0 : if(this != &obj){
66 0 : pParent=obj.pParent;
67 : }
68 0 : return *this;
69 : }
70 : //
71 : // class XMLParentNode
72 : //
73 :
74 :
75 : /*****************************************************************************/
76 0 : XMLParentNode::~XMLParentNode()
77 : /*****************************************************************************/
78 : {
79 0 : if( pChildList ){
80 0 : RemoveAndDeleteAllChildren();
81 0 : delete pChildList;
82 0 : pChildList = NULL;
83 : }
84 0 : pChildList = NULL;
85 0 : }
86 : /*****************************************************************************/
87 0 : XMLParentNode::XMLParentNode( const XMLParentNode& obj)
88 : /*****************************************************************************/
89 0 : : XMLChildNode( obj )
90 : {
91 0 : if( obj.pChildList ){
92 0 : pChildList=new XMLChildNodeList();
93 0 : XMLChildNode* pNode = NULL;
94 0 : for ( size_t i = 0; i < obj.pChildList->size(); i++ ){
95 0 : pNode = (*obj.pChildList)[ i ];
96 0 : if( pNode != NULL){
97 0 : switch(pNode->GetNodeType()){
98 : case XML_NODE_TYPE_ELEMENT:
99 0 : AddChild( new XMLElement( *static_cast<XMLElement* >(pNode) ) ); break;
100 : case XML_NODE_TYPE_DATA:
101 0 : AddChild( new XMLData ( *static_cast<XMLData* > (pNode) ) ); break;
102 : case XML_NODE_TYPE_COMMENT:
103 0 : AddChild( new XMLComment( *static_cast<XMLComment* >(pNode) ) ); break;
104 : case XML_NODE_TYPE_DEFAULT:
105 0 : AddChild( new XMLDefault( *static_cast<XMLDefault* >(pNode) ) ); break;
106 0 : default: fprintf(stdout,"XMLParentNode::XMLParentNode( const XMLParentNode& obj) strange obj");
107 : }
108 : }
109 : }
110 0 : }else pChildList = NULL;
111 0 : }
112 : /*****************************************************************************/
113 0 : XMLParentNode& XMLParentNode::operator=(const XMLParentNode& obj){
114 : /*****************************************************************************/
115 0 : if(this!=&obj){
116 0 : XMLChildNode::operator=(obj);
117 0 : if( pChildList ){
118 0 : RemoveAndDeleteAllChildren();
119 0 : delete pChildList;
120 0 : pChildList = NULL;
121 : }
122 0 : if( obj.pChildList ){
123 0 : pChildList=new XMLChildNodeList();
124 0 : for ( size_t i = 0; i < obj.pChildList->size(); i++ )
125 0 : AddChild( (*obj.pChildList)[ i ] );
126 0 : }else pChildList = NULL;
127 :
128 : }
129 0 : return *this;
130 : }
131 : /*****************************************************************************/
132 0 : void XMLParentNode::AddChild( XMLChildNode *pChild )
133 : /*****************************************************************************/
134 : {
135 0 : if ( !pChildList )
136 0 : pChildList = new XMLChildNodeList();
137 0 : pChildList->push_back( pChild );
138 0 : }
139 :
140 : /*****************************************************************************/
141 0 : void XMLParentNode::RemoveAndDeleteAllChildren(){
142 : /*****************************************************************************/
143 0 : if ( pChildList ) {
144 0 : for ( size_t i = 0; i < pChildList->size(); i++ )
145 0 : delete (*pChildList)[ i ];
146 0 : pChildList->clear();
147 : }
148 0 : }
149 :
150 : //
151 : // class XMLFile
152 : //
153 :
154 : /*****************************************************************************/
155 0 : sal_uInt16 XMLFile::GetNodeType()
156 : /*****************************************************************************/
157 : {
158 0 : return XML_NODE_TYPE_FILE;
159 : }
160 :
161 0 : void XMLFile::Write( OString const &aFilename )
162 : {
163 : std::ofstream s(
164 0 : aFilename.getStr(), std::ios_base::out | std::ios_base::trunc);
165 0 : if (!s.is_open()) {
166 : std::cerr
167 0 : << "Error: helpex cannot create file " << aFilename.getStr()
168 0 : << '\n';
169 0 : std::exit(EXIT_FAILURE);
170 : }
171 0 : Write(s);
172 0 : s.close();
173 0 : }
174 :
175 0 : void XMLFile::WriteString( ofstream &rStream, const OUString &sString )
176 : {
177 0 : OString sText(OUStringToOString(sString, RTL_TEXTENCODING_UTF8));
178 0 : rStream << sText.getStr();
179 0 : }
180 :
181 0 : sal_Bool XMLFile::Write( ofstream &rStream , XMLNode *pCur )
182 : {
183 0 : if ( !pCur )
184 0 : Write( rStream, this );
185 : else {
186 0 : switch( pCur->GetNodeType()) {
187 : case XML_NODE_TYPE_FILE: {
188 0 : if( GetChildList())
189 0 : for ( size_t i = 0; i < GetChildList()->size(); i++ )
190 0 : Write( rStream, (*GetChildList())[ i ] );
191 : }
192 0 : break;
193 : case XML_NODE_TYPE_ELEMENT: {
194 0 : XMLElement *pElement = ( XMLElement * ) pCur;
195 0 : rStream << "<";
196 0 : WriteString( rStream, pElement->GetName());
197 0 : if ( pElement->GetAttributeList())
198 0 : for ( size_t j = 0; j < pElement->GetAttributeList()->size(); j++ ) {
199 0 : rStream << " ";
200 0 : OUString sData( (*pElement->GetAttributeList())[ j ]->GetName() );
201 0 : WriteString( rStream , XMLUtil::QuotHTML( sData ) );
202 0 : rStream << "=\"";
203 0 : sData = (*pElement->GetAttributeList())[ j ]->GetValue();
204 0 : WriteString( rStream , XMLUtil::QuotHTML( sData ) );
205 0 : rStream << "\"";
206 0 : }
207 0 : if ( !pElement->GetChildList())
208 0 : rStream << "/>";
209 : else {
210 0 : rStream << ">";
211 0 : for ( size_t k = 0; k < pElement->GetChildList()->size(); k++ )
212 0 : Write( rStream, (*pElement->GetChildList())[ k ] );
213 0 : rStream << "</";
214 0 : WriteString( rStream, pElement->GetName());
215 0 : rStream << ">";
216 : }
217 : }
218 0 : break;
219 : case XML_NODE_TYPE_DATA: {
220 0 : XMLData *pData = ( XMLData * ) pCur;
221 0 : OUString sData( pData->GetData());
222 0 : WriteString( rStream, XMLUtil::QuotHTML( sData ) );
223 : }
224 0 : break;
225 : case XML_NODE_TYPE_COMMENT: {
226 0 : XMLComment *pComment = ( XMLComment * ) pCur;
227 0 : rStream << "<!--";
228 0 : WriteString( rStream, pComment->GetComment());
229 0 : rStream << "-->";
230 : }
231 0 : break;
232 : case XML_NODE_TYPE_DEFAULT: {
233 0 : XMLDefault *pDefault = ( XMLDefault * ) pCur;
234 0 : WriteString( rStream, pDefault->GetDefault());
235 : }
236 0 : break;
237 : }
238 : }
239 0 : return sal_True;
240 : }
241 :
242 :
243 0 : void XMLFile::Print( XMLNode *pCur, sal_uInt16 nLevel )
244 : {
245 :
246 0 : if ( !pCur )
247 0 : Print( this );
248 : else {
249 0 : switch( pCur->GetNodeType()) {
250 : case XML_NODE_TYPE_FILE: {
251 0 : if( GetChildList())
252 0 : for ( size_t i = 0; i < GetChildList()->size(); i++ )
253 0 : Print( (*GetChildList())[ i ] );
254 : }
255 0 : break;
256 : case XML_NODE_TYPE_ELEMENT: {
257 0 : XMLElement *pElement = ( XMLElement * ) pCur;
258 :
259 0 : fprintf( stdout, "<%s", OUStringToOString(pElement->GetName(), RTL_TEXTENCODING_UTF8).getStr());
260 0 : if ( pElement->GetAttributeList())
261 : {
262 0 : for (size_t j = 0; j < pElement->GetAttributeList()->size(); ++j)
263 : {
264 0 : OString aAttrName(OUStringToOString((*pElement->GetAttributeList())[j]->GetName(),
265 0 : RTL_TEXTENCODING_UTF8));
266 0 : if (!aAttrName.equalsIgnoreAsciiCase(XML_LANG))
267 : {
268 : fprintf( stdout, " %s=\"%s\"",
269 : aAttrName.getStr(),
270 0 : OUStringToOString( (*pElement->GetAttributeList())[ j ]->GetValue(),
271 0 : RTL_TEXTENCODING_UTF8).getStr());
272 : }
273 0 : }
274 : }
275 0 : if ( !pElement->GetChildList())
276 0 : fprintf( stdout, "/>" );
277 : else {
278 0 : fprintf( stdout, ">" );
279 0 : for ( size_t k = 0; k < pElement->GetChildList()->size(); k++ )
280 0 : Print( (*pElement->GetChildList())[ k ], nLevel + 1 );
281 0 : fprintf( stdout, "</%s>", OUStringToOString(pElement->GetName(), RTL_TEXTENCODING_UTF8).getStr());
282 : }
283 : }
284 0 : break;
285 : case XML_NODE_TYPE_DATA: {
286 0 : XMLData *pData = ( XMLData * ) pCur;
287 0 : OUString sData = pData->GetData();
288 0 : fprintf( stdout, "%s", OUStringToOString(sData, RTL_TEXTENCODING_UTF8).getStr());
289 : }
290 0 : break;
291 : case XML_NODE_TYPE_COMMENT: {
292 0 : XMLComment *pComment = ( XMLComment * ) pCur;
293 0 : fprintf( stdout, "<!--%s-->", OUStringToOString(pComment->GetComment(), RTL_TEXTENCODING_UTF8).getStr());
294 : }
295 0 : break;
296 : case XML_NODE_TYPE_DEFAULT: {
297 0 : XMLDefault *pDefault = ( XMLDefault * ) pCur;
298 0 : fprintf( stdout, "%s", OUStringToOString(pDefault->GetDefault(), RTL_TEXTENCODING_UTF8).getStr());
299 : }
300 0 : break;
301 : }
302 : }
303 0 : }
304 0 : XMLFile::~XMLFile()
305 : {
306 0 : if( XMLStrings != NULL ){
307 0 : XMLHashMap::iterator pos = XMLStrings->begin();
308 0 : for( ; pos != XMLStrings->end() ; ++pos ){
309 0 : delete pos->second; // Check and delete content also ?
310 : }
311 0 : delete XMLStrings;
312 0 : XMLStrings = NULL;
313 : }
314 0 : }
315 : /*****************************************************************************/
316 0 : XMLFile::XMLFile( const OUString &rFileName ) // the file name, empty if created from memory stream
317 : /*****************************************************************************/
318 : : XMLParentNode( NULL ),
319 : sFileName ( rFileName ),
320 : ID ( "id" ),
321 : OLDREF ( "oldref" ),
322 : XML_LANG ( "xml-lang" ),
323 0 : XMLStrings ( NULL )
324 :
325 : {
326 0 : nodes_localize.insert( TagMap::value_type(OString(RTL_CONSTASCII_STRINGPARAM("bookmark")) , sal_True) );
327 0 : nodes_localize.insert( TagMap::value_type(OString(RTL_CONSTASCII_STRINGPARAM("variable")) , sal_True) );
328 0 : nodes_localize.insert( TagMap::value_type(OString(RTL_CONSTASCII_STRINGPARAM("paragraph")) , sal_True) );
329 0 : nodes_localize.insert( TagMap::value_type(OString(RTL_CONSTASCII_STRINGPARAM("alt")) , sal_True) );
330 0 : nodes_localize.insert( TagMap::value_type(OString(RTL_CONSTASCII_STRINGPARAM("caption")) , sal_True) );
331 0 : nodes_localize.insert( TagMap::value_type(OString(RTL_CONSTASCII_STRINGPARAM("title")) , sal_True) );
332 0 : nodes_localize.insert( TagMap::value_type(OString(RTL_CONSTASCII_STRINGPARAM("link")) , sal_True) );
333 0 : }
334 : /*****************************************************************************/
335 0 : void XMLFile::Extract( XMLFile *pCur )
336 : /*****************************************************************************/
337 : {
338 0 : if( XMLStrings != NULL ) delete XMLStrings; // Elements ?
339 :
340 0 : XMLStrings = new XMLHashMap();
341 0 : if ( !pCur )
342 0 : SearchL10NElements( this );
343 : else {
344 0 : if( pCur->GetNodeType()==XML_NODE_TYPE_FILE) {
345 0 : SearchL10NElements(pCur);
346 : }
347 : }
348 0 : }
349 :
350 : /*****************************************************************************/
351 0 : void XMLFile::InsertL10NElement( XMLElement* pElement ){
352 : /*****************************************************************************/
353 0 : OString tmpStr,id,language("");
354 : LangHashMap* elem;
355 :
356 0 : if( pElement->GetAttributeList() != NULL ){
357 0 : for ( size_t j = 0; j < pElement->GetAttributeList()->size(); j++ )
358 : {
359 0 : tmpStr=OUStringToOString((*pElement->GetAttributeList())[ j ]->GetName(), RTL_TEXTENCODING_UTF8);
360 0 : if (tmpStr == ID) { // Get the "id" Attribute
361 0 : id = OUStringToOString((*pElement->GetAttributeList())[ j ]->GetValue(),RTL_TEXTENCODING_UTF8);
362 : }
363 0 : if (tmpStr == XML_LANG) { // Get the "xml-lang" Attribute
364 0 : language = OUStringToOString((*pElement->GetAttributeList())[j]->GetValue(),RTL_TEXTENCODING_UTF8);
365 : }
366 :
367 : }
368 : }else{
369 0 : fprintf(stdout,"XMLFile::InsertL10NElement: No AttributeList found");
370 0 : fprintf(stdout,"++++++++++++++++++++++++++++++++++++++++++++++++++");
371 0 : Print( pElement , 0 );
372 0 : fprintf(stdout,"++++++++++++++++++++++++++++++++++++++++++++++++++");
373 : }
374 :
375 0 : XMLHashMap::iterator pos = XMLStrings->find( id );
376 0 : if( pos == XMLStrings->end() ){ // No instanze , create new one
377 0 : elem = new LangHashMap();
378 0 : (*elem)[ language ]=pElement;
379 0 : XMLStrings->insert( XMLHashMap::value_type( id , elem ) );
380 0 : order.push_back( id );
381 : }else{ // Already there
382 0 : elem=pos->second;
383 0 : if ( (*elem)[ language ] )
384 : {
385 0 : fprintf(stdout,"Error: Duplicated entry. ID = %s LANG = %s in File %s\n", id.getStr(), language.getStr(), OUStringToOString(sFileName, RTL_TEXTENCODING_ASCII_US).getStr() );
386 0 : exit( -1 );
387 : }
388 0 : (*elem)[ language ]=pElement;
389 0 : }
390 0 : }
391 :
392 0 : XMLFile::XMLFile( const XMLFile& obj )
393 : /*****************************************************************************/
394 : : XMLParentNode( obj ),
395 : sFileName ( obj.sFileName ),
396 : ID ( "id" ),
397 : OLDREF ( "oldref" ),
398 : XML_LANG ( "xml-lang" ),
399 0 : XMLStrings ( NULL )
400 : {
401 0 : if( this!=&obj )
402 : {
403 0 : nodes_localize =obj.nodes_localize;
404 0 : order =obj.order;
405 :
406 : }
407 0 : }
408 : /*****************************************************************************/
409 0 : XMLFile& XMLFile::operator=(const XMLFile& obj){
410 : /*****************************************************************************/
411 0 : if( this!=&obj ){
412 :
413 0 : XMLParentNode::operator=(obj);
414 :
415 0 : nodes_localize =obj.nodes_localize;
416 0 : order =obj.order;
417 :
418 0 : if( XMLStrings ) delete XMLStrings;
419 :
420 0 : if( obj.XMLStrings )
421 : {
422 0 : XMLStrings = new XMLHashMap();
423 0 : for( XMLHashMap::iterator pos = obj.XMLStrings->begin() ; pos != obj.XMLStrings->end() ; ++pos )
424 : {
425 0 : LangHashMap* elem=pos->second;
426 0 : LangHashMap* newelem = new LangHashMap();
427 0 : for(LangHashMap::iterator pos2=elem->begin(); pos2!=elem->end();++pos2){
428 0 : (*newelem)[ pos2->first ] = new XMLElement( *pos2->second );
429 : }
430 0 : (*XMLStrings)[ pos->first ] = newelem;
431 : }
432 : }
433 : }
434 0 : return *this;
435 : }
436 :
437 :
438 : /*****************************************************************************/
439 0 : void XMLFile::SearchL10NElements( XMLParentNode *pCur , int pos)
440 : /*****************************************************************************/
441 : {
442 0 : static const OString LOCALIZE("localize");
443 0 : static const OString THEID("id");
444 0 : bool bInsert = true;
445 0 : if ( !pCur )
446 0 : SearchL10NElements( this );
447 : else {
448 0 : switch( pCur->GetNodeType()) {
449 : case XML_NODE_TYPE_FILE: {
450 : XMLParentNode* pElement;
451 0 : if( GetChildList()){
452 0 : for ( size_t i = 0; i < GetChildList()->size(); i++ ){
453 0 : pElement = (XMLParentNode*) (*GetChildList())[ i ];
454 0 : if( pElement->GetNodeType() == XML_NODE_TYPE_ELEMENT ) SearchL10NElements( pElement , i);
455 : }
456 : }
457 : }
458 0 : break;
459 : case XML_NODE_TYPE_ELEMENT: {
460 0 : XMLElement *pElement = ( XMLElement * ) pCur;
461 0 : OString sName(OUStringToOString(pElement->GetName(), RTL_TEXTENCODING_ASCII_US).toAsciiLowerCase());
462 0 : OString language,tmpStrVal,oldref;
463 0 : if ( pElement->GetAttributeList())
464 : {
465 0 : for ( size_t j = 0 , cnt = pElement->GetAttributeList()->size(); j < cnt && bInsert; ++j )
466 : {
467 0 : const OString tmpStr = OUStringToOString((*pElement->GetAttributeList())[j]->GetName(), RTL_TEXTENCODING_UTF8);
468 0 : if (tmpStr == THEID) { // Get the "id" Attribute
469 0 : tmpStrVal=OUStringToOString( (*pElement->GetAttributeList())[ j ]->GetValue(),RTL_TEXTENCODING_UTF8 );
470 : }
471 0 : if (tmpStr == LOCALIZE) { // Get the "localize" Attribute
472 0 : bInsert=false;
473 : }
474 0 : if (tmpStr == XML_LANG) { // Get the "xml-lang" Attribute
475 0 : language=OUStringToOString( (*pElement->GetAttributeList())[ j ]->GetValue(),RTL_TEXTENCODING_UTF8 );
476 : }
477 0 : if (tmpStr == OLDREF) { // Get the "oldref" Attribute
478 0 : oldref=OUStringToOString( (*pElement->GetAttributeList())[ j ]->GetValue(),RTL_TEXTENCODING_UTF8 );
479 : }
480 0 : }
481 0 : pElement->SetLanguageId ( language );
482 0 : pElement->SetId(tmpStrVal);
483 0 : pElement->SetOldRef ( oldref );
484 0 : pElement->SetPos( pos );
485 : }
486 :
487 0 : if ( bInsert && ( nodes_localize.find( sName ) != nodes_localize.end() ) )
488 0 : InsertL10NElement(pElement);
489 0 : else if ( bInsert && pElement->GetChildList() ){
490 0 : for ( size_t k = 0; k < pElement->GetChildList()->size(); k++ )
491 0 : SearchL10NElements( (XMLParentNode*)(*pElement->GetChildList())[ k ], k);
492 0 : }
493 : }
494 0 : break;
495 : case XML_NODE_TYPE_DATA: {
496 : }
497 0 : break;
498 : case XML_NODE_TYPE_COMMENT: {
499 : }
500 0 : break;
501 : case XML_NODE_TYPE_DEFAULT: {
502 : }
503 0 : break;
504 : }
505 : }
506 0 : }
507 :
508 : /*****************************************************************************/
509 0 : bool XMLFile::CheckExportStatus( XMLParentNode *pCur )
510 : /*****************************************************************************/
511 : {
512 : static bool bStatusExport = true;
513 0 : const OString STATUS(RTL_CONSTASCII_STRINGPARAM("status"));
514 0 : const OString PUBLISH(RTL_CONSTASCII_STRINGPARAM("PUBLISH"));
515 0 : const OString DEPRECATED(RTL_CONSTASCII_STRINGPARAM("DEPRECATED"));
516 0 : const OString TOPIC(RTL_CONSTASCII_STRINGPARAM("topic"));
517 :
518 0 : bool bInsert = true;
519 0 : if ( !pCur )
520 0 : CheckExportStatus( this );
521 : else {
522 0 : switch( pCur->GetNodeType()) {
523 : case XML_NODE_TYPE_FILE: {
524 : XMLParentNode* pElement;
525 0 : if( GetChildList()){
526 0 : for ( size_t i = 0; i < GetChildList()->size(); i++ ){
527 0 : pElement = (XMLParentNode*)(*GetChildList())[ i ];
528 0 : if( pElement->GetNodeType() == XML_NODE_TYPE_ELEMENT ) CheckExportStatus( pElement );//, i);
529 : }
530 : }
531 : }
532 0 : break;
533 : case XML_NODE_TYPE_ELEMENT: {
534 0 : XMLElement *pElement = ( XMLElement * ) pCur;
535 0 : OString sName(OUStringToOString(pElement->GetName(), RTL_TEXTENCODING_ASCII_US));
536 0 : if (sName.equalsIgnoreAsciiCase(TOPIC))
537 : {
538 0 : if ( pElement->GetAttributeList())
539 : {
540 0 : for (size_t j = 0 , cnt = pElement->GetAttributeList()->size(); j < cnt && bInsert; ++j)
541 : {
542 0 : const OString tmpStr(OUStringToOString((*pElement->GetAttributeList())[j]->GetName(),
543 0 : RTL_TEXTENCODING_UTF8));
544 0 : if (tmpStr.equalsIgnoreAsciiCase(STATUS))
545 : {
546 0 : OString tmpStrVal(OUStringToOString( (*pElement->GetAttributeList())[j]->GetValue(),
547 0 : RTL_TEXTENCODING_UTF8));
548 0 : if (!tmpStrVal.equalsIgnoreAsciiCase(PUBLISH) &&
549 0 : !tmpStrVal.equalsIgnoreAsciiCase(DEPRECATED))
550 : {
551 0 : bStatusExport = false;
552 0 : }
553 : }
554 :
555 0 : }
556 : }
557 : }
558 0 : else if ( pElement->GetChildList() )
559 : {
560 0 : for (size_t k = 0; k < pElement->GetChildList()->size(); ++k)
561 0 : CheckExportStatus( (XMLParentNode*)(*pElement->GetChildList())[k] );
562 0 : }
563 : }
564 0 : break;
565 : }
566 : }
567 0 : return bStatusExport;
568 : }
569 :
570 : /*****************************************************************************/
571 0 : sal_uInt16 XMLElement::GetNodeType()
572 : /*****************************************************************************/
573 : {
574 0 : return XML_NODE_TYPE_ELEMENT;
575 : }
576 :
577 : /*****************************************************************************/
578 0 : XMLElement::XMLElement(const XMLElement& obj)
579 : /*****************************************************************************/
580 : :
581 : XMLParentNode ( obj ),
582 : sElementName ( obj.sElementName ),
583 : pAttributes ( NULL ),
584 : project ( obj.project ),
585 : filename ( obj.filename ),
586 : id ( obj.id ),
587 : sOldRef ( obj.sOldRef ),
588 : resourceType ( obj.resourceType ),
589 : languageId ( obj.languageId ),
590 0 : nPos ( obj.nPos )
591 :
592 : {
593 0 : if ( obj.pAttributes ){
594 0 : pAttributes = new XMLAttributeList();
595 0 : for ( size_t i = 0; i < obj.pAttributes->size(); i++ )
596 0 : AddAttribute( (*obj.pAttributes)[ i ]->GetName(), (*obj.pAttributes)[ i ]->GetValue() );
597 : }
598 0 : }
599 :
600 : /*****************************************************************************/
601 0 : XMLElement& XMLElement::operator=(const XMLElement& obj){
602 : /*****************************************************************************/
603 0 : if( this!=&obj ){
604 0 : XMLParentNode::operator=(obj);
605 0 : sElementName =obj.sElementName;
606 0 : project =obj.project;
607 0 : filename =obj.filename;
608 0 : id =obj.id;
609 0 : sOldRef =obj.sOldRef;
610 0 : resourceType =obj.resourceType;
611 0 : languageId =obj.languageId;
612 0 : nPos =obj.nPos;
613 :
614 0 : if ( pAttributes ){
615 0 : for ( size_t i = 0; i < pAttributes->size(); i++ )
616 0 : delete (*pAttributes)[ i ];
617 0 : delete pAttributes;
618 : }
619 0 : if ( obj.pAttributes ){
620 0 : pAttributes =new XMLAttributeList();
621 0 : for ( size_t i = 0; i < obj.pAttributes->size(); i++ )
622 0 : AddAttribute( (*obj.pAttributes)[ i ]->GetName(), (*obj.pAttributes)[ i ]->GetValue() );
623 : }
624 : }
625 0 : return *this;
626 : }
627 :
628 : /*****************************************************************************/
629 0 : void XMLElement::AddAttribute( const OUString &rAttribute, const OUString &rValue )
630 : /*****************************************************************************/
631 : {
632 0 : if ( !pAttributes )
633 0 : pAttributes = new XMLAttributeList();
634 0 : pAttributes->push_back( new XMLAttribute( rAttribute, rValue ) );
635 0 : }
636 :
637 : /*****************************************************************************/
638 0 : void XMLElement::ChangeLanguageTag( const OUString &rValue )
639 : {
640 0 : SetLanguageId(OUStringToOString(rValue, RTL_TEXTENCODING_UTF8));
641 0 : if ( pAttributes )
642 : {
643 0 : for (size_t i = 0; i < pAttributes->size(); ++i)
644 : {
645 0 : if ( (*pAttributes)[ i ]->GetName() == "xml-lang" )
646 0 : (*pAttributes)[ i ]->setValue(rValue);
647 : }
648 : }
649 0 : XMLChildNode* pNode = NULL;
650 0 : XMLElement* pElem = NULL;
651 0 : XMLChildNodeList* pCList = GetChildList();
652 :
653 0 : if( pCList != NULL )
654 : {
655 0 : for ( size_t i = 0; i < pCList->size(); i++ )
656 : {
657 0 : pNode = (*pCList)[ i ];
658 0 : if( pNode != NULL && pNode->GetNodeType() == XML_NODE_TYPE_ELEMENT )
659 : {
660 0 : pElem = static_cast< XMLElement* >(pNode);
661 0 : pElem->ChangeLanguageTag( rValue );
662 0 : pElem->SetLanguageId(OUStringToOString(rValue, RTL_TEXTENCODING_UTF8));
663 0 : pElem = NULL;
664 0 : pNode = NULL;
665 : }
666 : }
667 0 : pCList = NULL;
668 : }
669 0 : }
670 :
671 : /*****************************************************************************/
672 0 : XMLElement::~XMLElement()
673 : /*****************************************************************************/
674 : {
675 0 : if ( pAttributes ) {
676 0 : for ( size_t i = 0; i < pAttributes->size(); i++ )
677 0 : delete (*pAttributes)[ i ];
678 :
679 0 : delete pAttributes;
680 0 : pAttributes = NULL;
681 : }
682 0 : }
683 :
684 : /*****************************************************************************/
685 0 : OUString XMLElement::ToOUString(){
686 : /*****************************************************************************/
687 0 : OUStringBuffer* buffer = new OUStringBuffer();
688 0 : Print(this,*buffer,true);
689 0 : OUString result=buffer->makeStringAndClear();
690 0 : OUString xy(result.getStr());
691 0 : result=OUString(xy);
692 0 : delete buffer;
693 0 : return result;
694 : }
695 : /*****************************************************************************/
696 0 : void XMLElement::Print(XMLNode *pCur, OUStringBuffer& buffer , bool rootelement ){
697 : /*****************************************************************************/
698 0 : static const OUString XML_LANG ( "xml-lang" );
699 :
700 0 : if(pCur!=NULL){
701 0 : if(rootelement){
702 0 : XMLElement *pElement = ( XMLElement * ) pCur;
703 0 : if ( pElement->GetAttributeList()){
704 0 : if ( pElement->GetChildList()){
705 0 : XMLChildNode* tmp=NULL;
706 0 : for ( size_t k = 0; k < pElement->GetChildList()->size(); k++ ){
707 0 : tmp = (*pElement->GetChildList())[ k ];
708 0 : Print( tmp, buffer , false);
709 : }
710 : }
711 : }
712 : }
713 : else{
714 :
715 0 : switch( pCur->GetNodeType()) {
716 : case XML_NODE_TYPE_ELEMENT: {
717 0 : XMLElement *pElement = ( XMLElement * ) pCur;
718 :
719 0 : if( !pElement->GetName().equalsIgnoreAsciiCase("comment") ){
720 0 : buffer.append( OUString("<") );
721 0 : buffer.append( pElement->GetName() );
722 0 : if ( pElement->GetAttributeList()){
723 0 : for ( size_t j = 0; j < pElement->GetAttributeList()->size(); j++ ){
724 :
725 0 : OUString aAttrName( (*pElement->GetAttributeList())[ j ]->GetName() );
726 0 : if( !aAttrName.equalsIgnoreAsciiCase( XML_LANG ) ) {
727 0 : buffer.append( OUString(" ") );
728 0 : buffer.append( aAttrName );
729 0 : buffer.append( OUString("=") );
730 0 : buffer.append( OUString("\"") );
731 0 : buffer.append( (*pElement->GetAttributeList())[ j ]->GetValue() );
732 0 : buffer.append( OUString("\"") );
733 : }
734 0 : }
735 : }
736 0 : if ( !pElement->GetChildList())
737 0 : buffer.append( OUString("/>") );
738 : else {
739 0 : buffer.append( OUString(">") );
740 0 : XMLChildNode* tmp=NULL;
741 0 : for ( size_t k = 0; k < pElement->GetChildList()->size(); k++ ){
742 0 : tmp = (*pElement->GetChildList())[ k ];
743 0 : Print( tmp, buffer , false);
744 : }
745 0 : buffer.append( OUString("</") );
746 0 : buffer.append( pElement->GetName() );
747 0 : buffer.append( OUString(">") );
748 : }
749 : }
750 : }
751 0 : break;
752 : case XML_NODE_TYPE_DATA: {
753 0 : XMLData *pData = ( XMLData * ) pCur;
754 0 : OUString sData = pData->GetData();
755 0 : buffer.append( sData );
756 : }
757 0 : break;
758 : case XML_NODE_TYPE_COMMENT: {
759 0 : XMLComment *pComment = ( XMLComment * ) pCur;
760 0 : buffer.append( OUString("<!--") );
761 0 : buffer.append( pComment->GetComment() );
762 0 : buffer.append( OUString("-->") );
763 : }
764 0 : break;
765 : case XML_NODE_TYPE_DEFAULT: {
766 0 : XMLDefault *pDefault = ( XMLDefault * ) pCur;
767 0 : buffer.append( pDefault->GetDefault() );
768 : }
769 0 : break;
770 : }
771 : }
772 : }else {
773 0 : fprintf(stdout,"\n#+------Error: NULL Pointer in XMLELement::Print------+#\n");
774 0 : return;
775 : }
776 : }
777 :
778 :
779 : //
780 : // class XMLData
781 : //
782 : /*****************************************************************************/
783 0 : XMLData::XMLData(const XMLData& obj)
784 : /*****************************************************************************/
785 : : XMLChildNode( obj ),
786 : sData( obj.sData ) ,
787 0 : isNewCreated ( obj.isNewCreated ){}
788 :
789 : /*****************************************************************************/
790 0 : XMLData& XMLData::operator=(const XMLData& obj){
791 : /*****************************************************************************/
792 0 : if( this!=&obj ){
793 0 : XMLChildNode::operator=( obj );
794 0 : sData = obj.sData;
795 0 : isNewCreated = obj.isNewCreated;
796 : }
797 0 : return *this;
798 : }
799 : /*****************************************************************************/
800 0 : void XMLData::AddData( const OUString &rData) {
801 : /*****************************************************************************/
802 0 : sData += rData;
803 0 : }
804 :
805 : /*****************************************************************************/
806 0 : sal_uInt16 XMLData::GetNodeType()
807 : /*****************************************************************************/
808 : {
809 0 : return XML_NODE_TYPE_DATA;
810 : }
811 :
812 : //
813 : // class XMLComment
814 : //
815 :
816 : /*****************************************************************************/
817 0 : sal_uInt16 XMLComment::GetNodeType()
818 : /*****************************************************************************/
819 : {
820 0 : return XML_NODE_TYPE_COMMENT;
821 : }
822 : /*****************************************************************************/
823 0 : XMLComment::XMLComment(const XMLComment& obj)
824 : /*****************************************************************************/
825 : : XMLChildNode( obj ),
826 0 : sComment( obj.sComment ){}
827 :
828 : /*****************************************************************************/
829 0 : XMLComment& XMLComment::operator=(const XMLComment& obj){
830 : /*****************************************************************************/
831 0 : if( this!=&obj ){
832 0 : XMLChildNode::operator=( obj );
833 0 : sComment = obj.sComment;
834 : }
835 0 : return *this;
836 : }
837 :
838 : //
839 : // class XMLDefault
840 : //
841 :
842 : /*****************************************************************************/
843 0 : sal_uInt16 XMLDefault::GetNodeType()
844 : /*****************************************************************************/
845 : {
846 0 : return XML_NODE_TYPE_DEFAULT;
847 : }
848 : /*****************************************************************************/
849 0 : XMLDefault::XMLDefault(const XMLDefault& obj)
850 : /*****************************************************************************/
851 : : XMLChildNode( obj ),
852 0 : sDefault( obj.sDefault){}
853 :
854 : /*****************************************************************************/
855 0 : XMLDefault& XMLDefault::operator=(const XMLDefault& obj){
856 : /*****************************************************************************/
857 0 : if( this!=&obj ){
858 0 : XMLChildNode::operator=( obj );
859 0 : sDefault = obj.sDefault;
860 : }
861 0 : return *this;
862 : }
863 :
864 :
865 : //
866 : // class SimpleXMLParser
867 : //
868 :
869 : #define XML_CHAR_TO_OUSTRING(x) OStringToOUString(OString(x), RTL_TEXTENCODING_UTF8)
870 : #define XML_CHAR_N_TO_OUSTRING(x,n) OStringToOUString(OString(x,n), RTL_TEXTENCODING_UTF8 )
871 :
872 : namespace
873 : {
874 :
875 0 : static OUString lcl_pathnameToAbsoluteUrl(const OUString& rPathname) {
876 0 : OUString sUrl;
877 0 : if (osl::FileBase::getFileURLFromSystemPath(rPathname, sUrl)
878 : != osl::FileBase::E_None)
879 : {
880 0 : std::cerr << "Error: Cannot convert input pathname to URL\n";
881 0 : std::exit(EXIT_FAILURE);
882 : }
883 0 : OUString sCwd;
884 0 : if (osl_getProcessWorkingDir(&sCwd.pData) != osl_Process_E_None) {
885 0 : std::cerr << "Error: Cannot determine cwd\n";
886 0 : std::exit(EXIT_FAILURE);
887 : }
888 0 : if (osl::FileBase::getAbsoluteFileURL(sCwd, sUrl, sUrl)
889 : != osl::FileBase::E_None)
890 : {
891 0 : std::cerr << "Error: Cannot convert input URL to absolute URL\n";
892 0 : std::exit(EXIT_FAILURE);
893 : }
894 0 : return sUrl;
895 : }
896 : }
897 :
898 :
899 : /*****************************************************************************/
900 0 : SimpleXMLParser::SimpleXMLParser()
901 : /*****************************************************************************/
902 0 : : pXMLFile( NULL )
903 : {
904 0 : aParser = XML_ParserCreate( NULL );
905 0 : XML_SetUserData( aParser, this );
906 0 : XML_SetElementHandler( aParser, (XML_StartElementHandler) StartElementHandler, (XML_EndElementHandler) EndElementHandler );
907 0 : XML_SetCharacterDataHandler( aParser, (XML_CharacterDataHandler) CharacterDataHandler );
908 0 : XML_SetCommentHandler( aParser, (XML_CommentHandler) CommentHandler );
909 0 : XML_SetDefaultHandler( aParser, (XML_DefaultHandler) DefaultHandler );
910 0 : }
911 :
912 : /*****************************************************************************/
913 0 : SimpleXMLParser::~SimpleXMLParser()
914 : /*****************************************************************************/
915 : {
916 0 : XML_ParserFree( aParser );
917 0 : }
918 :
919 : /*****************************************************************************/
920 0 : void SimpleXMLParser::StartElementHandler(
921 : void *userData, const XML_Char *name, const XML_Char **atts )
922 : /*****************************************************************************/
923 : {
924 0 : (( SimpleXMLParser * ) userData )->StartElement( name, atts );
925 0 : }
926 :
927 :
928 : /*****************************************************************************/
929 0 : void SimpleXMLParser::EndElementHandler(
930 : void *userData, const XML_Char *name )
931 : /*****************************************************************************/
932 : {
933 0 : (( SimpleXMLParser * ) userData )->EndElement( name );
934 0 : }
935 :
936 : /*****************************************************************************/
937 0 : void SimpleXMLParser::CharacterDataHandler(
938 : void *userData, const XML_Char *s, int len )
939 : /*****************************************************************************/
940 : {
941 0 : (( SimpleXMLParser * ) userData )->CharacterData( s, len );
942 0 : }
943 :
944 : /*****************************************************************************/
945 0 : void SimpleXMLParser::CommentHandler(
946 : void *userData, const XML_Char *data )
947 : /*****************************************************************************/
948 : {
949 0 : (( SimpleXMLParser * ) userData )->Comment( data );
950 0 : }
951 :
952 : /*****************************************************************************/
953 0 : void SimpleXMLParser::DefaultHandler(
954 : void *userData, const XML_Char *s, int len )
955 : /*****************************************************************************/
956 : {
957 0 : (( SimpleXMLParser * ) userData )->Default( s, len );
958 0 : }
959 :
960 : /*****************************************************************************/
961 0 : void SimpleXMLParser::StartElement(
962 : const XML_Char *name, const XML_Char **atts )
963 : /*****************************************************************************/
964 : {
965 0 : OUString sElementName = OUString( XML_CHAR_TO_OUSTRING( name ));
966 0 : XMLElement *pElement = new XMLElement( sElementName, ( XMLParentNode * ) pCurNode );
967 0 : pCurNode = pElement;
968 0 : pCurData = NULL;
969 :
970 0 : int i = 0;
971 0 : while( atts[i] ) {
972 : pElement->AddAttribute(
973 : OUString( XML_CHAR_TO_OUSTRING( atts[ i ] )),
974 0 : OUString( XML_CHAR_TO_OUSTRING( atts[ i + 1 ] )));
975 0 : i += 2;
976 0 : }
977 0 : }
978 :
979 : /*****************************************************************************/
980 0 : void SimpleXMLParser::EndElement( const XML_Char *name )
981 : /*****************************************************************************/
982 : {
983 : // This variable is not used at all, but the sax C interface can't be changed
984 : // To prevent warnings this dummy assignment is used
985 : // +++
986 : (void) name;
987 :
988 0 : pCurNode = pCurNode->GetParent();
989 0 : pCurData = NULL;
990 0 : }
991 :
992 : /*****************************************************************************/
993 0 : void SimpleXMLParser::CharacterData(
994 : const XML_Char *s, int len )
995 : /*****************************************************************************/
996 : {
997 0 : if ( !pCurData ){
998 0 : OUString x = XML_CHAR_N_TO_OUSTRING( s, len );
999 0 : XMLUtil::UnQuotHTML(x);
1000 0 : pCurData = new XMLData( x , pCurNode );
1001 : }else{
1002 0 : OUString x = XML_CHAR_N_TO_OUSTRING( s, len );
1003 0 : XMLUtil::UnQuotHTML(x);
1004 0 : pCurData->AddData( x );
1005 :
1006 : }
1007 0 : }
1008 :
1009 : /*****************************************************************************/
1010 0 : void SimpleXMLParser::Comment(
1011 : const XML_Char *data )
1012 : /*****************************************************************************/
1013 : {
1014 0 : pCurData = NULL;
1015 0 : new XMLComment( OUString( XML_CHAR_TO_OUSTRING( data )), pCurNode );
1016 0 : }
1017 :
1018 : /*****************************************************************************/
1019 0 : void SimpleXMLParser::Default(
1020 : const XML_Char *s, int len )
1021 : /*****************************************************************************/
1022 : {
1023 0 : pCurData = NULL;
1024 : new XMLDefault(
1025 0 : OUString( XML_CHAR_N_TO_OUSTRING( s, len )), pCurNode );
1026 0 : }
1027 :
1028 : /*****************************************************************************/
1029 0 : XMLFile *SimpleXMLParser::Execute( const OUString &rFileName, XMLFile* pXMLFileIn )
1030 : /*****************************************************************************/
1031 : {
1032 0 : aErrorInformation.eCode = XML_ERROR_NONE;
1033 0 : aErrorInformation.nLine = 0;
1034 0 : aErrorInformation.nColumn = 0;
1035 0 : aErrorInformation.sMessage = OUString( "ERROR: Unable to open file ");
1036 0 : aErrorInformation.sMessage += rFileName;
1037 :
1038 0 : OUString aFileURL(lcl_pathnameToAbsoluteUrl(rFileName));
1039 :
1040 : oslFileHandle h;
1041 0 : if (osl_openFile(aFileURL.pData, &h, osl_File_OpenFlag_Read)
1042 : != osl_File_E_None)
1043 : {
1044 0 : return 0;
1045 : }
1046 :
1047 : sal_uInt64 s;
1048 0 : oslFileError e = osl_getFileSize(h, &s);
1049 0 : void * p = NULL;
1050 0 : if (e == osl_File_E_None) {
1051 0 : e = osl_mapFile(h, &p, s, 0, 0);
1052 : }
1053 0 : if (e != osl_File_E_None) {
1054 0 : osl_closeFile(h);
1055 0 : return 0;
1056 : }
1057 :
1058 0 : pXMLFile = pXMLFileIn;
1059 0 : pXMLFile->SetName( rFileName );
1060 :
1061 0 : pCurNode = pXMLFile;
1062 0 : pCurData = NULL;
1063 :
1064 0 : aErrorInformation.eCode = XML_ERROR_NONE;
1065 0 : aErrorInformation.nLine = 0;
1066 0 : aErrorInformation.nColumn = 0;
1067 0 : if ( !pXMLFile->GetName().isEmpty()) {
1068 0 : aErrorInformation.sMessage = OUString( "File ");
1069 0 : aErrorInformation.sMessage += pXMLFile->GetName();
1070 0 : aErrorInformation.sMessage += OUString( " parsed successfully");
1071 : }
1072 : else
1073 0 : aErrorInformation.sMessage = OUString( "XML-File parsed successfully");
1074 :
1075 0 : if (!XML_Parse(aParser, reinterpret_cast< char * >(p), s, true))
1076 : {
1077 0 : aErrorInformation.eCode = XML_GetErrorCode( aParser );
1078 0 : aErrorInformation.nLine = XML_GetErrorLineNumber( aParser );
1079 0 : aErrorInformation.nColumn = XML_GetErrorColumnNumber( aParser );
1080 :
1081 0 : aErrorInformation.sMessage = OUString( "ERROR: ");
1082 0 : if ( !pXMLFile->GetName().isEmpty())
1083 0 : aErrorInformation.sMessage += pXMLFile->GetName();
1084 : else
1085 0 : aErrorInformation.sMessage += OUString( "XML-File (");
1086 0 : aErrorInformation.sMessage += OUString::valueOf(
1087 0 : sal::static_int_cast< sal_Int64 >(aErrorInformation.nLine));
1088 0 : aErrorInformation.sMessage += OUString( ",");
1089 0 : aErrorInformation.sMessage += OUString::valueOf(
1090 0 : sal::static_int_cast< sal_Int64 >(aErrorInformation.nColumn));
1091 0 : aErrorInformation.sMessage += OUString( "): ");
1092 :
1093 0 : switch (aErrorInformation.eCode) {
1094 : case XML_ERROR_NO_MEMORY:
1095 0 : aErrorInformation.sMessage += OUString( "No memory");
1096 0 : break;
1097 : case XML_ERROR_SYNTAX:
1098 0 : aErrorInformation.sMessage += OUString( "Syntax");
1099 0 : break;
1100 : case XML_ERROR_NO_ELEMENTS:
1101 0 : aErrorInformation.sMessage += OUString( "No elements");
1102 0 : break;
1103 : case XML_ERROR_INVALID_TOKEN:
1104 0 : aErrorInformation.sMessage += OUString( "Invalid token");
1105 0 : break;
1106 : case XML_ERROR_UNCLOSED_TOKEN:
1107 0 : aErrorInformation.sMessage += OUString( "Unclosed token");
1108 0 : break;
1109 : case XML_ERROR_PARTIAL_CHAR:
1110 0 : aErrorInformation.sMessage += OUString( "Partial char");
1111 0 : break;
1112 : case XML_ERROR_TAG_MISMATCH:
1113 0 : aErrorInformation.sMessage += OUString( "Tag mismatch");
1114 0 : break;
1115 : case XML_ERROR_DUPLICATE_ATTRIBUTE:
1116 0 : aErrorInformation.sMessage += OUString( "Dublicat attribute");
1117 0 : break;
1118 : case XML_ERROR_JUNK_AFTER_DOC_ELEMENT:
1119 0 : aErrorInformation.sMessage += OUString( "Junk after doc element");
1120 0 : break;
1121 : case XML_ERROR_PARAM_ENTITY_REF:
1122 0 : aErrorInformation.sMessage += OUString( "Param entity ref");
1123 0 : break;
1124 : case XML_ERROR_UNDEFINED_ENTITY:
1125 0 : aErrorInformation.sMessage += OUString( "Undefined entity");
1126 0 : break;
1127 : case XML_ERROR_RECURSIVE_ENTITY_REF:
1128 0 : aErrorInformation.sMessage += OUString( "Recursive entity ref");
1129 0 : break;
1130 : case XML_ERROR_ASYNC_ENTITY:
1131 0 : aErrorInformation.sMessage += OUString( "Async_entity");
1132 0 : break;
1133 : case XML_ERROR_BAD_CHAR_REF:
1134 0 : aErrorInformation.sMessage += OUString( "Bad char ref");
1135 0 : break;
1136 : case XML_ERROR_BINARY_ENTITY_REF:
1137 0 : aErrorInformation.sMessage += OUString( "Binary entity");
1138 0 : break;
1139 : case XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF:
1140 0 : aErrorInformation.sMessage += OUString( "Attribute external entity ref");
1141 0 : break;
1142 : case XML_ERROR_MISPLACED_XML_PI:
1143 0 : aErrorInformation.sMessage += OUString( "Misplaced xml pi");
1144 0 : break;
1145 : case XML_ERROR_UNKNOWN_ENCODING:
1146 0 : aErrorInformation.sMessage += OUString( "Unknown encoding");
1147 0 : break;
1148 : case XML_ERROR_INCORRECT_ENCODING:
1149 0 : aErrorInformation.sMessage += OUString( "Incorrect encoding");
1150 0 : break;
1151 : case XML_ERROR_UNCLOSED_CDATA_SECTION:
1152 0 : aErrorInformation.sMessage += OUString( "Unclosed cdata section");
1153 0 : break;
1154 : case XML_ERROR_EXTERNAL_ENTITY_HANDLING:
1155 0 : aErrorInformation.sMessage += OUString( "External entity handling");
1156 0 : break;
1157 : case XML_ERROR_NOT_STANDALONE:
1158 0 : aErrorInformation.sMessage += OUString( "Not standalone");
1159 0 : break;
1160 : case XML_ERROR_NONE:
1161 0 : break;
1162 : default:
1163 0 : break;
1164 : }
1165 0 : delete pXMLFile;
1166 0 : pXMLFile = NULL;
1167 : }
1168 :
1169 0 : osl_unmapMappedFile(h, p, s);
1170 0 : osl_closeFile(h);
1171 :
1172 0 : return pXMLFile;
1173 : }
1174 :
1175 : namespace
1176 : {
1177 :
1178 0 : static icu::UnicodeString lcl_QuotRange(
1179 : const icu::UnicodeString& rString, const sal_Int32 nStart,
1180 : const sal_Int32 nEnd, bool bInsideTag = false )
1181 : {
1182 0 : icu::UnicodeString sReturn;
1183 : assert( nStart < nEnd );
1184 : assert( nStart >= 0 );
1185 : assert( nEnd <= rString.length() );
1186 0 : for (sal_Int32 i = nStart; i < nEnd; ++i)
1187 : {
1188 0 : switch (rString[i])
1189 : {
1190 : case '<':
1191 0 : sReturn.append("<");
1192 0 : break;
1193 : case '>':
1194 0 : sReturn.append(">");
1195 0 : break;
1196 : case '"':
1197 0 : if( !bInsideTag )
1198 0 : sReturn.append(""");
1199 : else
1200 0 : sReturn.append(rString[i]);
1201 0 : break;
1202 : case '&':
1203 0 : if (rString.startsWith("&", i, 5))
1204 0 : sReturn.append('&');
1205 : else
1206 0 : sReturn.append("&");
1207 0 : break;
1208 : default:
1209 0 : sReturn.append(rString[i]);
1210 0 : break;
1211 : }
1212 : }
1213 0 : return sReturn;
1214 : }
1215 :
1216 0 : static bool lcl_isTag( const icu::UnicodeString& rString )
1217 : {
1218 0 : const int nSize = 12;
1219 : static const icu::UnicodeString vTags[nSize] = {
1220 : "ahelp", "link", "item", "emph", "defaultinline",
1221 : "switchinline", "caseinline", "variable",
1222 0 : "bookmark_value", "image", "embedvar", "alt" };
1223 :
1224 0 : for( int nIndex = 0; nIndex < nSize; ++nIndex )
1225 : {
1226 0 : if( rString.startsWith("<" + vTags[nIndex]) ||
1227 0 : rString == "</" + vTags[nIndex] + ">" )
1228 0 : return true;
1229 : }
1230 :
1231 0 : return rString == "<br/>" || rString =="<help-id-missing/>";
1232 : }
1233 :
1234 : } /// anonymous namespace
1235 :
1236 0 : OUString XMLUtil::QuotHTML( const OUString &rString )
1237 : {
1238 0 : if( rString.trim().isEmpty() )
1239 0 : return rString;
1240 0 : UErrorCode nIcuErr = U_ZERO_ERROR;
1241 : static const sal_uInt32 nSearchFlags =
1242 : UREGEX_DOTALL | UREGEX_CASE_INSENSITIVE;
1243 : static const OUString sPattern(
1244 0 : "<[/]\?\?[a-z_-]+?(?:| +[a-z]+?=\".*?\") *[/]\?\?>");
1245 : static const UnicodeString sSearchPat(
1246 0 : reinterpret_cast<const UChar*>(sPattern.getStr()),
1247 0 : sPattern.getLength() );
1248 :
1249 : icu::UnicodeString sSource(
1250 : reinterpret_cast<const UChar*>(
1251 0 : rString.getStr()), rString.getLength() );
1252 :
1253 0 : RegexMatcher aRegexMatcher( sSearchPat, nSearchFlags, nIcuErr );
1254 0 : aRegexMatcher.reset( sSource );
1255 :
1256 0 : icu::UnicodeString sReturn;
1257 0 : int32_t nEndPos = 0;
1258 0 : int32_t nStartPos = 0;
1259 0 : while( aRegexMatcher.find(nStartPos, nIcuErr) && nIcuErr == U_ZERO_ERROR )
1260 : {
1261 0 : nStartPos = aRegexMatcher.start(nIcuErr);
1262 0 : if ( nEndPos < nStartPos )
1263 0 : sReturn.append(lcl_QuotRange(sSource, nEndPos, nStartPos));
1264 0 : nEndPos = aRegexMatcher.end(nIcuErr);
1265 0 : icu::UnicodeString sMatch = aRegexMatcher.group(nIcuErr);
1266 0 : if( lcl_isTag(sMatch) )
1267 : {
1268 0 : sReturn.append("<");
1269 0 : sReturn.append(lcl_QuotRange(sSource, nStartPos+1, nEndPos-1, true));
1270 0 : sReturn.append(">");
1271 : }
1272 : else
1273 0 : sReturn.append(lcl_QuotRange(sSource, nStartPos, nEndPos));
1274 0 : ++nStartPos;
1275 0 : }
1276 0 : if( nEndPos < sSource.length() )
1277 0 : sReturn.append(lcl_QuotRange(sSource, nEndPos, sSource.length()));
1278 0 : sReturn.append('\0');
1279 0 : return OUString(reinterpret_cast<const sal_Unicode*>(sReturn.getBuffer()));
1280 : }
1281 :
1282 0 : OUString XMLUtil::UnQuotHTML( const OUString& rString )
1283 : {
1284 0 : const OString sString(OUStringToOString(rString, RTL_TEXTENCODING_UTF8));
1285 0 : return OStringToOUString(helper::UnQuotHTML(sString), RTL_TEXTENCODING_UTF8);
1286 0 : }
1287 :
1288 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
