FormulaCompiler.hxx

Go to the documentation of this file.

/* -*- 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_FORMULA_FORMULACOMPILER_HXX
#define INCLUDED_FORMULA_FORMULACOMPILER_HXX
 
#include <memory>
#include <unordered_map>
#include <vector>
 
#include <com/sun/star/uno/Sequence.hxx>
#include <formula/formuladllapi.h>
#include <formula/grammar.hxx>
#include <formula/opcode.hxx>
#include <formula/tokenarray.hxx>
#include <formula/types.hxx>
#include <formula/paramclass.hxx>
#include <rtl/ustrbuf.hxx>
#include <rtl/ustring.hxx>
#include <sal/types.h>
#include <tools/debug.hxx>
 
#define FORMULA_MAXJUMPCOUNT    32  /* maximum number of jumps (ocChoose) */
#define FORMULA_MAXTOKENS     8192  /* maximum number of tokens in formula */
#define FORMULA_MAXPARAMS      255  /* maximum number of parameters per function (byte) */
#define FORMULA_MAXPARAMSII      8  /* maximum number of parameters for functions that have implicit intersection ranges */
 
 
namespace com::sun::star {
    namespace sheet {
        struct FormulaOpCodeMapEntry;
        struct FormulaToken;
    }
}
 
class CharClass;
enum class FormulaError : sal_uInt16;
enum class SvNumFormatType : sal_Int16;
 
namespace formula
{
 
struct FormulaArrayStack
{
    FormulaArrayStack*  pNext;
    FormulaTokenArray*  pArr;
    FormulaTokenRef     mpLastToken;
    sal_uInt16          nIndex;
    bool bTemp;
};
 
typedef std::unordered_map< OUString, OpCode > OpCodeHashMap;
typedef std::unordered_map< OUString, OUString > ExternalHashMap;
 
class FORMULA_DLLPUBLIC FormulaCompiler
{
private:
    FormulaCompiler(const FormulaCompiler&) = delete;
    FormulaCompiler& operator=(const FormulaCompiler&) = delete;
public:
    FormulaCompiler(bool bComputeII = false, bool bMatrixFlag = false);
    FormulaCompiler(FormulaTokenArray& _rArr, bool bComputeII = false, bool bMatrixFlag = false);
    virtual ~FormulaCompiler();
 
    class FORMULA_DLLPUBLIC OpCodeMap final
    {
        OpCodeHashMap           maHashMap;                  
        std::unique_ptr<OUString[]> mpTable;                
        ExternalHashMap         maExternalHashMap;          
        ExternalHashMap         maReverseExternalHashMap;   
        FormulaGrammar::Grammar meGrammar;                  
        sal_uInt16              mnSymbols;                  
        bool                    mbCore          : 1;        
        bool                    mbEnglish       : 1;        
        bool                    mbEnglishLocale : 1;        
 
        OpCodeMap( const OpCodeMap& ) = delete;
        OpCodeMap& operator=( const OpCodeMap& ) = delete;
 
    public:
 
        OpCodeMap(sal_uInt16 nSymbols, bool bCore, FormulaGrammar::Grammar eGrammar ) :
            maHashMap(nSymbols),
            mpTable( new OUString[ nSymbols ]),
            meGrammar( eGrammar),
            mnSymbols( nSymbols),
            mbCore( bCore),
            mbEnglish ( FormulaGrammar::isEnglish(eGrammar) ),
            mbEnglishLocale ( mbEnglish )
        {
        }
 
        void copyFrom( const OpCodeMap& r );
 
        const OpCodeHashMap& getHashMap() const { return maHashMap; }
 
        const ExternalHashMap& getExternalHashMap() const { return maExternalHashMap; }
 
        const ExternalHashMap& getReverseExternalHashMap() const { return maReverseExternalHashMap; }
 
        const OUString& getSymbol( const OpCode eOp ) const
        {
            DBG_ASSERT( sal_uInt16(eOp) < mnSymbols, "OpCodeMap::getSymbol: OpCode out of range");
            if (sal_uInt16(eOp) < mnSymbols)
                return mpTable[ eOp ];
            static OUString s_sEmpty;
            return s_sEmpty;
        }
 
        sal_Unicode getSymbolChar( const OpCode eOp ) const {  return getSymbol(eOp)[0]; };
 
        FormulaGrammar::Grammar getGrammar() const { return meGrammar; }
 
        sal_uInt16 getSymbolCount() const { return mnSymbols; }
 
        bool isEnglish() const { return mbEnglish; }
 
        bool isEnglishLocale() const { return mbEnglishLocale; }
 
        bool isPODF() const { return FormulaGrammar::isPODF( meGrammar); }
 
        /* TODO: add isAPI() once a FormulaLanguage was added. */
 
        bool isODFF() const { return FormulaGrammar::isODFF( meGrammar); }
 
        bool isOOXML() const { return FormulaGrammar::isOOXML( meGrammar); }
 
        bool hasExternals() const { return !maExternalHashMap.empty(); }
 
        void putOpCode( const OUString & rStr, const OpCode eOp, const CharClass* pCharClass );
 
        void putExternal( const OUString & rSymbol, const OUString & rAddIn );
 
        void putExternalSoftly( const OUString & rSymbol, const OUString & rAddIn );
 
        css::uno::Sequence< css::sheet::FormulaToken >
            createSequenceOfFormulaTokens(const FormulaCompiler& _rCompiler,
                    const css::uno::Sequence< OUString >& rNames ) const;
 
        css::uno::Sequence< css::sheet::FormulaOpCodeMapEntry >
            createSequenceOfAvailableMappings( const FormulaCompiler& _rCompiler,const sal_Int32 nGroup ) const;
 
        static sal_Int32 getOpCodeUnknown() { return -1; }
 
    private:
 
        void putCopyOpCode( const OUString& rSymbol, OpCode eOp );
    };
 
public:
    typedef std::shared_ptr< const OpCodeMap >  OpCodeMapPtr;
    typedef std::shared_ptr< OpCodeMap >        NonConstOpCodeMapPtr;
 
protected:
    OpCodeMapPtr GetFinalOpCodeMap( const sal_Int32 nLanguage ) const;
 
public:
    OpCodeMapPtr GetOpCodeMap( const sal_Int32 nLanguage ) const;
 
    void DestroyOpCodeMap( const sal_Int32 nLanguage );
 
    bool HasOpCodeMap( const sal_Int32 nLanguage ) const;
 
    static OpCodeMapPtr CreateOpCodeMap(
            const css::uno::Sequence< const css::sheet::FormulaOpCodeMapEntry > & rMapping,
            bool bEnglish );
 
    const OpCodeMapPtr& GetCurrentOpCodeMap() const { return mxSymbols; }
 
    OpCode GetEnglishOpCode( const OUString& rName ) const;
 
    FormulaError GetErrorConstant( const OUString& rName ) const;
    void AppendErrorConstant( OUStringBuffer& rBuffer, FormulaError nError ) const;
 
    void EnableJumpCommandReorder( bool bEnable );
    void EnableStopOnError( bool bEnable );
 
    static bool IsOpCodeVolatile( OpCode eOp );
    static bool IsOpCodeJumpCommand( OpCode eOp );
 
    static bool DeQuote( OUString& rStr );
 
 
    static const OUString&  GetNativeSymbol( OpCode eOp );
    static sal_Unicode      GetNativeSymbolChar( OpCode eOp );
    static  bool            IsMatrixFunction(OpCode _eOpCode);   // if a function _always_ returns a Matrix
 
    SvNumFormatType GetNumFormatType() const { return nNumFmt; }
    bool  CompileTokenArray();
 
    void CreateStringFromTokenArray( OUString& rFormula );
    void CreateStringFromTokenArray( OUStringBuffer& rBuffer );
    const FormulaToken* CreateStringFromToken( OUString& rFormula, const FormulaToken* pToken );
    const FormulaToken* CreateStringFromToken( OUStringBuffer& rBuffer, const FormulaToken* pToken,
                                    bool bAllowArrAdvance = false );
 
    void AppendBoolean( OUStringBuffer& rBuffer, bool bVal ) const;
    void AppendDouble( OUStringBuffer& rBuffer, double fVal ) const;
    static void AppendString( OUStringBuffer& rBuffer, const OUString & rStr );
 
    FormulaGrammar::Grammar   GetGrammar() const { return meGrammar; }
 
    bool NeedsTableRefTransformation() const;
 
    virtual formula::ParamClass GetForceArrayParameter( const FormulaToken* pToken, sal_uInt16 nParam ) const;
 
    static void UpdateSeparatorsNative( const OUString& rSep, const OUString& rArrayColSep, const OUString& rArrayRowSep );
    static void ResetNativeSymbols();
    static void SetNativeSymbols( const OpCodeMapPtr& xMap );
 
    void SetComputeIIFlag(bool bSet) { mbComputeII = bSet; }
 
    void SetMatrixFlag(bool bSet) { mbMatrixFlag = bSet; }
 
    enum class SeparatorType
    {
        RESOURCE_BASE,
        SEMICOLON_BASE
    };
 
protected:
    virtual OUString FindAddInFunction( const OUString& rUpperName, bool bLocalFirst ) const;
    virtual void fillFromAddInCollectionUpperName( const NonConstOpCodeMapPtr& xMap ) const;
    virtual void fillFromAddInMap( const NonConstOpCodeMapPtr& xMap, FormulaGrammar::Grammar _eGrammar ) const;
    virtual void fillFromAddInCollectionEnglishName( const NonConstOpCodeMapPtr& xMap ) const;
    virtual void fillAddInToken(::std::vector< css::sheet::FormulaOpCodeMapEntry >& _rVec, bool _bIsEnglish) const;
 
    virtual void SetError(FormulaError nError);
    virtual FormulaTokenRef ExtendRangeReference( FormulaToken & rTok1, FormulaToken & rTok2 );
    virtual bool HandleExternalReference(const FormulaToken& _aToken);
    virtual bool HandleRange();
    virtual bool HandleColRowName();
    virtual bool HandleDbData();
    virtual bool HandleTableRef();
 
    virtual void CreateStringFromExternal( OUStringBuffer& rBuffer, const FormulaToken* pToken ) const;
    virtual void CreateStringFromSingleRef( OUStringBuffer& rBuffer, const FormulaToken* pToken ) const;
    virtual void CreateStringFromDoubleRef( OUStringBuffer& rBuffer, const FormulaToken* pToken ) const;
    virtual void CreateStringFromMatrix( OUStringBuffer& rBuffer, const FormulaToken* pToken ) const;
    virtual void CreateStringFromIndex( OUStringBuffer& rBuffer, const FormulaToken* pToken ) const;
    virtual void LocalizeString( OUString& rName ) const;   // modify rName - input: exact name
 
    bool   GetToken();
    OpCode NextToken();
    void PutCode( FormulaTokenRef& );
    void Factor();
    void RangeLine();
    void UnionLine();
    void IntersectionLine();
    void UnaryLine();
    void PostOpLine();
    void PowLine();
    void MulDivLine();
    void AddSubLine();
    void ConcatLine();
    void CompareLine();
    OpCode Expression();
    void PopTokenArray();
    void PushTokenArray( FormulaTokenArray*, bool );
 
    bool MergeRangeReference( FormulaToken * * const pCode1, FormulaToken * const * const pCode2 );
 
    // Returns whether the opcode has implicit intersection ranges as parameters.
    // Called for (most) opcodes to possibly handle implicit intersection for the parameters.
    virtual void HandleIIOpCode(FormulaToken* /*token*/,
                                FormulaToken*** /*pppToken*/, sal_uInt8 /*nNumParams*/) {}
 
    // Called from CompileTokenArray() after RPN code generation is done.
    virtual void PostProcessCode() {}
 
    virtual void AnnotateOperands() {}
 
    OUString            aCorrectedFormula;      // autocorrected Formula
    OUString            aCorrectedSymbol;       // autocorrected Symbol
 
    OpCodeMapPtr        mxSymbols;              // which symbols are used
 
    FormulaTokenRef     mpToken;                // current token
    FormulaTokenRef     pCurrentFactorToken;    // current factor token (of Factor() method)
    sal_uInt16          nCurrentFactorParam;    // current factor token's parameter, 1-based
    FormulaTokenArray*  pArr;
    FormulaTokenArrayPlainIterator maArrIterator;
    FormulaTokenRef     mpLastToken;            // last token
 
    FormulaToken**      pCode;
    FormulaArrayStack*  pStack;
 
    OpCode              eLastOp;
    short               nRecursion;             // GetToken() recursions
    SvNumFormatType     nNumFmt;                // set during CompileTokenArray()
    sal_uInt16          pc;                     // program counter
 
    FormulaGrammar::Grammar meGrammar;          // The grammar used, language plus convention.
 
    bool                bAutoCorrect;           // whether to apply AutoCorrection
    bool                bCorrected;             // AutoCorrection was applied
    bool                glSubTotal;             // if code contains one or more subtotal functions
    bool                needsRPNTokenCheck;     // whether to make FormulaTokenArray check all tokens at the end
 
    bool mbJumpCommandReorder; 
    bool mbStopOnError;        
 
    bool mbComputeII;  // whether to attempt computing implicit intersection ranges while building the RPN array.
    bool mbMatrixFlag; // whether the formula is a matrix formula (needed for II computation)
 
public:
    enum InitSymbols
    {
        ASK = 0,
        INIT,
        DESTROY
    };
 
private:
    bool InitSymbolsNative( InitSymbols ) const;    
    bool InitSymbolsEnglish( InitSymbols ) const;   
    bool InitSymbolsPODF( InitSymbols ) const;      
    bool InitSymbolsAPI( InitSymbols ) const;       
    bool InitSymbolsODFF( InitSymbols ) const;      
    bool InitSymbolsEnglishXL( InitSymbols ) const; 
    bool InitSymbolsOOXML( InitSymbols ) const;     
 
    void loadSymbols(const std::pair<const char*, int>* pSymbols, FormulaGrammar::Grammar eGrammar, NonConstOpCodeMapPtr& rxMap,
            SeparatorType eSepType = SeparatorType::SEMICOLON_BASE) const;
 
    void CheckSetForceArrayParameter( FormulaTokenRef const & rCurr, sal_uInt8 nParam );
 
    void ForceArrayOperator( FormulaTokenRef const & rCurr );
 
    class CurrentFactor
    {
        FormulaTokenRef  pPrevFac;
        sal_uInt16       nPrevParam;
        FormulaCompiler* pCompiler;
        CurrentFactor( const CurrentFactor& ) = delete;
        CurrentFactor& operator=( const CurrentFactor& ) = delete;
    public:
        explicit CurrentFactor( FormulaCompiler* pComp )
            : pPrevFac( pComp->pCurrentFactorToken )
            , nPrevParam( pComp->nCurrentFactorParam )
            , pCompiler( pComp )
            {}
        ~CurrentFactor()
            {
                pCompiler->pCurrentFactorToken = pPrevFac;
                pCompiler->nCurrentFactorParam = nPrevParam;
            }
        // yes, this operator= may modify the RValue
        void operator=( FormulaTokenRef const & r )
            {
                pCompiler->ForceArrayOperator( r );
                pCompiler->pCurrentFactorToken = r;
                pCompiler->nCurrentFactorParam = 0;
            }
        void operator=( FormulaToken* p )
            {
                FormulaTokenRef xTemp( p );
                *this = xTemp;
            }
        operator FormulaTokenRef&()
            { return pCompiler->pCurrentFactorToken; }
        FormulaToken* operator->()
            { return pCompiler->pCurrentFactorToken.operator->(); }
        operator FormulaToken*()
            { return operator->(); }
    };
 
 
    mutable NonConstOpCodeMapPtr  mxSymbolsODFF;      // ODFF symbols
    mutable NonConstOpCodeMapPtr  mxSymbolsPODF;      // ODF 1.1 symbols
    mutable NonConstOpCodeMapPtr  mxSymbolsAPI;       // XFunctionAccess API symbols
    mutable NonConstOpCodeMapPtr  mxSymbolsNative;    // native symbols
    mutable NonConstOpCodeMapPtr  mxSymbolsEnglish;   // English symbols
    mutable NonConstOpCodeMapPtr  mxSymbolsEnglishXL; // English Excel symbols (for VBA formula parsing)
    mutable NonConstOpCodeMapPtr  mxSymbolsOOXML;     // Excel OOXML symbols
 
    static FormulaTokenArray smDummyTokenArray;
};
 
} // formula
 
 
#endif // INCLUDED_FORMULA_FORMULACOMPILER_HXX
 
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */