sax/source/fastparser/legacyfastparser.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <com/sun/star/lang/XServiceInfo.hpp>
  21 #include <com/sun/star/xml/sax/XParser.hpp>
  22 #include <com/sun/star/xml/sax/FastParser.hpp>
  23 #include <com/sun/star/lang/XInitialization.hpp>
  24 #include <com/sun/star/beans/Pair.hpp>
  25 #include <comphelper/attributelist.hxx>
  26 #include <cppuhelper/supportsservice.hxx>
  27 #include <comphelper/processfactory.hxx>
  28 #include <rtl/ref.hxx>
  29 #include <memory>
  30 #include <vector>
  31
  32 using namespace std;
  33 using namespace ::cppu;
  34 using namespace css;
  35 using namespace uno;
  36 using namespace lang;
  37 using namespace xml::sax;
  38 using namespace io;
  39
  40 namespace {
  41
  42 class NamespaceHandler : public WeakImplHelper< XFastNamespaceHandler >
  43 {
  44 private:
  45     struct NamespaceDefine
  46     {
  47         OUString    m_aPrefix;
  48         OUString    m_aNamespaceURI;
  49
  50         NamespaceDefine( const OUString& rPrefix, const OUString& rNamespaceURI ) : m_aPrefix( rPrefix ), m_aNamespaceURI( rNamespaceURI ) {}
  51     };
  52     vector< unique_ptr< NamespaceDefine > > m_aNamespaceDefines;
  53
  54 public:
  55     NamespaceHandler();
  56     void addNSDeclAttributes( rtl::Reference < comphelper::AttributeList > const & rAttrList );
  57
  58     //XFastNamespaceHandler
  59     virtual void SAL_CALL registerNamespace( const OUString& rNamespacePrefix, const OUString& rNamespaceURI ) override;
  60     virtual OUString SAL_CALL getNamespaceURI( const OUString& rNamespacePrefix ) override;
  61 };
  62
  63 NamespaceHandler::NamespaceHandler()
  64 {
  65 }
  66
  67 void NamespaceHandler::addNSDeclAttributes( rtl::Reference < comphelper::AttributeList > const & rAttrList )
  68 {
  69     for(const auto& aNamespaceDefine : m_aNamespaceDefines)
  70     {
  71         OUString& rPrefix = aNamespaceDefine->m_aPrefix;
  72         OUString& rNamespaceURI = aNamespaceDefine->m_aNamespaceURI;
  73         OUString sDecl;
  74         if ( rPrefix.isEmpty() )
  75             sDecl = "xmlns";
  76         else
  77             sDecl = "xmlns:" + rPrefix;
  78         rAttrList->AddAttribute( sDecl, "CDATA", rNamespaceURI );
  79     }
  80     m_aNamespaceDefines.clear();
  81 }
  82
  83 void NamespaceHandler::registerNamespace( const OUString& rNamespacePrefix, const OUString& rNamespaceURI )
  84 {
  85     m_aNamespaceDefines.push_back( std::make_unique<NamespaceDefine>(
  86                                     rNamespacePrefix, rNamespaceURI) );
  87 }
  88
  89 OUString NamespaceHandler::getNamespaceURI( const OUString&/* rNamespacePrefix */ )
  90 {
  91     return OUString();
  92 }
  93
  94 class SaxLegacyFastParser : public WeakImplHelper< XInitialization, XServiceInfo, XParser >
  95 {
  96 private:
  97     rtl::Reference< NamespaceHandler > m_aNamespaceHandler;
  98 public:
  99     SaxLegacyFastParser();
 100
 101 // css::lang::XInitialization:
 102     virtual void SAL_CALL initialize(css::uno::Sequence<css::uno::Any> const& rArguments) override;
 103
 104 // The SAX-Parser-Interface
 105     virtual void SAL_CALL parseStream(  const InputSource& structSource) override;
 106     virtual void SAL_CALL setDocumentHandler(const Reference< XDocumentHandler > & xHandler) override;
 107     virtual void SAL_CALL setErrorHandler(const Reference< XErrorHandler > & xHandler) override;
 108     virtual void SAL_CALL setDTDHandler(const Reference < XDTDHandler > & xHandler) override;
 109     virtual void SAL_CALL setEntityResolver(const Reference<  XEntityResolver >& xResolver) override;
 110     virtual void SAL_CALL setLocale( const Locale &locale ) override;
 111
 112 // XServiceInfo
 113     OUString SAL_CALL getImplementationName() override;
 114     Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
 115     sal_Bool SAL_CALL supportsService(const OUString& ServiceName) override;
 116
 117 private:
 118     Reference< XFastParser > m_xParser;
 119     Reference< XDocumentHandler > m_xDocumentHandler;
 120     Reference< XFastTokenHandler > m_xTokenHandler;
 121
 122 };
 123
 124
 125 class CallbackDocumentHandler : public WeakImplHelper< XFastDocumentHandler >
 126 {
 127 private:
 128     Reference< XDocumentHandler > m_xDocumentHandler;
 129     Reference< XFastTokenHandler > m_xTokenHandler;
 130     rtl::Reference< NamespaceHandler > m_aNamespaceHandler;
 131     OUString getNamespacePrefixFromToken( sal_Int32 nToken );
 132     OUString getNameFromToken( sal_Int32 nToken );
 133
 134     static const OUString aDefaultNamespace;
 135     static const OUString aNamespaceSeparator;
 136
 137 public:
 138     CallbackDocumentHandler( Reference< XDocumentHandler > const & xDocumentHandler,
 139                              rtl::Reference< NamespaceHandler > const & rNamespaceHandler,
 140                              Reference< XFastTokenHandler > const & xTokenHandler);
 141
 142     // XFastDocumentHandler
 143     virtual void SAL_CALL startDocument() override;
 144     virtual void SAL_CALL endDocument() override;
 145     virtual void SAL_CALL processingInstruction( const OUString& rTarget, const OUString& rData ) override;
 146     virtual void SAL_CALL setDocumentLocator( const Reference< XLocator >& xLocator ) override;
 147
 148     // XFastContextHandler
 149     virtual void SAL_CALL startFastElement( sal_Int32 nElement, const Reference< XFastAttributeList >& Attribs ) override;
 150     virtual void SAL_CALL startUnknownElement( const OUString& Namespace, const OUString& Name, const Reference< XFastAttributeList >& Attribs ) override;
 151     virtual void SAL_CALL endFastElement( sal_Int32 Element ) override;
 152     virtual void SAL_CALL endUnknownElement( const OUString& Namespace, const OUString& Name ) override;
 153     virtual Reference< XFastContextHandler > SAL_CALL createFastChildContext( sal_Int32 nElement, const Reference< XFastAttributeList >& Attribs ) override;
 154     virtual Reference< XFastContextHandler > SAL_CALL createUnknownChildContext( const OUString& Namespace, const OUString& Name, const Reference< XFastAttributeList >& Attribs ) override;
 155     virtual void SAL_CALL characters( const OUString& aChars ) override;
 156
 157 };
 158
 159 const OUString CallbackDocumentHandler::aDefaultNamespace = OUString("");
 160 const OUString CallbackDocumentHandler::aNamespaceSeparator = OUString(":");
 161
 162 OUString CallbackDocumentHandler::getNamespacePrefixFromToken( sal_Int32 nToken )
 163 {
 164     if ( ( nToken & 0xffff0000 ) != 0 )
 165     {
 166         Sequence< sal_Int8 > aSeq = m_xTokenHandler->getUTF8Identifier( nToken & 0xffff0000 );
 167         return OUString( reinterpret_cast< const char* >(
 168                         aSeq.getConstArray() ), aSeq.getLength(), RTL_TEXTENCODING_UTF8 );
 169     }
 170     else
 171         return OUString();
 172 }
 173
 174 OUString CallbackDocumentHandler::getNameFromToken( sal_Int32 nToken )
 175 {
 176     Sequence< sal_Int8 > aSeq = m_xTokenHandler->getUTF8Identifier( nToken & 0xffff );
 177     return OUString( reinterpret_cast< const char* >(
 178                     aSeq.getConstArray() ), aSeq.getLength(), RTL_TEXTENCODING_UTF8 );
 179 }
 180
 181 CallbackDocumentHandler::CallbackDocumentHandler( Reference< XDocumentHandler > const & xDocumentHandler,
 182                                                   rtl::Reference< NamespaceHandler > const & rNamespaceHandler,
 183                                                   Reference< XFastTokenHandler > const & xTokenHandler)
 184 {
 185    m_xDocumentHandler.set( xDocumentHandler );
 186    m_aNamespaceHandler.set( rNamespaceHandler.get() );
 187    m_xTokenHandler.set( xTokenHandler );
 188 }
 189
 190 void SAL_CALL CallbackDocumentHandler::startDocument()
 191 {
 192     if ( m_xDocumentHandler.is() )
 193         m_xDocumentHandler->startDocument();
 194 }
 195
 196 void SAL_CALL CallbackDocumentHandler::endDocument()
 197 {
 198     if ( m_xDocumentHandler.is() )
 199         m_xDocumentHandler->endDocument();
 200 }
 201
 202 void SAL_CALL CallbackDocumentHandler::processingInstruction( const OUString& rTarget, const OUString& rData )
 203 {
 204     if ( m_xDocumentHandler.is() )
 205         m_xDocumentHandler->processingInstruction( rTarget, rData );
 206 }
 207
 208 void SAL_CALL CallbackDocumentHandler::setDocumentLocator( const Reference< XLocator >& xLocator )
 209 {
 210     if ( m_xDocumentHandler.is() )
 211         m_xDocumentHandler->setDocumentLocator( xLocator );
 212 }
 213
 214 void SAL_CALL CallbackDocumentHandler::startFastElement( sal_Int32 nElement , const Reference< XFastAttributeList >& Attribs  )
 215 {
 216     const OUString& rPrefix = CallbackDocumentHandler::getNamespacePrefixFromToken( nElement );
 217     const OUString& rLocalName = CallbackDocumentHandler::getNameFromToken( nElement );
 218     startUnknownElement( aDefaultNamespace, (rPrefix.isEmpty())? rLocalName : rPrefix + aNamespaceSeparator + rLocalName, Attribs );
 219 }
 220
 221 void SAL_CALL CallbackDocumentHandler::startUnknownElement( const OUString& /*Namespace*/, const OUString& Name, const Reference< XFastAttributeList >& Attribs  )
 222 {
 223     if ( m_xDocumentHandler.is() )
 224     {
 225         rtl::Reference < comphelper::AttributeList > rAttrList = new comphelper::AttributeList;
 226         m_aNamespaceHandler->addNSDeclAttributes( rAttrList );
 227
 228         const Sequence< xml::FastAttribute > fastAttribs = Attribs->getFastAttributes();
 229         for (const auto& rAttr : fastAttribs)
 230         {
 231             const OUString& rAttrValue = rAttr.Value;
 232             sal_Int32 nToken = rAttr.Token;
 233             const OUString& rAttrNamespacePrefix = CallbackDocumentHandler::getNamespacePrefixFromToken( nToken );
 234             OUString sAttrName = CallbackDocumentHandler::getNameFromToken( nToken );
 235             if ( !rAttrNamespacePrefix.isEmpty() )
 236                 sAttrName = rAttrNamespacePrefix + aNamespaceSeparator + sAttrName;
 237
 238             rAttrList->AddAttribute( sAttrName, "CDATA", rAttrValue );
 239         }
 240
 241         const Sequence< xml::Attribute > unknownAttribs = Attribs->getUnknownAttributes();
 242         for (const auto& rAttr : unknownAttribs)
 243         {
 244             const OUString& rAttrValue = rAttr.Value;
 245             const OUString& rAttrName = rAttr.Name;
 246
 247             rAttrList->AddAttribute( rAttrName, "CDATA", rAttrValue );
 248         }
 249         m_xDocumentHandler->startElement( Name, rAttrList.get() );
 250     }
 251 }
 252
 253 void SAL_CALL CallbackDocumentHandler::endFastElement( sal_Int32 nElement )
 254 {
 255     const OUString& rPrefix = CallbackDocumentHandler::getNamespacePrefixFromToken( nElement );
 256     const OUString& rLocalName = CallbackDocumentHandler::getNameFromToken( nElement );
 257     endUnknownElement( aDefaultNamespace, (rPrefix.isEmpty())? rLocalName : rPrefix + aNamespaceSeparator + rLocalName );
 258 }
 259
 260
 261 void SAL_CALL CallbackDocumentHandler::endUnknownElement( const OUString& /*Namespace*/, const OUString& Name )
 262 {
 263     if ( m_xDocumentHandler.is() )
 264     {
 265         m_xDocumentHandler->endElement( Name );
 266     }
 267 }
 268
 269 Reference< XFastContextHandler > SAL_CALL CallbackDocumentHandler::createFastChildContext( sal_Int32/* nElement */, const Reference< XFastAttributeList >&/* Attribs */ )
 270 {
 271     return this;
 272 }
 273
 274
 275 Reference< XFastContextHandler > SAL_CALL CallbackDocumentHandler::createUnknownChildContext( const OUString&/* Namespace */, const OUString&/* Name */, const Reference< XFastAttributeList >&/* Attribs */ )
 276 {
 277     return this;
 278 }
 279
 280 void SAL_CALL CallbackDocumentHandler::characters( const OUString& aChars )
 281 {
 282     if ( m_xDocumentHandler.is() )
 283         m_xDocumentHandler->characters( aChars );
 284 }
 285
 286 SaxLegacyFastParser::SaxLegacyFastParser( ) : m_aNamespaceHandler( new NamespaceHandler )
 287 {
 288     m_xParser = FastParser::create(
 289         ::comphelper::getProcessComponentContext() );
 290     m_xParser->setNamespaceHandler( m_aNamespaceHandler.get() );
 291 }
 292
 293 void SAL_CALL SaxLegacyFastParser::initialize(Sequence< Any > const& rArguments )
 294 {
 295     if (rArguments.hasElements())
 296     {
 297         Reference< XFastTokenHandler > xTokenHandler;
 298         OUString str;
 299         if ( ( rArguments[0] >>= xTokenHandler ) && xTokenHandler.is() )
 300         {
 301             m_xTokenHandler.set( xTokenHandler );
 302         }
 303         else if ( ( rArguments[0] >>= str ) && "registerNamespaces" == str )
 304         {
 305             css::beans::Pair< OUString, sal_Int32 > rPair;
 306             for (sal_Int32 i = 1; i < rArguments.getLength(); i++ )
 307             {
 308                 rArguments[i] >>= rPair;
 309                 m_xParser->registerNamespace( rPair.First, rPair.Second );
 310             }
 311         }
 312         else
 313         {
 314             uno::Reference<lang::XInitialization> const xInit(m_xParser,
 315                             uno::UNO_QUERY_THROW);
 316             xInit->initialize( rArguments );
 317         }
 318     }
 319 }
 320
 321 void SaxLegacyFastParser::parseStream( const InputSource& structSource )
 322 {
 323     m_xParser->setFastDocumentHandler( new CallbackDocumentHandler( m_xDocumentHandler.get(),
 324                                        m_aNamespaceHandler.get(), m_xTokenHandler.get() ) );
 325     m_xParser->setTokenHandler( m_xTokenHandler );
 326     m_xParser->parseStream( structSource );
 327 }
 328
 329 void SaxLegacyFastParser::setDocumentHandler( const Reference< XDocumentHandler > & xHandler )
 330 {
 331     m_xDocumentHandler = xHandler;
 332 }
 333
 334 void SaxLegacyFastParser::setErrorHandler( const Reference< XErrorHandler > & xHandler )
 335 {
 336     m_xParser->setErrorHandler( xHandler );
 337 }
 338
 339 void SaxLegacyFastParser::setDTDHandler( const Reference < XDTDHandler > &/* xHandler */ )
 340 {
 341
 342 }
 343
 344 void SaxLegacyFastParser::setEntityResolver( const Reference<  XEntityResolver >& xResolver )
 345 {
 346     m_xParser->setEntityResolver( xResolver );
 347 }
 348
 349 void SaxLegacyFastParser::setLocale( const Locale &locale )
 350 {
 351     m_xParser->setLocale( locale );
 352 }
 353
 354 OUString SaxLegacyFastParser::getImplementationName()
 355 {
 356     return "com.sun.star.comp.extensions.xml.sax.LegacyFastParser";
 357 }
 358
 359 sal_Bool SaxLegacyFastParser::supportsService(const OUString& ServiceName)
 360 {
 361     return cppu::supportsService(this, ServiceName);
 362 }
 363
 364 Sequence< OUString > SaxLegacyFastParser::getSupportedServiceNames()
 365 {
 366     Sequence<OUString> seq { "com.sun.star.xml.sax.LegacyFastParser" };
 367     return seq;
 368 }
 369
 370 } //namespace
 371
 372 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
 373 com_sun_star_comp_extensions_xml_sax_LegacyFastParser_get_implementation(
 374     css::uno::XComponentContext *,
 375     css::uno::Sequence<css::uno::Any> const &)
 376 {
 377     return cppu::acquire(new SaxLegacyFastParser);
 378 }
 379
 380  /* vim:set shiftwidth=4 softtabstop=4 expandtab: */