svx/workben/msview/xmlconfig.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: xmlconfig.cxx,v $
  10  * $Revision: 1.5 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31
  32 // MARKER(update_precomp.py): autogen include statement, do not remove
  33 #include "precompiled_svx.hxx"
  34 #include <com/sun/star/xml/sax/XDocumentHandler.hpp>
  35 #include <com/sun/star/xml/sax/InputSource.hpp>
  36 #include <com/sun/star/xml/sax/XParser.hpp>
  37 #include <com/sun/star/xml/sax/SAXParseException.hpp>
  38 #include <com/sun/star/io/IOException.hpp>
  39 #include <cppuhelper/implbase1.hxx>
  40 #include <comphelper/processfactory.hxx>
  41 #include <unotools/ucbstreamhelper.hxx>
  42 #include <unotools/streamwrap.hxx>
  43 #include <tools/debug.hxx>
  44 #include "comphelper/anytostring.hxx"
  45 #include "cppuhelper/exc_hlp.hxx"
  46 #include "rtl/ref.hxx"
  47
  48 #include <svx/msdffimp.hxx>
  49
  50 #include "xmlconfig.hxx"
  51
  52 #include <stdio.h>
  53 #include <ctype.h>
  54 #include <stack>
  55
  56 using ::rtl::OUString;
  57 using ::com::sun::star::io::XInputStream;
  58 using ::com::sun::star::io::IOException;
  59
  60 using namespace ::com::sun::star::uno;
  61 using namespace ::com::sun::star::xml::sax;
  62
  63 ///////////////////////////////////////////////////////////////////////
  64
  65 AtomConfigMap gAtomConfigMap;
  66
  67 ///////////////////////////////////////////////////////////////////////
  68
  69 class ConfigHandler : public ::cppu::WeakAggImplHelper1<XDocumentHandler>
  70 {
  71 public:
  72     // XDocumentHandler
  73     virtual void SAL_CALL startDocument(void) throw( SAXException, RuntimeException );
  74     virtual void SAL_CALL endDocument(void) throw( SAXException, RuntimeException );
  75     virtual void SAL_CALL startElement(const OUString& aName, const Reference< XAttributeList > & xAttribs) throw( SAXException, RuntimeException );
  76     virtual void SAL_CALL endElement(const OUString& aName) throw( SAXException, RuntimeException );
  77     virtual void SAL_CALL characters(const OUString& aChars) throw( SAXException, RuntimeException );
  78     virtual void SAL_CALL ignorableWhitespace(const OUString& aWhitespaces) throw( SAXException, RuntimeException );
  79     virtual void SAL_CALL processingInstruction(const OUString& aTarget, const OUString& aData) throw( SAXException, RuntimeException );
  80     virtual void SAL_CALL setDocumentLocator(const Reference< XLocator > & xLocator) throw( SAXException, RuntimeException );
  81
  82 private:
  83     void errorThrow( const OUString& rErrorMessage ) throw (SAXException );
  84     ElementConfigType parseType( const OUString& rErrorMessage ) throw ( SAXException );
  85     void addElement( ElementConfigPtr& rElementConfig ) throw ( SAXException );
  86     OUString getAttribute( const Reference< XAttributeList > & xAttribs, const sal_Char* pName ) throw( SAXException );
  87
  88     ElementConfigPtr importAtomConfig( const Reference< XAttributeList > & xAttribs, bool bIsContainer ) throw( SAXException );
  89     ElementConfigPtr importElementConfig( const Reference< XAttributeList > & xAttribs ) throw( SAXException );
  90     ElementConfigPtr importSwitchConfig( const Reference< XAttributeList > & xAttribs ) throw( SAXException );
  91     ElementConfigPtr importCaseConfig( const Reference< XAttributeList > & xAttribs ) throw( SAXException );
  92     ElementConfigPtr importValueElementConfig( const Reference< XAttributeList > & xAttribs ) throw( SAXException );
  93
  94     std::stack< ElementConfigPtr > maElementStack;
  95 };
  96
  97 void ConfigHandler::errorThrow( const OUString& rErrorMessage ) throw (SAXException )
  98 {
  99     Reference< XInterface > aContext;
 100     Any aWrappedException;
 101     throw SAXException(rErrorMessage, aContext, aWrappedException);
 102 }
 103
 104 ElementConfigType ConfigHandler::parseType( const OUString& sType ) throw (SAXException )
 105 {
 106     if( sType.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("uint") ) )
 107     {
 108         return ECT_UINT;
 109     }
 110     else if( sType.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("byte") ) )
 111     {
 112         return ECT_BYTE;
 113     }
 114     else if( sType.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("unistring") ) )
 115     {
 116         return ECT_UNISTRING;
 117     }
 118     else if( sType.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("float") ) )
 119     {
 120         return ETC_FLOAT;
 121     }
 122     else if( sType.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("hexdump") ) )
 123     {
 124     }
 125     else
 126     {
 127         OUString aMessage( RTL_CONSTASCII_USTRINGPARAM( "unknown type: " ) );
 128         aMessage += sType;
 129         errorThrow( aMessage );
 130     }
 131
 132     return ECT_HEXDUMP;
 133 }
 134
 135 void ConfigHandler::addElement( ElementConfigPtr& rElementConfig ) throw ( SAXException )
 136 {
 137     ElementConfigContainer* pParent = dynamic_cast< ElementConfigContainer* >( maElementStack.top().get() );
 138
 139     if( !pParent )
 140         errorThrow( OUString( RTL_CONSTASCII_USTRINGPARAM( "illegal parent for element" ) ) );
 141
 142
 143     pParent->addElementConfig( rElementConfig );
 144 }
 145
 146 OUString ConfigHandler::getAttribute( const Reference< XAttributeList > & xAttribs, const sal_Char* pName ) throw( SAXException )
 147 {
 148     OUString aName( OUString::createFromAscii( pName ) );
 149
 150     const sal_Int16 nAttrCount = xAttribs.is() ? xAttribs->getLength() : 0;
 151     sal_Int16 i;
 152     for(i=0; i < nAttrCount; i++)
 153     {
 154         if( xAttribs->getNameByIndex( i ) == aName )
 155             return xAttribs->getValueByIndex( i );
 156     }
 157
 158     OUString aMessage( RTL_CONSTASCII_USTRINGPARAM( "missing required attribute: ") );
 159     aMessage += aName;
 160     errorThrow( aMessage );
 161
 162     return OUString();
 163 }
 164
 165 void SAL_CALL ConfigHandler::startDocument(void) throw( SAXException, RuntimeException )
 166 {
 167 }
 168
 169 void SAL_CALL ConfigHandler::endDocument(void) throw( SAXException, RuntimeException )
 170 {
 171 }
 172
 173 void SAL_CALL ConfigHandler::startElement(const OUString& aName, const Reference< XAttributeList > & xAttribs) throw( SAXException, RuntimeException )
 174 {
 175     ElementConfigPtr pElement;
 176
 177     if( aName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "config" ) ) )
 178     {
 179         return;
 180     }
 181
 182     if( aName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "container" ) ) )
 183     {
 184         pElement = importAtomConfig( xAttribs, true );
 185     }
 186     else if( aName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "atom" ) ) )
 187     {
 188         pElement = importAtomConfig( xAttribs, false );
 189     }
 190     else if( aName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "element" ) ) )
 191     {
 192         pElement = importElementConfig( xAttribs );
 193     }
 194     else if( aName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "value" ) ) )
 195     {
 196         pElement = importValueElementConfig( xAttribs );
 197     }
 198     else if( aName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "switch" ) ) )
 199     {
 200         pElement = importSwitchConfig( xAttribs );
 201     }
 202     else if( aName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "case" ) ) )
 203     {
 204         pElement = importCaseConfig( xAttribs );
 205     }
 206
 207     if( !pElement.get() )
 208     {
 209         OUString aMessage( OUString( RTL_CONSTASCII_USTRINGPARAM("unknown config element: ")) );
 210         aMessage += aName;
 211         errorThrow( aMessage  );
 212     }
 213
 214     maElementStack.push( pElement );
 215 }
 216
 217 sal_Int32 toInt( const OUString& rText )
 218 {
 219     if( rText.compareToAscii("0x",2) == 0)
 220     {
 221         sal_Int32 nValue = 0;
 222         const sal_Unicode *p = rText;
 223         p += 2;
 224         sal_Int32 nLength = rText.getLength() - 2;
 225         while( (nLength--) > 0 )
 226         {
 227             nValue <<= 4;
 228             if( *p >= '0' && *p <= '9' )
 229             {
 230                 nValue += *p - '0';
 231             }
 232             else if( *p >= 'a' && *p <= 'f' )
 233             {
 234                 nValue += *p - ('a' - 10);
 235             }
 236             else if( *p >= 'A' && *p <= 'F' )
 237             {
 238                 nValue += *p - ('A' - 10 );
 239             }
 240             p++;
 241         }
 242
 243         return nValue;
 244     }
 245     else
 246     {
 247         return rText.toInt32();
 248     }
 249 }
 250
 251 ElementConfigPtr ConfigHandler::importAtomConfig( const Reference< XAttributeList > & xAttribs, bool bIsContainer ) throw (SAXException)
 252 {
 253     if( !maElementStack.empty() )
 254         errorThrow( OUString( RTL_CONSTASCII_USTRINGPARAM("atom elements must be root" ) ) );
 255
 256     ElementConfigPtr aPtr( new AtomConfig( getAttribute(xAttribs,"name"), bIsContainer ) );
 257     gAtomConfigMap[ (UINT16)toInt(getAttribute(xAttribs,"id"))] = aPtr;
 258     return aPtr;
 259 }
 260
 261 ElementConfigPtr ConfigHandler::importElementConfig( const Reference< XAttributeList > & xAttribs ) throw (SAXException)
 262 {
 263     ElementConfigType nType = parseType( getAttribute( xAttribs, "type" ) );
 264     ElementConfigPtr pElementConfig( new ElementConfigContainer( getAttribute( xAttribs, "name" ), nType ) );
 265     addElement( pElementConfig );
 266     return pElementConfig;
 267 }
 268
 269 ElementConfigPtr ConfigHandler::importValueElementConfig( const Reference< XAttributeList > & xAttribs ) throw (SAXException)
 270 {
 271     ElementConfigPtr pElementConfig( new ElementValueConfig( getAttribute( xAttribs, "name" ), getAttribute( xAttribs, "value" ) ) );
 272     addElement( pElementConfig );
 273     return pElementConfig;
 274 }
 275
 276 ElementConfigPtr ConfigHandler::importSwitchConfig( const Reference< XAttributeList > & xAttribs ) throw (SAXException)
 277 {
 278     ElementConfigType nType = parseType( getAttribute( xAttribs, "type" ) );
 279     ElementConfigPtr pElementConfig( new SwitchElementConfig( nType ) );
 280     addElement( pElementConfig );
 281     return pElementConfig;
 282 }
 283
 284 ElementConfigPtr ConfigHandler::importCaseConfig( const Reference< XAttributeList > & xAttribs ) throw (SAXException)
 285 {
 286     ElementConfigPtr pElementConfig( new CaseElementConfig( getAttribute( xAttribs, "value" ) ) );
 287     addElement( pElementConfig );
 288     return pElementConfig;
 289 }
 290
 291 void SAL_CALL ConfigHandler::endElement(const OUString& aName) throw( SAXException, RuntimeException )
 292 {
 293     if( aName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "config" ) ) )
 294     {
 295         return;
 296     }
 297
 298     maElementStack.pop();
 299 }
 300
 301 void SAL_CALL ConfigHandler::characters(const OUString& aChars) throw( SAXException, RuntimeException )
 302 {
 303 }
 304
 305 void SAL_CALL ConfigHandler::ignorableWhitespace(const OUString& aWhitespaces) throw( SAXException, RuntimeException )
 306 {
 307 }
 308
 309 void SAL_CALL ConfigHandler::processingInstruction(const OUString& aTarget, const OUString& aData) throw( SAXException, RuntimeException )
 310 {
 311 }
 312
 313 void SAL_CALL ConfigHandler::setDocumentLocator(const Reference< XLocator > & xLocator) throw( SAXException, RuntimeException )
 314 {
 315 }
 316
 317 void load_config( const OUString& rPath )
 318 {
 319     try
 320     {
 321         // create stream
 322         SvStream*       pIStm = ::utl::UcbStreamHelper::CreateStream( rPath, STREAM_READ );
 323         Reference<XInputStream> xInputStream( new utl::OInputStreamWrapper( pIStm, sal_True ) );
 324
 325         // prepare ParserInputSrouce
 326         InputSource aParserInput;
 327         aParserInput.sSystemId = rPath;
 328         aParserInput.aInputStream = xInputStream;
 329
 330         // get parser
 331         Reference< XParser > xParser(
 332             comphelper::getProcessServiceFactory()->createInstance(
 333                 OUString::createFromAscii("com.sun.star.xml.sax.Parser") ),
 334             UNO_QUERY_THROW );
 335
 336         // get filter
 337         ConfigHandler* pConfigHandler = new ConfigHandler();
 338         Reference< XDocumentHandler > xFilter( pConfigHandler );
 339
 340         // connect parser and filter
 341         xParser->setDocumentHandler( xFilter );
 342
 343         // finally, parser the stream
 344         xParser->parseStream( aParserInput );
 345     }
 346     catch( Exception& r )
 347     {
 348         DBG_ERROR(
 349             (rtl::OString("load_config(), "
 350                      "exception caught: ") +
 351              rtl::OUStringToOString(
 352                  comphelper::anyToString( cppu::getCaughtException() ),
 353                  RTL_TEXTENCODING_UTF8 )).getStr() );
 354
 355         (void)r;
 356     }
 357 }
 358
 359 ///////////////////////////////////////////////////////////////////////
 360
 361 rtl::OUString ElementConfig::format( SvStream& rStream, sal_Size& nLength ) const
 362 {
 363     OUString aRet;
 364     if( maName.getLength() )
 365     {
 366         aRet += maName;
 367         aRet += OUString( RTL_CONSTASCII_USTRINGPARAM( " = " ) );
 368     }
 369
 370     switch( mnType )
 371     {
 372     case ECT_BYTE:              aRet += dump_byte( rStream, nLength ); break;
 373     case ECT_UINT:              aRet += dump_uint( rStream, nLength ); break;
 374     case ECT_UNISTRING: aRet += dump_unistring( rStream, nLength ); break;
 375     case ETC_FLOAT:             aRet += dump_float( rStream, nLength ); break;
 376     case ECT_HEXDUMP:
 377     default:                    aRet += dump_hex( rStream, nLength ); break;
 378     }
 379
 380     return aRet;
 381 }
 382
 383 rtl::OUString ElementConfig::dump_hex( SvStream& rStream, sal_Size& nLength )
 384 {
 385     char buffer[128];
 386     OUString aOut, aEmpty;
 387     OUString aHex, aAscii;
 388     sal_Char c;
 389     int nRow = 0;
 390     while( nLength && (rStream.GetError() == 0) )
 391     {
 392         rStream >> c;
 393         nLength--;
 394
 395         unsigned int i = c;
 396         i &= 0xff;
 397         sprintf( buffer, "%02x ", i );
 398         aHex += OUString::createFromAscii( buffer );
 399
 400         if( !isprint( c ) )
 401             c = '.';
 402
 403         aAscii += OUString( (sal_Unicode) c );
 404         nRow++;
 405
 406         if( (nRow == 16) || (nLength==0) )
 407         {
 408             while( aHex.getLength() < (16*3) )
 409                 aHex += OUString( RTL_CONSTASCII_USTRINGPARAM(" ") );
 410             aOut += aHex;
 411             aOut += aAscii;
 412             aOut += OUString( RTL_CONSTASCII_USTRINGPARAM( "\n\r" ) );
 413             aHex = aEmpty;
 414             aAscii = aEmpty;
 415             nRow = 0;
 416         }
 417     }
 418
 419     aOut += aHex;
 420     aOut += aAscii;
 421
 422     return aOut;
 423 }
 424
 425 rtl::OUString ElementConfig::dump_byte( SvStream& rStream, sal_Size& nLength )
 426 {
 427     OUString aRet;
 428     if( nLength >= sizeof(sal_Char) )
 429     {
 430         sal_Char c;
 431         rStream >> c;
 432
 433         char buffer[128];
 434         sprintf( buffer, "%u", (int)c );
 435         aRet += OUString::createFromAscii( buffer );
 436         nLength -= sizeof(sal_Char);
 437     }
 438
 439     return aRet;
 440 }
 441
 442 rtl::OUString ElementConfig::dump_uint( SvStream& rStream, sal_Size& nLength )
 443 {
 444     OUString aRet;
 445     if( nLength >= sizeof( sal_uInt32 ) )
 446     {
 447         sal_uInt32 c;
 448         rStream >> c;
 449
 450         char buffer[128];
 451         sprintf( buffer, "%u", c );
 452         aRet += OUString::createFromAscii( buffer );
 453         nLength-= sizeof( sal_uInt32 );
 454     }
 455
 456     return aRet;
 457 }
 458
 459 rtl::OUString ElementConfig::dump_unistring( SvStream& rStream, sal_Size& nLength )
 460 {
 461     String aString;
 462     SvxMSDffManager::MSDFFReadZString( rStream, aString, nLength, sal_True );
 463     nLength = 0;
 464     return aString;
 465 }
 466
 467 rtl::OUString ElementConfig::dump_float( SvStream& rStream, sal_Size& nLength )
 468 {
 469     OUString aRet;
 470     if( nLength >= sizeof( float ) )
 471     {
 472         float c;
 473         rStream >> c;
 474
 475         char buffer[128];
 476         sprintf( buffer, "%g", (double)c );
 477         aRet += OUString::createFromAscii( buffer );
 478         nLength-= sizeof( float );
 479     }
 480
 481     return aRet;
 482 }
 483
 484 ///////////////////////////////////////////////////////////////////////
 485
 486 rtl::OUString ElementConfigContainer::format( SvStream& rStream, sal_Size& nLength ) const
 487 {
 488     OUString aRet;
 489
 490     if( getType() == ETC_CONTAINER )
 491     {
 492
 493         ElementConfigList::const_iterator aIter( maElementConfigList.begin() );
 494         const ElementConfigList::const_iterator aEnd( maElementConfigList.end() );
 495         while( (aIter != aEnd) && (nLength > 0) )
 496         {
 497             aRet += (*aIter++)->format( rStream, nLength );
 498             if( (aIter != aEnd) || (nLength != 0) )
 499                 aRet += OUString( RTL_CONSTASCII_USTRINGPARAM( "\n\r" ) );
 500         }
 501
 502         if( nLength )
 503             aRet += ElementConfig::dump_hex( rStream, nLength );
 504     }
 505     else
 506     {
 507         aRet = getName();
 508         if( aRet.getLength() )
 509             aRet += OUString( RTL_CONSTASCII_USTRINGPARAM( " = " ) );
 510
 511         OUString aValue;
 512         switch( getType() )
 513         {
 514         case ECT_BYTE:          aValue = dump_byte( rStream, nLength ); break;
 515         case ECT_UINT:          aValue = dump_uint( rStream, nLength ); break;
 516         case ECT_UNISTRING:     aValue = dump_unistring( rStream, nLength ); break;
 517         case ETC_FLOAT:         aValue = dump_float( rStream, nLength ); break;
 518         case ECT_HEXDUMP:
 519         default:                        aValue = dump_hex( rStream, nLength ); break;
 520         }
 521
 522         if( aValue.getLength() )
 523         {
 524             if( !maElementConfigList.empty() )
 525             {
 526                 ElementConfigList::const_iterator aIter( maElementConfigList.begin() );
 527                 const ElementConfigList::const_iterator aEnd( maElementConfigList.end() );
 528                 while( (aIter != aEnd) && (nLength > 0) )
 529                 {
 530                     ElementValueConfig* pValue = dynamic_cast< ElementValueConfig* >( (*aIter++).get() );
 531                     if( pValue && pValue->getValue() == aValue )
 532                     {
 533                         aValue = pValue->getName();
 534                         break;
 535                     }
 536                 }
 537             }
 538         }
 539         else
 540         {
 541             aValue = OUString( RTL_CONSTASCII_USTRINGPARAM("<empty!?>") );
 542         }
 543
 544         aRet += aValue;
 545     }
 546
 547     return aRet;
 548 }
 549
 550 ///////////////////////////////////////////////////////////////////////
 551
 552 rtl::OUString SwitchElementConfig::format( SvStream& rStream, sal_Size& nLength ) const
 553 {
 554     OUString aValue;
 555
 556     switch( getType() )
 557     {
 558     case ECT_BYTE:                      aValue = dump_byte( rStream, nLength ); break;
 559     case ECT_UINT:                      aValue = dump_uint( rStream, nLength ); break;
 560     case ETC_FLOAT:                     aValue = dump_float( rStream, nLength ); break;
 561     case ECT_UNISTRING:         aValue = dump_unistring( rStream, nLength ); break;
 562     }
 563
 564     if( aValue.getLength()  )
 565     {
 566         ElementConfigList::const_iterator aIter( maElementConfigList.begin() );
 567         const ElementConfigList::const_iterator aEnd( maElementConfigList.end() );
 568         while( (aIter != aEnd) && (nLength > 0) )
 569         {
 570             CaseElementConfig* pCase = dynamic_cast< CaseElementConfig* >( (*aIter++).get() );
 571             if( pCase && pCase->getValue() == aValue )
 572                 return pCase->format( rStream, nLength );
 573         }
 574     }
 575
 576     return ElementConfig::dump_hex( rStream, nLength );
 577 }
 578