oox/source/core/recordparser.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 "oox/core/recordparser.hxx"
  21
  22 #include <vector>
  23 #include <com/sun/star/lang/DisposedException.hpp>
  24 #include <com/sun/star/xml/sax/XLocator.hpp>
  25 #include <cppuhelper/implbase1.hxx>
  26 #include <osl/diagnose.h>
  27 #include "oox/core/fragmenthandler.hxx"
  28
  29 namespace oox {
  30 namespace core {
  31
  32 using namespace ::com::sun::star::io;
  33 using namespace ::com::sun::star::lang;
  34 using namespace ::com::sun::star::uno;
  35 using namespace ::com::sun::star::xml::sax;
  36
  37 namespace prv {
  38
  39 class Locator : public ::cppu::WeakImplHelper1< XLocator >
  40 {
  41 public:
  42     inline explicit         Locator( RecordParser* pParser ) : mpParser( pParser ) {}
  43
  44     void                    dispose();
  45     void                    checkDispose() throw( RuntimeException );
  46
  47     // com.sun.star.sax.XLocator interface
  48
  49     virtual sal_Int32 SAL_CALL getColumnNumber() throw( RuntimeException, std::exception ) SAL_OVERRIDE;
  50     virtual sal_Int32 SAL_CALL getLineNumber() throw( RuntimeException, std::exception ) SAL_OVERRIDE;
  51     virtual OUString SAL_CALL getPublicId() throw( RuntimeException, std::exception ) SAL_OVERRIDE;
  52     virtual OUString SAL_CALL getSystemId() throw( RuntimeException, std::exception ) SAL_OVERRIDE;
  53
  54 private:
  55     RecordParser*           mpParser;
  56 };
  57
  58 void Locator::dispose()
  59 {
  60     mpParser = 0;
  61 }
  62
  63 void Locator::checkDispose() throw( RuntimeException )
  64 {
  65     if( !mpParser )
  66         throw DisposedException();
  67 }
  68
  69 sal_Int32 SAL_CALL Locator::getColumnNumber() throw( RuntimeException, std::exception )
  70 {
  71     return -1;
  72 }
  73
  74 sal_Int32 SAL_CALL Locator::getLineNumber() throw( RuntimeException, std::exception )
  75 {
  76     return -1;
  77 }
  78
  79 OUString SAL_CALL Locator::getPublicId() throw( RuntimeException, std::exception )
  80 {
  81     checkDispose();
  82     return mpParser->getInputSource().maPublicId;
  83 }
  84
  85 OUString SAL_CALL Locator::getSystemId() throw( RuntimeException, std::exception )
  86 {
  87     checkDispose();
  88     return mpParser->getInputSource().maSystemId;
  89 }
  90
  91 class ContextStack
  92 {
  93 public:
  94     explicit            ContextStack( FragmentHandlerRef xHandler );
  95
  96     inline bool         empty() const { return maStack.empty(); }
  97
  98     sal_Int32           getCurrentRecId() const;
  99     bool                hasCurrentEndRecId() const;
 100     ContextHandlerRef   getCurrentContext() const;
 101
 102     void                pushContext( const RecordInfo& rRec, const ContextHandlerRef& rxContext );
 103     void                popContext();
 104
 105 private:
 106     typedef ::std::pair< RecordInfo, ContextHandlerRef >    ContextInfo;
 107     typedef ::std::vector< ContextInfo >                    ContextInfoVec;
 108
 109     FragmentHandlerRef  mxHandler;
 110     ContextInfoVec      maStack;
 111 };
 112
 113 ContextStack::ContextStack( FragmentHandlerRef xHandler ) :
 114     mxHandler( xHandler )
 115 {
 116 }
 117
 118 sal_Int32 ContextStack::getCurrentRecId() const
 119 {
 120     return maStack.empty() ? -1 : maStack.back().first.mnStartRecId;
 121 }
 122
 123 bool ContextStack::hasCurrentEndRecId() const
 124 {
 125     return !maStack.empty() && (maStack.back().first.mnEndRecId >= 0);
 126 }
 127
 128 ContextHandlerRef ContextStack::getCurrentContext() const
 129 {
 130     if( !maStack.empty() )
 131         return maStack.back().second;
 132     return mxHandler.get();
 133 }
 134
 135 void ContextStack::pushContext( const RecordInfo& rRecInfo, const ContextHandlerRef& rxContext )
 136 {
 137     OSL_ENSURE( (rRecInfo.mnEndRecId >= 0) || maStack.empty() || hasCurrentEndRecId(),
 138         "ContextStack::pushContext - nested incomplete context record identifiers" );
 139     maStack.push_back( ContextInfo( rRecInfo, rxContext ) );
 140 }
 141
 142 void ContextStack::popContext()
 143 {
 144     OSL_ENSURE( !maStack.empty(), "ContextStack::popContext - no context on stack" );
 145     if( !maStack.empty() )
 146     {
 147         ContextInfo& rContextInfo = maStack.back();
 148         if( rContextInfo.second.is() )
 149             rContextInfo.second->endRecord( rContextInfo.first.mnStartRecId );
 150         maStack.pop_back();
 151     }
 152 }
 153
 154 } // namespace prv
 155
 156 namespace {
 157
 158 /** Reads a byte from the passed stream, returns true on success. */
 159 inline bool lclReadByte( sal_uInt8& ornByte, BinaryInputStream& rStrm )
 160 {
 161     return rStrm.readMemory( &ornByte, 1 ) == 1;
 162 }
 163
 164 /** Reads a compressed signed 32-bit integer from the passed stream. */
 165 bool lclReadCompressedInt( sal_Int32& ornValue, BinaryInputStream& rStrm )
 166 {
 167     ornValue = 0;
 168     sal_uInt8 nByte;
 169     if( !lclReadByte( nByte, rStrm ) ) return false;
 170     ornValue = nByte & 0x7F;
 171     if( (nByte & 0x80) == 0 ) return true;
 172     if( !lclReadByte( nByte, rStrm ) ) return false;
 173     ornValue |= sal_Int32( nByte & 0x7F ) << 7;
 174     if( (nByte & 0x80) == 0 ) return true;
 175     if( !lclReadByte( nByte, rStrm ) ) return false;
 176     ornValue |= sal_Int32( nByte & 0x7F ) << 14;
 177     if( (nByte & 0x80) == 0 ) return true;
 178     if( !lclReadByte( nByte, rStrm ) ) return false;
 179     ornValue |= sal_Int32( nByte & 0x7F ) << 21;
 180     return true;
 181 }
 182
 183 bool lclReadRecordHeader( sal_Int32& ornRecId, sal_Int32& ornRecSize, BinaryInputStream& rStrm )
 184 {
 185     return
 186         lclReadCompressedInt( ornRecId, rStrm ) && (ornRecId >= 0) &&
 187         lclReadCompressedInt( ornRecSize, rStrm ) && (ornRecSize >= 0);
 188 }
 189
 190 bool lclReadNextRecord( sal_Int32& ornRecId, StreamDataSequence& orData, BinaryInputStream& rStrm )
 191 {
 192     sal_Int32 nRecSize = 0;
 193     bool bValid = lclReadRecordHeader( ornRecId, nRecSize, rStrm );
 194     if( bValid )
 195     {
 196         orData.realloc( nRecSize );
 197         bValid = (nRecSize == 0) || (rStrm.readData( orData, nRecSize ) == nRecSize);
 198     }
 199     return bValid;
 200 }
 201
 202 } // namespace
 203
 204 RecordParser::RecordParser()
 205 {
 206     mxLocator.set( new prv::Locator( this ) );
 207 }
 208
 209 RecordParser::~RecordParser()
 210 {
 211     if( mxLocator.is() )
 212         mxLocator->dispose();
 213 }
 214
 215 void RecordParser::setFragmentHandler( const ::rtl::Reference< FragmentHandler >& rxHandler )
 216 {
 217     mxHandler = rxHandler;
 218
 219     // build record infos
 220     maStartMap.clear();
 221     maEndMap.clear();
 222     const RecordInfo* pRecs = mxHandler.is() ? mxHandler->getRecordInfos() : 0;
 223     OSL_ENSURE( pRecs, "RecordInfoProvider::RecordInfoProvider - missing record list" );
 224     for( ; pRecs && pRecs->mnStartRecId >= 0; ++pRecs )
 225     {
 226         maStartMap[ pRecs->mnStartRecId ] = *pRecs;
 227         if( pRecs->mnEndRecId >= 0 )
 228             maEndMap[ pRecs->mnEndRecId ] = *pRecs;
 229     }
 230 }
 231
 232 void RecordParser::parseStream( const RecordInputSource& rInputSource ) throw( SAXException, IOException, RuntimeException )
 233 {
 234     maSource = rInputSource;
 235
 236     if( !maSource.mxInStream || maSource.mxInStream->isEof() )
 237         throw IOException();
 238     if( !mxHandler.is() )
 239         throw SAXException();
 240
 241     // start the document
 242     Reference< XLocator > xLocator( mxLocator.get() );
 243     mxHandler->setDocumentLocator( xLocator );
 244     mxHandler->startDocument();
 245
 246     // parse the stream
 247     mxStack.reset( new prv::ContextStack( mxHandler ) );
 248     sal_Int32 nRecId = 0;
 249     StreamDataSequence aRecData;
 250     while( lclReadNextRecord( nRecId, aRecData, *maSource.mxInStream ) )
 251     {
 252         // create record stream object from imported record data
 253         SequenceInputStream aRecStrm( aRecData );
 254         // try to leave a context, there may be other incomplete contexts on the stack
 255         if( const RecordInfo* pEndRecInfo = getEndRecordInfo( nRecId ) )
 256         {
 257             // finalize contexts without record identifier for context end
 258             while( !mxStack->empty() && !mxStack->hasCurrentEndRecId() )
 259                 mxStack->popContext();
 260             // finalize the current context and pop context info from stack
 261             OSL_ENSURE( mxStack->getCurrentRecId() == pEndRecInfo->mnStartRecId, "RecordParser::parseStream - context records mismatch" );
 262             (void)pEndRecInfo;  // suppress compiler warning for unused variable
 263             ContextHandlerRef xCurrContext = mxStack->getCurrentContext();
 264             if( xCurrContext.is() )
 265             {
 266                 // context end record may contain some data, handle it as simple record
 267                 aRecStrm.seekToStart();
 268                 xCurrContext->startRecord( nRecId, aRecStrm );
 269                 xCurrContext->endRecord( nRecId );
 270             }
 271             mxStack->popContext();
 272         }
 273         else
 274         {
 275             // end context with incomplete record id, if the same id comes again
 276             if( (mxStack->getCurrentRecId() == nRecId) && !mxStack->hasCurrentEndRecId() )
 277                 mxStack->popContext();
 278             // try to start a new context
 279             ContextHandlerRef xCurrContext = mxStack->getCurrentContext();
 280             if( xCurrContext.is() )
 281             {
 282                 aRecStrm.seekToStart();
 283                 xCurrContext = xCurrContext->createRecordContext( nRecId, aRecStrm );
 284             }
 285             // track all context identifiers on the stack (do not push simple records)
 286             const RecordInfo* pStartRecInfo = getStartRecordInfo( nRecId );
 287             if( pStartRecInfo )
 288                 mxStack->pushContext( *pStartRecInfo, xCurrContext );
 289             // import the record
 290             if( xCurrContext.is() )
 291             {
 292                 // import the record
 293                 aRecStrm.seekToStart();
 294                 xCurrContext->startRecord( nRecId, aRecStrm );
 295                 // end simple records (context records are finished in ContextStack::popContext)
 296                 if( !pStartRecInfo )
 297                     xCurrContext->endRecord( nRecId );
 298             }
 299         }
 300     }
 301     // close remaining contexts (missing context end records or stream error)
 302     while( !mxStack->empty() )
 303         mxStack->popContext();
 304     mxStack.reset();
 305
 306     // finish document
 307     mxHandler->endDocument();
 308
 309     maSource = RecordInputSource();
 310 }
 311
 312 const RecordInfo* RecordParser::getStartRecordInfo( sal_Int32 nRecId ) const
 313 {
 314     RecordInfoMap::const_iterator aIt = maStartMap.find( nRecId );
 315     return (aIt == maStartMap.end()) ? 0 : &aIt->second;
 316 }
 317
 318 const RecordInfo* RecordParser::getEndRecordInfo( sal_Int32 nRecId ) const
 319 {
 320     RecordInfoMap::const_iterator aIt = maEndMap.find( nRecId );
 321     return (aIt == maEndMap.end()) ? 0 : &aIt->second;
 322 }
 323
 324 } // namespace core
 325 } // namespace oox
 326
 327 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */