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