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