configmgr/source/xml/basicparser.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: basicparser.cxx,v $
  10  * $Revision: 1.11 $
  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 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_configmgr.hxx"
  33
  34 #include "basicparser.hxx"
  35 #include <com/sun/star/xml/sax/SAXException.hpp>
  36 #include "valuetypeconverter.hxx"
  37 // -----------------------------------------------------------------------------
  38
  39 namespace configmgr
  40 {
  41 // -----------------------------------------------------------------------------
  42     namespace xml
  43     {
  44 // -----------------------------------------------------------------------------
  45         namespace uno           = ::com::sun::star::uno;
  46         namespace sax           = ::com::sun::star::xml::sax;
  47 // -----------------------------------------------------------------------------
  48
  49 namespace
  50 {
  51     static inline
  52     uno::Reference< script::XTypeConverter > createTCV(uno::Reference< uno::XComponentContext > const & _xContext)
  53     {
  54         OSL_ENSURE(_xContext.is(),"Cannot create Parser without a Context");
  55
  56         static const rtl::OUString k_sTCVService(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.script.Converter"));
  57
  58         uno::Reference< lang::XMultiComponentFactory > xSvcFactory = _xContext->getServiceManager();
  59         return uno::Reference< script::XTypeConverter >::query(xSvcFactory->createInstanceWithContext(k_sTCVService,_xContext));
  60     }
  61 }
  62 // -----------------------------------------------------------------------------
  63
  64 struct BasicParser::ValueData : ValueConverter
  65 {
  66     rtl::OUString    content;
  67     rtl::OUString    locale;
  68     bool    isLocalized;
  69
  70     ValueData(uno::Type const& _aType, uno::Reference< script::XTypeConverter > const & _xTCV)
  71     : ValueConverter(_aType, _xTCV)
  72     , content()
  73     , locale()
  74     , isLocalized(false)
  75     {
  76     }
  77
  78     uno::Any convertToAny() const
  79     {
  80         return ValueConverter::convertToAny(this->content);
  81     }
  82
  83     rtl::OUString toString() const
  84     {
  85         return this->content;
  86     }
  87
  88     uno::Sequence<rtl::OUString> toStringList() const
  89     {
  90         return ValueConverter::splitStringList(this->content);
  91     }
  92
  93     void setLocalized(rtl::OUString const & _aLocale)
  94     {
  95         isLocalized = true;
  96         locale = _aLocale;
  97     }
  98 };
  99 // -----------------------------------------------------------------------------
 100
 101 BasicParser::BasicParser(uno::Reference< uno::XComponentContext > const & _xContext)
 102 : m_xTypeConverter( createTCV(_xContext) )
 103 , m_xLocator(NULL)
 104 , m_aDataParser(Logger(_xContext))
 105 , m_aNodes()
 106 , m_aValueType()
 107 , m_pValueData(NULL)
 108 , m_nSkipLevels(0)
 109 , m_bEmpty(true)
 110 , m_bInProperty(false)
 111 {
 112     if (!m_xTypeConverter.is())
 113         throw uno::RuntimeException();
 114
 115     OSL_DEBUG_ONLY( dbgUpdateLocation() );
 116 }
 117 // -----------------------------------------------------------------------------
 118
 119 BasicParser::~BasicParser()
 120 {
 121     delete m_pValueData;
 122 }
 123 // -----------------------------------------------------------------------------
 124
 125 #if OSL_DEBUG_LEVEL > 0
 126 void BasicParser::dbgUpdateLocation()
 127 {
 128 #ifndef DBG_UTIL
 129     rtl::OUString  dbgPublicId,    dbgSystemId;
 130     sal_Int32 dbgLineNo,      dbgColumnNo;
 131 #endif // OSL_DEBUG_LEVEL
 132
 133     if (m_xLocator.is())
 134     {
 135         dbgPublicId   = m_xLocator->getPublicId();
 136         dbgSystemId   = m_xLocator->getSystemId();
 137         dbgLineNo     = m_xLocator->getLineNumber();
 138         dbgColumnNo   = m_xLocator->getColumnNumber();
 139     }
 140     else
 141     {
 142         dbgPublicId = dbgSystemId = rtl::OUString::createFromAscii("<<<unknown>>>");
 143         dbgLineNo = dbgColumnNo = -1;
 144     }
 145 }
 146 #endif
 147 // -----------------------------------------------------------------------------
 148 void SAL_CALL BasicParser::startDocument(  )
 149         throw (sax::SAXException, uno::RuntimeException)
 150 {
 151     m_aDataParser.reset();
 152     m_aValueType    = uno::Type();
 153     m_bInProperty   = false;
 154     m_nSkipLevels   = 0;
 155
 156     delete m_pValueData, m_pValueData = NULL;
 157
 158     while (!m_aNodes.empty()) m_aNodes.pop();
 159
 160     m_bEmpty = true;
 161
 162     OSL_DEBUG_ONLY( dbgUpdateLocation() );
 163 }
 164 // -----------------------------------------------------------------------------
 165
 166 void SAL_CALL BasicParser::endDocument(  ) throw (sax::SAXException, uno::RuntimeException)
 167 {
 168     OSL_DEBUG_ONLY( dbgUpdateLocation() );
 169
 170     if (!m_aNodes.empty() || isSkipping() || isInValueData())
 171         raiseParseException( "Configuration XML Parser - Invalid XML: Unexpected end of document" );
 172
 173     m_xLocator.clear();
 174 }
 175 // -----------------------------------------------------------------------------
 176
 177 void SAL_CALL BasicParser::characters( const rtl::OUString& aChars )
 178         throw (sax::SAXException, uno::RuntimeException)
 179 {
 180     OSL_DEBUG_ONLY( dbgUpdateLocation() );
 181
 182     if (isInValueData())
 183     {
 184         m_pValueData->content += aChars;
 185     }
 186 #ifdef CONFIG_XMLPARSER_VALIDATE_WHITESPACE
 187     else
 188         OSL_ENSURE( isSkipping() || aChars.trim().getLength() == 0, "Unexpected text content in configuration XML");
 189 #endif
 190 }
 191 // -----------------------------------------------------------------------------
 192
 193 void SAL_CALL BasicParser::ignorableWhitespace( const rtl::OUString& aWhitespaces )
 194         throw (sax::SAXException, uno::RuntimeException)
 195 {
 196     OSL_DEBUG_ONLY( dbgUpdateLocation() );
 197     if (isInValueData())
 198     {
 199         OSL_ENSURE(false, "Configuration XML: Unexpected ignorable (!) whitespace instruction in value data");
 200         if (!m_pValueData->isNull())
 201             m_pValueData->content += aWhitespaces;
 202     }
 203 #ifdef CONFIG_XMLPARSER_VALIDATE_WHITESPACE
 204     else
 205         OSL_ENSURE( aChars.trim().getLength() == 0, "Unexpected non-space content in ignorable whitespace");
 206 #endif
 207 }
 208 // -----------------------------------------------------------------------------
 209
 210 void SAL_CALL BasicParser::processingInstruction( const rtl::OUString& /*aTarget*/, const rtl::OUString& /*aData*/ )
 211         throw (sax::SAXException, uno::RuntimeException)
 212 {
 213     OSL_DEBUG_ONLY( dbgUpdateLocation() );
 214     OSL_ENSURE(false, "Unexpected processing instruction in Configuration XML");
 215 }
 216 // -----------------------------------------------------------------------------
 217
 218 void SAL_CALL BasicParser::setDocumentLocator( const uno::Reference< sax::XLocator >& xLocator )
 219         throw (sax::SAXException, uno::RuntimeException)
 220 {
 221     m_xLocator = xLocator;
 222     OSL_DEBUG_ONLY( dbgUpdateLocation() );
 223 }
 224 // -----------------------------------------------------------------------------
 225
 226 void BasicParser::startNode( ElementInfo const & aInfo, const uno::Reference< sax::XAttributeList >& /*xAttribs*/ )
 227 {
 228     { (void)aInfo; }
 229     OSL_DEBUG_ONLY( dbgUpdateLocation() );
 230
 231     OSL_ENSURE( !isSkipping(), "While skipping, call startSkipping() instead of startNode()");
 232     OSL_ENSURE( aInfo.type != ElementType::property, "For properties, call startProperty() instead of startNode()");
 233
 234     if (isInProperty())
 235         raiseParseException( "Configuration XML Parser - Invalid Data: Cannot have a node nested in a property" );
 236
 237     m_aNodes.push(aInfo);
 238     m_bEmpty = (aInfo.flags != 0) || (aInfo.op > Operation::modify);
 239
 240     OSL_POSTCOND( isInNode(), "Could not start a node ");
 241 }
 242 // -----------------------------------------------------------------------------
 243
 244 void BasicParser::endNode( )
 245 {
 246     OSL_DEBUG_ONLY( dbgUpdateLocation() );
 247
 248     OSL_ENSURE( !isSkipping(), "While skipping, honor wasSkipping() instead of calling endNode()");
 249     OSL_ENSURE( !isInProperty(), "For properties, call endProperty() instead of endNode()" );
 250
 251     ensureInNode();
 252
 253     m_aNodes.pop();
 254     m_bEmpty = false;
 255 }
 256 // -----------------------------------------------------------------------------
 257
 258 void BasicParser::ensureInNode( )
 259 {
 260     if (!isInNode())
 261         raiseParseException("Unexpected endElement without matching startElement");
 262 }
 263 // -----------------------------------------------------------------------------
 264
 265 bool BasicParser::isInNode( )
 266 {
 267     return ! m_aNodes.empty();
 268 }
 269 // -----------------------------------------------------------------------------
 270
 271 bool BasicParser::isEmptyNode( )
 272 {
 273     return m_bEmpty;
 274 }
 275 // -----------------------------------------------------------------------------
 276
 277 ElementInfo const & BasicParser::getActiveNodeInfo( )
 278 {
 279     ensureInNode();
 280
 281     return m_aNodes.top();
 282 }
 283 // -----------------------------------------------------------------------------
 284
 285 void BasicParser::startProperty( ElementInfo const & aInfo, const uno::Reference< sax::XAttributeList >& xAttribs )
 286 {
 287     OSL_DEBUG_ONLY( dbgUpdateLocation() );
 288
 289     OSL_ENSURE( !isSkipping(), "While skipping, call startSkipping() instead of startProperty()");
 290     OSL_ENSURE( aInfo.type == ElementType::property, "For non-property nodes, call startNode() instead of startProperty()");
 291
 292     if (isInProperty())
 293         raiseParseException( "Configuration XML Parser - Invalid Data: Properties may not nest" );
 294
 295     try
 296     {
 297         m_aValueType = getDataParser().getPropertyValueType(xAttribs);
 298     }
 299     catch (ElementParser::BadValueType & error)
 300     {
 301         raiseParseException(error.message());
 302     }
 303
 304     m_bInProperty = true;
 305
 306     m_aNodes.push(aInfo);
 307     m_bEmpty = true;
 308
 309     OSL_POSTCOND( isInProperty(), "Could not get data to start a property" );
 310     OSL_POSTCOND( isInUnhandledProperty(), "Could not mark property as unhandled");
 311 }
 312 // -----------------------------------------------------------------------------
 313
 314 void BasicParser::endProperty( )
 315 {
 316     OSL_DEBUG_ONLY( dbgUpdateLocation() );
 317
 318     OSL_ENSURE( !isSkipping(), "While skipping, honor wasSkipping() instead of calling endProperty()");
 319     OSL_ENSURE( isInProperty(), "For non-property nodes, call endNode() instead of endProperty()" );
 320
 321     ensureInNode();
 322
 323     m_aNodes.pop();
 324     m_bEmpty = false;
 325
 326     m_aValueType = uno::Type();
 327     m_bInProperty = false;
 328
 329     OSL_POSTCOND( !isInProperty(), "Could not get mark end of property" );
 330 }
 331 // -----------------------------------------------------------------------------
 332
 333 uno::Type BasicParser::getActivePropertyType()
 334 {
 335     return m_aValueType;
 336 }
 337 // -----------------------------------------------------------------------------
 338
 339 bool BasicParser::isInProperty()
 340 {
 341     return m_bInProperty;
 342 }
 343 // -----------------------------------------------------------------------------
 344
 345 bool BasicParser::isInUnhandledProperty()
 346 {
 347     return m_bEmpty && m_bInProperty;
 348 }
 349 // -----------------------------------------------------------------------------
 350
 351 void BasicParser::startValueData(const uno::Reference< sax::XAttributeList >& xAttribs)
 352 {
 353     OSL_DEBUG_ONLY( dbgUpdateLocation() );
 354
 355     if (!isInProperty())
 356         raiseParseException( "Configuration XML Parser - Invalid Data: A value may occur only within a property" );
 357
 358     if (m_aValueType.getTypeClass() == uno::TypeClass_ANY)
 359         raiseParseException( "Configuration XML Parser - Invalid Data: Cannot have values for properties of type 'Any'" );
 360
 361     if (isInValueData())
 362         raiseParseException( "Configuration XML Parser - Invalid Data: Unexpected element while parsing value data" );
 363
 364     m_pValueData = new ValueData(m_aValueType, m_xTypeConverter);
 365
 366     m_pValueData->setIsNull( getDataParser().isNull(xAttribs) );
 367
 368     m_pValueData->setSeparator( getDataParser().getSeparator(xAttribs) );
 369
 370     OSL_ENSURE( !m_pValueData->hasSeparator() ||
 371                 !m_pValueData->isTypeSet() ||
 372                 m_pValueData->isList(),
 373                 "Warning: Spurious oor:separator on value that is not a list");
 374     OSL_ENSURE( !m_pValueData->hasSeparator() ||
 375                 !m_pValueData->isNull(),
 376                 "Warning: Spurious oor:separator on value that is not a list");
 377
 378     rtl::OUString aLocale;
 379     if ( getDataParser().getLanguage(xAttribs,aLocale) )
 380         m_pValueData->setLocalized( aLocale );
 381 }
 382 // -----------------------------------------------------------------------------
 383
 384 bool BasicParser::isInValueData()
 385 {
 386     return m_pValueData != NULL;
 387 }
 388 // -----------------------------------------------------------------------------
 389
 390 bool BasicParser::isValueDataLocalized()
 391 {
 392     OSL_ENSURE(isInValueData(), "There is no value data that could be localized");
 393
 394     return m_pValueData && m_pValueData->isLocalized;
 395 }
 396 // -----------------------------------------------------------------------------
 397
 398 rtl::OUString BasicParser::getValueDataLocale()
 399 {
 400     OSL_ENSURE(isValueDataLocalized(), "There is no value data or it is not localized");
 401
 402     return m_pValueData->locale;
 403 }
 404 // -----------------------------------------------------------------------------
 405
 406 uno::Any BasicParser::getCurrentValue()
 407 {
 408     OSL_DEBUG_ONLY( dbgUpdateLocation() );
 409
 410     OSL_ASSERT( isInValueData() );
 411
 412     uno::Any aResult;
 413
 414     if (m_pValueData->isTypeSet())
 415         try
 416         {
 417             aResult = m_pValueData->convertToAny();
 418         }
 419         catch (script::CannotConvertException & e)
 420         {
 421             this->raiseParseException(uno::makeAny(e),"Configuration XML Parser - Invalid Data: Cannot convert value to type of property" );
 422         }
 423     else if (m_pValueData->isNull())
 424     {
 425         // nothing to do
 426     }
 427     else if (m_pValueData->hasSeparator() || m_pValueData->isList())
 428     {
 429         aResult <<= m_pValueData->toStringList();
 430     }
 431     else
 432     {
 433         aResult <<= m_pValueData->toString();
 434     }
 435     return aResult;
 436 }
 437 // -----------------------------------------------------------------------------
 438
 439 /// end collecting data for a value
 440 void BasicParser::endValueData()
 441 {
 442     OSL_DEBUG_ONLY( dbgUpdateLocation() );
 443
 444     OSL_ASSERT( isInValueData() );
 445
 446     delete m_pValueData, m_pValueData = NULL;
 447     m_bEmpty = false;
 448
 449     OSL_POSTCOND( !isInValueData(), "Could not end value data tag" );
 450     OSL_POSTCOND( !isInUnhandledProperty(), "Could not mark property as handled" );
 451 }
 452 // -----------------------------------------------------------------------------
 453
 454 void BasicParser::startSkipping( const rtl::OUString& aName, const uno::Reference< sax::XAttributeList >& /*xAttribs*/ )
 455 {
 456     OSL_DEBUG_ONLY( dbgUpdateLocation() );
 457
 458     m_aNodes.push( ElementInfo(aName) );
 459     ++m_nSkipLevels;
 460 }
 461 // -----------------------------------------------------------------------------
 462
 463 bool BasicParser::wasSkipping( const rtl::OUString& aName )
 464 {
 465     OSL_DEBUG_ONLY( dbgUpdateLocation() );
 466
 467     if (m_nSkipLevels == 0) return false;
 468
 469     if (m_aNodes.empty())
 470         raiseParseException( "Configuration XML Parser - Invalid XML: Unexpected end of element (while skipping data)" );
 471
 472     if (aName != m_aNodes.top().name)
 473         raiseParseException( "Configuration XML Parser - Invalid XML: End tag does not match start tag (while skipping data)" );
 474
 475     --m_nSkipLevels;
 476     m_aNodes.pop();
 477
 478     return true;
 479 }
 480 // -----------------------------------------------------------------------------
 481
 482 bool BasicParser::isSkipping( )
 483 {
 484     return m_nSkipLevels != 0;
 485 }
 486 // -----------------------------------------------------------------------------
 487
 488 void BasicParser::raiseParseException( uno::Any const & _aTargetException, sal_Char const * _pMsg )
 489     SAL_THROW((sax::SAXException, uno::RuntimeException))
 490 {
 491     OSL_DEBUG_ONLY( dbgUpdateLocation() );
 492
 493     if (_pMsg == 0) _pMsg = "Configuration XML Parser: Invalid Data: ";
 494
 495     rtl::OUString sMessage = rtl::OUString::createFromAscii(_pMsg);
 496
 497     uno::Exception aEx;
 498     if (_aTargetException >>= aEx)
 499         sMessage += aEx.Message;
 500
 501     getLogger().error(sMessage,"parse","configuration::xml::BasicParser");
 502     throw sax::SAXException( sMessage, *this, _aTargetException );
 503 }
 504 // -----------------------------------------------------------------------------
 505
 506 void BasicParser::raiseParseException( sal_Char const * _pMsg )
 507     SAL_THROW((sax::SAXException, uno::RuntimeException))
 508 {
 509     OSL_DEBUG_ONLY( dbgUpdateLocation() );
 510
 511     if (_pMsg == 0) _pMsg = "Configuration XML Parser: Invalid XML";
 512
 513     rtl::OUString const sMessage = rtl::OUString::createFromAscii(_pMsg);
 514
 515     getLogger().error(sMessage,"parse","configuration::xml::BasicParser");
 516     throw sax::SAXException( sMessage, *this, uno::Any() );
 517 }
 518 // -----------------------------------------------------------------------------
 519
 520 void BasicParser::raiseParseException( rtl::OUString const & sMessage )
 521     SAL_THROW((sax::SAXException, uno::RuntimeException))
 522 {
 523     OSL_DEBUG_ONLY( dbgUpdateLocation() );
 524
 525     if (sMessage.getLength() == 0) raiseParseException(NULL);
 526
 527     getLogger().error(sMessage,"parse","configuration::xml::BasicParser");
 528     throw sax::SAXException( sMessage, *this, uno::Any() );
 529 }
 530 // -----------------------------------------------------------------------------
 531 // -----------------------------------------------------------------------------
 532     } // namespace
 533
 534 // -----------------------------------------------------------------------------
 535 } // namespace
 536