sc/html/interpre_8hxx_source.html

 /* -*- 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 .

  */


 #ifndef INCLUDED_SC_SOURCE_CORE_INC_INTERPRE_HXX

 #define INCLUDED_SC_SOURCE_CORE_INC_INTERPRE_HXX


 #include <rtl/math.hxx>

 #include <rtl/ustring.hxx>

 #include <unotools/textsearch.hxx>

 #include <formula/errorcodes.hxx>

 #include <formula/tokenarray.hxx>

 #include <types.hxx>

 #include <externalrefmgr.hxx>

 #include <calcconfig.hxx>

 #include <token.hxx>

 #include <math.hxx>

 #include "parclass.hxx"


 #include <map>

 #include <memory>

 #include <vector>

 #include <limits>

 #include <ostream>


 namespace sfx2 { class LinkManager; }


 class ScDocument;

 class SbxVariable;

 class ScFormulaCell;

 class ScDBRangeBase;

 struct ScQueryParam;

 struct ScDBQueryParamBase;

 struct ScQueryEntry;


 struct ScSingleRefData;

 struct ScComplexRefData;

 struct ScInterpreterContext;


 class ScJumpMatrix;

 struct ScRefCellValue;


 namespace sc {


 struct CompareOptions;


 struct ParamIfsResult

 {

     double mfSum = 0.0;

     double mfMem = 0.0;

     double mfCount = 0.0;

     double mfMin = std::numeric_limits<double>::max();

     double mfMax = std::numeric_limits<double>::lowest();

 };


 template<typename charT, typename traits>

 inline std::basic_ostream<charT, traits> & operator <<(std::basic_ostream<charT, traits> & stream, const ParamIfsResult& rRes)

 {

     stream << "{" <<

         "sum=" << rRes.mfSum << "," <<

         "mem=" << rRes.mfMem << "," <<

         "count=" << rRes.mfCount << "," <<

         "min=" << rRes.mfMin << "," <<

         "max=" << rRes.mfMax << "," <<

         "}";


     return stream;

 }


 }


 namespace svl {


 class SharedStringPool;


 }


 constexpr sal_Int32 kScInterpreterMaxStrLen = SAL_MAX_INT32 / 8;


 #define MAXSTACK      (4096 / sizeof(formula::FormulaToken*))


 class ScTokenStack

 {

 public:

     const formula::FormulaToken* pPointer[ MAXSTACK ];

 };


 enum ScIterFunc {

     ifSUM,                              // Add up

     ifSUMSQ,                            // Sums of squares

     ifPRODUCT,                          // Product

     ifAVERAGE,                          // Average

     ifCOUNT,                            // Count Values

     ifCOUNT2,                           // Count Values (not empty)

     ifMIN,                              // Minimum

     ifMAX                               // Maximum

 };


 enum ScIterFuncIf

 {

     ifSUMIF,                            // Conditional sum

     ifAVERAGEIF                         // Conditional average

 };


 enum ScETSType

 {

     etsAdd,

     etsMult,

     etsSeason,

     etsPIAdd,

     etsPIMult,

     etsStatAdd,

     etsStatMult

 };


 struct FormulaTokenRef_less

 {

     bool operator () ( const formula::FormulaConstTokenRef& r1, const formula::FormulaConstTokenRef& r2 ) const

         { return r1.get() < r2.get(); }

 };

 typedef ::std::map< const formula::FormulaConstTokenRef, formula::FormulaConstTokenRef, FormulaTokenRef_less> ScTokenMatrixMap;


 class ScInterpreter

 {

     // distribution function objects need the GetxxxDist methods

     friend class ScGammaDistFunction;

     friend class ScBetaDistFunction;

     friend class ScTDistFunction;

     friend class ScFDistFunction;

     friend class ScChiDistFunction;

     friend class ScChiSqDistFunction;


 public:

     static void SetGlobalConfig(const ScCalcConfig& rConfig);

     static const ScCalcConfig& GetGlobalConfig();


     static void GlobalExit();           // called by ScGlobal::Clear()


     static bool MayBeRegExp( const OUString& rStr );


     static bool MayBeWildcard( const OUString& rStr );


     static utl::SearchParam::SearchType DetectSearchType( const OUString& rStr, const ScDocument& rDoc );


     static inline double div( const double& fNumerator, const double& fDenominator );


     ScMatrixRef GetNewMat(SCSIZE nC, SCSIZE nR, bool bEmpty = false);


     ScMatrixRef GetNewMat(SCSIZE nC, SCSIZE nR, const std::vector<double>& rValues);


     enum VolatileType {

         VOLATILE,

         VOLATILE_MACRO,

         NOT_VOLATILE

     };


     VolatileType GetVolatileType() const { return meVolatileType;}


 private:

     static ScCalcConfig& GetOrCreateGlobalConfig();

     static ScCalcConfig *mpGlobalConfig;


     static thread_local std::unique_ptr<ScTokenStack>  pGlobalStack;

     static thread_local bool                           bGlobalStackInUse;


     ScCalcConfig maCalcConfig;

     formula::FormulaTokenIterator aCode;

     ScAddress   aPos;

     ScTokenArray* pArr;

     ScInterpreterContext& mrContext;

     ScDocument& mrDoc;

     sfx2::LinkManager* mpLinkManager;

     svl::SharedStringPool& mrStrPool;

     formula::FormulaConstTokenRef  xResult;

     ScJumpMatrix*   pJumpMatrix;        // currently active array condition, if any

     std::unique_ptr<ScTokenMatrixMap> pTokenMatrixMap;  // map FormulaToken* to formula::FormulaTokenRef if in array condition

     ScFormulaCell* pMyFormulaCell;      // the cell of this formula expression

     SvNumberFormatter* pFormatter;


     const formula::FormulaToken* pCur;  // current token

     ScTokenStack* pStackObj;            // contains the stacks

     const formula::FormulaToken ** pStack;  // the current stack

     FormulaError nGlobalError;          // global (local to this formula expression) error

     sal_uInt16  sp;                     // stack pointer

     sal_uInt16  maxsp;                  // the maximal used stack pointer

     sal_uInt32  nFuncFmtIndex;          // NumberFormatIndex of a function

     sal_uInt32  nCurFmtIndex;           // current NumberFormatIndex

     sal_uInt32  nRetFmtIndex;           // NumberFormatIndex of an expression, if any

     SvNumFormatType nFuncFmtType;       // NumberFormatType of a function

     SvNumFormatType nCurFmtType;        // current NumberFormatType

     SvNumFormatType nRetFmtType;        // NumberFormatType of an expression

     FormulaError  mnStringNoValueError; // the error set in ConvertStringToValue() if no value

     SubtotalFlags mnSubTotalFlags;      // flags for subtotal and aggregate functions

     sal_uInt8   cPar;                   // current count of parameters

     bool        bCalcAsShown;           // precision as shown

     bool        bMatrixFormula;         // formula cell is a matrix formula


     VolatileType meVolatileType;


     void MakeMatNew(ScMatrixRef& rMat, SCSIZE nC, SCSIZE nR);


     void MergeCalcConfig();


     // nMust <= nAct <= nMax ? ok : PushError

     inline bool MustHaveParamCount( short nAct, short nMust );

     inline bool MustHaveParamCount( short nAct, short nMust, short nMax );

     inline bool MustHaveParamCountMin( short nAct, short nMin );

     void PushParameterExpected();

     void PushIllegalParameter();

     void PushIllegalArgument();

     void PushNoValue();

     void PushNA();


     // Functions for accessing a document


     void ReplaceCell( ScAddress& );     // for TableOp

     bool IsTableOpInRange( const ScRange& );

     sal_uInt32 GetCellNumberFormat( const ScAddress& rPos, ScRefCellValue& rCell );

     double ConvertStringToValue( const OUString& );

 public:

     static double ScGetGCD(double fx, double fy);

     double ConvertStringToValue( const OUString&, FormulaError& rError, SvNumFormatType& rCurFmtType );

 private:

     double GetCellValue( const ScAddress&, ScRefCellValue& rCell );

     double GetCellValueOrZero( const ScAddress&, ScRefCellValue& rCell );

     double GetValueCellValue( const ScAddress&, double fOrig );

     void GetCellString( svl::SharedString& rStr, ScRefCellValue& rCell );

     static FormulaError GetCellErrCode( const ScRefCellValue& rCell );


     bool CreateDoubleArr(SCCOL nCol1, SCROW nRow1, SCTAB nTab1,

                          SCCOL nCol2, SCROW nRow2, SCTAB nTab2, sal_uInt8* pCellArr);

     bool CreateStringArr(SCCOL nCol1, SCROW nRow1, SCTAB nTab1,

                          SCCOL nCol2, SCROW nRow2, SCTAB nTab2, sal_uInt8* pCellArr);

     bool CreateCellArr(SCCOL nCol1, SCROW nRow1, SCTAB nTab1,

                        SCCOL nCol2, SCROW nRow2, SCTAB nTab2, sal_uInt8* pCellArr);


     // Stack operations


     void Push( const formula::FormulaToken& r );


     void PushWithoutError( const formula::FormulaToken& r );


     void PushTempToken( formula::FormulaToken* );


     void PushTokenRef( const formula::FormulaConstTokenRef& );


     void PushTempTokenWithoutError( const formula::FormulaToken* );


     bool IfErrorPushError()

     {

         if (nGlobalError != FormulaError::NONE)

         {

             PushTempTokenWithoutError( new formula::FormulaErrorToken( nGlobalError));

             return true;

         }

         return false;

     }


     void PushCellResultToken( bool bDisplayEmptyAsString, const ScAddress & rAddress,

             SvNumFormatType * pRetTypeExpr, sal_uInt32 * pRetIndexExpr, bool bFinalResult = false );


     formula::FormulaConstTokenRef PopToken();

     void Pop();

     void PopError();

     double PopDouble();

     svl::SharedString PopString();

     void ValidateRef( const ScSingleRefData & rRef );

     void ValidateRef( const ScComplexRefData & rRef );

     void ValidateRef( const ScRefList & rRefList );

     void SingleRefToVars( const ScSingleRefData & rRef, SCCOL & rCol, SCROW & rRow, SCTAB & rTab );

     void PopSingleRef( ScAddress& );

     void PopSingleRef(SCCOL& rCol, SCROW &rRow, SCTAB& rTab);

     void DoubleRefToRange( const ScComplexRefData&, ScRange&, bool bDontCheckForTableOp = false );

     void PopDoubleRef( ScRange & rRange, short & rParam, size_t & rRefInList );

     void PopDoubleRef( ScRange&, bool bDontCheckForTableOp = false );

     void DoubleRefToVars( const formula::FormulaToken* p,

             SCCOL& rCol1, SCROW &rRow1, SCTAB& rTab1,

             SCCOL& rCol2, SCROW &rRow2, SCTAB& rTab2 );

     ScDBRangeBase* PopDBDoubleRef();

     void PopDoubleRef(SCCOL& rCol1, SCROW &rRow1, SCTAB& rTab1,

                               SCCOL& rCol2, SCROW &rRow2, SCTAB& rTab2 );


     void PopExternalSingleRef(sal_uInt16& rFileId, OUString& rTabName, ScSingleRefData& rRef);


     void PopExternalSingleRef(ScExternalRefCache::TokenRef& rToken, ScExternalRefCache::CellFormat* pFmt = nullptr);


     void PopExternalSingleRef(sal_uInt16& rFileId, OUString& rTabName, ScSingleRefData& rRef,

                               ScExternalRefCache::TokenRef& rToken, ScExternalRefCache::CellFormat* pFmt = nullptr);


     void PopExternalDoubleRef(sal_uInt16& rFileId, OUString& rTabName, ScComplexRefData& rRef);

     void PopExternalDoubleRef(ScExternalRefCache::TokenArrayRef& rArray);

     void PopExternalDoubleRef(ScMatrixRef& rMat);

     void GetExternalDoubleRef(sal_uInt16 nFileId, const OUString& rTabName, const ScComplexRefData& aData, ScExternalRefCache::TokenArrayRef& rArray);

     bool PopDoubleRefOrSingleRef( ScAddress& rAdr );

     void PopDoubleRefPushMatrix();

     void PopRefListPushMatrixOrRef();

     // If MatrixFormula: convert svDoubleRef to svMatrix, create JumpMatrix.

     // Else convert area reference parameters marked as ForceArray to array.

     // Returns true if JumpMatrix created.

     bool ConvertMatrixParameters();

     // If MatrixFormula: ConvertMatrixJumpConditionToMatrix()

     inline void MatrixJumpConditionToMatrix();

     // For MatrixFormula (preconditions already checked by

     // MatrixJumpConditionToMatrix()): convert svDoubleRef to svMatrix, or if

     // JumpMatrix currently in effect convert also other types to svMatrix so

     // another JumpMatrix will be created by jump commands.

     void ConvertMatrixJumpConditionToMatrix();

     // If MatrixFormula or ForceArray: ConvertMatrixParameters()

     inline bool MatrixParameterConversion();

     // If MatrixFormula or ForceArray. Can be used within spreadsheet functions

     // that do not depend on the formula cell's matrix size, for which only

     // bMatrixFormula can be used.

     inline bool IsInArrayContext() const;

     ScMatrixRef PopMatrix();

     sc::RangeMatrix PopRangeMatrix();

     void QueryMatrixType(const ScMatrixRef& xMat, SvNumFormatType& rRetTypeExpr, sal_uInt32& rRetIndexExpr);


     formula::FormulaToken* CreateFormulaDoubleToken( double fVal, SvNumFormatType nFmt = SvNumFormatType::NUMBER );

     formula::FormulaToken* CreateDoubleOrTypedToken( double fVal );


     void PushDouble(double nVal);

     void PushInt( int nVal );

     void PushStringBuffer( const sal_Unicode* pString );

     void PushString( const OUString& rStr );

     void PushString( const svl::SharedString& rString );

     void PushSingleRef(SCCOL nCol, SCROW nRow, SCTAB nTab);

     void PushDoubleRef(SCCOL nCol1, SCROW nRow1, SCTAB nTab1,

                        SCCOL nCol2, SCROW nRow2, SCTAB nTab2);

     void PushExternalSingleRef(sal_uInt16 nFileId, const OUString& rTabName,

                                SCCOL nCol, SCROW nRow, SCTAB nTab);

     void PushExternalDoubleRef(sal_uInt16 nFileId, const OUString& rTabName,

                                SCCOL nCol1, SCROW nRow1, SCTAB nTab1,

                                SCCOL nCol2, SCROW nRow2, SCTAB nTab2);

     void PushSingleRef( const ScRefAddress& rRef );

     void PushDoubleRef( const ScRefAddress& rRef1, const ScRefAddress& rRef2 );

     void PushMatrix( const sc::RangeMatrix& rMat );

     void PushMatrix(const ScMatrixRef& pMat);

     void PushError( FormulaError nError );

     formula::StackVar GetRawStackType();

     formula::StackVar GetStackType();

     // peek StackType of Parameter, Parameter 1 == TOS, 2 == TOS-1, ...

     formula::StackVar GetStackType( sal_uInt8 nParam );

     sal_uInt8 GetByte() const { return cPar; }

     // reverse order of stack

     void ReverseStack( sal_uInt8 nParamCount );

     // generates a position-dependent SingleRef out of a DoubleRef

     bool DoubleRefToPosSingleRef( const ScRange& rRange, ScAddress& rAdr );

     double GetDoubleFromMatrix(const ScMatrixRef& pMat);

     double GetDouble();

     double GetDoubleWithDefault(double nDefault);

     bool IsMissing() const;

     sal_Int32 double_to_int32(double fVal);

     sal_Int32 GetInt32();

     sal_Int32 GetInt32WithDefault( sal_Int32 nDefault );

     sal_Int16 GetInt16();

     sal_uInt32 GetUInt32();

     bool GetBool() { return GetDouble() != 0.0; }

     bool GetDoubleOrString( double& rValue, svl::SharedString& rString );

     svl::SharedString GetString();

     svl::SharedString GetStringFromMatrix(const ScMatrixRef& pMat);

     svl::SharedString GetStringFromDouble( const double fVal);

     // pop matrix and obtain one element, upper left or according to jump matrix

     ScMatValType GetDoubleOrStringFromMatrix( double& rDouble, svl::SharedString& rString );

     ScMatrixRef CreateMatrixFromDoubleRef( const formula::FormulaToken* pToken,

             SCCOL nCol1, SCROW nRow1, SCTAB nTab1,

             SCCOL nCol2, SCROW nRow2, SCTAB nTab2 );

     inline ScTokenMatrixMap& GetTokenMatrixMap();

     static std::unique_ptr<ScTokenMatrixMap> CreateTokenMatrixMap();

     ScMatrixRef GetMatrix();

     ScMatrixRef GetMatrix( short & rParam, size_t & rInRefList );

     sc::RangeMatrix GetRangeMatrix();


     void ScTableOp();                                       // repeated operations


     // common helper functions


     void CurFmtToFuncFmt()

         { nFuncFmtType = nCurFmtType; nFuncFmtIndex = nCurFmtIndex; }


     static inline bool CheckStringPositionArgument( double & fVal );


     inline sal_Int32 GetStringPositionArgument();


     // Check for String overflow of rResult+rAdd and set error and erase rResult

     // if so. Return true if ok, false if overflow

     inline bool CheckStringResultLen( OUString& rResult, const OUString& rAdd );


     // Check for String overflow of rResult+rAdd and set error and erase rResult

     // if so. Return true if ok, false if overflow

     inline bool CheckStringResultLen( OUStringBuffer& rResult, const OUString& rAdd );


     // Set error according to rVal, and set rVal to 0.0 if there was an error.

     inline void TreatDoubleError( double& rVal );

     // Lookup using ScLookupCache, @returns true if found and result address

     bool LookupQueryWithCache( ScAddress & o_rResultPos,

             const ScQueryParam & rParam ) const;


     void ScIfJump();

     void ScIfError( bool bNAonly );

     void ScChooseJump();


     // Be sure to only call this if pStack[sp-nStackLevel] really contains a

     // ScJumpMatrixToken, no further checks are applied!

     // Returns true if last jump was executed and result matrix pushed.

     bool JumpMatrix( short nStackLevel );


     double Compare( ScQueryOp eOp );

     sc::RangeMatrix CompareMat( ScQueryOp eOp, sc::CompareOptions* pOptions = nullptr );

     ScMatrixRef QueryMat( const ScMatrixRef& pMat, sc::CompareOptions& rOptions );

     void ScEqual();

     void ScNotEqual();

     void ScLess();

     void ScGreater();

     void ScLessEqual();

     void ScGreaterEqual();

     void ScAnd();

     void ScOr();

     void ScXor();

     void ScNot();

     void ScNeg();

     void ScPercentSign();

     void ScIntersect();

     void ScRangeFunc();

     void ScUnionFunc();

     void ScPi();

     void ScRandom();

     void ScRandbetween();

     void ScRandomImpl( const std::function<double( double fFirst, double fLast )>& RandomFunc,

             double fFirst, double fLast );

     void ScTrue();

     void ScFalse();

     void ScDeg();

     void ScRad();

     void ScSin();

     void ScCos();

     void ScTan();

     void ScCot();

     void ScArcSin();

     void ScArcCos();

     void ScArcTan();

     void ScArcCot();

     void ScSinHyp();

     void ScCosHyp();

     void ScTanHyp();

     void ScCotHyp();

     void ScArcSinHyp();

     void ScArcCosHyp();

     void ScArcTanHyp();

     void ScArcCotHyp();

     void ScCosecant();

     void ScSecant();

     void ScCosecantHyp();

     void ScSecantHyp();

     void ScExp();

     void ScLn();

     void ScLog10();

     void ScSqrt();

     void ScIsEmpty();

     bool IsString();

     void ScIsString();

     void ScIsNonString();

     void ScIsLogical();

     void ScType();

     void ScCell();

     void ScCellExternal();

     void ScIsRef();

     void ScIsValue();

     void ScIsFormula();

     void ScFormula();

     void ScRoman();

     void ScArabic();

     void ScIsNV();

     void ScIsErr();

     void ScIsError();

     bool IsEven();

     void ScIsEven();

     void ScIsOdd();

     void ScN();

     void ScCode();

     void ScTrim();

     void ScUpper();

     void ScProper();

     void ScLower();

     void ScLen();

     void ScT();

     void ScValue();

     void ScNumberValue();

     void ScClean();

     void ScChar();

     void ScJis();

     void ScAsc();

     void ScUnicode();

     void ScUnichar();

     void ScMin( bool bTextAsZero = false );

     void ScMax( bool bTextAsZero = false );

     size_t GetRefListArrayMaxSize( short nParamCount );

     bool SwitchToArrayRefList( ScMatrixRef& xResMat, SCSIZE nMatRows, double fCurrent,

             const std::function<void( SCSIZE i, double fCurrent )>& MatOpFunc, bool bDoMatOp );

     void IterateParameters( ScIterFunc, bool bTextAsZero = false );

     void ScSumSQ();

     void ScSum();

     void ScProduct();

     void ScAverage( bool bTextAsZero = false );

     void ScCount();

     void ScCount2();

     void GetStVarParams( bool bTextAsZero, double(*VarResult)( double fVal, size_t nValCount ) );

     void ScVar( bool bTextAsZero = false );

     void ScVarP( bool bTextAsZero = false );

     void ScStDev( bool bTextAsZero = false );

     void ScStDevP( bool bTextAsZero = false );

     void ScRawSubtract();

     void ScColumns();

     void ScRows();

     void ScSheets();

     void ScColumn();

     void ScRow();

     void ScSheet();

     void ScMatch();

     void IterateParametersIf( ScIterFuncIf );

     void ScCountIf();

     void ScSumIf();

     void ScAverageIf();

     void IterateParametersIfs( double(*ResultFunc)( const sc::ParamIfsResult& rRes ) );

     void ScSumIfs();

     void ScAverageIfs();

     void ScCountIfs();

     void ScCountEmptyCells();

     void ScLookup();

     void ScHLookup();

     void ScVLookup();

     void ScSubTotal();


     // If upon call rMissingField==true then the database field parameter may be

     // missing (Xcl DCOUNT() syntax), or may be faked as missing by having the

     // value 0.0 or being exactly the entire database range reference (old SO

     // compatibility). If this was the case then rMissingField is set to true upon

     // return. If rMissingField==false upon call all "missing cases" are considered

     // to be an error.

     std::unique_ptr<ScDBQueryParamBase> GetDBParams( bool& rMissingField );


     void DBIterator( ScIterFunc );

     void ScDBSum();

     void ScDBCount();

     void ScDBCount2();

     void ScDBAverage();

     void ScDBGet();

     void ScDBMax();

     void ScDBMin();

     void ScDBProduct();

     void GetDBStVarParams( double& rVal, double& rValCount );

     void ScDBStdDev();

     void ScDBStdDevP();

     void ScDBVar();

     void ScDBVarP();

     void ScIndirect();

     void ScAddressFunc();

     void ScOffset();

     void ScIndex();

     void ScMultiArea();

     void ScAreas();

     void ScCurrency();

     void ScReplace();

     void ScFixed();

     void ScFind();

     void ScExact();

     void ScLeft();

     void ScRight();

     void ScSearch();

     void ScMid();

     void ScText();

     void ScSubstitute();

     void ScRept();

     void ScRegex();

     void ScConcat();

     void ScConcat_MS();

     void ScTextJoin_MS();

     void ScIfs_MS();

     void ScSwitch_MS();

     void ScMinIfs_MS();

     void ScMaxIfs_MS();

     void ScExternal();

     void ScMissing();

     void ScMacro();

     bool SetSbxVariable( SbxVariable* pVar, const ScAddress& );

     FormulaError GetErrorType();

     void ScErrorType();

     void ScErrorType_ODF();

     void ScDBArea();

     void ScColRowNameAuto();

     void ScGetPivotData();

     void ScHyperLink();

     void ScBahtText();

     void ScBitAnd();

     void ScBitOr();

     void ScBitXor();

     void ScBitRshift();

     void ScBitLshift();

     void ScTTT();

     void ScDebugVar();


     double GetDateSerial( sal_Int16 nYear, sal_Int16 nMonth, sal_Int16 nDay, bool bStrict );


     void ScGetActDate();

     void ScGetActTime();

     void ScGetYear();

     void ScGetMonth();

     void ScGetDay();

     void ScGetDayOfWeek();

     void ScGetWeekOfYear();

     void ScGetIsoWeekOfYear();

     void ScWeeknumOOo();

     void ScEasterSunday();

     FormulaError GetWeekendAndHolidayMasks( const sal_uInt8 nParamCount, const sal_uInt32 nNullDate,

             ::std::vector<double>& rSortArray, bool bWeekendMask[ 7 ] );

     FormulaError GetWeekendAndHolidayMasks_MS( const sal_uInt8 nParamCount, const sal_uInt32 nNullDate,

             ::std::vector<double>& rSortArray, bool bWeekendMask[ 7 ], bool bWorkdayFunction );

     static inline sal_Int16 GetDayOfWeek( sal_Int32 n );

     void ScNetWorkdays( bool bOOXML_Version );

     void ScWorkday_MS();

     void ScGetHour();

     void ScGetMin();

     void ScGetSec();

     void ScPlusMinus();

     void ScAbs();

     void ScInt();

     void ScEven();

     void ScOdd();

     void ScCeil( bool bODFF );

     void ScCeil_MS();

     void ScCeil_Precise();

     void ScFloor( bool bODFF );

     void ScFloor_MS();

     void ScFloor_Precise();

     void RoundNumber( rtl_math_RoundingMode eMode );

     void ScRound();

     void ScRoundUp();

     void ScRoundDown();

     void ScGetDateValue();

     void ScGetTimeValue();

     void ScArcTan2();

     void ScLog();

     void ScGetDate();

     void ScGetTime();

     void ScGetDiffDate();

     void ScGetDiffDate360();

     void ScGetDateDif();

     void ScPower();

     void ScAmpersand();

     void ScAdd();

     void ScSub();

     void ScMul();

     void ScDiv();

     void ScPow();

     void ScCurrent();

     void ScStyle();

     void ScDde();

     void ScBase();

     void ScDecimal();

     void ScConvertOOo();

     void ScEuroConvert();

     void ScRoundSignificant();

     static void RoundSignificant( double fX, double fDigits, double &fRes );


     // financial functions

     void ScNPV();

     void ScIRR();

     void ScMIRR();

     void ScISPMT();


     static double ScGetPV(double fRate, double fNper, double fPmt,

                           double fFv, bool bPayInAdvance);

     void ScPV();

     void ScSYD();

     static double ScGetDDB(double fCost, double fSalvage, double fLife,

                            double fPeriod, double fFactor);

     void ScDDB();

     void ScDB();

     static double ScInterVDB(double fCost, double fSalvage, double fLife, double fLife1,

                              double fPeriod, double fFactor);

     void ScVDB();

     void ScPDuration();

     void ScSLN();

     static double ScGetPMT(double fRate, double fNper, double fPv,

                            double fFv, bool bPayInAdvance);

     void ScPMT();

     void ScRRI();

     static double ScGetFV(double fRate, double fNper, double fPmt,

                           double fPv, bool bPayInAdvance);

     void ScFV();

     void ScNper();

     static bool RateIteration(double fNper, double fPayment, double fPv,

                               double fFv, bool bPayType, double& fGuess);

     void ScRate();

     double ScGetIpmt(double fRate, double fPer, double fNper, double fPv,

                                  double fFv, bool bPayInAdvance, double& fPmt);

     void ScIpmt();

     void ScPpmt();

     void ScCumIpmt();

     void ScCumPrinc();

     void ScEffect();

     void ScNominal();

     void ScMod();

     void ScIntercept();

     void ScGCD();

     void ScLCM();


     // matrix functions

     void ScMatValue();

     static void MEMat(const ScMatrixRef& mM, SCSIZE n);

     void ScMatDet();

     void ScMatInv();

     void ScMatMult();

     void ScMatTrans();

     void ScEMat();

     void ScMatRef();

     ScMatrixRef MatConcat(const ScMatrixRef& pMat1, const ScMatrixRef& pMat2);

     void ScSumProduct();

     void ScSumX2MY2();

     void ScSumX2DY2();

     void ScSumXMY2();

     void ScGrowth();

     bool CalculateSkew(double& fSum,double& fCount,double& vSum,std::vector<double>& values);

     void CalculateSkewOrSkewp( bool bSkewp );

     void CalculateSlopeIntercept(bool bSlope);

     void CalculateSmallLarge(bool bSmall);

     void CalculatePearsonCovar( bool _bPearson, bool _bStexy, bool _bSample );  //fdo#70000 argument _bSample is ignored if _bPearson == true

     bool CalculateTest( bool _bTemplin

                        ,const SCSIZE nC1, const SCSIZE nC2,const SCSIZE nR1,const SCSIZE nR2

                        ,const ScMatrixRef& pMat1,const ScMatrixRef& pMat2

                        ,double& fT,double& fF);

     void CalculateLookup(bool bHLookup);

     bool FillEntry(ScQueryEntry& rEntry);

     void CalculateAddSub(bool _bSub);

     void CalculateTrendGrowth(bool _bGrowth);

     void CalculateRGPRKP(bool _bRKP);

     void CalculateSumX2MY2SumX2DY2(bool _bSumX2DY2);

     void CalculateMatrixValue(const ScMatrix* pMat,SCSIZE nC,SCSIZE nR);

     bool CheckMatrix(bool _bLOG,sal_uInt8& nCase,SCSIZE& nCX,SCSIZE& nCY,SCSIZE& nRX,SCSIZE& nRY,SCSIZE& M,SCSIZE& N,ScMatrixRef& pMatX,ScMatrixRef& pMatY);

     void ScLinest();

     void ScLogest();

     void ScForecast();

     void ScForecast_Ets( ScETSType eETSType );

     void ScFourier();

     void ScNoName();

     void ScBadName();

     // Statistics:

     static double taylor(const double* pPolynom, sal_uInt16 nMax, double x);

     static double gauss(double x);


 public:

     static double phi(double x);

     static double integralPhi(double x);

     static double gaussinv(double x);

     static double GetPercentile( ::std::vector<double> & rArray, double fPercentile );


 private:

     double GetBetaDist(double x, double alpha, double beta);  //cumulative distribution function

     double GetBetaDistPDF(double fX, double fA, double fB); //probability density function)

     double GetChiDist(double fChi, double fDF);     // for LEGACY.CHIDIST, returns right tail

     double GetChiSqDistCDF(double fX, double fDF);  // for CHISQDIST, returns left tail

     static double GetChiSqDistPDF(double fX, double fDF);  // probability density function

     double GetFDist(double x, double fF1, double fF2);

     double GetTDist( double T, double fDF, int nType );

     double Fakultaet(double x);

     static double BinomKoeff(double n, double k);

     double GetGamma(double x);

     static double GetLogGamma(double x);

     double GetBeta(double fAlpha, double fBeta);

     static double GetLogBeta(double fAlpha, double fBeta);

     double GetBinomDistPMF(double x, double n, double p); //probability mass function

     double GetHypGeomDist( double x, double n, double M, double N );

     void ScLogGamma();

     void ScGamma();

     void ScPhi();

     void ScGauss();

     void ScStdNormDist();

     void ScStdNormDist_MS();

     void ScFisher();

     void ScFisherInv();

     void ScFact();

     void ScNormDist( int nMinParamCount );

     void ScGammaDist( bool bODFF );

     void ScGammaInv();

     void ScExpDist();

     void ScBinomDist();

     void ScPoissonDist( bool bODFF );

     void ScCombin();

     void ScCombinA();

     void ScPermut();

     void ScPermutationA();

     void ScB();

     void ScHypGeomDist( int nMinParamCount );

     void ScLogNormDist( int nMinParamCount );

     void ScLogNormInv();

     void ScTDist();

     void ScTDist_MS();

     void ScTDist_T( int nTails );

     void ScFDist();

     void ScFDist_LT();

     void ScChiDist( bool bODFF);   // for LEGACY.CHIDIST, returns right tail

     void ScChiSqDist(); // returns left tail or density

     void ScChiSqDist_MS();

     void ScChiSqInv(); // inverse to CHISQDIST

     void ScWeibull();

     void ScBetaDist();

     void ScBetaDist_MS();

     void ScFInv();

     void ScFInv_LT();

     void ScTInv( int nType );

     void ScChiInv();

     void ScBetaInv();

     void ScCritBinom();

     void ScNegBinomDist();

     void ScNegBinomDist_MS();

     void ScKurt();

     void ScHarMean();

     void ScGeoMean();

     void ScStandard();

     void ScSkew();

     void ScSkewp();

     void ScMedian();

     double GetMedian( ::std::vector<double> & rArray );

     double GetPercentileExclusive( ::std::vector<double> & rArray, double fPercentile );

     std::vector<double> GetTopNumberArray( SCSIZE& rCol, SCSIZE& rRow );

     void GetNumberSequenceArray( sal_uInt8 nParamCount, ::std::vector<double>& rArray, bool bConvertTextInArray );

     void GetSortArray( sal_uInt8 nParamCount, ::std::vector<double>& rSortArray, ::std::vector<tools::Long>* pIndexOrder, bool bConvertTextInArray, bool bAllowEmptyArray );

     static void QuickSort(::std::vector<double>& rSortArray, ::std::vector<tools::Long>* pIndexOrder);

     void ScModalValue();

     void ScModalValue_MS( bool bSingle );

     void ScAveDev();

     void ScAggregate();

     void ScDevSq();

     void ScZTest();

     void ScTTest();

     void ScFTest();

     void ScChiTest();

     void ScRank( bool bAverage );

     void ScPercentile( bool bInclusive );

     void ScPercentrank( bool bInclusive );

     static double GetPercentrank( ::std::vector<double> & rArray, double fVal, bool bInclusive );

     void ScLarge();

     void ScSmall();

     void ScFrequency();

     void ScQuartile( bool bInclusive );

     void ScNormInv();

     void ScSNormInv();

     void ScConfidence();

     void ScConfidenceT();

     void ScTrimMean();

     void ScProbability();

     void ScCorrel();

     void ScCovarianceP();

     void ScCovarianceS();

     void ScPearson();

     void ScRSQ();

     void ScSTEYX();

     void ScSlope();

     void ScTrend();

     void ScInfo();

     void ScLenB();

     void ScRightB();

     void ScLeftB();

     void ScMidB();

     void ScReplaceB();

     void ScFindB();

     void ScSearchB();


     void ScFilterXML();

     void ScWebservice();

     void ScEncodeURL();

     void ScColor();

     void ScErf();

     void ScErfc();


     static const double fMaxGammaArgument;


     double GetGammaContFraction(double fA,double fX);

     double GetGammaSeries(double fA,double fX);

     double GetLowRegIGamma(double fA,double fX);    // lower regularized incomplete gamma function, GAMMAQ

     double GetUpRegIGamma(double fA,double fX);     // upper regularized incomplete gamma function, GAMMAP

     // probability density function; fLambda is "scale" parameter

     double GetGammaDistPDF(double fX, double fAlpha, double fLambda);

     // cumulative distribution function; fLambda is "scale" parameter

     double GetGammaDist(double fX, double fAlpha, double fLambda);

     double GetTInv( double fAlpha, double fSize, int nType );


 public:

     ScInterpreter( ScFormulaCell* pCell, ScDocument& rDoc, ScInterpreterContext& rContext,

                     const ScAddress&, ScTokenArray&, bool bForGroupThreading = false );

     ~ScInterpreter();


     // Used only for threaded formula-groups.

     // Resets the interpreter object, allowing reuse of interpreter object for each cell

     // in the group.

     void Init( ScFormulaCell* pCell, const ScAddress& rPos, ScTokenArray& rTokArray );


     formula::StackVar Interpret();


     void SetError(FormulaError nError)

             { if (nError != FormulaError::NONE && nGlobalError == FormulaError::NONE) nGlobalError = nError; }

     void AssertFormulaMatrix();


     void SetLinkManager(sfx2::LinkManager* pLinkMgr)

             { mpLinkManager = pLinkMgr; }


     FormulaError                GetError() const            { return nGlobalError; }

     formula::StackVar           GetResultType() const       { return xResult->GetType(); }

     const svl::SharedString & GetStringResult() const;

     double                      GetNumResult() const        { return xResult->GetDouble(); }

     const formula::FormulaConstTokenRef& GetResultToken() const { return xResult; }

     SvNumFormatType             GetRetFormatType() const    { return nRetFmtType; }

     sal_uLong                   GetRetFormatIndex() const   { return nRetFmtIndex; }

 };


 inline bool ScInterpreter::IsInArrayContext() const

 {

     return bMatrixFormula || pCur->IsInForceArray();

 }


 inline void ScInterpreter::MatrixJumpConditionToMatrix()

 {

     if (IsInArrayContext())

         ConvertMatrixJumpConditionToMatrix();

 }


 inline bool ScInterpreter::MatrixParameterConversion()

 {

     if ( (IsInArrayContext() || ScParameterClassification::HasForceArray( pCur->GetOpCode())) &&

             !pJumpMatrix && sp > 0 )

         return ConvertMatrixParameters();

     return false;

 }


 inline ScTokenMatrixMap& ScInterpreter::GetTokenMatrixMap()

 {

     if (!pTokenMatrixMap)

         pTokenMatrixMap = CreateTokenMatrixMap();

     return *pTokenMatrixMap;

 }


 inline bool ScInterpreter::MustHaveParamCount( short nAct, short nMust )

 {

     if ( nAct == nMust )

         return true;

     if ( nAct < nMust )

         PushParameterExpected();

     else

         PushIllegalParameter();

     return false;

 }


 inline bool ScInterpreter::MustHaveParamCount( short nAct, short nMust, short nMax )

 {

     if ( nMust <= nAct && nAct <= nMax )

         return true;

     if ( nAct < nMust )

         PushParameterExpected();

     else

         PushIllegalParameter();

     return false;

 }


 inline bool ScInterpreter::MustHaveParamCountMin( short nAct, short nMin )

 {

     if ( nAct >= nMin )

         return true;

     PushParameterExpected();

     return false;

 }


 inline bool ScInterpreter::CheckStringPositionArgument( double & fVal )

 {

     if (!std::isfinite( fVal))

     {

         fVal = -1.0;

         return false;

     }

     else if (fVal < 0.0)

     {

         fVal = 0.0;

         return false;

     }

     else if (fVal > SAL_MAX_INT32)

     {

         fVal = static_cast<double>(SAL_MAX_INT32);

         return false;

     }

     return true;

 }


 inline sal_Int32 ScInterpreter::GetStringPositionArgument()

 {

     double fVal = rtl::math::approxFloor( GetDouble());

     if (!CheckStringPositionArgument( fVal))

     {

         fVal = -1.0;

         SetError( FormulaError::IllegalArgument);

     }

     return static_cast<sal_Int32>(fVal);

 }


 inline bool ScInterpreter::CheckStringResultLen( OUString& rResult, const OUString& rAdd )

 {

     if (rAdd.getLength() > kScInterpreterMaxStrLen - rResult.getLength())

     {

         SetError( FormulaError::StringOverflow );

         rResult.clear();

         return false;

     }

     return true;

 }


 inline bool ScInterpreter::CheckStringResultLen( OUStringBuffer& rResult, const OUString& rAdd )

 {

     if (rAdd.getLength() > kScInterpreterMaxStrLen - rResult.getLength())

     {

         SetError( FormulaError::StringOverflow );

         rResult = OUStringBuffer();

         return false;

     }

     return true;

 }


 inline void ScInterpreter::TreatDoubleError( double& rVal )

 {

     if ( !std::isfinite( rVal ) )

     {

         FormulaError nErr = GetDoubleErrorValue( rVal );

         if ( nErr != FormulaError::NONE )

             SetError( nErr );

         else

             SetError( FormulaError::NoValue );

         rVal = 0.0;

     }

 }


 inline double ScInterpreter::div( const double& fNumerator, const double& fDenominator )

 {

     return sc::div(fNumerator, fDenominator);

 }


 inline sal_Int16 ScInterpreter::GetDayOfWeek( sal_Int32 n )

 {   // monday = 0, ..., sunday = 6

     return static_cast< sal_Int16 >( ( n - 1 ) % 7 );

 }


 #endif


 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

ScTokenArray
Definition: tokenarray.hxx:49

ScMatrix
Matrix data type that can store values of mixed types.
Definition: scmatrix.hxx:113

ScInterpreter::ScErf
void ScErf()
Definition: interpr7.cxx:496

ScBetaDistFunction
Definition: interpr3.cxx:2200

ScInterpreter::ScFDist_LT
void ScFDist_LT()
Definition: interpr3.cxx:1706

ScInterpreter::ScGCD
void ScGCD()
Definition: interpr5.cxx:129

ScInterpreter::ScDecimal
void ScDecimal()
Definition: interpr2.cxx:2962

sfx2

ScInterpreter::GetLowRegIGamma
double GetLowRegIGamma(double fA, double fX)
You must ensure fA>0.0 && fX>0.0)
Definition: interpr6.cxx:119

ScInterpreter::ScRoundSignificant
void ScRoundSignificant()
Definition: interpr2.cxx:1029

ifSUM
Definition: interpre.hxx:105

ScInterpreter::ScFormula
void ScFormula()
Definition: interpr1.cxx:2760

ScInterpreter::ScGetDiffDate
void ScGetDiffDate()
Definition: interpr2.cxx:670

formula::FormulaConstTokenRef
::boost::intrusive_ptr< const FormulaToken > FormulaConstTokenRef

formula::StackVar
StackVar

ScInterpreter::ScFrequency
void ScFrequency()
Definition: interpr5.cxx:1880

ScInterpreter::ScDBArea
void ScDBArea()
Definition: interpr4.cxx:3653

ScInterpreter::ScBadName
void ScBadName()
Definition: interpr3.cxx:182

ScInterpreter::ScIndirect
void ScIndirect()
Definition: interpr1.cxx:8053

formula::FormulaErrorToken

ScInterpreter::ScArcTan2
void ScArcTan2()
Definition: interpr2.cxx:1258

ScInterpreter::GetExternalDoubleRef
void GetExternalDoubleRef(sal_uInt16 nFileId, const OUString &rTabName, const ScComplexRefData &aData, ScExternalRefCache::TokenArrayRef &rArray)
Definition: interpr4.cxx:1258

ScInterpreter::ScLessEqual
void ScLessEqual()
Definition: interpr1.cxx:1231

ScInterpreter::ScPearson
void ScPearson()
Definition: interpr3.cxx:4530

ScInterpreter::ScCell
void ScCell()
Definition: interpr1.cxx:2239

ScInterpreter::ScSumIfs
void ScSumIfs()
Definition: interpr1.cxx:6492

ScIterFunc
ScIterFunc
Definition: interpre.hxx:104

ScInterpreter::nRetFmtIndex
sal_uInt32 nRetFmtIndex
Definition: interpre.hxx:216

ifCOUNT
Definition: interpre.hxx:109

ScInterpreter::GetInt32
sal_Int32 GetInt32()
if GetDouble() not within int32 limits sets nGlobalError and returns SAL_MAX_INT32 ...
Definition: interpr4.cxx:2183

ScInterpreter::CalculateMatrixValue
void CalculateMatrixValue(const ScMatrix *pMat, SCSIZE nC, SCSIZE nR)
Definition: interpr5.cxx:707

ScInterpreter::ScEasterSunday
void ScEasterSunday()
Definition: interpr2.cxx:305

ScInterpreter::RoundSignificant
static void RoundSignificant(double fX, double fDigits, double &fRes)
Definition: interpr2.cxx:1017

ScInterpreter::ScVarP
void ScVarP(bool bTextAsZero=false)
Definition: interpr1.cxx:4162

ScInterpreter::aCode
formula::FormulaTokenIterator aCode
Definition: interpre.hxx:195

ScInterpreter::nFuncFmtType
SvNumFormatType nFuncFmtType
Definition: interpre.hxx:217

ScInterpreter::ScGetTimeValue
void ScGetTimeValue()
Definition: interpr2.cxx:924

ScInterpreter::ScSwitch_MS
void ScSwitch_MS()
Definition: interpr8.cxx:1919

ScInterpreter::ScUnichar
void ScUnichar()
Definition: interpr1.cxx:3573

ScInterpreter::ScIRR
void ScIRR()
Definition: interpr2.cxx:1402

ScInterpreter::ScErfc
void ScErfc()
Definition: interpr7.cxx:506

ScInterpreter::ScUnicode
void ScUnicode()
Definition: interpr1.cxx:3559

ScFormulaCell
Definition: formulacell.hxx:107

ScInterpreter::ScDebugVar
void ScDebugVar()
Definition: interpr7.cxx:450

ScInterpreter::ScInfo
void ScInfo()
Definition: interpr5.cxx:3314

ScInterpreter::ScBetaInv
void ScBetaInv()
Definition: interpr3.cxx:2214

ScInterpreter::ScRank
void ScRank(bool bAverage)
Definition: interpr3.cxx:4219

ScInterpreter::CalculateAddSub
void CalculateAddSub(bool _bSub)
Definition: interpr5.cxx:1279

etsAdd
Definition: interpre.hxx:123

ScInterpreter::ScMacro
void ScMacro()
Definition: interpr4.cxx:3188

ScInterpreter::GetPercentile
static double GetPercentile(::std::vector< double > &rArray, double fPercentile)
Definition: interpr3.cxx:3413

ScInterpreter::PushIllegalParameter
void PushIllegalParameter()
Definition: interpr4.cxx:1906

ScInterpreter::ScRSQ
void ScRSQ()
Definition: interpr3.cxx:4624

etsPIMult
Definition: interpre.hxx:127

ScInterpreter::ScGauss
void ScGauss()
Definition: interpr3.cxx:1142

ScInterpreter::ScGetDay
void ScGetDay()
Definition: interpr2.cxx:132

ScInterpreter::PushTempToken
void PushTempToken(formula::FormulaToken *)
Does substitute with formula::FormulaErrorToken in case nGlobalError is set and the token passed is n...
Definition: interpr4.cxx:612

ScInterpreter::ScLCM
void ScLCM()
Definition: interpr5.cxx:203

ScInterpreter::ScCritBinom
void ScCritBinom()
Definition: interpr3.cxx:1408

ScInterpreter::ScEMat
void ScEMat()
Definition: interpr5.cxx:730

ScInterpreter::ScFloor_Precise
void ScFloor_Precise()
Definition: interpr2.cxx:1208

ScInterpreter::phi
static double phi(double x)
Definition: interpr3.cxx:192

ScInterpreter::GetError
FormulaError GetError() const
Definition: interpre.hxx:1026

ScSingleRefData
Single reference (one address) into the sheet.
Definition: refdata.hxx:30

ScInterpreter::GetChiSqDistPDF
static double GetChiSqDistPDF(double fX, double fDF)
Definition: interpr3.cxx:686

ScInterpreter::ScRangeFunc
void ScRangeFunc()
Definition: interpr2.cxx:2549

ScInterpreter::ScCos
void ScCos()
Definition: interpr1.cxx:1845

ScInterpreter::nRetFmtType
SvNumFormatType nRetFmtType
Definition: interpre.hxx:219

ScInterpreter::CalculateSumX2MY2SumX2DY2
void CalculateSumX2MY2SumX2DY2(bool _bSumX2DY2)
Definition: interpr5.cxx:1801

ScInterpreter::ScLog10
void ScLog10()
Definition: interpr2.cxx:1295

ScInterpreter::ScPDuration
void ScPDuration()
Definition: interpr2.cxx:1887

etsSeason
Definition: interpre.hxx:125

ScInterpreter::Interpret
formula::StackVar Interpret()
Definition: interpr4.cxx:3939

ScInterpreter::ScIntersect
void ScIntersect()
Definition: interpr2.cxx:2402

ScInterpreter::ScLog
void ScLog()
Definition: interpr2.cxx:1268

ScInterpreter::ScStdNormDist_MS
void ScStdNormDist_MS()
Definition: interpr3.cxx:1603

ScInterpreter::PushSingleRef
void PushSingleRef(SCCOL nCol, SCROW nRow, SCTAB nTab)
Definition: interpr4.cxx:1804

ScInterpreter::ScNumberValue
void ScNumberValue()
Definition: interpr1.cxx:3349

ScInterpreter::ScLogest
void ScLogest()
Definition: interpr5.cxx:2403

ScInterpreter::ScAdd
void ScAdd()
Definition: interpr5.cxx:1274

ScInterpreter::GetFDist
double GetFDist(double x, double fF1, double fF2)
Definition: interpr3.cxx:637

ifSUMSQ
Definition: interpre.hxx:106

ScInterpreter::ScChiTest
void ScChiTest()
Definition: interpr3.cxx:2797

ifCOUNT2
Definition: interpre.hxx:110

ScInterpreter::ScTDist_MS
void ScTDist_MS()
Definition: interpr3.cxx:1676

ScInterpreter::ScTextJoin_MS
void ScTextJoin_MS()
Definition: interpr8.cxx:1511

ScInterpreter::xResult
formula::FormulaConstTokenRef xResult
Definition: interpre.hxx:202

ScInterpreter::mnSubTotalFlags
SubtotalFlags mnSubTotalFlags
Definition: interpre.hxx:221

ScInterpreter::ScRound
void ScRound()
Definition: interpr2.cxx:1002

ScInterpreter::ScOffset
void ScOffset()
Definition: interpr1.cxx:8374

ScInterpreter::ReverseStack
void ReverseStack(sal_uInt8 nParamCount)
Definition: interpr4.cxx:1977

ScInterpreter::SetLinkManager
void SetLinkManager(sfx2::LinkManager *pLinkMgr)
Definition: interpre.hxx:1023

ScInterpreter::ScEffect
void ScEffect()
Definition: interpr2.cxx:2345

sc::ParamIfsResult::mfCount
double mfCount
Definition: interpre.hxx:66

ScInterpreter::ScStandard
void ScStandard()
Definition: interpr3.cxx:3208

etsStatAdd
Definition: interpre.hxx:128

ScInterpreter::AssertFormulaMatrix
void AssertFormulaMatrix()
Definition: interpr4.cxx:4745

ScInterpreter::ScDiv
void ScDiv()
Definition: interpr5.cxx:1580

ScInterpreter::GetCellValueOrZero
double GetCellValueOrZero(const ScAddress &, ScRefCellValue &rCell)
Definition: interpr4.cxx:185

ScInterpreter::ScHypGeomDist
void ScHypGeomDist(int nMinParamCount)
Calculates a value of the hypergeometric distribution.
Definition: interpr3.cxx:1858

ScInterpreter::ScRoman
void ScRoman()
Definition: interpr2.cxx:3041

ScInterpreter::GetSortArray
void GetSortArray(sal_uInt8 nParamCount,::std::vector< double > &rSortArray,::std::vector< tools::Long > *pIndexOrder, bool bConvertTextInArray, bool bAllowEmptyArray)
Definition: interpr3.cxx:4125

ScInterpreter::ScLogNormInv
void ScLogNormInv()
Definition: interpr3.cxx:2145

ScInterpreter::ScFourier
void ScFourier()
Definition: interpr3.cxx:5491

ScInterpreter::GetMatrix
ScMatrixRef GetMatrix()
Definition: interpr5.cxx:478

sal_uLong
sal_uIntPtr sal_uLong

ScInterpreter::GetPercentileExclusive
double GetPercentileExclusive(::std::vector< double > &rArray, double fPercentile)
Definition: interpr3.cxx:3437

ScInterpreter::IsMissing
bool IsMissing() const
Definition: interpr4.cxx:1926

ScInterpreter::ScDBMin
void ScDBMin()
Definition: interpr1.cxx:7973

ScInterpreter::maCalcConfig
ScCalcConfig maCalcConfig
Definition: interpre.hxx:194

ScInterpreter::ScRRI
void ScRRI()
Definition: interpr2.cxx:1949

ScInterpreter::GetInt32WithDefault
sal_Int32 GetInt32WithDefault(sal_Int32 nDefault)
if GetDoubleWithDefault() not within int32 limits sets nGlobalError and returns SAL_MAX_INT32 ...
Definition: interpr4.cxx:2188

ScInterpreter::pCur
const formula::FormulaToken * pCur
Definition: interpre.hxx:208

ScInterpreter::ScNper
void ScNper()
Definition: interpr2.cxx:1999

ScInterpreter::ScRightB
void ScRightB()
Definition: interpr1.cxx:9099

ScInterpreter::DoubleRefToPosSingleRef
bool DoubleRefToPosSingleRef(const ScRange &rRange, ScAddress &rAdr)
Definition: interpr4.cxx:1985

ScInterpreter::CalculateSkew
bool CalculateSkew(double &fSum, double &fCount, double &vSum, std::vector< double > &values)
Definition: interpr3.cxx:3223

ScInterpreter::ScMax
void ScMax(bool bTextAsZero=false)
Definition: interpr1.cxx:3772

ScInterpreter::GetWeekendAndHolidayMasks_MS
FormulaError GetWeekendAndHolidayMasks_MS(const sal_uInt8 nParamCount, const sal_uInt32 nNullDate,::std::vector< double > &rSortArray, bool bWeekendMask[7], bool bWorkdayFunction)
Definition: interpr2.cxx:386

ScInterpreter::ConvertMatrixJumpConditionToMatrix
void ConvertMatrixJumpConditionToMatrix()
Definition: interpr4.cxx:1412

ScInterpreter::GetGamma
double GetGamma(double x)
You must ensure non integer arguments for fZ<1.
Definition: interpr3.cxx:582

ScInterpreter::ScIsEven
void ScIsEven()
Definition: interpr1.cxx:3111

ScInterpreter::ScMul
void ScMul()
Definition: interpr5.cxx:1503

ScInterpreter::ScFV
void ScFV()
Definition: interpr2.cxx:1981

ScInterpreter::ScGreater
void ScGreater()
Definition: interpr1.cxx:1214

ScInterpreter::ScDDB
void ScDDB()
Definition: interpr2.cxx:1688

ScInterpreter::ScDBVar
void ScDBVar()
Definition: interpr1.cxx:8039

ScJumpMatrix
Definition: jumpmatrix.hxx:58

ScInterpreter::ScCeil_MS
void ScCeil_MS()
Definition: interpr2.cxx:1099

ScInterpreter::ScHLookup
void ScHLookup()
Definition: interpr1.cxx:7194

ScInterpreter::bGlobalStackInUse
static thread_local bool bGlobalStackInUse
Definition: interpre.hxx:192

ScInterpreter::GetNumberSequenceArray
void GetNumberSequenceArray(sal_uInt8 nParamCount,::std::vector< double > &rArray, bool bConvertTextInArray)
Definition: interpr3.cxx:3942

ScInterpreter::ScColumn
void ScColumn()
Definition: interpr1.cxx:4374

ScInterpreter::ScCeil
void ScCeil(bool bODFF)
tdf69552 ODFF1.2 function CEILING and Excel function CEILING.MATH In essence, the difference between ...
Definition: interpr2.cxx:1059

ScInterpreter::PopSingleRef
void PopSingleRef(ScAddress &)
Definition: interpr4.cxx:901

ScInterpreter
Definition: interpre.hxx:139

ScInterpreter::FillEntry
bool FillEntry(ScQueryEntry &rEntry)
Definition: interpr1.cxx:7452

ScInterpreter::ScConcat_MS
void ScConcat_MS()
Definition: interpr8.cxx:1378

ScInterpreter::ScIfs_MS
void ScIfs_MS()
Definition: interpr8.cxx:1852

ScInterpreter::ScGetActDate
void ScGetActDate()
Definition: interpr2.cxx:98

ScInterpreter::ScDevSq
void ScDevSq()
Definition: interpr3.cxx:4440

ScInterpreter::PushDoubleRef
void PushDoubleRef(SCCOL nCol1, SCROW nRow1, SCTAB nTab1, SCCOL nCol2, SCROW nRow2, SCTAB nTab2)
Definition: interpr4.cxx:1814

ScInterpreter::ScBitAnd
void ScBitAnd()
Definition: interpr1.cxx:1640

ScInterpreter::ScIsNV
void ScIsNV()
Definition: interpr1.cxx:2838

ScInterpreter::GetChiDist
double GetChiDist(double fChi, double fDF)
You must ensure fDF>0.0.
Definition: interpr3.cxx:666

formula::FormulaToken::GetOpCode
OpCode GetOpCode() const

ifAVERAGE
Definition: interpre.hxx:108

ScInterpreter::ScIsEmpty
void ScIsEmpty()
Definition: interpr1.cxx:1966

ScInterpreter::GetRawStackType
formula::StackVar GetRawStackType()
Raw stack type without default replacements.
Definition: interpr4.cxx:1931

ScInterpreter::ScChiSqDist_MS
void ScChiSqDist_MS()
Definition: interpr3.cxx:747

ScInterpreter::CalculateRGPRKP
void CalculateRGPRKP(bool _bRKP)
Definition: interpr5.cxx:2408

ScInterpreter::ScIntercept
void ScIntercept()
Definition: interpr3.cxx:4726

ScRefCellValue
This is very similar to ScCellValue, except that it references the original value instead of copying ...
Definition: cellvalue.hxx:104

ScInterpreter::GetCellValue
double GetCellValue(const ScAddress &, ScRefCellValue &rCell)
Definition: interpr4.cxx:175

parclass.hxx

ScInterpreter::ScDde
void ScDde()
Definition: interpr2.cxx:2721

ScInterpreter::ScChiSqDist
void ScChiSqDist()
Definition: interpr3.cxx:724

ScInterpreter::ScPi
void ScPi()
Definition: interpr1.cxx:1731

ScInterpreter::ScStdNormDist
void ScStdNormDist()
Definition: interpr3.cxx:1598

ScInterpreter::ScGetDiffDate360
void ScGetDiffDate360()
Definition: interpr2.cxx:680

ScInterpreter::ScConcat
void ScConcat()
Definition: interpr1.cxx:9761

ScInterpreter::ScSumProduct
void ScSumProduct()
Definition: interpr5.cxx:1749

ScInterpreter::ScBitLshift
void ScBitLshift()
Definition: interpr1.cxx:1685

ScRange
Definition: address.hxx:497

ScInterpreter::ScModalValue_MS
void ScModalValue_MS(bool bSingle)
Definition: interpr3.cxx:3557

ScInterpreter::ScDB
void ScDB()
Definition: interpr2.cxx:1711

ScInterpreter::GetRetFormatIndex
sal_uLong GetRetFormatIndex() const
Definition: interpre.hxx:1032

ScInterpreter::ScDBCount2
void ScDBCount2()
Definition: interpr1.cxx:7933

ScInterpreter::ScGetMin
void ScGetMin()
Definition: interpr2.cxx:139

ScInterpreter::ScArcCotHyp
void ScArcCotHyp()
Definition: interpr1.cxx:1923

ScInterpreter::IsString
bool IsString()
Definition: interpr1.cxx:2020

ScInterpreter::ScEven
void ScEven()
Definition: interpr2.cxx:1231

ScInterpreter::ScPermut
void ScPermut()
Definition: interpr3.cxx:1196

ScInterpreter::ScRawSubtract
void ScRawSubtract()
Definition: interpr6.cxx:1068

ScInterpreter::ScGammaInv
void ScGammaInv()
Definition: interpr3.cxx:2174

sfx2::LinkManager

ScInterpreter::ScPoissonDist
void ScPoissonDist(bool bODFF)
Definition: interpr3.cxx:1783

ScInterpreter::GetTopNumberArray
std::vector< double > GetTopNumberArray(SCSIZE &rCol, SCSIZE &rRow)
Definition: interpr3.cxx:3857

ScInterpreter::ScEqual
void ScEqual()
Definition: interpr1.cxx:1163

ScInterpreter::ScRow
void ScRow()
Definition: interpr1.cxx:4478

ScInterpreter::ScFilterXML
void ScFilterXML()
Definition: interpr7.cxx:39

ScInterpreter::GetDoubleWithDefault
double GetDoubleWithDefault(double nDefault)
Definition: interpr4.cxx:2146

ScInterpreter::ScTrim
void ScTrim()
Definition: interpr1.cxx:3138

ScInterpreter::ScGammaDist
void ScGammaDist(bool bODFF)
Definition: interpr3.cxx:2093

ScInterpreter::IfErrorPushError
bool IfErrorPushError()
If nGlobalError is set push formula::FormulaErrorToken.
Definition: interpre.hxx:305

ScInterpreter::ConvertMatrixParameters
bool ConvertMatrixParameters()
Definition: interpr4.cxx:1436

ScInterpreter::PopDoubleRefOrSingleRef
bool PopDoubleRefOrSingleRef(ScAddress &rAdr)
Definition: interpr4.cxx:1316

ScInterpreter::ScRight
void ScRight()
Definition: interpr1.cxx:9291

ScInterpreter::ScGetActTime
void ScGetActTime()
Definition: interpr2.cxx:106

ScInterpreter::CreateTokenMatrixMap
static std::unique_ptr< ScTokenMatrixMap > CreateTokenMatrixMap()
Definition: interpr4.cxx:1431

ScInterpreter::GetTokenMatrixMap
ScTokenMatrixMap & GetTokenMatrixMap()
Definition: interpre.hxx:1054

ScInterpreter::pFormatter
SvNumberFormatter * pFormatter
Definition: interpre.hxx:206

ScInterpreter::PushCellResultToken
void PushCellResultToken(bool bDisplayEmptyAsString, const ScAddress &rAddress, SvNumFormatType *pRetTypeExpr, sal_uInt32 *pRetIndexExpr, bool bFinalResult=false)
Obtain cell result / content from address and push as temp token.
Definition: interpr4.cxx:681

sc::ParamIfsResult::mfMax
double mfMax
Definition: interpre.hxx:68

ScInterpreter::ScNoName
void ScNoName()
Definition: interpr3.cxx:177

ScInterpreter::CurFmtToFuncFmt
void CurFmtToFuncFmt()
Definition: interpre.hxx:465

ScInterpreter::ScCount2
void ScCount2()
Definition: interpr6.cxx:1063

kScInterpreterMaxStrLen
constexpr sal_Int32 kScInterpreterMaxStrLen
Arbitrary 256MB result string length limit.
Definition: interpre.hxx:94

ScInterpreter::PushTempTokenWithoutError
void PushTempTokenWithoutError(const formula::FormulaToken *)
Does not substitute with formula::FormulaErrorToken in case nGlobalError is set.
Definition: interpr4.cxx:641

ScInterpreter::PushParameterExpected
void PushParameterExpected()
Definition: interpr4.cxx:1901

ScInterpreter::ScRandbetween
void ScRandbetween()
Definition: interpr1.cxx:1796

SubtotalFlags
SubtotalFlags
Definition: global.hxx:250

ScInterpreter::ScCellExternal
void ScCellExternal()
Definition: interpr1.cxx:2427

ScInterpreter::SwitchToArrayRefList
bool SwitchToArrayRefList(ScMatrixRef &xResMat, SCSIZE nMatRows, double fCurrent, const std::function< void(SCSIZE i, double fCurrent)> &MatOpFunc, bool bDoMatOp)
Switch to array reference list if current TOS is one and create/init or update matrix and return true...
Definition: interpr1.cxx:3588

ScInterpreter::ScN
void ScN()
Definition: interpr1.cxx:3121

sal_Unicode
sal_uInt16 sal_Unicode

ScInterpreter::ScSumSQ
void ScSumSQ()
Definition: interpr6.cxx:1038

ScInterpreter::GetCellNumberFormat
sal_uInt32 GetCellNumberFormat(const ScAddress &rPos, ScRefCellValue &rCell)
Definition: interpr4.cxx:122

ScInterpreter::ScReplaceB
void ScReplaceB()
Definition: interpr1.cxx:9189

ifMIN
Definition: interpre.hxx:111

ScInterpreter::ScCeil_Precise
void ScCeil_Precise()
Definition: interpr2.cxx:1117

ScInterpreter::PopDouble
double PopDouble()
Definition: interpr4.cxx:775

ScInterpreter::ScInterpreter
ScInterpreter(ScFormulaCell *pCell, ScDocument &rDoc, ScInterpreterContext &rContext, const ScAddress &, ScTokenArray &, bool bForGroupThreading=false)
Definition: interpr4.cxx:3768

ScInterpreter::VOLATILE
Definition: interpre.hxx:180

ScInterpreter::GetBeta
double GetBeta(double fAlpha, double fBeta)
Definition: interpr3.cxx:797

nParamCount
char sal_uInt16 & nParamCount
Definition: callform.cxx:53

ScInterpreter::ScGetHour
void ScGetHour()
Definition: interpr2.cxx:158

ScInterpreter::ScSearchB
void ScSearchB()
Definition: interpr1.cxx:9246

ScGammaDistFunction
Definition: interpr3.cxx:2160

ScInterpreter::ScUnionFunc
void ScUnionFunc()
Definition: interpr2.cxx:2569

ScInterpreter::Fakultaet
double Fakultaet(double x)
Definition: interpr3.cxx:436

ScInterpreter::ScCorrel
void ScCorrel()
Definition: interpr3.cxx:4514

ScInterpreter::GetInt16
sal_Int16 GetInt16()
if GetDouble() not within int16 limits sets nGlobalError and returns SAL_MAX_INT16 ...
Definition: interpr4.cxx:2197

ScInterpreter::ScDBAverage
void ScDBAverage()
Definition: interpr1.cxx:7963

ScInterpreter::PushInt
void PushInt(int nVal)
Definition: interpr4.cxx:1776

ScInterpreter::ScAverage
void ScAverage(bool bTextAsZero=false)
Definition: interpr6.cxx:1053

ScInterpreter::nCurFmtType
SvNumFormatType nCurFmtType
Definition: interpre.hxx:218

ScInterpreter::GetStringPositionArgument
sal_Int32 GetStringPositionArgument()
Obtain a sal_Int32 suitable as string position or length argument.
Definition: interpre.hxx:1111

ScInterpreter::ScDeg
void ScDeg()
Definition: interpr1.cxx:1830

ScInterpreter::pTokenMatrixMap
std::unique_ptr< ScTokenMatrixMap > pTokenMatrixMap
Definition: interpre.hxx:204

SCSIZE
size_t SCSIZE
size_t typedef to be able to find places where code was changed from USHORT to size_t and is used to ...
Definition: address.hxx:45

ScInterpreter::ScNegBinomDist_MS
void ScNegBinomDist_MS()
Definition: interpr3.cxx:1522

ScInterpreter::GetNewMat
ScMatrixRef GetNewMat(SCSIZE nC, SCSIZE nR, bool bEmpty=false)
Definition: interpr5.cxx:298

ScInterpreter::mpGlobalConfig
static ScCalcConfig * mpGlobalConfig
Definition: interpre.hxx:189

ScInterpreter::ScMatTrans
void ScMatTrans()
Definition: interpr5.cxx:1127

ScInterpreter::ScSinHyp
void ScSinHyp()
Definition: interpr1.cxx:1880

ScInterpreter::ScGetDateValue
void ScGetDateValue()
Definition: interpr2.cxx:166

ScInterpreter::ScExpDist
void ScExpDist()
Definition: interpr3.cxx:1617

ScInterpreter::PushExternalDoubleRef
void PushExternalDoubleRef(sal_uInt16 nFileId, const OUString &rTabName, SCCOL nCol1, SCROW nRow1, SCTAB nTab1, SCCOL nCol2, SCROW nRow2, SCTAB nTab2)
Definition: interpr4.cxx:1837

ScInterpreter::ScFisher
void ScFisher()
Definition: interpr3.cxx:1147

ScInterpreter::ScGetPMT
static double ScGetPMT(double fRate, double fNper, double fPv, double fFv, bool bPayInAdvance)
Definition: interpr2.cxx:1913

ScInterpreter::CalculateSlopeIntercept
void CalculateSlopeIntercept(bool bSlope)
Definition: interpr3.cxx:4649

ScInterpreter::ScNormInv
void ScNormInv()
Definition: interpr3.cxx:2118

ScInterpreter::ScGetFV
static double ScGetFV(double fRate, double fNper, double fPmt, double fPv, bool bPayInAdvance)
Definition: interpr2.cxx:1964

ScIterFuncIf
ScIterFuncIf
Definition: interpre.hxx:115

ScInterpreter::MatrixJumpConditionToMatrix
void MatrixJumpConditionToMatrix()
Definition: interpre.hxx:1040

ScInterpreter::QueryMat
ScMatrixRef QueryMat(const ScMatrixRef &pMat, sc::CompareOptions &rOptions)
Definition: interpr1.cxx:1141

ScInterpreter::gaussinv
static double gaussinv(double x)
Definition: interpr3.cxx:265

ScETSType
ScETSType
Definition: interpre.hxx:121

ScInterpreter::ScNot
void ScNot()
Definition: interpr1.cxx:1610

ScInterpreter::ScProper
void ScProper()
Definition: interpr1.cxx:3160

calcconfig.hxx

ScInterpreter::fMaxGammaArgument
static const double fMaxGammaArgument
Definition: interpre.hxx:995

ScInterpreter::ScFindB
void ScFindB()
Definition: interpr1.cxx:9212

ScInterpreter::double_to_int32
sal_Int32 double_to_int32(double fVal)
Definition: interpr4.cxx:2155

ScMatrixRef
::boost::intrusive_ptr< ScMatrix > ScMatrixRef
Definition: types.hxx:26

ScInterpreter::ScWebservice
void ScWebservice()
Definition: interpr7.cxx:272

ScInterpreter::ScColumns
void ScColumns()
Definition: interpr1.cxx:4213

ScInterpreter::PushString
void PushString(const OUString &rStr)
Definition: interpr4.cxx:1793

ScInterpreter::pMyFormulaCell
ScFormulaCell * pMyFormulaCell
Definition: interpre.hxx:205

ScInterpreter::mnStringNoValueError
FormulaError mnStringNoValueError
Definition: interpre.hxx:220

ScInterpreter::ScArcSinHyp
void ScArcSinHyp()
Definition: interpr1.cxx:1900

ScDBQueryParamBase
Definition: queryparam.hxx:169

ScInterpreter::ScSecantHyp
void ScSecantHyp()
Definition: interpr1.cxx:1947

GetDoubleErrorValue
FormulaError GetDoubleErrorValue(double fVal)

ScInterpreter::ScMatDet
void ScMatDet()
Definition: interpr5.cxx:919

ScInterpreter::ScRandomImpl
void ScRandomImpl(const std::function< double(double fFirst, double fLast)> &RandomFunc, double fFirst, double fLast)
Definition: interpr1.cxx:1736

ScInterpreter::ScLinest
void ScLinest()
Definition: interpr5.cxx:2397

ScInterpreter::pStack
const formula::FormulaToken ** pStack
Definition: interpre.hxx:210

ScInterpreter::ScDBCount
void ScDBCount()
Definition: interpr1.cxx:7875

ScInterpreter::ScConvertOOo
void ScConvertOOo()
Definition: interpr2.cxx:3018

ScInterpreter::ScChooseJump
void ScChooseJump()
Definition: interpr1.cxx:407

ScInterpreter::ScIsString
void ScIsString()
Definition: interpr1.cxx:2088

formula::FormulaToken

ScInterpreter::PushError
void PushError(FormulaError nError)
Definition: interpr4.cxx:1895

ScInterpreter::CompareMat
sc::RangeMatrix CompareMat(ScQueryOp eOp, sc::CompareOptions *pOptions=nullptr)
Definition: interpr1.cxx:979

ScInterpreter::ScCount
void ScCount()
Definition: interpr6.cxx:1058

ScInterpreter::ScChiSqInv
void ScChiSqInv()
Definition: interpr3.cxx:2405

ScInterpreter::ScSumIf
void ScSumIf()
Definition: interpr1.cxx:5621

ScInterpreter::ScGetWeekOfYear
void ScGetWeekOfYear()
Definition: interpr2.cxx:245

ScInterpreter::GetTDist
double GetTDist(double T, double fDF, int nType)
Definition: interpr3.cxx:645

ScInterpreter::ScSheet
void ScSheet()
Definition: interpr1.cxx:4581

ScInterpreter::ScType
void ScType()
Definition: interpr1.cxx:2139

etsMult
Definition: interpre.hxx:124

ScInterpreter::ScFalse
void ScFalse()
Definition: interpr1.cxx:1824

FormulaTokenRef_less
Definition: interpre.hxx:132

ScInterpreter::ScGreaterEqual
void ScGreaterEqual()
Definition: interpr1.cxx:1248

ScInterpreter::ScNetWorkdays
void ScNetWorkdays(bool bOOXML_Version)
Definition: interpr2.cxx:503

ScChiDistFunction
Definition: interpr3.cxx:2356

ScInterpreter::ScColRowNameAuto
void ScColRowNameAuto()
Definition: interpr4.cxx:3670

ScInterpreter::IterateParametersIf
void IterateParametersIf(ScIterFuncIf)
Definition: interpr1.cxx:5191

ScQueryParam
Definition: queryparam.hxx:134

ScInterpreter::ScFisherInv
void ScFisherInv()
Definition: interpr3.cxx:1156

ScInterpreter::MakeMatNew
void MakeMatNew(ScMatrixRef &rMat, SCSIZE nC, SCSIZE nR)
Definition: interpr5.cxx:283

ScInterpreter::PopRangeMatrix
sc::RangeMatrix PopRangeMatrix()
Definition: interpr4.cxx:1642

ScInterpreter::ScIsOdd
void ScIsOdd()
Definition: interpr1.cxx:3116

ScInterpreter::ScSub
void ScSub()
Definition: interpr5.cxx:1498

ScInterpreter::GetDouble
double GetDouble()
Definition: interpr4.cxx:2065

ScInterpreter::GetDBParams
std::unique_ptr< ScDBQueryParamBase > GetDBParams(bool &rMissingField)
Definition: interpr1.cxx:7659

ScInterpreter::gauss
static double gauss(double x)
Definition: interpr3.cxx:212

externalrefmgr.hxx

ScInterpreter::CreateCellArr
bool CreateCellArr(SCCOL nCol1, SCROW nRow1, SCTAB nTab1, SCCOL nCol2, SCROW nRow2, SCTAB nTab2, sal_uInt8 *pCellArr)
Definition: interpr4.cxx:456

ScInterpreter::mrContext
ScInterpreterContext & mrContext
Definition: interpre.hxx:198

ScInterpreter::ScInt
void ScInt()
Definition: interpr2.cxx:962

textsearch.hxx

ScInterpreter::ScOdd
void ScOdd()
Definition: interpr2.cxx:1240

ScInterpreter::ScEuroConvert
void ScEuroConvert()
Definition: interpr2.cxx:3313

ScInterpreter::LookupQueryWithCache
bool LookupQueryWithCache(ScAddress &o_rResultPos, const ScQueryParam &rParam) const
Definition: interpr1.cxx:10032

ScInterpreter::MustHaveParamCount
bool MustHaveParamCount(short nAct, short nMust)
Definition: interpre.hxx:1061

ScInterpreter::SetGlobalConfig
static void SetGlobalConfig(const ScCalcConfig &rConfig)
Definition: interpr4.cxx:3862

ScInterpreter::ScSkewp
void ScSkewp()
Definition: interpr3.cxx:3374

ScInterpreter::ScRows
void ScRows()
Definition: interpr1.cxx:4270

ScInterpreter::PopMatrix
ScMatrixRef PopMatrix()
Definition: interpr4.cxx:1610

ScInterpreter::ScFloor_MS
void ScFloor_MS()
Definition: interpr2.cxx:1187

ScInterpreter::Push
void Push(const formula::FormulaToken &r)
Does substitute with formula::FormulaErrorToken in case nGlobalError is set and the token passed is n...
Definition: interpr4.cxx:594

ScInterpreter::PopToken
formula::FormulaConstTokenRef PopToken()
Definition: interpr4.cxx:760

ScInterpreter::ScGeoMean
void ScGeoMean()
Definition: interpr3.cxx:3036

ScInterpreter::IsEven
bool IsEven()
Definition: interpr1.cxx:3017

ScInterpreter::DoubleRefToRange
void DoubleRefToRange(const ScComplexRefData &, ScRange &, bool bDontCheckForTableOp=false)
Definition: interpr4.cxx:1023

ScInterpreter::CalculateSmallLarge
void CalculateSmallLarge(bool bSmall)
Definition: interpr3.cxx:3643

ScTokenMatrixMap
::std::map< const formula::FormulaConstTokenRef, formula::FormulaConstTokenRef, FormulaTokenRef_less > ScTokenMatrixMap
Definition: interpre.hxx:137

ScRefAddress
Definition: address.hxx:835

ScInterpreter::ScAddressFunc
void ScAddressFunc()
Definition: interpr1.cxx:8272

ScInterpreter::GlobalExit
static void GlobalExit()
Definition: interpr4.cxx:3878

ScInterpreter::GetDoubleOrStringFromMatrix
ScMatValType GetDoubleOrStringFromMatrix(double &rDouble, svl::SharedString &rString)
Definition: interpr4.cxx:2403

ScInterpreter::ScMIRR
void ScMIRR()
Definition: interpr2.cxx:1468

SAL_MAX_INT32
#define SAL_MAX_INT32

ScInterpreter::ScTInv
void ScTInv(int nType)
Definition: interpr3.cxx:2266

ScInterpreter::div
static double div(const double &fNumerator, const double &fDenominator)
Fail safe division, returning a FormulaError::DivisionByZero coded into a double if denominator is 0...
Definition: interpre.hxx:1157

ScInterpreter::ConvertStringToValue
double ConvertStringToValue(const OUString &)
Definition: interpr4.cxx:160

ScInterpreter::GetStringResult
const svl::SharedString & GetStringResult() const
Definition: interpr4.cxx:4750

ScInterpreter::ScFInv
void ScFInv()
Definition: interpr3.cxx:2314

ScInterpreter::sp
sal_uInt16 sp
Definition: interpre.hxx:212

ScInterpreter::ScLookup
void ScLookup()
Definition: interpr1.cxx:6579

ScInterpreter::ScLen
void ScLen()
Definition: interpr1.cxx:3190

ScInterpreter::ScTrimMean
void ScTrimMean()
Definition: interpr3.cxx:3828

ScInterpreter::VOLATILE_MACRO
Definition: interpre.hxx:181

ScInterpreter::ScSYD
void ScSYD()
Definition: interpr2.cxx:1647

ScInterpreter::ScVar
void ScVar(bool bTextAsZero=false)
Definition: interpr1.cxx:4150

ScInterpreter::ScCountEmptyCells
void ScCountEmptyCells()
Definition: interpr1.cxx:5111

ScInterpreter::mpLinkManager
sfx2::LinkManager * mpLinkManager
Definition: interpre.hxx:200

ScInterpreter::ScGetIsoWeekOfYear
void ScGetIsoWeekOfYear()
Definition: interpr2.cxx:295

ScInterpreter::IsTableOpInRange
bool IsTableOpInRange(const ScRange &)
Definition: interpr4.cxx:104

ScInterpreter::ScLogGamma
void ScLogGamma()
Definition: interpr3.cxx:788

ScInterpreter::ScGetDateDif
void ScGetDateDif()
Definition: interpr2.cxx:775

ScInterpreter::ScPMT
void ScPMT()
Definition: interpr2.cxx:1931

ScInterpreter::PopString
svl::SharedString PopString()
Definition: interpr4.cxx:807

ScInterpreter::CalculatePearsonCovar
void CalculatePearsonCovar(bool _bPearson, bool _bStexy, bool _bSample)
Definition: interpr3.cxx:4535

ScInterpreter::PushDouble
void PushDouble(double nVal)
Definition: interpr4.cxx:1769

ScInterpreter::ScIsRef
void ScIsRef()
Definition: interpr1.cxx:2568

ScInterpreter::ScBinomDist
void ScBinomDist()
Definition: interpr3.cxx:1344

SCCOL
sal_Int16 SCCOL
Definition: types.hxx:22

ScInterpreter::ScGetIpmt
double ScGetIpmt(double fRate, double fPer, double fNper, double fPv, double fFv, bool bPayInAdvance, double &fPmt)
Definition: interpr2.cxx:2186

ScInterpreter::ScErrorType
void ScErrorType()
Definition: interpr1.cxx:9848

ScInterpreter::ScTan
void ScTan()
Definition: interpr1.cxx:1850

ScInterpreter::ScPercentile
void ScPercentile(bool bInclusive)
Definition: interpr3.cxx:3467

ScInterpreterContext
Definition: interpretercontext.hxx:54

ScInterpreter::GetGammaDist
double GetGammaDist(double fX, double fAlpha, double fLambda)
Gamma distribution, cumulative distribution function.
Definition: interpr6.cxx:198

ScInterpreter::GetRefListArrayMaxSize
size_t GetRefListArrayMaxSize(short nParamCount)
Check for array of references to determine the maximum size of a return column vector if in array con...
Definition: interpr6.cxx:469

ScInterpreter::ScCot
void ScCot()
Definition: interpr1.cxx:1855

ScInterpreter::GetLogGamma
static double GetLogGamma(double x)
You must ensure fZ>0.
Definition: interpr3.cxx:626

ScInterpreter::ScAbs
void ScAbs()
Definition: interpr2.cxx:957

ScInterpreter::ScTTT
void ScTTT()
Definition: interpr4.cxx:3757

nParam
sal_uInt16 & nParam
Definition: callform.cxx:57

sc
Definition: celltextattr.cxx:13

ScInterpreter::ScMaxIfs_MS
void ScMaxIfs_MS()
Definition: interpr1.cxx:6562

ScDBRangeBase
Base class for abstracting range data backends for database functions.
Definition: doubleref.hxx:38

ScInterpreter::ScJis
void ScJis()
Definition: interpr1.cxx:3541

ScInterpreter::CreateMatrixFromDoubleRef
ScMatrixRef CreateMatrixFromDoubleRef(const formula::FormulaToken *pToken, SCCOL nCol1, SCROW nRow1, SCTAB nTab1, SCCOL nCol2, SCROW nRow2, SCTAB nTab2)
Definition: interpr5.cxx:316

ScInterpreter::PopDoubleRef
void PopDoubleRef(ScRange &rRange, short &rParam, size_t &rRefInList)
If formula::StackVar formula::svDoubleRef pop ScDoubleRefToken and return values of ScComplexRefData...
Definition: interpr4.cxx:1041

formula::FormulaToken::IsInForceArray
bool IsInForceArray() const

ScInterpreter::ScMedian
void ScMedian()
Definition: interpr3.cxx:3403

ScInterpreter::ScArcCos
void ScArcCos()
Definition: interpr1.cxx:1865

ScInterpreter::ScMatValue
void ScMatValue()
Definition: interpr5.cxx:629

ScInterpreter::ScAmpersand
void ScAmpersand()
Definition: interpr5.cxx:1407

ScInterpreter::ScSlope
void ScSlope()
Definition: interpr3.cxx:4721

ScInterpreter::ScSum
void ScSum()
Definition: interpr6.cxx:1043

ScInterpreter::ScArcTan
void ScArcTan()
Definition: interpr1.cxx:1870

ScInterpreter::ScDBGet
void ScDBGet()
Definition: interpr4.cxx:2474

ScInterpreter::GetOrCreateGlobalConfig
static ScCalcConfig & GetOrCreateGlobalConfig()
Definition: interpr4.cxx:3855

ScInterpreter::ScIsFormula
void ScIsFormula()
Definition: interpr1.cxx:2691

ScInterpreter::QuickSort
static void QuickSort(::std::vector< double > &rSortArray,::std::vector< tools::Long > *pIndexOrder)
Definition: interpr3.cxx:4192

ScInterpreter::ScSqrt
void ScSqrt()
Definition: interpr1.cxx:1957

ScInterpreter::GetDoubleFromMatrix
double GetDoubleFromMatrix(const ScMatrixRef &pMat)
Definition: interpr4.cxx:2024

ScInterpreter::CreateFormulaDoubleToken
formula::FormulaToken * CreateFormulaDoubleToken(double fVal, SvNumFormatType nFmt=SvNumFormatType::NUMBER)
Definition: interpr4.cxx:1734

ScInterpreter::MustHaveParamCountMin
bool MustHaveParamCountMin(short nAct, short nMin)
Definition: interpre.hxx:1083

ScInterpreter::GetRetFormatType
SvNumFormatType GetRetFormatType() const
Definition: interpre.hxx:1031

ScInterpreter::PushMatrix
void PushMatrix(const sc::RangeMatrix &rMat)
Definition: interpr4.cxx:1870

ScInterpreter::ScTDist_T
void ScTDist_T(int nTails)
Definition: interpr3.cxx:1658

ifAVERAGEIF
Definition: interpre.hxx:118

ScInterpreter::ScKurt
void ScKurt()
Definition: interpr3.cxx:2873

ScInterpreter::pArr
ScTokenArray * pArr
Definition: interpre.hxx:197

ScInterpreter::ScErrorType_ODF
void ScErrorType_ODF()
Definition: interpr1.cxx:9862

ScInterpreter::ScIfJump
void ScIfJump()
Definition: interpr1.cxx:84

ScInterpreter::GetCellErrCode
static FormulaError GetCellErrCode(const ScRefCellValue &rCell)
Definition: interpr4.cxx:155

ScInterpreter::meVolatileType
VolatileType meVolatileType
Definition: interpre.hxx:226

ScInterpreter::PushExternalSingleRef
void PushExternalSingleRef(sal_uInt16 nFileId, const OUString &rTabName, SCCOL nCol, SCROW nRow, SCTAB nTab)
Definition: interpr4.cxx:1825

ScInterpreter::ScConfidence
void ScConfidence()
Definition: interpr3.cxx:2425

ScInterpreter::QueryMatrixType
void QueryMatrixType(const ScMatrixRef &xMat, SvNumFormatType &rRetTypeExpr, sal_uInt32 &rRetIndexExpr)
Definition: interpr4.cxx:1682

SvNumFormatType
SvNumFormatType

ScInterpreter::ScMidB
void ScMidB()
Definition: interpr1.cxx:9169

ScInterpreter::GetCellString
void GetCellString(svl::SharedString &rStr, ScRefCellValue &rCell)
Definition: interpr4.cxx:242

ScInterpreter::ScCotHyp
void ScCotHyp()
Definition: interpr1.cxx:1895

ScInterpreter::ScMod
void ScMod()
Definition: interpr2.cxx:2381

ScInterpreter::ScCountIfs
void ScCountIfs()
Definition: interpr1.cxx:6527

ScInterpreter::ScText
void ScText()
Definition: interpr1.cxx:9601

ScInterpreter::ScNeg
void ScNeg()
Definition: interpr1.cxx:1564

ScInterpreter::ScGetYear
void ScGetYear()
Definition: interpr2.cxx:118

ScInterpreter::ScIpmt
void ScIpmt()
Definition: interpr2.cxx:2209

ScInterpreter::ScAverageIfs
void ScAverageIfs()
Definition: interpr1.cxx:6510

ScInterpreter::cPar
sal_uInt8 cPar
Definition: interpre.hxx:222

ScInterpreter::ScAreas
void ScAreas()
Definition: interpr1.cxx:8754

ScInterpreter::nGlobalError
FormulaError nGlobalError
Definition: interpre.hxx:211

ScInterpreter::ScFTest
void ScFTest()
Definition: interpr3.cxx:2732

ScInterpreter::ScGetTime
void ScGetTime()
Definition: interpr2.cxx:654

ScInterpreter::CreateStringArr
bool CreateStringArr(SCCOL nCol1, SCROW nRow1, SCTAB nTab1, SCCOL nCol2, SCROW nRow2, SCTAB nTab2, sal_uInt8 *pCellArr)
Definition: interpr4.cxx:359

ScInterpreter::GetStringFromMatrix
svl::SharedString GetStringFromMatrix(const ScMatrixRef &pMat)
Definition: interpr4.cxx:2381

ScInterpreter::GetUpRegIGamma
double GetUpRegIGamma(double fA, double fX)
You must ensure fA>0.0 && fX>0.0)
Definition: interpr6.cxx:130

ScParameterClassification::HasForceArray
static bool HasForceArray(OpCode eOp)
Whether OpCode has a parameter of type ForceArray or ReferenceOrForceArray.
Definition: parclass.hxx:64

ScInterpreter::ScDBStdDev
void ScDBStdDev()
Definition: interpr1.cxx:8025

ScInterpreter::JumpMatrix
bool JumpMatrix(short nStackLevel)
Definition: interpr1.cxx:536

ScInterpreter::taylor
static double taylor(const double *pPolynom, sal_uInt16 nMax, double x)
Definition: interpr3.cxx:202

ScInterpreter::ScIsLogical
void ScIsLogical()
Definition: interpr1.cxx:2098

SvNumberFormatter

math.hxx

ScInterpreter::ScChiDist
void ScChiDist(bool bODFF)
Definition: interpr3.cxx:1743

ScInterpreter::ScNPV
void ScNPV()
Definition: interpr2.cxx:1304

ScInterpreter::GetDateSerial
double GetDateSerial(sal_Int16 nYear, sal_Int16 nMonth, sal_Int16 nDay, bool bStrict)
Obtain the date serial number for a given date.
Definition: interpr2.cxx:58

ScInterpreter::PopRefListPushMatrixOrRef
void PopRefListPushMatrixOrRef()
Definition: interpr4.cxx:1352

ScChiSqDistFunction
Definition: interpr3.cxx:2391

ScInterpreter::GetResultType
formula::StackVar GetResultType() const
Definition: interpre.hxx:1027

ScInterpreter::ScNotEqual
void ScNotEqual()
Definition: interpr1.cxx:1180

ScInterpreter::ScRoundDown
void ScRoundDown()
Definition: interpr2.cxx:1007

ScInterpreter::ScXor
void ScXor()
Definition: interpr1.cxx:1462

ScInterpreter::ScCumPrinc
void ScCumPrinc()
Definition: interpr2.cxx:2302

ScInterpreter::ScCosecantHyp
void ScCosecantHyp()
Definition: interpr1.cxx:1942

ScInterpreter::nFuncFmtIndex
sal_uInt32 nFuncFmtIndex
Definition: interpre.hxx:214

ScInterpreter::ScSheets
void ScSheets()
Definition: interpr1.cxx:4327

ScInterpreter::GetStackType
formula::StackVar GetStackType()
Stack type with replacement of defaults, e.g. svMissing and formula::svEmptyCell will result in formu...
Definition: interpr4.cxx:1946

ScInterpreter::CheckMatrix
bool CheckMatrix(bool _bLOG, sal_uInt8 &nCase, SCSIZE &nCX, SCSIZE &nCY, SCSIZE &nRX, SCSIZE &nRY, SCSIZE &M, SCSIZE &N, ScMatrixRef &pMatX, ScMatrixRef &pMatY)
Definition: interpr5.cxx:2291

ScInterpreter::ScAsc
void ScAsc()
Definition: interpr1.cxx:3553

ScInterpreter::ScDBStdDevP
void ScDBStdDevP()
Definition: interpr1.cxx:8032

ScInterpreter::ScPV
void ScPV()
Definition: interpr2.cxx:1629

ScInterpreter::ReplaceCell
void ReplaceCell(ScAddress &)
Definition: interpr4.cxx:85

ScInterpreter::ScConfidenceT
void ScConfidenceT()
Definition: interpr3.cxx:2439

ScInterpreter::pGlobalStack
static thread_local std::unique_ptr< ScTokenStack > pGlobalStack
Definition: interpre.hxx:191

ScInterpreter::ScFloor
void ScFloor(bool bODFF)
tdf69552 ODFF1.2 function FLOOR and Excel function FLOOR.MATH In essence, the difference between the ...
Definition: interpr2.cxx:1147

ScInterpreter::GetValueCellValue
double GetValueCellValue(const ScAddress &, double fOrig)
Only ValueCell, formula cells already store the result rounded.
Definition: interpr4.cxx:145

SbxVariable

ScInterpreter::ScMissing
void ScMissing()
Definition: interpr4.cxx:3090

ScInterpreter::ScDBVarP
void ScDBVarP()
Definition: interpr1.cxx:8046

FormulaError
FormulaError

ScInterpreter::GetByte
sal_uInt8 GetByte() const
Definition: interpre.hxx:426

ScInterpreter::ScGetSec
void ScGetSec()
Definition: interpr2.cxx:147

ScInterpreter::SetSbxVariable
bool SetSbxVariable(SbxVariable *pVar, const ScAddress &)

ScInterpreter::GetGlobalConfig
static const ScCalcConfig & GetGlobalConfig()
Definition: interpr4.cxx:3867

ScInterpreter::ScSLN
void ScSLN()
Definition: interpr2.cxx:1901

ScTokenStack
Definition: interpre.hxx:98

ScInterpreter::ScExp
void ScExp()
Definition: interpr1.cxx:1952

ScInterpreter::ScCosHyp
void ScCosHyp()
Definition: interpr1.cxx:1885

ScInterpreter::ScIndex
void ScIndex()
Definition: interpr1.cxx:8536

ScInterpreter::ValidateRef
void ValidateRef(const ScSingleRefData &rRef)
Definition: interpr4.cxx:835

ScInterpreter::CalculateTrendGrowth
void CalculateTrendGrowth(bool _bGrowth)
Definition: interpr5.cxx:2932

stream
Reference< XOutputStream > stream

ScInterpreter::mrStrPool
svl::SharedStringPool & mrStrPool
Definition: interpre.hxx:201

ScInterpreter::bCalcAsShown
bool bCalcAsShown
Definition: interpre.hxx:223

ScInterpreter::GetBinomDistPMF
double GetBinomDistPMF(double x, double n, double p)
Definition: interpr3.cxx:1229

ScInterpreter::GetGammaContFraction
double GetGammaContFraction(double fA, double fX)
You must ensure fA>0.0 && fX>0.0 valid results only if fX > fA+1.0 uses continued fraction with odd i...
Definition: interpr6.cxx:44

sc::ParamIfsResult
Definition: interpre.hxx:62

ScInterpreter::Init
void Init(ScFormulaCell *pCell, const ScAddress &rPos, ScTokenArray &rTokArray)
Definition: interpr4.cxx:3831

ScInterpreter::PopDBDoubleRef
ScDBRangeBase * PopDBDoubleRef()
Definition: interpr4.cxx:959

ScInterpreter::GetWeekendAndHolidayMasks
FormulaError GetWeekendAndHolidayMasks(const sal_uInt8 nParamCount, const sal_uInt32 nNullDate,::std::vector< double > &rSortArray, bool bWeekendMask[7])
Definition: interpr2.cxx:346

ScInterpreter::IterateParameters
void IterateParameters(ScIterFunc, bool bTextAsZero=false)
Definition: interpr6.cxx:511

ScCalcConfig
Configuration options for formula interpreter.
Definition: calcconfig.hxx:44

ScInterpreter::ScTanHyp
void ScTanHyp()
Definition: interpr1.cxx:1890

ScInterpreter::CalculateSkewOrSkewp
void CalculateSkewOrSkewp(bool bSkewp)
Definition: interpr3.cxx:3329

ScInterpreter::ScLeft
void ScLeft()
Definition: interpr1.cxx:8985

ScInterpreter::ScMid
void ScMid()
Definition: interpr1.cxx:9567

ScInterpreter::ScUpper
void ScUpper()
Definition: interpr1.cxx:3154

ScAddress
Definition: address.hxx:194

ScInterpreter::ScSmall
void ScSmall()
Definition: interpr3.cxx:3728

ScInterpreter::ScMatRef
void ScMatRef()
Definition: interpr5.cxx:3230

ScInterpreter::maxsp
sal_uInt16 maxsp
Definition: interpre.hxx:213

ScInterpreter::PushIllegalArgument
void PushIllegalArgument()
Definition: interpr4.cxx:1911

ScInterpreter::ScEncodeURL
void ScEncodeURL()
Returns a string in which all non-alphanumeric characters except stroke and underscore (-_) have been...
Definition: interpr7.cxx:413

ScInterpreter::GetUInt32
sal_uInt32 GetUInt32()
if GetDouble() not within uint32 limits sets nGlobalError and returns SAL_MAX_UINT32 ...
Definition: interpr4.cxx:2226

ScInterpreter::ScReplace
void ScReplace()
Definition: interpr1.cxx:8847

ScExternalRefCache::TokenRef
::formula::FormulaTokenRef TokenRef
Definition: externalrefmgr.hxx:84

ScInterpreter::ScGetDate
void ScGetDate()
Definition: interpr2.cxx:635

ScInterpreter::ScWeeknumOOo
void ScWeeknumOOo()
Definition: interpr2.cxx:233

ScInterpreter::ScB
void ScB()
Definition: interpr3.cxx:1277

ScInterpreter::ScCumIpmt
void ScCumIpmt()
Definition: interpr2.cxx:2260

SCROW
sal_Int32 SCROW
Definition: types.hxx:18

ScInterpreter::ScLower
void ScLower()
Definition: interpr1.cxx:3184

ScInterpreter::ScIsNonString
void ScIsNonString()
Definition: interpr1.cxx:2093

svl::SharedString

ScInterpreter::ScModalValue
void ScModalValue()
Definition: interpr3.cxx:3513

ScInterpreter::ScISPMT
void ScISPMT()
Definition: interpr2.cxx:1593

ScInterpreter::PushNA
void PushNA()
Definition: interpr4.cxx:1916

ScInterpreter::ScBitRshift
void ScBitRshift()
Definition: interpr1.cxx:1708

ScInterpreter::PushWithoutError
void PushWithoutError(const formula::FormulaToken &r)
Does not substitute with formula::FormulaErrorToken in case nGlobalError is set.
Definition: interpr4.cxx:578

ScInterpreter::ScAnd
void ScAnd()
Definition: interpr1.cxx:1265

ScInterpreter::ScMinIfs_MS
void ScMinIfs_MS()
Definition: interpr1.cxx:6544

ScInterpreter::GetLogBeta
static double GetLogBeta(double fAlpha, double fBeta)
Definition: interpr3.cxx:830

ScInterpreter::ScArcCot
void ScArcCot()
Definition: interpr1.cxx:1875

ScInterpreter::RateIteration
static bool RateIteration(double fNper, double fPayment, double fPv, double fFv, bool bPayType, double &fGuess)
Definition: interpr2.cxx:2026

ScInterpreter::ScStyle
void ScStyle()
Definition: interpr2.cxx:2654

ScInterpreter::ScAggregate
void ScAggregate()
Definition: interpr1.cxx:7563

ScInterpreter::ScStDevP
void ScStDevP(bool bTextAsZero=false)
Definition: interpr1.cxx:4184

ScInterpreter::ScLarge
void ScLarge()
Definition: interpr3.cxx:3723

ScInterpreter::ScFind
void ScFind()
Definition: interpr1.cxx:8941

ifSUMIF
Definition: interpre.hxx:117

ScInterpreter::GetDayOfWeek
static sal_Int16 GetDayOfWeek(sal_Int32 n)
Definition: interpre.hxx:1162

ScInterpreter::BinomKoeff
static double BinomKoeff(double n, double k)
Definition: interpr3.cxx:457

ScInterpreter::ScPlusMinus
void ScPlusMinus()
Definition: interpr2.cxx:946

ScInterpreter::ScGetDDB
static double ScGetDDB(double fCost, double fSalvage, double fLife, double fPeriod, double fFactor)
Definition: interpr2.cxx:1662

ScInterpreter::GetChiSqDistCDF
double GetChiSqDistCDF(double fX, double fDF)
You must ensure fDF>0.0.
Definition: interpr3.cxx:678

ScInterpreter::ScBetaDist
void ScBetaDist()
Definition: interpr3.cxx:1033

ScInterpreter::ScSumX2DY2
void ScSumX2DY2()
Definition: interpr5.cxx:1841

ScInterpreter::ScDBMax
void ScDBMax()
Definition: interpr1.cxx:7968

ScInterpreter::DetectSearchType
static utl::SearchParam::SearchType DetectSearchType(const OUString &rStr, const ScDocument &rDoc)
Detect if string should be used as regular expression or wildcard expression or literal string...
Definition: interpr1.cxx:9958

ScInterpreter::ScArabic
void ScArabic()
Definition: interpr2.cxx:3127

sal_uInt8
unsigned char sal_uInt8

ScInterpreter::ScForecast_Ets
void ScForecast_Ets(ScETSType eETSType)
Definition: interpr8.cxx:1171

ScInterpreter::ScLenB
void ScLenB()
Definition: interpr1.cxx:9067

ScInterpreter::ScRandom
void ScRandom()
Definition: interpr1.cxx:1787

ScInterpreter::CreateDoubleArr
bool CreateDoubleArr(SCCOL nCol1, SCROW nRow1, SCTAB nTab1, SCCOL nCol2, SCROW nRow2, SCTAB nTab2, sal_uInt8 *pCellArr)
Definition: interpr4.cxx:277

ScInterpreter::ScMatInv
void ScMatInv()
Definition: interpr5.cxx:966

ScInterpreter::bMatrixFormula
bool bMatrixFormula
Definition: interpre.hxx:224

ScInterpreter::PopDoubleRefPushMatrix
void PopDoubleRefPushMatrix()
Definition: interpr4.cxx:1338

ScInterpreter::GetErrorType
FormulaError GetErrorType()
Definition: interpr1.cxx:9776

ScInterpreter::ScIsError
void ScIsError()
Definition: interpr1.cxx:2958

ScInterpreter::MayBeRegExp
static bool MayBeRegExp(const OUString &rStr)
Could string be a regular expression? if regularExpressions are disabled the function returns false r...
Definition: interpr1.cxx:9918

ScInterpreter::mrDoc
ScDocument & mrDoc
Definition: interpre.hxx:199

ScInterpreter::ScTrend
void ScTrend()
Definition: interpr5.cxx:2922

ScInterpreter::CalculateLookup
void CalculateLookup(bool bHLookup)
Definition: interpr1.cxx:7199

ScInterpreter::ScCurrency
void ScCurrency()
Definition: interpr1.cxx:8790

ScInterpreter::ScLeftB
void ScLeftB()
Definition: interpr1.cxx:9148

ScExternalRefCache::TokenArrayRef
std::shared_ptr< ScTokenArray > TokenArrayRef
Definition: externalrefmgr.hxx:85

ScInterpreter::VolatileType
VolatileType
Definition: interpre.hxx:179

ScInterpreter::ScCurrent
void ScCurrent()
Definition: interpr2.cxx:2642

ScInterpreter::GetStVarParams
void GetStVarParams(bool bTextAsZero, double(*VarResult)(double fVal, size_t nValCount))
Definition: interpr1.cxx:3930

ScInterpreter::ScInterVDB
static double ScInterVDB(double fCost, double fSalvage, double fLife, double fLife1, double fPeriod, double fFactor)
Definition: interpr2.cxx:1756

tokenarray.hxx

svl::SharedStringPool

ScInterpreter::pJumpMatrix
ScJumpMatrix * pJumpMatrix
Definition: interpre.hxx:203

ScInterpreter::ScNegBinomDist
void ScNegBinomDist()
Definition: interpr3.cxx:1502

ScInterpreter::ScLogNormDist
void ScLogNormDist(int nMinParamCount)
Definition: interpr3.cxx:1568

ScInterpreter::GetTInv
double GetTInv(double fAlpha, double fSize, int nType)
Definition: interpr3.cxx:2290

ScInterpreter::ScDBSum
void ScDBSum()
Definition: interpr1.cxx:7870

ifPRODUCT
Definition: interpre.hxx:107

ScInterpreter::ScChar
void ScChar()
Definition: interpr1.cxx:3481

ScInterpreter::ScPhi
void ScPhi()
Definition: interpr3.cxx:1137

ScInterpreter::aPos
ScAddress aPos
Definition: interpre.hxx:196

ScMatValType
ScMatValType
Definition: types.hxx:32

ScInterpreter::ScWorkday_MS
void ScWorkday_MS()
Definition: interpr2.cxx:563

ScInterpreter::MatConcat
ScMatrixRef MatConcat(const ScMatrixRef &pMat1, const ScMatrixRef &pMat2)
Definition: interpr5.cxx:1230

ScInterpreter::ScBetaDist_MS
void ScBetaDist_MS()
Microsoft version has parameters in different order Also, upper and lowerbound are optional and have ...
Definition: interpr3.cxx:1097

ScInterpreter::SingleRefToVars
void SingleRefToVars(const ScSingleRefData &rRef, SCCOL &rCol, SCROW &rRow, SCTAB &rTab)
Definition: interpr4.cxx:857

ScInterpreter::GetStringFromDouble
svl::SharedString GetStringFromDouble(const double fVal)
Definition: interpr4.cxx:2464

ScInterpreter::ScCosecant
void ScCosecant()
Definition: interpr1.cxx:1932

ScInterpreter::ScNormDist
void ScNormDist(int nMinParamCount)
Definition: interpr3.cxx:1548

ScInterpreter::ScSubTotal
void ScSubTotal()
Definition: interpr1.cxx:7516

ScInterpreter::ScLess
void ScLess()
Definition: interpr1.cxx:1197

ScInterpreter::RoundNumber
void RoundNumber(rtl_math_RoundingMode eMode)
Definition: interpr2.cxx:967

ScInterpreter::ScBahtText
void ScBahtText()
Definition: interpr2.cxx:3485

nType
QPRO_FUNC_TYPE nType
Definition: qproform.cxx:400

ScExternalRefCache::CellFormat
Definition: externalrefmgr.hxx:95

ScInterpreter::GetString
svl::SharedString GetString()
Definition: interpr4.cxx:2302

etsStatMult
Definition: interpre.hxx:129

svl
These need to be in global namespace just like their respective types are.

ScInterpreter::GetNumResult
double GetNumResult() const
Definition: interpre.hxx:1029

ScInterpreter::ScVLookup
void ScVLookup()
Definition: interpr1.cxx:7511

ScInterpreter::ScTrue
void ScTrue()
Definition: interpr1.cxx:1818

ScInterpreter::~ScInterpreter
~ScInterpreter()
Definition: interpr4.cxx:3823

ScInterpreter::GetGammaSeries
double GetGammaSeries(double fA, double fX)
You must ensure fA>0.0 && fX>0.0 valid results only if fX <= fA+1.0 uses power series.
Definition: interpr6.cxx:96

ScInterpreter::PushNoValue
void PushNoValue()
Definition: interpr4.cxx:1921

ScInterpreter::ScNominal
void ScNominal()
Definition: interpr2.cxx:2364

ScInterpreter::ScPower
void ScPower()
Definition: interpr5.cxx:1658

ScInterpreter::MatrixParameterConversion
bool MatrixParameterConversion()
Definition: interpre.hxx:1046

sc::CompareOptions
Definition: compare.hxx:52

ScInterpreter::ScSumX2MY2
void ScSumX2MY2()
Definition: interpr5.cxx:1797

ScInterpreter::ScGetPivotData
void ScGetPivotData()
Definition: interpr2.cxx:3552

ScInterpreter::ScPermutationA
void ScPermutationA()
Definition: interpr3.cxx:1216

ScQueryOp
ScQueryOp
Definition: global.hxx:818

ScInterpreter::ScSTEYX
void ScSTEYX()
Definition: interpr3.cxx:4645

ScInterpreter::PopExternalSingleRef
void PopExternalSingleRef(sal_uInt16 &rFileId, OUString &rTabName, ScSingleRefData &rRef)
Definition: interpr4.cxx:1115

ScInterpreter::ScSumXMY2
void ScSumXMY2()
Definition: interpr5.cxx:1846

ScInterpreter::MergeCalcConfig
void MergeCalcConfig()
Merge global and document specific settings.
Definition: interpr4.cxx:3872

ScInterpreter::ScSecant
void ScSecant()
Definition: interpr1.cxx:1937

ScComplexRefData
Complex reference (a range) into the sheet.
Definition: refdata.hxx:123

ScInterpreter::ScRoundUp
void ScRoundUp()
Definition: interpr2.cxx:1012

ScInterpreter::ScChiInv
void ScChiInv()
Definition: interpr3.cxx:2370

ScInterpreter::CalculateTest
bool CalculateTest(bool _bTemplin, const SCSIZE nC1, const SCSIZE nC2, const SCSIZE nR1, const SCSIZE nR2, const ScMatrixRef &pMat1, const ScMatrixRef &pMat2, double &fT, double &fF)
Definition: interpr3.cxx:2582

ScInterpreter::GetHypGeomDist
double GetHypGeomDist(double x, double n, double M, double N)
Calculates a value of the hypergeometric distribution.
Definition: interpr3.cxx:1897

ScInterpreter::ScCovarianceS
void ScCovarianceS()
Definition: interpr3.cxx:4525

ScInterpreter::DBIterator
void DBIterator(ScIterFunc)
Definition: interpr1.cxx:7797

ScInterpreter::ScMatch
void ScMatch()
Definition: interpr1.cxx:4769

ScInterpreter::ScRegex
void ScRegex()
Definition: interpr1.cxx:9373

ScInterpreter::GetDBStVarParams
void GetDBStVarParams(double &rVal, double &rValCount)
Definition: interpr1.cxx:7983

ifMAX
Definition: interpre.hxx:112

sc::ParamIfsResult::mfSum
double mfSum
Definition: interpre.hxx:64

ScInterpreter::Pop
void Pop()
Definition: interpr4.cxx:738

ScInterpreter::ScAverageIf
void ScAverageIf()
Definition: interpr1.cxx:5626

ScInterpreter::ScFact
void ScFact()
Definition: interpr3.cxx:1161

ScInterpreter::PopError
void PopError()
Definition: interpr4.cxx:748

ScInterpreter::ScVDB
void ScVDB()
Definition: interpr2.cxx:1801

ScInterpreter::ScWeibull
void ScWeibull()
Definition: interpr3.cxx:1765

ScInterpreter::pStackObj
ScTokenStack * pStackObj
Definition: interpre.hxx:209

ScInterpreter::MayBeWildcard
static bool MayBeWildcard(const OUString &rStr)
Could string be a wildcard (*,?,~) expression? If wildcards are disabled the function returns false r...
Definition: interpr1.cxx:9938

ScInterpreter::GetRangeMatrix
sc::RangeMatrix GetRangeMatrix()
Definition: interpr5.cxx:615

ScInterpreter::ScBitXor
void ScBitXor()
Definition: interpr1.cxx:1670

sc::RangeMatrix
Definition: types.hxx:83

ScInterpreter::ScBitOr
void ScBitOr()
Definition: interpr1.cxx:1655

ScInterpreter::ScPow
void ScPow()
Definition: interpr5.cxx:1664

ScInterpreter::ScTDist
void ScTDist()
Definition: interpr3.cxx:1643

ScInterpreter::ScFInv_LT
void ScFInv_LT()
Definition: interpr3.cxx:2335

ScInterpreter::ScMin
void ScMin(bool bTextAsZero=false)
Definition: interpr1.cxx:3614

ScInterpreter::ScGetMonth
void ScGetMonth()
Definition: interpr2.cxx:125

ScInterpreter::ScT
void ScT()
Definition: interpr1.cxx:3203

ScInterpreter::ScLn
void ScLn()
Definition: interpr2.cxx:1286

ScInterpreter::ScProbability
void ScProbability()
Definition: interpr3.cxx:4449

ScInterpreter::PopExternalDoubleRef
void PopExternalDoubleRef(sal_uInt16 &rFileId, OUString &rTabName, ScComplexRefData &rRef)
Definition: interpr4.cxx:1194

ScInterpreter::ScPercentrank
void ScPercentrank(bool bInclusive)
Definition: interpr3.cxx:3733

ScInterpreter::ScIsErr
void ScIsErr()
Definition: interpr1.cxx:2895

ScInterpreter::CreateDoubleOrTypedToken
formula::FormulaToken * CreateDoubleOrTypedToken(double fVal)
Definition: interpr4.cxx:1759

ScInterpreter::ScClean
void ScClean()
Definition: interpr1.cxx:3450

ScInterpreter::ScGetDayOfWeek
void ScGetDayOfWeek()
Definition: interpr2.cxx:186

sc::ParamIfsResult::mfMin
double mfMin
Definition: interpre.hxx:67

ScInterpreter::CheckStringResultLen
bool CheckStringResultLen(OUString &rResult, const OUString &rAdd)
Definition: interpre.hxx:1122

formula::FormulaTokenIterator

ScInterpreter::NOT_VOLATILE
Definition: interpre.hxx:182

ScInterpreter::ScExternal
void ScExternal()
Definition: interpr4.cxx:2509

ScInterpreter::GetResultToken
const formula::FormulaConstTokenRef & GetResultToken() const
Definition: interpre.hxx:1030

ScInterpreter::ScSin
void ScSin()
Definition: interpr1.cxx:1840

ScInterpreter::ScExact
void ScExact()
Definition: interpr1.cxx:8974

ScFDistFunction
Definition: interpr3.cxx:2300

ScInterpreter::ScFDist
void ScFDist()
Definition: interpr3.cxx:1691

ScInterpreter::ScForecast
void ScForecast()
Definition: interpr3.cxx:4731

ScInterpreter::ScMultiArea
void ScMultiArea()
Definition: interpr1.cxx:8741

ScInterpreter::ScCode
void ScCode()
Definition: interpr1.cxx:3461

errorcodes.hxx

ScInterpreter::ScSearch
void ScSearch()
Definition: interpr1.cxx:9327

ScInterpreter::ScArcSin
void ScArcSin()
Definition: interpr1.cxx:1860

ScInterpreter::ScGrowth
void ScGrowth()
Definition: interpr5.cxx:2927

ScInterpreter::TreatDoubleError
void TreatDoubleError(double &rVal)
Definition: interpre.hxx:1144

ScChiSqDistFunction::fDF
double fDF
Definition: interpr3.cxx:2394

ScInterpreter::ScRad
void ScRad()
Definition: interpr1.cxx:1835

ScTokenStack::pPointer
const formula::FormulaToken * pPointer[MAXSTACK]
Definition: interpre.hxx:101

ScInterpreter::PushTokenRef
void PushTokenRef(const formula::FormulaConstTokenRef &)
Pushes the token or substitutes with formula::FormulaErrorToken in case nGlobalError is set and the t...
Definition: interpr4.cxx:661

ScInterpreter::MEMat
static void MEMat(const ScMatrixRef &mM, SCSIZE n)
Definition: interpr5.cxx:753

ScRefList
::std::vector< ScComplexRefData > ScRefList
Definition: token.hxx:38

ScInterpreter::Compare
double Compare(ScQueryOp eOp)
Definition: interpr1.cxx:882

ScInterpreter::ScCombin
void ScCombin()
Definition: interpr3.cxx:1170

ScInterpreter::ScRate
void ScRate()
Definition: interpr2.cxx:2126

sc::ParamIfsResult::mfMem
double mfMem
Definition: interpre.hxx:65

ScInterpreter::ScArcTanHyp
void ScArcTanHyp()
Definition: interpr1.cxx:1914

ScInterpreter::ScGetPV
static double ScGetPV(double fRate, double fNper, double fPmt, double fFv, bool bPayInAdvance)
Definition: interpr2.cxx:1610

ScInterpreter::ScBase
void ScBase()
Definition: interpr2.cxx:2836

ScInterpreter::PushStringBuffer
void PushStringBuffer(const sal_Unicode *pString)
Definition: interpr4.cxx:1782

ScTDistFunction
Definition: interpr3.cxx:2251

ScInterpreter::GetBetaDistPDF
double GetBetaDistPDF(double fX, double fA, double fB)
Definition: interpr3.cxx:859

ScInterpreter::ScSubstitute
void ScSubstitute()
Definition: interpr1.cxx:9685

ScDocument
Definition: document.hxx:313

ScInterpreter::ScSkew
void ScSkew()
Definition: interpr3.cxx:3369

ScInterpreter::ScQuartile
void ScQuartile(bool bInclusive)
Definition: interpr3.cxx:3490

ScInterpreter::IterateParametersIfs
void IterateParametersIfs(double(*ResultFunc)(const sc::ParamIfsResult &rRes))
Definition: interpr1.cxx:5828

ScInterpreter::ScValue
void ScValue()
Definition: interpr1.cxx:3270

ScInterpreter::ScProduct
void ScProduct()
Definition: interpr6.cxx:1048

ScInterpreter::ScOr
void ScOr()
Definition: interpr1.cxx:1363

ScInterpreter::ScIsValue
void ScIsValue()
Definition: interpr1.cxx:2620

ScInterpreter::GetGammaDistPDF
double GetGammaDistPDF(double fX, double fAlpha, double fLambda)
Gamma distribution, probability density function.
Definition: interpr6.cxx:144

utl::SearchParam::SearchType
SearchType

ScInterpreter::ScArcCosHyp
void ScArcCosHyp()
Definition: interpr1.cxx:1905

ScInterpreter::ScZTest
void ScZTest()
Definition: interpr3.cxx:2455

ScInterpreter::ScCombinA
void ScCombinA()
Definition: interpr3.cxx:1183

ScInterpreter::ScCountIf
void ScCountIf()
Definition: interpr1.cxx:5631

ScInterpreter::SetError
void SetError(FormulaError nError)
Definition: interpre.hxx:1019

ScInterpreter::ScPpmt
void ScPpmt()
Definition: interpr2.cxx:2234

ScInterpreter::GetMedian
double GetMedian(::std::vector< double > &rArray)
Definition: interpr3.cxx:3379

ScInterpreter::GetBool
bool GetBool()
Definition: interpre.hxx:444

ScInterpreter::CheckStringPositionArgument
static bool CheckStringPositionArgument(double &fVal)
Check if a double is suitable as string position or length argument.
Definition: interpre.hxx:1091

ScQueryEntry
Each instance of this struct represents a single filtering criteria.
Definition: queryentry.hxx:33

ScInterpreter::GetVolatileType
VolatileType GetVolatileType() const
Definition: interpre.hxx:185

ScInterpreter::ScTableOp
void ScTableOp()
Definition: interpr4.cxx:3562

ScInterpreter::ScFixed
void ScFixed()
Definition: interpr1.cxx:8885

ScInterpreter::DoubleRefToVars
void DoubleRefToVars(const formula::FormulaToken *p, SCCOL &rCol1, SCROW &rRow1, SCTAB &rTab1, SCCOL &rCol2, SCROW &rRow2, SCTAB &rTab2)
Definition: interpr4.cxx:938

ScInterpreter::ScStDev
void ScStDev(bool bTextAsZero=false)
Definition: interpr1.cxx:4172

sc::div
double div(const double &fNumerator, const double &fDenominator)
Return fNumerator/fDenominator if fDenominator!=0 else #DIV/0! error coded into double.
Definition: math.hxx:31

ScInterpreter::GetPercentrank
static double GetPercentrank(::std::vector< double > &rArray, double fVal, bool bInclusive)
Definition: interpr3.cxx:3771

ScInterpreter::ScGetGCD
static double ScGetGCD(double fx, double fy)
Definition: interpr5.cxx:108

ScInterpreter::ScHyperLink
void ScHyperLink()
Definition: interpr2.cxx:3184

ScInterpreter::GetDoubleOrString
bool GetDoubleOrString(double &rValue, svl::SharedString &rString)
returns TRUE if double (or error, check nGlobalError), else FALSE
Definition: interpr4.cxx:2242

SCTAB
sal_Int16 SCTAB
Definition: types.hxx:23

ScInterpreter::ScTTest
void ScTTest()
Definition: interpr3.cxx:2649

ScInterpreter::ScHarMean
void ScHarMean()
Definition: interpr3.cxx:2915

ScInterpreter::ScIfError
void ScIfError(bool bNAonly)
Definition: interpr1.cxx:240

ScInterpreter::ScPercentSign
void ScPercentSign()
Definition: interpr1.cxx:1596

ScInterpreter::ScSNormInv
void ScSNormInv()
Definition: interpr3.cxx:2134

ScInterpreter::ScColor
void ScColor()
Definition: interpr7.cxx:516

ScInterpreter::ScMatMult
void ScMatMult()
Definition: interpr5.cxx:1078

ScInterpreter::IsInArrayContext
bool IsInArrayContext() const
Definition: interpre.hxx:1035

ScInterpreter::ScDBProduct
void ScDBProduct()
Definition: interpr1.cxx:7978

ScInterpreter::GetBetaDist
double GetBetaDist(double x, double alpha, double beta)
Definition: interpr3.cxx:982

ScInterpreter::ScRept
void ScRept()
Definition: interpr1.cxx:9736

ScInterpreter::ScAveDev
void ScAveDev()
Definition: interpr3.cxx:4282

MAXSTACK
#define MAXSTACK
Definition: interpre.hxx:96

ScInterpreter::integralPhi
static double integralPhi(double x)
Definition: interpr3.cxx:197

FormulaTokenRef_less::operator()
bool operator()(const formula::FormulaConstTokenRef &r1, const formula::FormulaConstTokenRef &r2) const
Definition: interpre.hxx:134

ScInterpreter::nCurFmtIndex
sal_uInt32 nCurFmtIndex
Definition: interpre.hxx:215

ScInterpreter::ScGamma
void ScGamma()
Definition: interpr3.cxx:771

etsPIAdd
Definition: interpre.hxx:126

ScInterpreter::ScCovarianceP
void ScCovarianceP()
Definition: interpr3.cxx:4520