tokenarray.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_TOKENARRAY_HXX
#define INCLUDED_FORMULA_TOKENARRAY_HXX
 
#include <climits>
#include <memory>
#include <ostream>
#include <type_traits>
#include <unordered_set>
#include <unordered_map>
#include <vector>
 
#include <formula/ExternalReferenceHelper.hxx>
#include <formula/formuladllapi.h>
#include <formula/opcode.hxx>
#include <formula/token.hxx>
#include <o3tl/typed_flags_set.hxx>
#include <rtl/ustring.hxx>
#include <sal/types.h>
 
namespace com::sun::star {
    namespace sheet { struct FormulaToken; }
}
 
namespace com::sun::star::uno { template <typename > class Sequence; }
namespace formula { class FormulaTokenArray; }
 
namespace svl {
 
class SharedString;
class SharedStringPool;
 
}
 
// RecalcMode access only via TokenArray SetExclusiveRecalcMode...() /
// IsRecalcMode...()
 
// Only one of the exclusive bits can be set and one must be set,
// handled by TokenArray SetExclusiveRecalcMode...() methods.
// Exclusive bits are ordered by priority, AddRecalcMode() relies on that.
enum class ScRecalcMode : sal_uInt8
{
    ALWAYS         = 0x01,  // exclusive, always
    ONLOAD_MUST    = 0x02,  // exclusive, always after load
    ONLOAD_ONCE    = 0x04,  // exclusive, once after load, import filter
    ONLOAD_LENIENT = 0x08,  // exclusive, lenient after load (eg. macros not always, aliens, ...)
    NORMAL         = 0x10,  // exclusive
    FORCED         = 0x20,  // combined, also if cell isn't visible, for macros with side effects
    ONREFMOVE      = 0x40,  // combined, if reference was moved
    EMask          = ALWAYS | ONLOAD_MUST | ONLOAD_LENIENT | ONLOAD_ONCE | NORMAL   // mask of exclusive bits
};
namespace o3tl
{
    template<> struct typed_flags<ScRecalcMode> : is_typed_flags<ScRecalcMode, 0x7f> {};
}
 
namespace formula
{
 
class FORMULA_DLLPUBLIC MissingConvention
{
public:
    enum Convention
    {
        FORMULA_MISSING_CONVENTION_PODF,
        FORMULA_MISSING_CONVENTION_ODFF,
        FORMULA_MISSING_CONVENTION_OOXML
    };
    explicit            MissingConvention( Convention eConvention ) : meConvention(eConvention) {}
    bool        isPODF() const  { return meConvention == FORMULA_MISSING_CONVENTION_PODF; }
    bool        isODFF() const  { return meConvention == FORMULA_MISSING_CONVENTION_ODFF; }
    bool        isOOXML() const  { return meConvention == FORMULA_MISSING_CONVENTION_OOXML; }
    Convention  getConvention() const { return meConvention; }
private:
    Convention meConvention;
};
 
class FORMULA_DLLPUBLIC MissingConventionODF : public MissingConvention
{
public:
    explicit    MissingConventionODF( bool bODFF ) :
        MissingConvention( bODFF ?
                MissingConvention::FORMULA_MISSING_CONVENTION_ODFF :
                MissingConvention::FORMULA_MISSING_CONVENTION_PODF)
        {
        }
    // Implementation and usage only in token.cxx
    inline  bool    isRewriteNeeded( OpCode eOp ) const;
};
 
class FORMULA_DLLPUBLIC MissingConventionOOXML : public MissingConvention
{
public:
    explicit    MissingConventionOOXML() : MissingConvention( MissingConvention::FORMULA_MISSING_CONVENTION_OOXML) {}
    // Implementation and usage only in token.cxx
    static inline bool isRewriteNeeded( OpCode eOp );
};
 
typedef std::unordered_set<OpCode, std::hash<std::underlying_type<OpCode>::type> > unordered_opcode_set;
 
class FORMULA_DLLPUBLIC FormulaTokenArrayStandardRange
{
private:
    FormulaToken** mpBegin;
    FormulaToken** mpEnd;
 
public:
    FormulaTokenArrayStandardRange(FormulaToken** pBegin, sal_uInt16 nSize) :
        mpBegin(pBegin),
        mpEnd(pBegin + nSize)
    {
    }
 
    FormulaToken** begin() const
    {
        return mpBegin;
    }
 
    FormulaToken** end() const
    {
        return mpEnd;
    }
};
 
class FORMULA_DLLPUBLIC FormulaTokenArrayReferencesIterator
{
private:
    FormulaToken** maIter;
    FormulaToken** maEnd;
 
    void nextReference()
    {
        while (maIter != maEnd)
        {
            switch ((*maIter)->GetType())
            {
            case svSingleRef:
            case svDoubleRef:
            case svExternalSingleRef:
            case svExternalDoubleRef:
                return;
            default:
                ++maIter;
            }
        }
    }
 
    enum class Dummy { Flag };
 
    FormulaTokenArrayReferencesIterator(const FormulaTokenArrayStandardRange& rRange, Dummy) :
        maIter(rRange.end()),
        maEnd(rRange.end())
    {
    }
 
public:
    FormulaTokenArrayReferencesIterator(const FormulaTokenArrayStandardRange& rRange) :
        maIter(rRange.begin()),
        maEnd(rRange.end())
    {
        nextReference();
    }
 
    FormulaTokenArrayReferencesIterator operator++(int)
    {
        FormulaTokenArrayReferencesIterator result(*this);
        operator++();
        return result;
    }
 
    FormulaTokenArrayReferencesIterator const & operator++()
    {
        assert(maIter != maEnd);
        ++maIter;
        nextReference();
        return *this;
    }
 
    FormulaToken* operator*() const
    {
        return *maIter;
    }
 
    bool operator==(const FormulaTokenArrayReferencesIterator& rhs) const
    {
        return maIter == rhs.maIter;
    }
 
    bool operator!=(const FormulaTokenArrayReferencesIterator& rhs) const
    {
        return !operator==(rhs);
    }
 
    static FormulaTokenArrayReferencesIterator endOf(const FormulaTokenArrayStandardRange& rRange)
    {
        return FormulaTokenArrayReferencesIterator(rRange, Dummy::Flag);
    }
};
 
class FORMULA_DLLPUBLIC FormulaTokenArrayReferencesRange
{
private:
    const FormulaTokenArray& mrFTA;
 
public:
    FormulaTokenArrayReferencesRange(const FormulaTokenArray& rFTA) :
        mrFTA(rFTA)
    {
    }
 
    FormulaTokenArrayReferencesIterator begin();
 
    FormulaTokenArrayReferencesIterator end();
};
 
class FORMULA_DLLPUBLIC FormulaTokenArray
{
protected:
    std::unique_ptr<FormulaToken*[]> pCode; // Token code array
    FormulaToken**  pRPN;                   // RPN array
    sal_uInt16      nLen;                   // Length of token array
    sal_uInt16      nRPN;                   // Length of RPN array
    FormulaError    nError;                 // Error code
    ScRecalcMode    nMode;                  // Flags to indicate when to recalc this code
    bool            bHyperLink      :1;     // If HYPERLINK() occurs in the formula.
    bool            mbFromRangeName :1;     // If this array originates from a named expression
    bool            mbShareable     :1;     // Whether or not it can be shared with adjacent cells.
    bool            mbFinalized     :1;     // Whether code arrays have their final used size and no more tokens can be added.
 
protected:
    void                    Assign( const FormulaTokenArray& );
    void                    Assign( sal_uInt16 nCode, FormulaToken **pTokens );
    void                    Move( FormulaTokenArray&& );
 
    FormulaToken*           Add( FormulaToken* );
 
public:
    enum ReplaceMode
    {
        CODE_ONLY,      
        CODE_AND_RPN    
    };
 
    FormulaToken*           ReplaceToken( sal_uInt16 nOffset, FormulaToken*, ReplaceMode eMode );
 
    sal_uInt16              RemoveToken( sal_uInt16 nOffset, sal_uInt16 nCount );
 
    FormulaTokenArray();
    FormulaTokenArray( const FormulaTokenArray& );
    FormulaTokenArray( FormulaTokenArray&& );
    virtual ~FormulaTokenArray();
 
    virtual void Clear();
 
    void Finalize();
 
    void SetFromRangeName( bool b ) { mbFromRangeName = b; }
    bool IsFromRangeName() const { return mbFromRangeName; }
 
    void SetShareable( bool b ) { mbShareable = b; }
 
    bool IsShareable() const { return mbShareable; }
 
    void DelRPN();
    FormulaToken* FirstToken() const;
 
    FormulaToken* TokenAt( sal_uInt16 nIdx) const
    {
        if (nIdx >= nLen)
            return nullptr;
        return pCode[nIdx];
    }
 
    FormulaToken* PeekPrev( sal_uInt16 & nIdx ) const;
 
    OpCode OpCodeBefore( sal_uInt16 nIdx) const
    {
        if (nIdx == 0 || nIdx > nLen)
            return ocNone;
 
        return pCode[nIdx-1]->GetOpCode();
    }
 
    FormulaToken* FirstRPNToken() const;
    FormulaToken* LastRPNToken() const;
 
    bool HasReferences() const;
 
    bool    HasExternalRef() const;
    bool    HasOpCode( OpCode ) const;
    bool    HasOpCodeRPN( OpCode ) const;
    bool    HasNameOrColRowName() const;
 
    bool HasOpCodes( const unordered_opcode_set& rOpCodes ) const;
 
    void CreateNewRPNArrayFromData( FormulaToken** pData, sal_uInt16 nSize )
    {
        pRPN = new FormulaToken*[ nSize ];
        nRPN = nSize;
        memcpy( pRPN, pData, nSize * sizeof( FormulaToken* ) );
    }
 
    FormulaToken** GetArray() const  { return pCode.get(); }
 
    FormulaTokenArrayStandardRange Tokens() const
    {
        return FormulaTokenArrayStandardRange(pCode.get(), nLen);
    }
 
    FormulaToken** GetCode()  const  { return pRPN; }
 
    FormulaTokenArrayStandardRange RPNTokens() const
    {
        return FormulaTokenArrayStandardRange(pRPN, nRPN);
    }
 
    FormulaTokenArrayReferencesRange References() const
    {
        return FormulaTokenArrayReferencesRange(*this);
    }
 
    sal_uInt16     GetLen() const     { return nLen; }
    sal_uInt16     GetCodeLen() const { return nRPN; }
    FormulaError   GetCodeError() const      { return nError; }
    void      SetCodeError( FormulaError n )  { nError = n; }
    void      SetHyperLink( bool bVal ) { bHyperLink = bVal; }
    bool      IsHyperLink() const       { return bHyperLink; }
 
    ScRecalcMode    GetRecalcMode() const { return nMode; }
 
    void            SetCombinedBitsRecalcMode( ScRecalcMode nBits )
                                { nMode |= nBits & ~ScRecalcMode::EMask; }
    ScRecalcMode    GetCombinedBitsRecalcMode() const
                                { return nMode & ~ScRecalcMode::EMask; }
 
    void            SetMaskedRecalcMode( ScRecalcMode nBits )
                                { nMode = GetCombinedBitsRecalcMode() | nBits; }
 
    void            AddRecalcMode( ScRecalcMode nBits );
 
    void            ClearRecalcMode() { nMode = ScRecalcMode::NORMAL; }
    void            SetExclusiveRecalcModeNormal()
                                { SetMaskedRecalcMode( ScRecalcMode::NORMAL ); }
    void            SetExclusiveRecalcModeAlways()
                                { SetMaskedRecalcMode( ScRecalcMode::ALWAYS ); }
    void            SetRecalcModeForced()
                                { nMode |= ScRecalcMode::FORCED; }
    void            SetRecalcModeOnRefMove()
                                { nMode |= ScRecalcMode::ONREFMOVE; }
    bool            IsRecalcModeNormal() const
                                { return bool(nMode & ScRecalcMode::NORMAL); }
    bool            IsRecalcModeAlways() const
                                { return bool(nMode & ScRecalcMode::ALWAYS); }
    bool            IsRecalcModeForced() const
                                { return bool(nMode & ScRecalcMode::FORCED); }
    bool            IsRecalcModeOnRefMove() const
                                { return bool(nMode & ScRecalcMode::ONREFMOVE); }
    bool            IsRecalcModeMustAfterImport() const
                                { return (nMode & ScRecalcMode::EMask) <= ScRecalcMode::ONLOAD_ONCE; }
    void            ClearRecalcModeMustAfterImport()
                                {
                                    if (IsRecalcModeMustAfterImport() && !IsRecalcModeAlways())
                                        SetExclusiveRecalcModeNormal();
                                }
 
    inline OpCode           GetOuterFuncOpCode() const;
 
    bool                    HasMatrixDoubleRefOps() const;
 
    virtual FormulaToken* AddOpCode(OpCode e);
 
    virtual bool AddFormulaToken(
        const css::sheet::FormulaToken& rToken, svl::SharedStringPool& rSPool,
        ExternalReferenceHelper* pExtRef );
 
    bool Fill(
        const css::uno::Sequence<css::sheet::FormulaToken>& rSequence,
        svl::SharedStringPool& rSPool, ExternalReferenceHelper* pExtRef );
 
    virtual void CheckToken( const FormulaToken& t );
 
    void CheckAllRPNTokens();
 
    FormulaToken* AddToken( const FormulaToken& );
 
    FormulaToken* AddString( const svl::SharedString& rStr );
    FormulaToken* AddDouble( double fVal );
    void          AddExternal( const sal_Unicode* pStr );
    FormulaToken* AddExternal( const OUString& rStr, OpCode eOp = ocExternal );
    FormulaToken* AddBad( const OUString& rStr );          
    FormulaToken* AddStringXML( const OUString& rStr );    
 
    virtual FormulaToken* MergeArray( );
 
    FormulaTokenArray& operator=( const FormulaTokenArray& );
    FormulaTokenArray& operator=( FormulaTokenArray&& );
 
    bool                NeedsPodfRewrite( const MissingConventionODF & rConv );
 
    bool                NeedsOoxmlRewrite();
 
    FormulaTokenArray*  RewriteMissing( const MissingConvention & rConv );
 
    bool                MayReferenceFollow();
 
    void ReinternStrings( svl::SharedStringPool& rPool );
};
 
inline OpCode FormulaTokenArray::GetOuterFuncOpCode() const
{
    if ( pRPN && nRPN )
        return pRPN[nRPN-1]->GetOpCode();
    return ocNone;
}
 
inline FormulaTokenArrayReferencesIterator FormulaTokenArrayReferencesRange::begin()
{
    return FormulaTokenArrayReferencesIterator(mrFTA.Tokens());
}
 
inline FormulaTokenArrayReferencesIterator FormulaTokenArrayReferencesRange::end()
{
    return FormulaTokenArrayReferencesIterator::endOf(mrFTA.Tokens());
}
 
class FORMULA_DLLPUBLIC FormulaTokenIterator
{
    struct Item
    {
    public:
        const FormulaTokenArray* pArr;
        short nPC;
        short nStop;
 
        Item(const FormulaTokenArray* arr, short pc, short stop);
    };
 
    std::vector<Item> maStack;
 
public:
    FormulaTokenIterator( const FormulaTokenArray& );
   ~FormulaTokenIterator();
    void    Reset();
    const   FormulaToken* Next();
    const   FormulaToken* PeekNextOperator();
    bool    IsEndOfPath() const;    
    bool    HasStacked() const { return maStack.size() > 1; }
    short   GetPC() const { return maStack.back().nPC; }
 
    void Jump( short nStart, short nNext, short nStop = SHRT_MAX );
    void Push( const FormulaTokenArray* );
    void Pop();
 
    void ReInit( const FormulaTokenArray& );
 
private:
    const FormulaToken* GetNonEndOfPathToken( short nIdx ) const;
};
 
// For use in SAL_INFO, SAL_WARN etc
 
template<typename charT, typename traits>
inline std::basic_ostream<charT, traits> & operator <<(std::basic_ostream<charT, traits> & stream, const FormulaTokenArray& point)
{
    stream <<
        static_cast<const void*>(&point) <<
        ":{nLen=" << point.GetLen() <<
        ",nRPN=" << point.GetCodeLen() <<
        ",pCode=" << static_cast<void*>(point.GetArray()) <<
        ",pRPN=" << static_cast<void*>(point.GetCode()) <<
        "}";
 
    return stream;
}
 
class FORMULA_DLLPUBLIC FormulaTokenArrayPlainIterator
{
private:
    const FormulaTokenArray* mpFTA;
    sal_uInt16 mnIndex;                 // Current step index
 
public:
    FormulaTokenArrayPlainIterator( const FormulaTokenArray& rFTA ) :
        mpFTA( &rFTA ),
        mnIndex( 0 )
    {
    }
 
    void Reset()
    {
        mnIndex = 0;
    }
 
    sal_uInt16 GetIndex() const
    {
        return mnIndex;
    }
 
    FormulaToken* First()
    {
        mnIndex = 0;
        return Next();
    }
 
    void Jump(sal_uInt16 nIndex)
    {
        mnIndex = nIndex;
    }
 
    void StepBack()
    {
        assert(mnIndex > 0);
        mnIndex--;
    }
 
    FormulaToken* Next();
    FormulaToken* NextNoSpaces();
    FormulaToken* GetNextName();
    FormulaToken* GetNextReference();
    FormulaToken* GetNextReferenceRPN();
    FormulaToken* GetNextReferenceOrName();
    FormulaToken* GetNextColRowName();
    FormulaToken* PeekNext();
    FormulaToken* PeekPrevNoSpaces() const;    
    FormulaToken* PeekNextNoSpaces() const;    
 
    FormulaToken* FirstRPN()
    {
        mnIndex = 0;
        return NextRPN();
    }
 
    FormulaToken* NextRPN();
 
    FormulaToken* LastRPN()
    {
        mnIndex = mpFTA->GetCodeLen();
        return PrevRPN();
    }
 
    FormulaToken* PrevRPN();
 
    void AfterRemoveToken( sal_uInt16 nOffset, sal_uInt16 nCount );
};
 
 
} // formula
 
#endif // INCLUDED_FORMULA_TOKENARRAY_HXX
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */