svx/workben/msview/xmlconfig.cxx

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