sc/source/ui/unoobj/tokenuno.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 "tokenuno.hxx"
  21
  22 #include <sal/macros.h>
  23
  24 #include <com/sun/star/sheet/ComplexReference.hpp>
  25 #include <com/sun/star/sheet/ExternalReference.hpp>
  26 #include <com/sun/star/sheet/ReferenceFlags.hpp>
  27 #include <com/sun/star/sheet/AddressConvention.hpp>
  28 #include <com/sun/star/sheet/NameToken.hpp>
  29 #include <com/sun/star/table/CellAddress.hpp>
  30
  31 #include <svl/itemprop.hxx>
  32 #include <vcl/svapp.hxx>
  33
  34 #include "miscuno.hxx"
  35 #include "convuno.hxx"
  36 #include "unonames.hxx"
  37 #include "token.hxx"
  38 #include "compiler.hxx"
  39 #include "tokenarray.hxx"
  40 #include "docsh.hxx"
  41 #include "rangeseq.hxx"
  42 #include "externalrefmgr.hxx"
  43
  44 using namespace ::formula;
  45 using namespace ::com::sun::star;
  46
  47 static const SfxItemPropertyMapEntry* lcl_GetFormulaParserMap()
  48 {
  49     static const SfxItemPropertyMapEntry aFormulaParserMap_Impl[] =
  50     {
  51         {OUString(SC_UNO_COMPILEFAP),           0,  cppu::UnoType<bool>::get(),                   0, 0 },
  52         {OUString(SC_UNO_COMPILEENGLISH),       0,  cppu::UnoType<bool>::get(),                   0, 0 },
  53         {OUString(SC_UNO_IGNORELEADING),        0,  cppu::UnoType<bool>::get(),                   0, 0 },
  54         {OUString(SC_UNO_FORMULACONVENTION),    0,  cppu::UnoType<decltype(sheet::AddressConvention::UNSPECIFIED)>::get(), 0, 0 },
  55         {OUString(SC_UNO_OPCODEMAP),            0,  cppu::UnoType<uno::Sequence< sheet::FormulaOpCodeMapEntry >>::get(), 0, 0 },
  56         { OUString(), 0, css::uno::Type(), 0, 0 }
  57     };
  58     return aFormulaParserMap_Impl;
  59 }
  60
  61 SC_SIMPLE_SERVICE_INFO( ScFormulaParserObj, "ScFormulaParserObj", SC_SERVICENAME_FORMULAPARS )
  62
  63 ScFormulaParserObj::ScFormulaParserObj(ScDocShell* pDocSh) :
  64     mpDocShell( pDocSh ),
  65     mnConv( sheet::AddressConvention::UNSPECIFIED ),
  66     mbEnglish( false ),
  67     mbIgnoreSpaces( true ),
  68     mbCompileFAP( false )
  69 {
  70     mpDocShell->GetDocument().AddUnoObject(*this);
  71 }
  72
  73 ScFormulaParserObj::~ScFormulaParserObj()
  74 {
  75     SolarMutexGuard g;
  76
  77     if (mpDocShell)
  78         mpDocShell->GetDocument().RemoveUnoObject(*this);
  79 }
  80
  81 void ScFormulaParserObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
  82 {
  83     const SfxSimpleHint* pSimpleHint = dynamic_cast<const SfxSimpleHint*>(&rHint);
  84     if ( pSimpleHint && pSimpleHint->GetId() == SFX_HINT_DYING )
  85         mpDocShell = NULL;
  86 }
  87
  88 // XFormulaParser
  89
  90 void ScFormulaParserObj::SetCompilerFlags( ScCompiler& rCompiler ) const
  91 {
  92     static const formula::FormulaGrammar::AddressConvention aConvMap[] = {
  93         formula::FormulaGrammar::CONV_OOO,        // <- AddressConvention::OOO
  94         formula::FormulaGrammar::CONV_XL_A1,      // <- AddressConvention::XL_A1
  95         formula::FormulaGrammar::CONV_XL_R1C1,    // <- AddressConvention::XL_R1C1
  96         formula::FormulaGrammar::CONV_XL_OOX,     // <- AddressConvention::XL_OOX
  97         formula::FormulaGrammar::CONV_LOTUS_A1    // <- AddressConvention::LOTUS_A1
  98     };
  99     static const sal_Int16 nConvMapCount = sizeof(aConvMap)/sizeof(aConvMap[0]);
 100
 101     // If mxOpCodeMap is not empty it overrides mbEnglish, and vice versa. We
 102     // don't need to initialize things twice.
 103     if (mxOpCodeMap.get())
 104         rCompiler.SetFormulaLanguage( mxOpCodeMap );
 105     else
 106     {
 107         sal_Int32 nFormulaLanguage = mbEnglish ?
 108             sheet::FormulaLanguage::ENGLISH :
 109             sheet::FormulaLanguage::NATIVE;
 110         ScCompiler::OpCodeMapPtr xMap = rCompiler.GetOpCodeMap( nFormulaLanguage);
 111         rCompiler.SetFormulaLanguage( xMap);
 112     }
 113
 114     formula::FormulaGrammar::AddressConvention eConv = formula::FormulaGrammar::CONV_UNSPECIFIED;
 115     if (mnConv >= 0 && mnConv < nConvMapCount)
 116         eConv = aConvMap[mnConv];
 117
 118     rCompiler.SetRefConvention( eConv );
 119     rCompiler.EnableJumpCommandReorder(!mbCompileFAP);
 120     rCompiler.EnableStopOnError(!mbCompileFAP);
 121
 122     rCompiler.SetExternalLinks( maExternalLinks);
 123 }
 124
 125 uno::Sequence<sheet::FormulaToken> SAL_CALL ScFormulaParserObj::parseFormula(
 126     const OUString& aFormula, const table::CellAddress& rReferencePos )
 127         throw (uno::RuntimeException, std::exception)
 128 {
 129     SolarMutexGuard aGuard;
 130     uno::Sequence<sheet::FormulaToken> aRet;
 131
 132     if (mpDocShell)
 133     {
 134         ScDocument& rDoc = mpDocShell->GetDocument();
 135         ScExternalRefManager::ApiGuard aExtRefGuard(&rDoc);
 136
 137         ScAddress aRefPos( ScAddress::UNINITIALIZED );
 138         ScUnoConversion::FillScAddress( aRefPos, rReferencePos );
 139         ScCompiler aCompiler( &rDoc, aRefPos);
 140         aCompiler.SetGrammar(rDoc.GetGrammar());
 141         SetCompilerFlags( aCompiler );
 142
 143         ScTokenArray* pCode = aCompiler.CompileString( aFormula );
 144         (void)ScTokenConversion::ConvertToTokenSequence( rDoc, aRet, *pCode );
 145         delete pCode;
 146     }
 147
 148     return aRet;
 149 }
 150
 151 OUString SAL_CALL ScFormulaParserObj::printFormula(
 152         const uno::Sequence<sheet::FormulaToken>& aTokens, const table::CellAddress& rReferencePos )
 153                                 throw (uno::RuntimeException, std::exception)
 154 {
 155     SolarMutexGuard aGuard;
 156     OUString aRet;
 157
 158     if (mpDocShell)
 159     {
 160         ScDocument& rDoc = mpDocShell->GetDocument();
 161         ScTokenArray aCode;
 162         (void)ScTokenConversion::ConvertToTokenArray( rDoc, aCode, aTokens );
 163         ScAddress aRefPos( ScAddress::UNINITIALIZED );
 164         ScUnoConversion::FillScAddress( aRefPos, rReferencePos );
 165         ScCompiler aCompiler( &rDoc, aRefPos, aCode);
 166         aCompiler.SetGrammar(rDoc.GetGrammar());
 167         SetCompilerFlags( aCompiler );
 168
 169         OUStringBuffer aBuffer;
 170         aCompiler.CreateStringFromTokenArray( aBuffer );
 171         aRet = aBuffer.makeStringAndClear();
 172     }
 173
 174     return aRet;
 175 }
 176
 177 // XPropertySet
 178
 179 uno::Reference<beans::XPropertySetInfo> SAL_CALL ScFormulaParserObj::getPropertySetInfo()
 180                                                         throw(uno::RuntimeException, std::exception)
 181 {
 182     SolarMutexGuard aGuard;
 183     static uno::Reference< beans::XPropertySetInfo > aRef(new SfxItemPropertySetInfo( lcl_GetFormulaParserMap() ));
 184     return aRef;
 185 }
 186
 187 void SAL_CALL ScFormulaParserObj::setPropertyValue(
 188                         const OUString& aPropertyName, const uno::Any& aValue )
 189                 throw(beans::UnknownPropertyException, beans::PropertyVetoException,
 190                         lang::IllegalArgumentException, lang::WrappedTargetException,
 191                         uno::RuntimeException, std::exception)
 192 {
 193     SolarMutexGuard aGuard;
 194     OUString aString(aPropertyName);
 195     if ( aString == SC_UNO_COMPILEFAP )
 196     {
 197         aValue >>= mbCompileFAP;
 198     }
 199     else if ( aString == SC_UNO_COMPILEENGLISH )
 200     {
 201         bool bOldEnglish = mbEnglish;
 202         if (aValue >>= mbEnglish)
 203         {
 204             // Need to recreate the symbol map to change English property
 205             // because the map is const. So for performance reasons set
 206             // CompileEnglish _before_ OpCodeMap!
 207             if (mxOpCodeMap.get() && mbEnglish != bOldEnglish)
 208             {
 209                 ScDocument& rDoc = mpDocShell->GetDocument();
 210                 ScCompiler aCompiler( &rDoc, ScAddress());
 211                 aCompiler.SetGrammar(rDoc.GetGrammar());
 212                 mxOpCodeMap = formula::FormulaCompiler::CreateOpCodeMap( maOpCodeMapping, mbEnglish);
 213             }
 214         }
 215         else
 216             throw lang::IllegalArgumentException();
 217     }
 218     else if ( aString == SC_UNO_FORMULACONVENTION )
 219     {
 220         aValue >>= mnConv;
 221     }
 222     else if ( aString == SC_UNO_IGNORELEADING )
 223     {
 224         aValue >>= mbIgnoreSpaces;
 225     }
 226     else if ( aString == SC_UNO_OPCODEMAP )
 227     {
 228         if (aValue >>= maOpCodeMapping)
 229         {
 230             ScDocument& rDoc = mpDocShell->GetDocument();
 231             ScCompiler aCompiler( &rDoc, ScAddress());
 232             aCompiler.SetGrammar(rDoc.GetGrammar());
 233             mxOpCodeMap = formula::FormulaCompiler::CreateOpCodeMap( maOpCodeMapping, mbEnglish);
 234         }
 235         else
 236             throw lang::IllegalArgumentException();
 237     }
 238     else if ( aString == SC_UNO_EXTERNALLINKS )
 239     {
 240         if (!(aValue >>= maExternalLinks))
 241             throw lang::IllegalArgumentException();
 242     }
 243     else
 244         throw beans::UnknownPropertyException();
 245 }
 246
 247 uno::Any SAL_CALL ScFormulaParserObj::getPropertyValue( const OUString& aPropertyName )
 248                 throw(beans::UnknownPropertyException, lang::WrappedTargetException,
 249                         uno::RuntimeException, std::exception)
 250 {
 251     SolarMutexGuard aGuard;
 252     uno::Any aRet;
 253     OUString aString(aPropertyName);
 254     if ( aString == SC_UNO_COMPILEFAP )
 255     {
 256         aRet <<= mbCompileFAP;
 257     }
 258     else if ( aString == SC_UNO_COMPILEENGLISH )
 259     {
 260         aRet <<= mbEnglish;
 261     }
 262     else if ( aString == SC_UNO_FORMULACONVENTION )
 263     {
 264         aRet <<= mnConv;
 265     }
 266     else if ( aString == SC_UNO_IGNORELEADING )
 267     {
 268         aRet <<= mbIgnoreSpaces;
 269     }
 270     else if ( aString == SC_UNO_OPCODEMAP )
 271     {
 272         aRet <<= maOpCodeMapping;
 273     }
 274     else if ( aString == SC_UNO_EXTERNALLINKS )
 275     {
 276         aRet <<= maExternalLinks;
 277     }
 278     else
 279         throw beans::UnknownPropertyException();
 280     return aRet;
 281 }
 282
 283 SC_IMPL_DUMMY_PROPERTY_LISTENER( ScFormulaParserObj )
 284
 285 static void lcl_ExternalRefToApi( sheet::SingleReference& rAPI, const ScSingleRefData& rRef )
 286 {
 287     rAPI.Column         = 0;
 288     rAPI.Row            = 0;
 289     rAPI.Sheet          = 0;
 290     rAPI.RelativeColumn = 0;
 291     rAPI.RelativeRow    = 0;
 292     rAPI.RelativeSheet  = 0;
 293
 294     sal_Int32 nFlags = 0;
 295     if ( rRef.IsColRel() )
 296     {
 297         nFlags |= sheet::ReferenceFlags::COLUMN_RELATIVE;
 298         rAPI.RelativeColumn = rRef.Col();
 299     }
 300     else
 301         rAPI.Column = rRef.Col();
 302
 303     if ( rRef.IsRowRel() )
 304     {
 305         nFlags |= sheet::ReferenceFlags::ROW_RELATIVE;
 306         rAPI.RelativeRow = rRef.Row();
 307     }
 308     else
 309         rAPI.Row = rRef.Row();
 310
 311     if ( rRef.IsColDeleted() ) nFlags |= sheet::ReferenceFlags::COLUMN_DELETED;
 312     if ( rRef.IsRowDeleted() ) nFlags |= sheet::ReferenceFlags::ROW_DELETED;
 313     if ( rRef.IsFlag3D() )     nFlags |= sheet::ReferenceFlags::SHEET_3D;
 314     if ( rRef.IsRelName() )    nFlags |= sheet::ReferenceFlags::RELATIVE_NAME;
 315     rAPI.Flags = nFlags;
 316 }
 317
 318 static void lcl_SingleRefToApi( sheet::SingleReference& rAPI, const ScSingleRefData& rRef )
 319 {
 320     sal_Int32 nFlags = 0;
 321     if ( rRef.IsColRel() )
 322     {
 323         nFlags |= sheet::ReferenceFlags::COLUMN_RELATIVE;
 324         rAPI.RelativeColumn = rRef.Col();
 325         rAPI.Column = 0;
 326     }
 327     else
 328     {
 329         rAPI.RelativeColumn = 0;
 330         rAPI.Column = rRef.Col();
 331     }
 332
 333     if ( rRef.IsRowRel() )
 334     {
 335         nFlags |= sheet::ReferenceFlags::ROW_RELATIVE;
 336         rAPI.RelativeRow = rRef.Row();
 337         rAPI.Row = 0;
 338     }
 339     else
 340     {
 341         rAPI.RelativeRow = 0;
 342         rAPI.Row = rRef.Row();
 343     }
 344
 345     if ( rRef.IsTabRel() )
 346     {
 347         nFlags |= sheet::ReferenceFlags::SHEET_RELATIVE;
 348         rAPI.RelativeSheet = rRef.Tab();
 349         rAPI.Sheet = 0;
 350     }
 351     else
 352     {
 353         rAPI.RelativeSheet = 0;
 354         rAPI.Sheet = rRef.Tab();
 355     }
 356
 357     if ( rRef.IsColDeleted() ) nFlags |= sheet::ReferenceFlags::COLUMN_DELETED;
 358     if ( rRef.IsRowDeleted() ) nFlags |= sheet::ReferenceFlags::ROW_DELETED;
 359     if ( rRef.IsTabDeleted() ) nFlags |= sheet::ReferenceFlags::SHEET_DELETED;
 360     if ( rRef.IsFlag3D() )     nFlags |= sheet::ReferenceFlags::SHEET_3D;
 361     if ( rRef.IsRelName() )    nFlags |= sheet::ReferenceFlags::RELATIVE_NAME;
 362     rAPI.Flags = nFlags;
 363 }
 364
 365 bool ScTokenConversion::ConvertToTokenArray( ScDocument& rDoc,
 366         ScTokenArray& rTokenArray, const uno::Sequence<sheet::FormulaToken>& rSequence )
 367 {
 368     return !rTokenArray.Fill(rSequence, rDoc.GetSharedStringPool(), rDoc.GetExternalRefManager());
 369 }
 370
 371 bool ScTokenConversion::ConvertToTokenSequence( const ScDocument& rDoc,
 372         uno::Sequence<sheet::FormulaToken>& rSequence, const ScTokenArray& rTokenArray )
 373 {
 374     bool bError = false;
 375
 376     sal_Int32 nLen = static_cast<sal_Int32>(rTokenArray.GetLen());
 377     formula::FormulaToken** pTokens = rTokenArray.GetArray();
 378     if ( pTokens )
 379     {
 380         rSequence.realloc(nLen);
 381         for (sal_Int32 nPos=0; nPos<nLen; nPos++)
 382         {
 383             const formula::FormulaToken& rToken = *pTokens[nPos];
 384             sheet::FormulaToken& rAPI = rSequence[nPos];
 385
 386             OpCode eOpCode = rToken.GetOpCode();
 387             // eOpCode may be changed in the following switch/case
 388             switch ( rToken.GetType() )
 389             {
 390                 case svByte:
 391                     // Only the count of spaces is stored as "long". Parameter count is ignored.
 392                     if ( eOpCode == ocSpaces )
 393                         rAPI.Data <<= (sal_Int32) rToken.GetByte();
 394                     else
 395                         rAPI.Data.clear();      // no data
 396                     break;
 397                 case formula::svDouble:
 398                     rAPI.Data <<= rToken.GetDouble();
 399                     break;
 400                 case formula::svString:
 401                     rAPI.Data <<= rToken.GetString().getString();
 402                     break;
 403                 case svExternal:
 404                     // Function name is stored as string.
 405                     // Byte (parameter count) is ignored.
 406                     rAPI.Data <<= OUString( rToken.GetExternal() );
 407                     break;
 408                 case svSingleRef:
 409                     {
 410                         sheet::SingleReference aSingleRef;
 411                         lcl_SingleRefToApi( aSingleRef, *rToken.GetSingleRef() );
 412                         rAPI.Data <<= aSingleRef;
 413                     }
 414                     break;
 415                 case formula::svDoubleRef:
 416                     {
 417                         sheet::ComplexReference aCompRef;
 418                         lcl_SingleRefToApi( aCompRef.Reference1, *rToken.GetSingleRef() );
 419                         lcl_SingleRefToApi( aCompRef.Reference2, *rToken.GetSingleRef2() );
 420                         rAPI.Data <<= aCompRef;
 421                     }
 422                     break;
 423                 case svIndex:
 424                     {
 425                         sheet::NameToken aNameToken;
 426                         aNameToken.Index = static_cast<sal_Int32>( rToken.GetIndex() );
 427                         aNameToken.Global = rToken.IsGlobal();
 428                         rAPI.Data <<= aNameToken;
 429                     }
 430                     break;
 431                 case svMatrix:
 432                     if (!ScRangeToSequence::FillMixedArray( rAPI.Data, rToken.GetMatrix(), true))
 433                         rAPI.Data.clear();
 434                     break;
 435                 case svExternalSingleRef:
 436                     {
 437                         sheet::SingleReference aSingleRef;
 438                         lcl_ExternalRefToApi( aSingleRef, *rToken.GetSingleRef() );
 439                         size_t nCacheId;
 440                         rDoc.GetExternalRefManager()->getCacheTable(
 441                             rToken.GetIndex(), rToken.GetString().getString(), false, &nCacheId);
 442                         aSingleRef.Sheet = static_cast< sal_Int32 >( nCacheId );
 443                         sheet::ExternalReference aExtRef;
 444                         aExtRef.Index = rToken.GetIndex();
 445                         aExtRef.Reference <<= aSingleRef;
 446                         rAPI.Data <<= aExtRef;
 447                         eOpCode = ocPush;
 448                     }
 449                     break;
 450                 case svExternalDoubleRef:
 451                     {
 452                         sheet::ComplexReference aComplRef;
 453                         lcl_ExternalRefToApi( aComplRef.Reference1, *rToken.GetSingleRef() );
 454                         lcl_ExternalRefToApi( aComplRef.Reference2, *rToken.GetSingleRef2() );
 455                         size_t nCacheId;
 456                         rDoc.GetExternalRefManager()->getCacheTable(
 457                             rToken.GetIndex(), rToken.GetString().getString(), false, &nCacheId);
 458                         aComplRef.Reference1.Sheet = static_cast< sal_Int32 >( nCacheId );
 459                         // NOTE: This assumes that cached sheets are in consecutive order!
 460                         aComplRef.Reference2.Sheet =
 461                             aComplRef.Reference1.Sheet +
 462                             (rToken.GetSingleRef2()->Tab() - rToken.GetSingleRef()->Tab());
 463                         sheet::ExternalReference aExtRef;
 464                         aExtRef.Index = rToken.GetIndex();
 465                         aExtRef.Reference <<= aComplRef;
 466                         rAPI.Data <<= aExtRef;
 467                         eOpCode = ocPush;
 468                     }
 469                     break;
 470                 case svExternalName:
 471                     {
 472                         sheet::ExternalReference aExtRef;
 473                         aExtRef.Index = rToken.GetIndex();
 474                         aExtRef.Reference <<= rToken.GetString().getString();
 475                         rAPI.Data <<= aExtRef;
 476                         eOpCode = ocPush;
 477                     }
 478                     break;
 479                 default:
 480                     OSL_TRACE( "ScTokenConversion::ConvertToTokenSequence: unhandled token type SvStackVar %d", rToken.GetType());
 481                     //fall-through
 482                 case svSep:     // occurs with ocSep, ocOpen, ocClose, ocArray*
 483                 case svJump:    // occurs with ocIf, ocChoose
 484                 case svMissing: // occurs with ocMissing
 485                     rAPI.Data.clear();      // no data
 486             }
 487             rAPI.OpCode = static_cast<sal_Int32>(eOpCode);      //! assuming equal values for the moment
 488         }
 489     }
 490     else
 491         rSequence.realloc(0);
 492
 493     return !bError;
 494 }
 495
 496 ScFormulaOpCodeMapperObj::ScFormulaOpCodeMapperObj(::std::unique_ptr<formula::FormulaCompiler> && _pCompiler)
 497 : formula::FormulaOpCodeMapperObj(std::move(_pCompiler))
 498 {
 499 }
 500
 501 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */