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 :
20 : #include "sal/config.h"
21 :
22 : #include <iterator> /* std::iterator*/
23 :
24 : #include <stdio.h>
25 : #include <sal/alloca.h>
26 :
27 : #include "common.hxx"
28 : #include "xmlparse.hxx"
29 : #include <fstream>
30 : #include <iostream>
31 : #include <osl/mutex.hxx>
32 : #include <osl/thread.hxx>
33 : #include <rtl/strbuf.hxx>
34 :
35 : using namespace std;
36 : using namespace osl;
37 :
38 : //
39 : // class XMLChildNode
40 : //
41 :
42 : /*****************************************************************************/
43 0 : XMLChildNode::XMLChildNode( XMLParentNode *pPar )
44 : /*****************************************************************************/
45 0 : : pParent( pPar )
46 : {
47 0 : if ( pParent )
48 0 : pParent->AddChild( this );
49 0 : }
50 :
51 :
52 : /*****************************************************************************/
53 0 : XMLChildNode::XMLChildNode( const XMLChildNode& obj)
54 : /*****************************************************************************/
55 : : XMLNode(obj),
56 0 : pParent(obj.pParent){}
57 :
58 : /*****************************************************************************/
59 0 : XMLChildNode& XMLChildNode::operator=(const XMLChildNode& obj){
60 : /*****************************************************************************/
61 0 : if(this != &obj){
62 0 : pParent=obj.pParent;
63 : }
64 0 : return *this;
65 : }
66 : //
67 : // class XMLParentNode
68 : //
69 :
70 :
71 : /*****************************************************************************/
72 0 : XMLParentNode::~XMLParentNode()
73 : /*****************************************************************************/
74 : {
75 0 : if( pChildList ){
76 0 : RemoveAndDeleteAllChildren();
77 0 : delete pChildList;
78 0 : pChildList = NULL;
79 : }
80 0 : pChildList = NULL;
81 0 : }
82 : /*****************************************************************************/
83 0 : XMLParentNode::XMLParentNode( const XMLParentNode& obj)
84 : /*****************************************************************************/
85 0 : : XMLChildNode( obj )
86 : {
87 0 : if( obj.pChildList ){
88 0 : pChildList=new XMLChildNodeList();
89 0 : XMLChildNode* pNode = NULL;
90 0 : for ( size_t i = 0; i < obj.pChildList->size(); i++ ){
91 0 : pNode = (*obj.pChildList)[ i ];
92 0 : if( pNode != NULL){
93 0 : switch(pNode->GetNodeType()){
94 : case XML_NODE_TYPE_ELEMENT:
95 0 : AddChild( new XMLElement( *static_cast<XMLElement* >(pNode) ) ); break;
96 : case XML_NODE_TYPE_DATA:
97 0 : AddChild( new XMLData ( *static_cast<XMLData* > (pNode) ) ); break;
98 : case XML_NODE_TYPE_COMMENT:
99 0 : AddChild( new XMLComment( *static_cast<XMLComment* >(pNode) ) ); break;
100 : case XML_NODE_TYPE_DEFAULT:
101 0 : AddChild( new XMLDefault( *static_cast<XMLDefault* >(pNode) ) ); break;
102 0 : default: fprintf(stdout,"XMLParentNode::XMLParentNode( const XMLParentNode& obj) strange obj");
103 : }
104 : }
105 : }
106 0 : }else pChildList = NULL;
107 0 : }
108 : /*****************************************************************************/
109 0 : XMLParentNode& XMLParentNode::operator=(const XMLParentNode& obj){
110 : /*****************************************************************************/
111 0 : if(this!=&obj){
112 0 : XMLChildNode::operator=(obj);
113 0 : if( pChildList ){
114 0 : RemoveAndDeleteAllChildren();
115 0 : delete pChildList;
116 0 : pChildList = NULL;
117 : }
118 0 : if( obj.pChildList ){
119 0 : pChildList=new XMLChildNodeList();
120 0 : for ( size_t i = 0; i < obj.pChildList->size(); i++ )
121 0 : AddChild( (*obj.pChildList)[ i ] );
122 0 : }else pChildList = NULL;
123 :
124 : }
125 0 : return *this;
126 : }
127 : /*****************************************************************************/
128 0 : void XMLParentNode::AddChild( XMLChildNode *pChild )
129 : /*****************************************************************************/
130 : {
131 0 : if ( !pChildList )
132 0 : pChildList = new XMLChildNodeList();
133 0 : pChildList->push_back( pChild );
134 0 : }
135 :
136 : /*****************************************************************************/
137 0 : void XMLParentNode::RemoveAndDeleteAllChildren(){
138 : /*****************************************************************************/
139 0 : if ( pChildList ) {
140 0 : for ( size_t i = 0; i < pChildList->size(); i++ )
141 0 : delete (*pChildList)[ i ];
142 0 : pChildList->clear();
143 : }
144 0 : }
145 :
146 : //
147 : // class XMLFile
148 : //
149 :
150 : /*****************************************************************************/
151 0 : sal_uInt16 XMLFile::GetNodeType()
152 : /*****************************************************************************/
153 : {
154 0 : return XML_NODE_TYPE_FILE;
155 : }
156 :
157 0 : void XMLFile::Write( rtl::OString const &aFilename )
158 : {
159 : std::ofstream s(
160 0 : aFilename.getStr(), std::ios_base::out | std::ios_base::trunc);
161 0 : if (!s.is_open()) {
162 : std::cerr
163 0 : << "Error: helpex cannot create file " << aFilename.getStr()
164 0 : << '\n';
165 0 : std::exit(EXIT_FAILURE);
166 : }
167 0 : Write(s);
168 0 : s.close();
169 0 : }
170 :
171 0 : void XMLFile::WriteString( ofstream &rStream, const rtl::OUString &sString )
172 : {
173 0 : rtl::OString sText(rtl::OUStringToOString(sString, RTL_TEXTENCODING_UTF8));
174 0 : rStream << sText.getStr();
175 0 : }
176 :
177 0 : sal_Bool XMLFile::Write( ofstream &rStream , XMLNode *pCur )
178 : {
179 0 : if ( !pCur )
180 0 : Write( rStream, this );
181 : else {
182 0 : switch( pCur->GetNodeType()) {
183 : case XML_NODE_TYPE_FILE: {
184 0 : if( GetChildList())
185 0 : for ( size_t i = 0; i < GetChildList()->size(); i++ )
186 0 : Write( rStream, (*GetChildList())[ i ] );
187 : }
188 0 : break;
189 : case XML_NODE_TYPE_ELEMENT: {
190 0 : XMLElement *pElement = ( XMLElement * ) pCur;
191 0 : rStream << "<";
192 0 : WriteString( rStream, pElement->GetName());
193 0 : if ( pElement->GetAttributeList())
194 0 : for ( size_t j = 0; j < pElement->GetAttributeList()->size(); j++ ) {
195 0 : rStream << " ";
196 0 : rtl::OUString sData( (*pElement->GetAttributeList())[ j ]->GetName() );
197 0 : XMLUtil::QuotHTML( sData );
198 0 : WriteString( rStream , sData );
199 0 : rStream << "=\"";
200 0 : sData = (*pElement->GetAttributeList())[ j ]->GetValue();
201 0 : XMLUtil::QuotHTML( sData );
202 0 : WriteString( rStream , sData );
203 0 : rStream << "\"";
204 0 : }
205 0 : if ( !pElement->GetChildList())
206 0 : rStream << "/>";
207 : else {
208 0 : rStream << ">";
209 0 : for ( size_t k = 0; k < pElement->GetChildList()->size(); k++ )
210 0 : Write( rStream, (*pElement->GetChildList())[ k ] );
211 0 : rStream << "</";
212 0 : WriteString( rStream, pElement->GetName());
213 0 : rStream << ">";
214 : }
215 : }
216 0 : break;
217 : case XML_NODE_TYPE_DATA: {
218 0 : XMLData *pData = ( XMLData * ) pCur;
219 0 : rtl::OUString sData( pData->GetData());
220 0 : XMLUtil::QuotHTML( sData );
221 0 : WriteString( rStream, sData );
222 : }
223 0 : break;
224 : case XML_NODE_TYPE_COMMENT: {
225 0 : XMLComment *pComment = ( XMLComment * ) pCur;
226 0 : rStream << "<!--";
227 0 : WriteString( rStream, pComment->GetComment());
228 0 : rStream << "-->";
229 : }
230 0 : break;
231 : case XML_NODE_TYPE_DEFAULT: {
232 0 : XMLDefault *pDefault = ( XMLDefault * ) pCur;
233 0 : WriteString( rStream, pDefault->GetDefault());
234 : }
235 0 : break;
236 : }
237 : }
238 0 : return sal_True;
239 : }
240 :
241 :
242 0 : void XMLFile::Print( XMLNode *pCur, sal_uInt16 nLevel )
243 : {
244 :
245 0 : if ( !pCur )
246 0 : Print( this );
247 : else {
248 0 : switch( pCur->GetNodeType()) {
249 : case XML_NODE_TYPE_FILE: {
250 0 : if( GetChildList())
251 0 : for ( size_t i = 0; i < GetChildList()->size(); i++ )
252 0 : Print( (*GetChildList())[ i ] );
253 : }
254 0 : break;
255 : case XML_NODE_TYPE_ELEMENT: {
256 0 : XMLElement *pElement = ( XMLElement * ) pCur;
257 :
258 0 : fprintf( stdout, "<%s", rtl::OUStringToOString(pElement->GetName(), RTL_TEXTENCODING_UTF8).getStr());
259 0 : if ( pElement->GetAttributeList())
260 : {
261 0 : for (size_t j = 0; j < pElement->GetAttributeList()->size(); ++j)
262 : {
263 0 : rtl::OString aAttrName(rtl::OUStringToOString((*pElement->GetAttributeList())[j]->GetName(),
264 0 : RTL_TEXTENCODING_UTF8));
265 0 : if (!aAttrName.equalsIgnoreAsciiCase(XML_LANG))
266 : {
267 : fprintf( stdout, " %s=\"%s\"",
268 : aAttrName.getStr(),
269 0 : rtl::OUStringToOString( (*pElement->GetAttributeList())[ j ]->GetValue(),
270 0 : RTL_TEXTENCODING_UTF8).getStr());
271 : }
272 0 : }
273 : }
274 0 : if ( !pElement->GetChildList())
275 0 : fprintf( stdout, "/>" );
276 : else {
277 0 : fprintf( stdout, ">" );
278 0 : for ( size_t k = 0; k < pElement->GetChildList()->size(); k++ )
279 0 : Print( (*pElement->GetChildList())[ k ], nLevel + 1 );
280 0 : fprintf( stdout, "</%s>", rtl::OUStringToOString(pElement->GetName(), RTL_TEXTENCODING_UTF8).getStr());
281 : }
282 : }
283 0 : break;
284 : case XML_NODE_TYPE_DATA: {
285 0 : XMLData *pData = ( XMLData * ) pCur;
286 0 : rtl::OUString sData = pData->GetData();
287 0 : fprintf( stdout, "%s", rtl::OUStringToOString(sData, RTL_TEXTENCODING_UTF8).getStr());
288 : }
289 0 : break;
290 : case XML_NODE_TYPE_COMMENT: {
291 0 : XMLComment *pComment = ( XMLComment * ) pCur;
292 0 : fprintf( stdout, "<!--%s-->", rtl::OUStringToOString(pComment->GetComment(), RTL_TEXTENCODING_UTF8).getStr());
293 : }
294 0 : break;
295 : case XML_NODE_TYPE_DEFAULT: {
296 0 : XMLDefault *pDefault = ( XMLDefault * ) pCur;
297 0 : fprintf( stdout, "%s", rtl::OUStringToOString(pDefault->GetDefault(), RTL_TEXTENCODING_UTF8).getStr());
298 : }
299 0 : break;
300 : }
301 : }
302 0 : }
303 0 : XMLFile::~XMLFile()
304 : {
305 0 : if( XMLStrings != NULL ){
306 0 : XMLHashMap::iterator pos = XMLStrings->begin();
307 0 : for( ; pos != XMLStrings->end() ; ++pos ){
308 0 : delete pos->second; // Check and delete content also ?
309 : }
310 0 : delete XMLStrings;
311 0 : XMLStrings = NULL;
312 : }
313 0 : }
314 : /*****************************************************************************/
315 0 : XMLFile::XMLFile( const rtl::OUString &rFileName ) // the file name, empty if created from memory stream
316 : /*****************************************************************************/
317 : : XMLParentNode( NULL ),
318 : sFileName ( rFileName ),
319 : ID ( "id" ),
320 : OLDREF ( "oldref" ),
321 : XML_LANG ( "xml-lang" ),
322 0 : XMLStrings ( NULL )
323 :
324 : {
325 0 : nodes_localize.insert( TagMap::value_type(rtl::OString(RTL_CONSTASCII_STRINGPARAM("bookmark")) , sal_True) );
326 0 : nodes_localize.insert( TagMap::value_type(rtl::OString(RTL_CONSTASCII_STRINGPARAM("variable")) , sal_True) );
327 0 : nodes_localize.insert( TagMap::value_type(rtl::OString(RTL_CONSTASCII_STRINGPARAM("paragraph")) , sal_True) );
328 0 : nodes_localize.insert( TagMap::value_type(rtl::OString(RTL_CONSTASCII_STRINGPARAM("alt")) , sal_True) );
329 0 : nodes_localize.insert( TagMap::value_type(rtl::OString(RTL_CONSTASCII_STRINGPARAM("caption")) , sal_True) );
330 0 : nodes_localize.insert( TagMap::value_type(rtl::OString(RTL_CONSTASCII_STRINGPARAM("title")) , sal_True) );
331 0 : nodes_localize.insert( TagMap::value_type(rtl::OString(RTL_CONSTASCII_STRINGPARAM("link")) , sal_True) );
332 0 : }
333 : /*****************************************************************************/
334 0 : void XMLFile::Extract( XMLFile *pCur )
335 : /*****************************************************************************/
336 : {
337 0 : if( XMLStrings != NULL ) delete XMLStrings; // Elements ?
338 :
339 0 : XMLStrings = new XMLHashMap();
340 0 : if ( !pCur )
341 0 : SearchL10NElements( this );
342 : else {
343 0 : if( pCur->GetNodeType()==XML_NODE_TYPE_FILE) {
344 0 : SearchL10NElements(pCur);
345 : }
346 : }
347 0 : }
348 :
349 : /*****************************************************************************/
350 0 : void XMLFile::InsertL10NElement( XMLElement* pElement ){
351 : /*****************************************************************************/
352 0 : rtl::OString tmpStr,id,oldref,language("");
353 : LangHashMap* elem;
354 :
355 0 : if( pElement->GetAttributeList() != NULL ){
356 0 : for ( size_t j = 0; j < pElement->GetAttributeList()->size(); j++ )
357 : {
358 0 : tmpStr=rtl::OUStringToOString((*pElement->GetAttributeList())[ j ]->GetName(), RTL_TEXTENCODING_UTF8);
359 0 : if (tmpStr == ID) { // Get the "id" Attribute
360 0 : id = rtl::OUStringToOString((*pElement->GetAttributeList())[ j ]->GetValue(),RTL_TEXTENCODING_UTF8);
361 : }
362 0 : if (tmpStr == XML_LANG) { // Get the "xml-lang" Attribute
363 0 : language = rtl::OUStringToOString((*pElement->GetAttributeList())[j]->GetValue(),RTL_TEXTENCODING_UTF8);
364 : }
365 :
366 : }
367 : }else{
368 0 : fprintf(stdout,"XMLFile::InsertL10NElement: No AttributeList found");
369 0 : fprintf(stdout,"++++++++++++++++++++++++++++++++++++++++++++++++++");
370 0 : Print( pElement , 0 );
371 0 : fprintf(stdout,"++++++++++++++++++++++++++++++++++++++++++++++++++");
372 : }
373 :
374 0 : XMLHashMap::iterator pos = XMLStrings->find( id );
375 0 : if( pos == XMLStrings->end() ){ // No instanze , create new one
376 0 : elem = new LangHashMap();
377 0 : (*elem)[ language ]=pElement;
378 0 : XMLStrings->insert( XMLHashMap::value_type( id , elem ) );
379 0 : order.push_back( id );
380 : }else{ // Already there
381 0 : elem=pos->second;
382 0 : if ( (*elem)[ language ] )
383 : {
384 0 : fprintf(stdout,"Error: Duplicated entry. ID = %s LANG = %s in File %s\n", id.getStr(), language.getStr(), rtl::OUStringToOString(sFileName, RTL_TEXTENCODING_ASCII_US).getStr() );
385 0 : exit( -1 );
386 : }
387 0 : (*elem)[ language ]=pElement;
388 0 : }
389 0 : }
390 :
391 0 : XMLFile::XMLFile( const XMLFile& obj )
392 : /*****************************************************************************/
393 : : XMLParentNode( obj ),
394 : sFileName ( obj.sFileName ),
395 : ID ( "id" ),
396 : OLDREF ( "oldref" ),
397 : XML_LANG ( "xml-lang" ),
398 0 : XMLStrings ( NULL )
399 : {
400 0 : if( this!=&obj )
401 : {
402 0 : nodes_localize =obj.nodes_localize;
403 0 : order =obj.order;
404 :
405 : }
406 0 : }
407 : /*****************************************************************************/
408 0 : XMLFile& XMLFile::operator=(const XMLFile& obj){
409 : /*****************************************************************************/
410 0 : if( this!=&obj ){
411 :
412 0 : XMLParentNode::operator=(obj);
413 :
414 0 : nodes_localize =obj.nodes_localize;
415 0 : order =obj.order;
416 :
417 0 : if( XMLStrings ) delete XMLStrings;
418 :
419 0 : if( obj.XMLStrings )
420 : {
421 0 : XMLStrings = new XMLHashMap();
422 0 : for( XMLHashMap::iterator pos = obj.XMLStrings->begin() ; pos != obj.XMLStrings->end() ; ++pos )
423 : {
424 0 : LangHashMap* elem=pos->second;
425 0 : LangHashMap* newelem = new LangHashMap();
426 0 : for(LangHashMap::iterator pos2=elem->begin(); pos2!=elem->end();++pos2){
427 0 : (*newelem)[ pos2->first ] = new XMLElement( *pos2->second );
428 : }
429 0 : (*XMLStrings)[ pos->first ] = newelem;
430 : }
431 : }
432 : }
433 0 : return *this;
434 : }
435 :
436 :
437 : /*****************************************************************************/
438 0 : void XMLFile::SearchL10NElements( XMLParentNode *pCur , int pos)
439 : /*****************************************************************************/
440 : {
441 0 : static const rtl::OString LOCALIZE("localize");
442 0 : static const rtl::OString THEID("id");
443 0 : bool bInsert = true;
444 0 : if ( !pCur )
445 0 : SearchL10NElements( this );
446 : else {
447 0 : switch( pCur->GetNodeType()) {
448 : case XML_NODE_TYPE_FILE: {
449 : XMLParentNode* pElement;
450 0 : if( GetChildList()){
451 0 : for ( size_t i = 0; i < GetChildList()->size(); i++ ){
452 0 : pElement = (XMLParentNode*) (*GetChildList())[ i ];
453 0 : if( pElement->GetNodeType() == XML_NODE_TYPE_ELEMENT ) SearchL10NElements( pElement , i);
454 : }
455 : }
456 : }
457 0 : break;
458 : case XML_NODE_TYPE_ELEMENT: {
459 0 : XMLElement *pElement = ( XMLElement * ) pCur;
460 0 : rtl::OString sName(rtl::OUStringToOString(pElement->GetName(), RTL_TEXTENCODING_ASCII_US).toAsciiLowerCase());
461 0 : rtl::OString language,tmpStrVal,oldref;
462 0 : if ( pElement->GetAttributeList())
463 : {
464 0 : for ( size_t j = 0 , cnt = pElement->GetAttributeList()->size(); j < cnt && bInsert; ++j )
465 : {
466 0 : const rtl::OString tmpStr = rtl::OUStringToOString((*pElement->GetAttributeList())[j]->GetName(), RTL_TEXTENCODING_UTF8);
467 0 : if (tmpStr == THEID) { // Get the "id" Attribute
468 0 : tmpStrVal=rtl::OUStringToOString( (*pElement->GetAttributeList())[ j ]->GetValue(),RTL_TEXTENCODING_UTF8 );
469 : }
470 0 : if (tmpStr == LOCALIZE) { // Get the "localize" Attribute
471 0 : bInsert=false;
472 : }
473 0 : if (tmpStr == XML_LANG) { // Get the "xml-lang" Attribute
474 0 : language=rtl::OUStringToOString( (*pElement->GetAttributeList())[ j ]->GetValue(),RTL_TEXTENCODING_UTF8 );
475 : }
476 0 : if (tmpStr == OLDREF) { // Get the "oldref" Attribute
477 0 : oldref=rtl::OUStringToOString( (*pElement->GetAttributeList())[ j ]->GetValue(),RTL_TEXTENCODING_UTF8 );
478 : }
479 0 : }
480 0 : pElement->SetLanguageId ( language );
481 0 : pElement->SetId(tmpStrVal);
482 0 : pElement->SetOldRef ( oldref );
483 0 : pElement->SetPos( pos );
484 : }
485 :
486 0 : if ( bInsert && ( nodes_localize.find( sName ) != nodes_localize.end() ) )
487 0 : InsertL10NElement(pElement);
488 0 : else if ( bInsert && pElement->GetChildList() ){
489 0 : for ( size_t k = 0; k < pElement->GetChildList()->size(); k++ )
490 0 : SearchL10NElements( (XMLParentNode*)(*pElement->GetChildList())[ k ], k);
491 0 : }
492 : }
493 0 : break;
494 : case XML_NODE_TYPE_DATA: {
495 : }
496 0 : break;
497 : case XML_NODE_TYPE_COMMENT: {
498 : }
499 0 : break;
500 : case XML_NODE_TYPE_DEFAULT: {
501 : }
502 0 : break;
503 : }
504 : }
505 0 : }
506 :
507 : /*****************************************************************************/
508 0 : bool XMLFile::CheckExportStatus( XMLParentNode *pCur )
509 : /*****************************************************************************/
510 : {
511 : static bool bStatusExport = true;
512 0 : const rtl::OString LOCALIZE("localize");
513 0 : const rtl::OString STATUS(RTL_CONSTASCII_STRINGPARAM("status"));
514 0 : const rtl::OString PUBLISH(RTL_CONSTASCII_STRINGPARAM("PUBLISH"));
515 0 : const rtl::OString DEPRECATED(RTL_CONSTASCII_STRINGPARAM("DEPRECATED"));
516 0 : const rtl::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 : rtl::OString sName(rtl::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 rtl::OString tmpStr(rtl::OUStringToOString((*pElement->GetAttributeList())[j]->GetName(),
543 0 : RTL_TEXTENCODING_UTF8));
544 0 : if (tmpStr.equalsIgnoreAsciiCase(STATUS))
545 : {
546 0 : rtl::OString tmpStrVal(rtl::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 rtl::OUString &rAttribute, const rtl::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 rtl::OUString &rValue )
639 : {
640 0 : SetLanguageId(rtl::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(rtl::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 : rtl::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().equalsIgnoreAsciiCaseAsciiL(RTL_CONSTASCII_STRINGPARAM("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 : rtl::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 rtl::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 :
873 : /*****************************************************************************/
874 0 : SimpleXMLParser::SimpleXMLParser()
875 : /*****************************************************************************/
876 0 : : pXMLFile( NULL )
877 : {
878 0 : aParser = XML_ParserCreate( NULL );
879 0 : XML_SetUserData( aParser, this );
880 0 : XML_SetElementHandler( aParser, (XML_StartElementHandler) StartElementHandler, (XML_EndElementHandler) EndElementHandler );
881 0 : XML_SetCharacterDataHandler( aParser, (XML_CharacterDataHandler) CharacterDataHandler );
882 0 : XML_SetCommentHandler( aParser, (XML_CommentHandler) CommentHandler );
883 0 : XML_SetDefaultHandler( aParser, (XML_DefaultHandler) DefaultHandler );
884 0 : }
885 :
886 : /*****************************************************************************/
887 0 : SimpleXMLParser::~SimpleXMLParser()
888 : /*****************************************************************************/
889 : {
890 0 : XML_ParserFree( aParser );
891 0 : }
892 :
893 : /*****************************************************************************/
894 0 : void SimpleXMLParser::StartElementHandler(
895 : void *userData, const XML_Char *name, const XML_Char **atts )
896 : /*****************************************************************************/
897 : {
898 0 : (( SimpleXMLParser * ) userData )->StartElement( name, atts );
899 0 : }
900 :
901 :
902 : /*****************************************************************************/
903 0 : void SimpleXMLParser::EndElementHandler(
904 : void *userData, const XML_Char *name )
905 : /*****************************************************************************/
906 : {
907 0 : (( SimpleXMLParser * ) userData )->EndElement( name );
908 0 : }
909 :
910 : /*****************************************************************************/
911 0 : void SimpleXMLParser::CharacterDataHandler(
912 : void *userData, const XML_Char *s, int len )
913 : /*****************************************************************************/
914 : {
915 0 : (( SimpleXMLParser * ) userData )->CharacterData( s, len );
916 0 : }
917 :
918 : /*****************************************************************************/
919 0 : void SimpleXMLParser::CommentHandler(
920 : void *userData, const XML_Char *data )
921 : /*****************************************************************************/
922 : {
923 0 : (( SimpleXMLParser * ) userData )->Comment( data );
924 0 : }
925 :
926 : /*****************************************************************************/
927 0 : void SimpleXMLParser::DefaultHandler(
928 : void *userData, const XML_Char *s, int len )
929 : /*****************************************************************************/
930 : {
931 0 : (( SimpleXMLParser * ) userData )->Default( s, len );
932 0 : }
933 :
934 : /*****************************************************************************/
935 0 : void SimpleXMLParser::StartElement(
936 : const XML_Char *name, const XML_Char **atts )
937 : /*****************************************************************************/
938 : {
939 0 : rtl::OUString sElementName = rtl::OUString( XML_CHAR_TO_OUSTRING( name ));
940 0 : XMLElement *pElement = new XMLElement( sElementName, ( XMLParentNode * ) pCurNode );
941 0 : pCurNode = pElement;
942 0 : pCurData = NULL;
943 :
944 0 : int i = 0;
945 0 : while( atts[i] ) {
946 : pElement->AddAttribute(
947 : rtl::OUString( XML_CHAR_TO_OUSTRING( atts[ i ] )),
948 0 : rtl::OUString( XML_CHAR_TO_OUSTRING( atts[ i + 1 ] )));
949 0 : i += 2;
950 0 : }
951 0 : }
952 :
953 : /*****************************************************************************/
954 0 : void SimpleXMLParser::EndElement( const XML_Char *name )
955 : /*****************************************************************************/
956 : {
957 : // This variable is not used at all, but the the sax C interface can't be changed
958 : // To prevent warnings this dummy assignment is used
959 : // +++
960 : (void) name;
961 :
962 0 : pCurNode = pCurNode->GetParent();
963 0 : pCurData = NULL;
964 0 : }
965 :
966 : /*****************************************************************************/
967 0 : void SimpleXMLParser::CharacterData(
968 : const XML_Char *s, int len )
969 : /*****************************************************************************/
970 : {
971 0 : if ( !pCurData ){
972 0 : rtl::OUString x = XML_CHAR_N_TO_OUSTRING( s, len );
973 0 : XMLUtil::UnQuotHTML(x);
974 0 : pCurData = new XMLData( x , pCurNode );
975 : }else{
976 0 : rtl::OUString x = XML_CHAR_N_TO_OUSTRING( s, len );
977 0 : XMLUtil::UnQuotHTML(x);
978 0 : pCurData->AddData( x );
979 :
980 : }
981 0 : }
982 :
983 : /*****************************************************************************/
984 0 : void SimpleXMLParser::Comment(
985 : const XML_Char *data )
986 : /*****************************************************************************/
987 : {
988 0 : pCurData = NULL;
989 0 : new XMLComment( rtl::OUString( XML_CHAR_TO_OUSTRING( data )), pCurNode );
990 0 : }
991 :
992 : /*****************************************************************************/
993 0 : void SimpleXMLParser::Default(
994 : const XML_Char *s, int len )
995 : /*****************************************************************************/
996 : {
997 0 : pCurData = NULL;
998 : new XMLDefault(
999 0 : rtl::OUString( XML_CHAR_N_TO_OUSTRING( s, len )), pCurNode );
1000 0 : }
1001 :
1002 : /*****************************************************************************/
1003 0 : XMLFile *SimpleXMLParser::Execute( const rtl::OUString &rFileName, XMLFile* pXMLFileIn )
1004 : /*****************************************************************************/
1005 : {
1006 0 : aErrorInformation.eCode = XML_ERROR_NONE;
1007 0 : aErrorInformation.nLine = 0;
1008 0 : aErrorInformation.nColumn = 0;
1009 0 : aErrorInformation.sMessage = rtl::OUString( "ERROR: Unable to open file ");
1010 0 : aErrorInformation.sMessage += rFileName;
1011 :
1012 0 : rtl::OUString aFileURL(common::pathnameToAbsoluteUrl(rFileName));
1013 :
1014 : oslFileHandle h;
1015 0 : if (osl_openFile(aFileURL.pData, &h, osl_File_OpenFlag_Read)
1016 : != osl_File_E_None)
1017 : {
1018 0 : return 0;
1019 : }
1020 :
1021 : sal_uInt64 s;
1022 0 : oslFileError e = osl_getFileSize(h, &s);
1023 0 : void * p = NULL;
1024 0 : if (e == osl_File_E_None) {
1025 0 : e = osl_mapFile(h, &p, s, 0, 0);
1026 : }
1027 0 : if (e != osl_File_E_None) {
1028 0 : osl_closeFile(h);
1029 0 : return 0;
1030 : }
1031 :
1032 0 : pXMLFile = pXMLFileIn;
1033 0 : pXMLFile->SetName( rFileName );
1034 :
1035 0 : pCurNode = pXMLFile;
1036 0 : pCurData = NULL;
1037 :
1038 0 : aErrorInformation.eCode = XML_ERROR_NONE;
1039 0 : aErrorInformation.nLine = 0;
1040 0 : aErrorInformation.nColumn = 0;
1041 0 : if ( !pXMLFile->GetName().isEmpty()) {
1042 0 : aErrorInformation.sMessage = rtl::OUString( "File ");
1043 0 : aErrorInformation.sMessage += pXMLFile->GetName();
1044 0 : aErrorInformation.sMessage += rtl::OUString( " parsed successfully");
1045 : }
1046 : else
1047 0 : aErrorInformation.sMessage = rtl::OUString( "XML-File parsed successfully");
1048 :
1049 0 : if (!XML_Parse(aParser, reinterpret_cast< char * >(p), s, true))
1050 : {
1051 0 : aErrorInformation.eCode = XML_GetErrorCode( aParser );
1052 0 : aErrorInformation.nLine = XML_GetErrorLineNumber( aParser );
1053 0 : aErrorInformation.nColumn = XML_GetErrorColumnNumber( aParser );
1054 :
1055 0 : aErrorInformation.sMessage = rtl::OUString( "ERROR: ");
1056 0 : if ( !pXMLFile->GetName().isEmpty())
1057 0 : aErrorInformation.sMessage += pXMLFile->GetName();
1058 : else
1059 0 : aErrorInformation.sMessage += rtl::OUString( "XML-File (");
1060 : aErrorInformation.sMessage += rtl::OUString::valueOf(
1061 0 : sal::static_int_cast< sal_Int64 >(aErrorInformation.nLine));
1062 0 : aErrorInformation.sMessage += rtl::OUString( ",");
1063 : aErrorInformation.sMessage += rtl::OUString::valueOf(
1064 0 : sal::static_int_cast< sal_Int64 >(aErrorInformation.nColumn));
1065 0 : aErrorInformation.sMessage += rtl::OUString( "): ");
1066 :
1067 0 : switch (aErrorInformation.eCode) {
1068 : case XML_ERROR_NO_MEMORY:
1069 0 : aErrorInformation.sMessage += rtl::OUString( "No memory");
1070 0 : break;
1071 : case XML_ERROR_SYNTAX:
1072 0 : aErrorInformation.sMessage += rtl::OUString( "Syntax");
1073 0 : break;
1074 : case XML_ERROR_NO_ELEMENTS:
1075 0 : aErrorInformation.sMessage += rtl::OUString( "No elements");
1076 0 : break;
1077 : case XML_ERROR_INVALID_TOKEN:
1078 0 : aErrorInformation.sMessage += rtl::OUString( "Invalid token");
1079 0 : break;
1080 : case XML_ERROR_UNCLOSED_TOKEN:
1081 0 : aErrorInformation.sMessage += rtl::OUString( "Unclosed token");
1082 0 : break;
1083 : case XML_ERROR_PARTIAL_CHAR:
1084 0 : aErrorInformation.sMessage += rtl::OUString( "Partial char");
1085 0 : break;
1086 : case XML_ERROR_TAG_MISMATCH:
1087 0 : aErrorInformation.sMessage += rtl::OUString( "Tag mismatch");
1088 0 : break;
1089 : case XML_ERROR_DUPLICATE_ATTRIBUTE:
1090 0 : aErrorInformation.sMessage += rtl::OUString( "Dublicat attribute");
1091 0 : break;
1092 : case XML_ERROR_JUNK_AFTER_DOC_ELEMENT:
1093 0 : aErrorInformation.sMessage += rtl::OUString( "Junk after doc element");
1094 0 : break;
1095 : case XML_ERROR_PARAM_ENTITY_REF:
1096 0 : aErrorInformation.sMessage += rtl::OUString( "Param entity ref");
1097 0 : break;
1098 : case XML_ERROR_UNDEFINED_ENTITY:
1099 0 : aErrorInformation.sMessage += rtl::OUString( "Undefined entity");
1100 0 : break;
1101 : case XML_ERROR_RECURSIVE_ENTITY_REF:
1102 0 : aErrorInformation.sMessage += rtl::OUString( "Recursive entity ref");
1103 0 : break;
1104 : case XML_ERROR_ASYNC_ENTITY:
1105 0 : aErrorInformation.sMessage += rtl::OUString( "Async_entity");
1106 0 : break;
1107 : case XML_ERROR_BAD_CHAR_REF:
1108 0 : aErrorInformation.sMessage += rtl::OUString( "Bad char ref");
1109 0 : break;
1110 : case XML_ERROR_BINARY_ENTITY_REF:
1111 0 : aErrorInformation.sMessage += rtl::OUString( "Binary entity");
1112 0 : break;
1113 : case XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF:
1114 0 : aErrorInformation.sMessage += rtl::OUString( "Attribute external entity ref");
1115 0 : break;
1116 : case XML_ERROR_MISPLACED_XML_PI:
1117 0 : aErrorInformation.sMessage += rtl::OUString( "Misplaced xml pi");
1118 0 : break;
1119 : case XML_ERROR_UNKNOWN_ENCODING:
1120 0 : aErrorInformation.sMessage += rtl::OUString( "Unknown encoding");
1121 0 : break;
1122 : case XML_ERROR_INCORRECT_ENCODING:
1123 0 : aErrorInformation.sMessage += rtl::OUString( "Incorrect encoding");
1124 0 : break;
1125 : case XML_ERROR_UNCLOSED_CDATA_SECTION:
1126 0 : aErrorInformation.sMessage += rtl::OUString( "Unclosed cdata section");
1127 0 : break;
1128 : case XML_ERROR_EXTERNAL_ENTITY_HANDLING:
1129 0 : aErrorInformation.sMessage += rtl::OUString( "External entity handling");
1130 0 : break;
1131 : case XML_ERROR_NOT_STANDALONE:
1132 0 : aErrorInformation.sMessage += rtl::OUString( "Not standalone");
1133 0 : break;
1134 : case XML_ERROR_NONE:
1135 0 : break;
1136 : default:
1137 0 : break;
1138 : }
1139 0 : delete pXMLFile;
1140 0 : pXMLFile = NULL;
1141 : }
1142 :
1143 0 : osl_unmapMappedFile(h, p, s);
1144 0 : osl_closeFile(h);
1145 :
1146 0 : return pXMLFile;
1147 : }
1148 :
1149 : /*****************************************************************************/
1150 0 : void XMLUtil::QuotHTML( rtl::OUString &rString )
1151 : /*****************************************************************************/
1152 : {
1153 0 : OUStringBuffer sReturn;
1154 0 : for (sal_Int32 i = 0; i < rString.getLength(); ++i) {
1155 0 : switch (rString[i]) {
1156 : case '\\':
1157 0 : if (i < rString.getLength()) {
1158 0 : switch (rString[i + 1]) {
1159 : case '"':
1160 : case '<':
1161 : case '>':
1162 : case '\\':
1163 0 : ++i;
1164 0 : break;
1165 : }
1166 : }
1167 : // fall through
1168 : default:
1169 0 : sReturn.append(rString[i]);
1170 0 : break;
1171 :
1172 : case '<':
1173 0 : sReturn.appendAscii(RTL_CONSTASCII_STRINGPARAM("<"));
1174 0 : break;
1175 :
1176 : case '>':
1177 0 : sReturn.appendAscii(RTL_CONSTASCII_STRINGPARAM(">"));
1178 0 : break;
1179 :
1180 : case '"':
1181 0 : sReturn.appendAscii(RTL_CONSTASCII_STRINGPARAM("""));
1182 0 : break;
1183 :
1184 : case '&':
1185 0 : if (rString.matchAsciiL(RTL_CONSTASCII_STRINGPARAM("&"), i))
1186 0 : sReturn.append('&');
1187 : else
1188 0 : sReturn.appendAscii(RTL_CONSTASCII_STRINGPARAM("&"));
1189 0 : break;
1190 : }
1191 : }
1192 0 : rString = sReturn.makeStringAndClear();
1193 0 : }
1194 :
1195 0 : void XMLUtil::UnQuotHTML( rtl::OUString &rString ){
1196 0 : rtl::OStringBuffer sReturn;
1197 0 : rtl::OString sString(rtl::OUStringToOString(rString, RTL_TEXTENCODING_UTF8));
1198 0 : for (sal_Int32 i = 0; i != sString.getLength();) {
1199 0 : if (sString[i] == '\\') {
1200 0 : sReturn.append(RTL_CONSTASCII_STRINGPARAM("\\\\"));
1201 0 : ++i;
1202 0 : } else if (sString.match("&", i)) {
1203 0 : sReturn.append('&');
1204 0 : i += RTL_CONSTASCII_LENGTH("&");
1205 0 : } else if (sString.match("<", i)) {
1206 0 : sReturn.append('<');
1207 0 : i += RTL_CONSTASCII_LENGTH("<");
1208 0 : } else if (sString.match(">", i)) {
1209 0 : sReturn.append('>');
1210 0 : i += RTL_CONSTASCII_LENGTH(">");
1211 0 : } else if (sString.match(""", i)) {
1212 0 : sReturn.append('"');
1213 0 : i += RTL_CONSTASCII_LENGTH(""");
1214 0 : } else if (sString.match("'", i)) {
1215 0 : sReturn.append('\'');
1216 0 : i += RTL_CONSTASCII_LENGTH("'");
1217 : } else {
1218 0 : sReturn.append(sString[i]);
1219 0 : ++i;
1220 : }
1221 : }
1222 0 : rString = rtl::OStringToOUString(sReturn.makeStringAndClear(), RTL_TEXTENCODING_UTF8);
1223 0 : }
1224 :
1225 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
