555 lines
21 KiB
C++
555 lines
21 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
* This file is part of the LibreOffice project.
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* This file incorporates work covered by the following license notice:
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed
|
|
* with this work for additional information regarding copyright
|
|
* ownership. The ASF licenses this file to you under the Apache
|
|
* License, Version 2.0 (the "License"); you may not use this file
|
|
* except in compliance with the License. You may obtain a copy of
|
|
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
|
|
*/
|
|
|
|
#include <memory>
|
|
#include <tokenuno.hxx>
|
|
|
|
#include <sal/macros.h>
|
|
#include <sal/log.hxx>
|
|
|
|
#include <com/sun/star/sheet/ComplexReference.hpp>
|
|
#include <com/sun/star/sheet/ExternalReference.hpp>
|
|
#include <com/sun/star/sheet/ReferenceFlags.hpp>
|
|
#include <com/sun/star/sheet/AddressConvention.hpp>
|
|
#include <com/sun/star/sheet/NameToken.hpp>
|
|
#include <com/sun/star/sheet/TableRefToken.hpp>
|
|
#include <com/sun/star/table/CellAddress.hpp>
|
|
|
|
#include <svl/itemprop.hxx>
|
|
#include <vcl/svapp.hxx>
|
|
#include <comphelper/string.hxx>
|
|
|
|
#include <miscuno.hxx>
|
|
#include <convuno.hxx>
|
|
#include <unonames.hxx>
|
|
#include <compiler.hxx>
|
|
#include <tokenarray.hxx>
|
|
#include <docsh.hxx>
|
|
#include <rangeseq.hxx>
|
|
#include <externalrefmgr.hxx>
|
|
|
|
using namespace ::formula;
|
|
using namespace ::com::sun::star;
|
|
|
|
static std::span<const SfxItemPropertyMapEntry> lcl_GetFormulaParserMap()
|
|
{
|
|
static const SfxItemPropertyMapEntry aFormulaParserMap_Impl[] =
|
|
{
|
|
{ SC_UNO_COMPILEFAP, 0, cppu::UnoType<bool>::get(), 0, 0 },
|
|
{ SC_UNO_COMPILEENGLISH, 0, cppu::UnoType<bool>::get(), 0, 0 },
|
|
{ SC_UNO_IGNORELEADING, 0, cppu::UnoType<bool>::get(), 0, 0 },
|
|
{ SC_UNO_FORMULACONVENTION, 0, cppu::UnoType<decltype(sheet::AddressConvention::UNSPECIFIED)>::get(), 0, 0 },
|
|
{ SC_UNO_OPCODEMAP, 0, cppu::UnoType<uno::Sequence< sheet::FormulaOpCodeMapEntry >>::get(), 0, 0 },
|
|
};
|
|
return aFormulaParserMap_Impl;
|
|
}
|
|
|
|
const formula::FormulaGrammar::AddressConvention aConvMap[] = {
|
|
formula::FormulaGrammar::CONV_OOO, // <- AddressConvention::OOO
|
|
formula::FormulaGrammar::CONV_XL_A1, // <- AddressConvention::XL_A1
|
|
formula::FormulaGrammar::CONV_XL_R1C1, // <- AddressConvention::XL_R1C1
|
|
formula::FormulaGrammar::CONV_XL_OOX, // <- AddressConvention::XL_OOX
|
|
formula::FormulaGrammar::CONV_LOTUS_A1 // <- AddressConvention::LOTUS_A1
|
|
};
|
|
// sal_Int16 because of comparison of integer expressions below.
|
|
constexpr sal_Int16 nConvMapCount = SAL_N_ELEMENTS(aConvMap);
|
|
|
|
|
|
SC_SIMPLE_SERVICE_INFO( ScFormulaParserObj, u"ScFormulaParserObj"_ustr, SC_SERVICENAME_FORMULAPARS )
|
|
|
|
ScFormulaParserObj::ScFormulaParserObj(ScDocShell* pDocSh) :
|
|
mpDocShell( pDocSh ),
|
|
mnConv( sheet::AddressConvention::UNSPECIFIED ),
|
|
mbEnglish( false ),
|
|
mbIgnoreSpaces( true ),
|
|
mbCompileFAP( false ),
|
|
mbRefConventionChartOOXML( false )
|
|
{
|
|
mpDocShell->GetDocument().AddUnoObject(*this);
|
|
}
|
|
|
|
ScFormulaParserObj::~ScFormulaParserObj()
|
|
{
|
|
SolarMutexGuard g;
|
|
|
|
if (mpDocShell)
|
|
mpDocShell->GetDocument().RemoveUnoObject(*this);
|
|
}
|
|
|
|
void ScFormulaParserObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
|
|
{
|
|
if ( rHint.GetId() == SfxHintId::Dying )
|
|
mpDocShell = nullptr;
|
|
}
|
|
|
|
// XFormulaParser
|
|
|
|
void ScFormulaParserObj::SetCompilerFlags( ScCompiler& rCompiler ) const
|
|
{
|
|
formula::FormulaGrammar::AddressConvention eConv = formula::FormulaGrammar::CONV_UNSPECIFIED;
|
|
if (mnConv >= 0 && mnConv < nConvMapCount)
|
|
eConv = aConvMap[mnConv];
|
|
|
|
// If mxOpCodeMap is not empty it overrides mbEnglish, and vice versa. We
|
|
// don't need to initialize things twice.
|
|
if (mxOpCodeMap)
|
|
rCompiler.SetFormulaLanguage( mxOpCodeMap );
|
|
else
|
|
{
|
|
const sal_Int32 nFormulaLanguage = (eConv == formula::FormulaGrammar::CONV_XL_OOX ?
|
|
sheet::FormulaLanguage::OOXML :
|
|
(mbEnglish ? sheet::FormulaLanguage::ENGLISH : sheet::FormulaLanguage::NATIVE));
|
|
ScCompiler::OpCodeMapPtr xMap = rCompiler.GetOpCodeMap( nFormulaLanguage);
|
|
rCompiler.SetFormulaLanguage( xMap);
|
|
}
|
|
|
|
rCompiler.SetRefConvention( eConv );
|
|
rCompiler.EnableJumpCommandReorder(!mbCompileFAP);
|
|
rCompiler.EnableStopOnError(!mbCompileFAP);
|
|
|
|
rCompiler.SetExternalLinks(maExternalLinks);
|
|
rCompiler.SetRefConventionChartOOXML(mbRefConventionChartOOXML);
|
|
}
|
|
|
|
uno::Sequence<sheet::FormulaToken> SAL_CALL ScFormulaParserObj::parseFormula(
|
|
const OUString& aFormula, const table::CellAddress& rReferencePos )
|
|
{
|
|
SolarMutexGuard aGuard;
|
|
uno::Sequence<sheet::FormulaToken> aRet;
|
|
|
|
if (mpDocShell)
|
|
{
|
|
ScDocument& rDoc = mpDocShell->GetDocument();
|
|
ScExternalRefManager::ApiGuard aExtRefGuard(rDoc);
|
|
|
|
ScAddress aRefPos( ScAddress::UNINITIALIZED );
|
|
ScUnoConversion::FillScAddress( aRefPos, rReferencePos );
|
|
ScCompiler aCompiler( rDoc, aRefPos, rDoc.GetGrammar());
|
|
SetCompilerFlags( aCompiler );
|
|
|
|
std::unique_ptr<ScTokenArray> pCode = aCompiler.CompileString( aFormula );
|
|
if (pCode->HasOpCode(ocTableRef))
|
|
{
|
|
FormulaError nErr = pCode->GetCodeError();
|
|
aCompiler.EnableJumpCommandReorder(true);
|
|
aCompiler.CompileTokenArray(); // needed for corresponding inner reference
|
|
pCode->DelRPN(); // can be discarded
|
|
pCode->SetCodeError(nErr); // reset to parsing error, if any
|
|
}
|
|
ScTokenConversion::ConvertToTokenSequence( rDoc, aRet, *pCode );
|
|
}
|
|
|
|
return aRet;
|
|
}
|
|
|
|
OUString SAL_CALL ScFormulaParserObj::printFormula(
|
|
const uno::Sequence<sheet::FormulaToken>& aTokens, const table::CellAddress& rReferencePos )
|
|
{
|
|
SolarMutexGuard aGuard;
|
|
OUString aRet;
|
|
|
|
if (mpDocShell)
|
|
{
|
|
ScDocument& rDoc = mpDocShell->GetDocument();
|
|
ScTokenArray aCode(rDoc);
|
|
(void)ScTokenConversion::ConvertToTokenArray( rDoc, aCode, aTokens );
|
|
ScAddress aRefPos( ScAddress::UNINITIALIZED );
|
|
ScUnoConversion::FillScAddress( aRefPos, rReferencePos );
|
|
ScCompiler aCompiler(rDoc, aRefPos, aCode, rDoc.GetGrammar());
|
|
SetCompilerFlags( aCompiler );
|
|
|
|
OUStringBuffer aBuffer;
|
|
aCompiler.CreateStringFromTokenArray( aBuffer );
|
|
aRet = aBuffer.makeStringAndClear();
|
|
}
|
|
|
|
return aRet;
|
|
}
|
|
|
|
// XPropertySet
|
|
|
|
uno::Reference<beans::XPropertySetInfo> SAL_CALL ScFormulaParserObj::getPropertySetInfo()
|
|
{
|
|
static uno::Reference< beans::XPropertySetInfo > aRef(new SfxItemPropertySetInfo( lcl_GetFormulaParserMap() ));
|
|
return aRef;
|
|
}
|
|
|
|
void SAL_CALL ScFormulaParserObj::setPropertyValue(
|
|
const OUString& aPropertyName, const uno::Any& aValue )
|
|
{
|
|
SolarMutexGuard aGuard;
|
|
if ( aPropertyName == SC_UNO_COMPILEFAP )
|
|
{
|
|
aValue >>= mbCompileFAP;
|
|
}
|
|
else if ( aPropertyName == SC_UNO_COMPILEENGLISH )
|
|
{
|
|
bool bOldEnglish = mbEnglish;
|
|
if (!(aValue >>= mbEnglish))
|
|
throw lang::IllegalArgumentException();
|
|
|
|
// Need to recreate the symbol map to change English property
|
|
// because the map is const. So for performance reasons set
|
|
// CompileEnglish _before_ OpCodeMap!
|
|
if (mxOpCodeMap && mbEnglish != bOldEnglish)
|
|
{
|
|
mxOpCodeMap = formula::FormulaCompiler::CreateOpCodeMap( maOpCodeMapping, mbEnglish);
|
|
}
|
|
|
|
}
|
|
else if ( aPropertyName == SC_UNO_FORMULACONVENTION )
|
|
{
|
|
aValue >>= mnConv;
|
|
|
|
bool bOldEnglish = mbEnglish;
|
|
if (mnConv >= 0 && mnConv < nConvMapCount
|
|
&& aConvMap[mnConv] == formula::FormulaGrammar::CONV_XL_OOX)
|
|
mbEnglish = true;
|
|
|
|
// Same as for SC_UNO_COMPILEENGLISH, though an OpCodeMap should not
|
|
// had been set for CONV_XL_OOX.
|
|
if (mxOpCodeMap && mbEnglish != bOldEnglish)
|
|
{
|
|
mxOpCodeMap = formula::FormulaCompiler::CreateOpCodeMap( maOpCodeMapping, mbEnglish);
|
|
}
|
|
}
|
|
else if ( aPropertyName == SC_UNO_IGNORELEADING )
|
|
{
|
|
aValue >>= mbIgnoreSpaces;
|
|
}
|
|
else if ( aPropertyName == SC_UNO_OPCODEMAP )
|
|
{
|
|
if (!(aValue >>= maOpCodeMapping))
|
|
throw lang::IllegalArgumentException();
|
|
|
|
mxOpCodeMap = formula::FormulaCompiler::CreateOpCodeMap( maOpCodeMapping, mbEnglish);
|
|
|
|
}
|
|
else if ( aPropertyName == SC_UNO_EXTERNALLINKS )
|
|
{
|
|
if (!(aValue >>= maExternalLinks))
|
|
throw lang::IllegalArgumentException();
|
|
}
|
|
else if ( aPropertyName == SC_UNO_REF_CONV_CHARTOOXML )
|
|
{
|
|
if (!(aValue >>= mbRefConventionChartOOXML))
|
|
throw lang::IllegalArgumentException();
|
|
}
|
|
else
|
|
throw beans::UnknownPropertyException(aPropertyName);
|
|
}
|
|
|
|
uno::Any SAL_CALL ScFormulaParserObj::getPropertyValue( const OUString& aPropertyName )
|
|
{
|
|
SolarMutexGuard aGuard;
|
|
uno::Any aRet;
|
|
if ( aPropertyName == SC_UNO_COMPILEFAP )
|
|
{
|
|
aRet <<= mbCompileFAP;
|
|
}
|
|
else if ( aPropertyName == SC_UNO_COMPILEENGLISH )
|
|
{
|
|
aRet <<= mbEnglish;
|
|
}
|
|
else if ( aPropertyName == SC_UNO_FORMULACONVENTION )
|
|
{
|
|
aRet <<= mnConv;
|
|
}
|
|
else if ( aPropertyName == SC_UNO_IGNORELEADING )
|
|
{
|
|
aRet <<= mbIgnoreSpaces;
|
|
}
|
|
else if ( aPropertyName == SC_UNO_OPCODEMAP )
|
|
{
|
|
aRet <<= maOpCodeMapping;
|
|
}
|
|
else if ( aPropertyName == SC_UNO_EXTERNALLINKS )
|
|
{
|
|
aRet <<= maExternalLinks;
|
|
}
|
|
else if ( aPropertyName == SC_UNO_REF_CONV_CHARTOOXML )
|
|
{
|
|
aRet <<= mbRefConventionChartOOXML;
|
|
}
|
|
else
|
|
throw beans::UnknownPropertyException(aPropertyName);
|
|
return aRet;
|
|
}
|
|
|
|
SC_IMPL_DUMMY_PROPERTY_LISTENER( ScFormulaParserObj )
|
|
|
|
static void lcl_ExternalRefToApi( sheet::SingleReference& rAPI, const ScSingleRefData& rRef )
|
|
{
|
|
rAPI.Column = 0;
|
|
rAPI.Row = 0;
|
|
rAPI.Sheet = 0;
|
|
rAPI.RelativeColumn = 0;
|
|
rAPI.RelativeRow = 0;
|
|
rAPI.RelativeSheet = 0;
|
|
|
|
sal_Int32 nFlags = 0;
|
|
if ( rRef.IsColRel() )
|
|
{
|
|
nFlags |= sheet::ReferenceFlags::COLUMN_RELATIVE;
|
|
rAPI.RelativeColumn = rRef.Col();
|
|
}
|
|
else
|
|
rAPI.Column = rRef.Col();
|
|
|
|
if ( rRef.IsRowRel() )
|
|
{
|
|
nFlags |= sheet::ReferenceFlags::ROW_RELATIVE;
|
|
rAPI.RelativeRow = rRef.Row();
|
|
}
|
|
else
|
|
rAPI.Row = rRef.Row();
|
|
|
|
if ( rRef.IsColDeleted() ) nFlags |= sheet::ReferenceFlags::COLUMN_DELETED;
|
|
if ( rRef.IsRowDeleted() ) nFlags |= sheet::ReferenceFlags::ROW_DELETED;
|
|
if ( rRef.IsFlag3D() ) nFlags |= sheet::ReferenceFlags::SHEET_3D;
|
|
if ( rRef.IsRelName() ) nFlags |= sheet::ReferenceFlags::RELATIVE_NAME;
|
|
rAPI.Flags = nFlags;
|
|
}
|
|
|
|
static void lcl_SingleRefToApi( sheet::SingleReference& rAPI, const ScSingleRefData& rRef )
|
|
{
|
|
sal_Int32 nFlags = 0;
|
|
if ( rRef.IsColRel() )
|
|
{
|
|
nFlags |= sheet::ReferenceFlags::COLUMN_RELATIVE;
|
|
rAPI.RelativeColumn = rRef.Col();
|
|
rAPI.Column = 0;
|
|
}
|
|
else
|
|
{
|
|
rAPI.RelativeColumn = 0;
|
|
rAPI.Column = rRef.Col();
|
|
}
|
|
|
|
if ( rRef.IsRowRel() )
|
|
{
|
|
nFlags |= sheet::ReferenceFlags::ROW_RELATIVE;
|
|
rAPI.RelativeRow = rRef.Row();
|
|
rAPI.Row = 0;
|
|
}
|
|
else
|
|
{
|
|
rAPI.RelativeRow = 0;
|
|
rAPI.Row = rRef.Row();
|
|
}
|
|
|
|
if ( rRef.IsTabRel() )
|
|
{
|
|
nFlags |= sheet::ReferenceFlags::SHEET_RELATIVE;
|
|
rAPI.RelativeSheet = rRef.Tab();
|
|
rAPI.Sheet = 0;
|
|
}
|
|
else
|
|
{
|
|
rAPI.RelativeSheet = 0;
|
|
rAPI.Sheet = rRef.Tab();
|
|
}
|
|
|
|
if ( rRef.IsColDeleted() ) nFlags |= sheet::ReferenceFlags::COLUMN_DELETED;
|
|
if ( rRef.IsRowDeleted() ) nFlags |= sheet::ReferenceFlags::ROW_DELETED;
|
|
if ( rRef.IsTabDeleted() ) nFlags |= sheet::ReferenceFlags::SHEET_DELETED;
|
|
if ( rRef.IsFlag3D() ) nFlags |= sheet::ReferenceFlags::SHEET_3D;
|
|
if ( rRef.IsRelName() ) nFlags |= sheet::ReferenceFlags::RELATIVE_NAME;
|
|
rAPI.Flags = nFlags;
|
|
}
|
|
|
|
bool ScTokenConversion::ConvertToTokenArray( ScDocument& rDoc,
|
|
ScTokenArray& rTokenArray, const uno::Sequence<sheet::FormulaToken>& rSequence )
|
|
{
|
|
return !rTokenArray.Fill(rSequence, rDoc.GetSharedStringPool(), rDoc.GetExternalRefManager());
|
|
}
|
|
|
|
void ScTokenConversion::ConvertToTokenSequence( const ScDocument& rDoc,
|
|
uno::Sequence<sheet::FormulaToken>& rSequence, const ScTokenArray& rTokenArray,
|
|
bool bIgnoreTableRefNoInnerReference )
|
|
{
|
|
sal_Int32 nLen = static_cast<sal_Int32>(rTokenArray.GetLen());
|
|
formula::FormulaToken** pTokens = rTokenArray.GetArray();
|
|
if ( pTokens )
|
|
{
|
|
rSequence.realloc(nLen);
|
|
auto pSequence = rSequence.getArray();
|
|
for (sal_Int32 nPos=0; nPos<nLen; nPos++)
|
|
{
|
|
const formula::FormulaToken& rToken = *pTokens[nPos];
|
|
sheet::FormulaToken& rAPI = pSequence[nPos];
|
|
|
|
OpCode eOpCode = rToken.GetOpCode();
|
|
// eOpCode may be changed in the following switch/case
|
|
switch ( rToken.GetType() )
|
|
{
|
|
case svByte:
|
|
// Only the count of spaces is stored as "long". Parameter count is ignored.
|
|
if ( eOpCode == ocSpaces )
|
|
rAPI.Data <<= static_cast<sal_Int32>(rToken.GetByte());
|
|
else if (eOpCode == ocWhitespace)
|
|
{
|
|
// Convention is one character repeated.
|
|
if (rToken.GetByte() == 1)
|
|
rAPI.Data <<= OUString( rToken.GetChar());
|
|
else
|
|
{
|
|
OUStringBuffer aBuf( rToken.GetByte());
|
|
comphelper::string::padToLength( aBuf, rToken.GetByte(), rToken.GetChar());
|
|
rAPI.Data <<= aBuf.makeStringAndClear();
|
|
}
|
|
}
|
|
else
|
|
rAPI.Data.clear(); // no data
|
|
break;
|
|
case formula::svDouble:
|
|
rAPI.Data <<= rToken.GetDouble();
|
|
break;
|
|
case formula::svString:
|
|
rAPI.Data <<= rToken.GetString().getString();
|
|
break;
|
|
case svExternal:
|
|
// Function name is stored as string.
|
|
// Byte (parameter count) is ignored.
|
|
rAPI.Data <<= rToken.GetExternal();
|
|
break;
|
|
case svSingleRef:
|
|
{
|
|
sheet::SingleReference aSingleRef;
|
|
lcl_SingleRefToApi( aSingleRef, *rToken.GetSingleRef() );
|
|
rAPI.Data <<= aSingleRef;
|
|
}
|
|
break;
|
|
case formula::svDoubleRef:
|
|
{
|
|
sheet::ComplexReference aCompRef;
|
|
lcl_SingleRefToApi( aCompRef.Reference1, *rToken.GetSingleRef() );
|
|
lcl_SingleRefToApi( aCompRef.Reference2, *rToken.GetSingleRef2() );
|
|
rAPI.Data <<= aCompRef;
|
|
}
|
|
break;
|
|
case svIndex:
|
|
{
|
|
const ScTableRefToken* pTR;
|
|
if (rToken.GetOpCode() == ocTableRef && (pTR = dynamic_cast<const ScTableRefToken*>(&rToken)))
|
|
{
|
|
sheet::TableRefToken aTableRefToken;
|
|
aTableRefToken.Index = static_cast<sal_Int32>( pTR->GetIndex());
|
|
aTableRefToken.Item = static_cast<sal_Int16>( pTR->GetItem());
|
|
const FormulaToken* pRef = pTR->GetAreaRefRPN();
|
|
assert((pRef || bIgnoreTableRefNoInnerReference)
|
|
&& "something forgot to create RPN for ocTableRef inner reference");
|
|
(void)bIgnoreTableRefNoInnerReference;
|
|
if (pRef)
|
|
{
|
|
switch (pRef->GetType())
|
|
{
|
|
case svSingleRef:
|
|
lcl_SingleRefToApi( aTableRefToken.Reference.Reference1, *pRef->GetSingleRef());
|
|
aTableRefToken.Reference.Reference2 = aTableRefToken.Reference.Reference1;
|
|
break;
|
|
case svDoubleRef:
|
|
lcl_SingleRefToApi( aTableRefToken.Reference.Reference1, *pRef->GetSingleRef());
|
|
lcl_SingleRefToApi( aTableRefToken.Reference.Reference2, *pRef->GetSingleRef2());
|
|
break;
|
|
default:
|
|
; // nothing
|
|
}
|
|
}
|
|
rAPI.Data <<= aTableRefToken;
|
|
}
|
|
else
|
|
{
|
|
sheet::NameToken aNameToken;
|
|
aNameToken.Index = static_cast<sal_Int32>( rToken.GetIndex() );
|
|
aNameToken.Sheet = rToken.GetSheet();
|
|
rAPI.Data <<= aNameToken;
|
|
}
|
|
}
|
|
break;
|
|
case svMatrix:
|
|
if (!ScRangeToSequence::FillMixedArray( rAPI.Data, rToken.GetMatrix(), true))
|
|
rAPI.Data.clear();
|
|
break;
|
|
case svExternalSingleRef:
|
|
{
|
|
sheet::SingleReference aSingleRef;
|
|
lcl_ExternalRefToApi( aSingleRef, *rToken.GetSingleRef() );
|
|
size_t nCacheId;
|
|
rDoc.GetExternalRefManager()->getCacheTable(
|
|
rToken.GetIndex(), rToken.GetString().getString(), false, &nCacheId);
|
|
aSingleRef.Sheet = static_cast< sal_Int32 >( nCacheId );
|
|
sheet::ExternalReference aExtRef;
|
|
aExtRef.Index = rToken.GetIndex();
|
|
aExtRef.Reference <<= aSingleRef;
|
|
rAPI.Data <<= aExtRef;
|
|
eOpCode = ocPush;
|
|
}
|
|
break;
|
|
case svExternalDoubleRef:
|
|
{
|
|
sheet::ComplexReference aComplRef;
|
|
lcl_ExternalRefToApi( aComplRef.Reference1, *rToken.GetSingleRef() );
|
|
lcl_ExternalRefToApi( aComplRef.Reference2, *rToken.GetSingleRef2() );
|
|
size_t nCacheId;
|
|
rDoc.GetExternalRefManager()->getCacheTable(
|
|
rToken.GetIndex(), rToken.GetString().getString(), false, &nCacheId);
|
|
aComplRef.Reference1.Sheet = static_cast< sal_Int32 >( nCacheId );
|
|
// NOTE: This assumes that cached sheets are in consecutive order!
|
|
aComplRef.Reference2.Sheet =
|
|
aComplRef.Reference1.Sheet +
|
|
(rToken.GetSingleRef2()->Tab() - rToken.GetSingleRef()->Tab());
|
|
sheet::ExternalReference aExtRef;
|
|
aExtRef.Index = rToken.GetIndex();
|
|
aExtRef.Reference <<= aComplRef;
|
|
rAPI.Data <<= aExtRef;
|
|
eOpCode = ocPush;
|
|
}
|
|
break;
|
|
case svExternalName:
|
|
{
|
|
sheet::ExternalReference aExtRef;
|
|
aExtRef.Index = rToken.GetIndex();
|
|
aExtRef.Reference <<= rToken.GetString().getString();
|
|
rAPI.Data <<= aExtRef;
|
|
eOpCode = ocPush;
|
|
}
|
|
break;
|
|
default:
|
|
SAL_WARN("sc", "ScTokenConversion::ConvertToTokenSequence: unhandled token type " << StackVarEnumToString(rToken.GetType()));
|
|
[[fallthrough]];
|
|
case svJump: // occurs with ocIf, ocChoose
|
|
case svError: // seems to be fairly common, and probably not exceptional and not worth a warning?
|
|
case svMissing: // occurs with ocMissing
|
|
case svSep: // occurs with ocSep, ocOpen, ocClose, ocArray*
|
|
rAPI.Data.clear(); // no data
|
|
}
|
|
rAPI.OpCode = static_cast<sal_Int32>(eOpCode); //! assuming equal values for the moment
|
|
}
|
|
}
|
|
else
|
|
rSequence.realloc(0);
|
|
}
|
|
|
|
ScFormulaOpCodeMapperObj::ScFormulaOpCodeMapperObj(::std::unique_ptr<formula::FormulaCompiler> && _pCompiler)
|
|
: formula::FormulaOpCodeMapperObj(std::move(_pCompiler))
|
|
{
|
|
}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|