xlformula.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_SC_SOURCE_FILTER_INC_XLFORMULA_HXX
#define INCLUDED_SC_SOURCE_FILTER_INC_XLFORMULA_HXX

#include <osl/diagnose.h>
#include <formula/opcode.hxx>
#include <address.hxx>
#include "ftools.hxx"
#include <map>
#include <memory>

namespace svl {

class SharedStringPool;

}

// Constants ==================================================================

const size_t EXC_TOKARR_MAXLEN              = 4096;     

// Token class flags ----------------------------------------------------------

const sal_uInt8 EXC_TOKCLASS_MASK           = 0x60;
const sal_uInt8 EXC_TOKCLASS_NONE           = 0x00;     
const sal_uInt8 EXC_TOKCLASS_REF            = 0x20;     
const sal_uInt8 EXC_TOKCLASS_VAL            = 0x40;     
const sal_uInt8 EXC_TOKCLASS_ARR            = 0x60;     

// Base tokens ----------------------------------------------------------------

const sal_uInt8 EXC_TOKID_MASK              = 0x1F;

const sal_uInt8 EXC_TOKID_NONE              = 0x00;     
const sal_uInt8 EXC_TOKID_EXP               = 0x01;     
const sal_uInt8 EXC_TOKID_TBL               = 0x02;     
const sal_uInt8 EXC_TOKID_ADD               = 0x03;     
const sal_uInt8 EXC_TOKID_SUB               = 0x04;     
const sal_uInt8 EXC_TOKID_MUL               = 0x05;     
const sal_uInt8 EXC_TOKID_DIV               = 0x06;     
const sal_uInt8 EXC_TOKID_POWER             = 0x07;     
const sal_uInt8 EXC_TOKID_CONCAT            = 0x08;     
const sal_uInt8 EXC_TOKID_LT                = 0x09;     
const sal_uInt8 EXC_TOKID_LE                = 0x0A;     
const sal_uInt8 EXC_TOKID_EQ                = 0x0B;     
const sal_uInt8 EXC_TOKID_GE                = 0x0C;     
const sal_uInt8 EXC_TOKID_GT                = 0x0D;     
const sal_uInt8 EXC_TOKID_NE                = 0x0E;     
const sal_uInt8 EXC_TOKID_ISECT             = 0x0F;     
const sal_uInt8 EXC_TOKID_LIST              = 0x10;     
const sal_uInt8 EXC_TOKID_RANGE             = 0x11;     
const sal_uInt8 EXC_TOKID_UPLUS             = 0x12;     
const sal_uInt8 EXC_TOKID_UMINUS            = 0x13;     
const sal_uInt8 EXC_TOKID_PERCENT           = 0x14;     
const sal_uInt8 EXC_TOKID_PAREN             = 0x15;     
const sal_uInt8 EXC_TOKID_MISSARG           = 0x16;     
const sal_uInt8 EXC_TOKID_STR               = 0x17;     
const sal_uInt8 EXC_TOKID_NLR               = 0x18;     
const sal_uInt8 EXC_TOKID_ATTR              = 0x19;     
const sal_uInt8 EXC_TOKID_SHEET             = 0x1A;     
const sal_uInt8 EXC_TOKID_ENDSHEET          = 0x1B;     
const sal_uInt8 EXC_TOKID_ERR               = 0x1C;     
const sal_uInt8 EXC_TOKID_BOOL              = 0x1D;     
const sal_uInt8 EXC_TOKID_INT               = 0x1E;     
const sal_uInt8 EXC_TOKID_NUM               = 0x1F;     

// Base IDs of classified tokens ----------------------------------------------

const sal_uInt8 EXC_TOKID_ARRAY             = 0x00;     
const sal_uInt8 EXC_TOKID_FUNC              = 0x01;     
const sal_uInt8 EXC_TOKID_FUNCVAR           = 0x02;     
const sal_uInt8 EXC_TOKID_NAME              = 0x03;     
const sal_uInt8 EXC_TOKID_REF               = 0x04;     
const sal_uInt8 EXC_TOKID_AREA              = 0x05;     
const sal_uInt8 EXC_TOKID_MEMAREA           = 0x06;     
const sal_uInt8 EXC_TOKID_MEMERR            = 0x07;     
const sal_uInt8 EXC_TOKID_MEMNOMEM          = 0x08;     
const sal_uInt8 EXC_TOKID_MEMFUNC           = 0x09;     
const sal_uInt8 EXC_TOKID_REFERR            = 0x0A;     
const sal_uInt8 EXC_TOKID_AREAERR           = 0x0B;     
const sal_uInt8 EXC_TOKID_REFN              = 0x0C;     
const sal_uInt8 EXC_TOKID_AREAN             = 0x0D;     
const sal_uInt8 EXC_TOKID_MEMAREAN          = 0x0E;     
const sal_uInt8 EXC_TOKID_MEMNOMEMN         = 0x0F;     
const sal_uInt8 EXC_TOKID_FUNCCE            = 0x18;
const sal_uInt8 EXC_TOKID_NAMEX             = 0x19;     
const sal_uInt8 EXC_TOKID_REF3D             = 0x1A;     
const sal_uInt8 EXC_TOKID_AREA3D            = 0x1B;     
const sal_uInt8 EXC_TOKID_REFERR3D          = 0x1C;     
const sal_uInt8 EXC_TOKID_AREAERR3D         = 0x1D;     

// specific token constants ---------------------------------------------------

const sal_uInt16 EXC_TOK_STR_MAXLEN         = 255;      

const sal_uInt8 EXC_TOK_BOOL_FALSE          = 0;        
const sal_uInt8 EXC_TOK_BOOL_TRUE           = 1;        

const sal_uInt8 EXC_TOK_ATTR_VOLATILE       = 0x01;     
const sal_uInt8 EXC_TOK_ATTR_IF             = 0x02;     
const sal_uInt8 EXC_TOK_ATTR_CHOOSE         = 0x04;     
const sal_uInt8 EXC_TOK_ATTR_GOTO           = 0x08;     
const sal_uInt8 EXC_TOK_ATTR_SUM            = 0x10;     
const sal_uInt8 EXC_TOK_ATTR_ASSIGN         = 0x20;     
const sal_uInt8 EXC_TOK_ATTR_SPACE          = 0x40;     

const sal_uInt8 EXC_TOK_ATTR_SPACE_SP       = 0x00;     
const sal_uInt8 EXC_TOK_ATTR_SPACE_BR       = 0x01;     
const sal_uInt8 EXC_TOK_ATTR_SPACE_SP_OPEN  = 0x02;     
const sal_uInt8 EXC_TOK_ATTR_SPACE_BR_OPEN  = 0x03;     
const sal_uInt8 EXC_TOK_ATTR_SPACE_SP_CLOSE = 0x04;     
const sal_uInt8 EXC_TOK_ATTR_SPACE_BR_CLOSE = 0x05;     
const sal_uInt8 EXC_TOK_ATTR_SPACE_SP_PRE   = 0x06;     

const sal_uInt16 EXC_TOK_FUNCVAR_CMD        = 0x8000;   
const sal_uInt16 EXC_TOK_FUNCVAR_INDEXMASK  = 0x7FFF;   
const sal_uInt8 EXC_TOK_FUNCVAR_PROMPT      = 0x80;     
const sal_uInt8 EXC_TOK_FUNCVAR_COUNTMASK   = 0x7F;     

const sal_uInt16 EXC_TOK_REF_COLREL         = 0x4000;   
const sal_uInt16 EXC_TOK_REF_ROWREL         = 0x8000;   

const sal_uInt8 EXC_TOK_NLR_ERR             = 0x01;     
const sal_uInt8 EXC_TOK_NLR_ROWR            = 0x02;     
const sal_uInt8 EXC_TOK_NLR_COLR            = 0x03;     
const sal_uInt8 EXC_TOK_NLR_ROWV            = 0x06;     
const sal_uInt8 EXC_TOK_NLR_COLV            = 0x07;     
const sal_uInt8 EXC_TOK_NLR_RANGE           = 0x0A;     
const sal_uInt8 EXC_TOK_NLR_SRANGE          = 0x0B;     
const sal_uInt8 EXC_TOK_NLR_SROWR           = 0x0C;     
const sal_uInt8 EXC_TOK_NLR_SCOLR           = 0x0D;     
const sal_uInt8 EXC_TOK_NLR_SROWV           = 0x0E;     
const sal_uInt8 EXC_TOK_NLR_SCOLV           = 0x0F;     
const sal_uInt8 EXC_TOK_NLR_RANGEERR        = 0x10;     
const sal_uInt8 EXC_TOK_NLR_SXNAME          = 0x1D;     
const sal_uInt16 EXC_TOK_NLR_REL            = 0x8000;   

const sal_uInt32 EXC_TOK_NLR_ADDREL         = 0x80000000;   
const sal_uInt32 EXC_TOK_NLR_ADDMASK        = 0x3FFFFFFF;   

enum XclFormulaType
{
    EXC_FMLATYPE_CELL,          
    EXC_FMLATYPE_MATRIX,        
    EXC_FMLATYPE_SHARED,        
    EXC_FMLATYPE_CONDFMT,       
    EXC_FMLATYPE_DATAVAL,       
    EXC_FMLATYPE_NAME,          
    EXC_FMLATYPE_CHART,         
    EXC_FMLATYPE_CONTROL,       
    EXC_FMLATYPE_WQUERY,        
    EXC_FMLATYPE_LISTVAL        
};

// Function parameter info ====================================================

enum XclFuncParamValidity
{
    EXC_PARAM_NONE = 0,         
    EXC_PARAM_REGULAR,          
    EXC_PARAM_CALCONLY,         
    EXC_PARAM_EXCELONLY         
};

enum XclFuncParamConv
{
    EXC_PARAMCONV_ORG,          
    EXC_PARAMCONV_VAL,          
    EXC_PARAMCONV_ARR,          
    EXC_PARAMCONV_RPT,          
    EXC_PARAMCONV_RPX,          
    EXC_PARAMCONV_RPO           
};

struct XclFuncParamInfo
{
    XclFuncParamValidity meValid;       
    XclFuncParamConv    meConv;         
    bool                mbValType;      
};

// Function data ==============================================================

const sal_uInt8 EXC_FUNC_MAXPARAM           = 30;       

const size_t EXC_FUNCINFO_PARAMINFO_COUNT   = 5;        

const sal_uInt8 EXC_FUNCFLAG_VOLATILE       = 0x01;     
const sal_uInt8 EXC_FUNCFLAG_IMPORTONLY     = 0x02;     
const sal_uInt8 EXC_FUNCFLAG_EXPORTONLY     = 0x04;     
const sal_uInt8 EXC_FUNCFLAG_PARAMPAIRS     = 0x08;     
const sal_uInt8 EXC_FUNCFLAG_ADDINEQUIV     = 0x10;     

// selected function IDs
const sal_uInt16 EXC_FUNCID_IF              = 1;
const sal_uInt16 EXC_FUNCID_SUM             = 4;
const sal_uInt16 EXC_FUNCID_AND             = 36;
const sal_uInt16 EXC_FUNCID_OR              = 37;
const sal_uInt16 EXC_FUNCID_CHOOSE          = 100;
const sal_uInt16 EXC_FUNCID_EXTERNCALL      = 255;

struct XclFunctionInfo
{
    OpCode               meOpCode;           
    sal_uInt16           mnXclFunc;          
    sal_uInt8            mnMinParamCount;    
    sal_uInt8            mnMaxParamCount;    
    sal_uInt8            mnRetClass;         
    XclFuncParamInfo     mpParamInfos[ EXC_FUNCINFO_PARAMINFO_COUNT ]; 
    sal_uInt8            mnFlags;            
    const char*          mpcMacroName;       
    bool         IsVolatile() const { return ::get_flag( mnFlags, EXC_FUNCFLAG_VOLATILE ); }
    bool         IsParamPairs() const { return ::get_flag( mnFlags, EXC_FUNCFLAG_PARAMPAIRS ); }
    bool         IsFixedParamCount() const { return (mnXclFunc != EXC_FUNCID_EXTERNCALL) && (mnMinParamCount == mnMaxParamCount); }
    bool         IsMacroFunc() const { return mpcMacroName != nullptr && !(mnFlags & EXC_FUNCFLAG_ADDINEQUIV); }
    bool         IsAddInEquivalent() const { return mpcMacroName != nullptr && (mnFlags & EXC_FUNCFLAG_ADDINEQUIV); }
    OUString            GetMacroFuncName() const;
    OUString            GetAddInEquivalentFuncName() const;
};

class XclRoot;

class XclFunctionProvider
{
public:
    explicit            XclFunctionProvider( const XclRoot& rRoot );

    const XclFunctionInfo* GetFuncInfoFromXclFunc( sal_uInt16 nXclFunc ) const;
    const XclFunctionInfo* GetFuncInfoFromXclMacroName( const OUString& rXclMacroName ) const;
    const XclFunctionInfo* GetFuncInfoFromOpCode( OpCode eOpCode ) const;

private:
    void                FillXclFuncMap( const XclFunctionInfo* pBeg, const XclFunctionInfo* pEnd );
    void                FillScFuncMap( const XclFunctionInfo* pBeg, const XclFunctionInfo* pEnd );

private:
    typedef ::std::map< sal_uInt16, const XclFunctionInfo* >    XclFuncMap;
    typedef ::std::map< OUString, const XclFunctionInfo* >      XclMacroNameMap;
    typedef ::std::map< OpCode, const XclFunctionInfo* >        ScFuncMap;

    XclFuncMap          maXclFuncMap;       
    XclMacroNameMap     maXclMacroNameMap;  
    ScFuncMap           maScFuncMap;        
};

// Token array ================================================================

class XclImpStream;
class XclExpStream;

class XclTokenArray
{
public:
    explicit            XclTokenArray( bool bVolatile = false );
    explicit            XclTokenArray( ScfUInt8Vec& rTokVec, ScfUInt8Vec& rExtDataVec, bool bVolatile = false );

    bool         Empty() const { return maTokVec.empty(); }
    sal_uInt16          GetSize() const;
    const sal_uInt8* GetData() const { return maTokVec.empty() ? nullptr : maTokVec.data(); }
    bool         IsVolatile() const { return mbVolatile; }

    void                ReadSize( XclImpStream& rStrm );
    void                ReadArray( XclImpStream& rStrm );
    void                Read( XclImpStream& rStrm );

    void                WriteSize( XclExpStream& rStrm ) const;
    void                WriteArray( XclExpStream& rStrm ) const;
    void                Write( XclExpStream& rStrm ) const;

    bool                operator==( const XclTokenArray& rTokArr ) const;

private:
    ScfUInt8Vec         maTokVec;       
    ScfUInt8Vec         maExtDataVec;   
    bool                mbVolatile;     
};

typedef std::shared_ptr< XclTokenArray > XclTokenArrayRef;

XclImpStream& operator>>( XclImpStream& rStrm, XclTokenArray& rTokArr );
XclExpStream& operator<<( XclExpStream& rStrm, const XclTokenArray& rTokArr );
XclExpStream& operator<<( XclExpStream& rStrm, const XclTokenArrayRef& rxTokArr );

namespace formula { class FormulaToken; }
class ScTokenArray;

class XclTokenArrayIterator
{
public:
    explicit            XclTokenArrayIterator();
    explicit            XclTokenArrayIterator( const ScTokenArray& rScTokArr, bool bSkipSpaces );
    explicit            XclTokenArrayIterator( const XclTokenArrayIterator& rTokArrIt, bool bSkipSpaces );

    void                Init( const ScTokenArray& rScTokArr, bool bSkipSpaces );

    bool         Is() const { return mppScToken != nullptr; }
    bool         operator!() const { return !Is(); }
    const ::formula::FormulaToken* Get() const { return mppScToken ? *mppScToken : nullptr; }
    const ::formula::FormulaToken* operator->() const { return Get(); }
    const ::formula::FormulaToken& operator*() const { return *Get(); }

    XclTokenArrayIterator& operator++();

private:
    void                NextRawToken();
    void                SkipSpaces();

private:
    const ::formula::FormulaToken*const* mppScTokenBeg;     
    const ::formula::FormulaToken*const* mppScTokenEnd;     
    const ::formula::FormulaToken*const* mppScToken;        
    bool                mbSkipSpaces;       
};

struct XclMultipleOpRefs
{
    ScAddress           maFmlaScPos;        
    ScAddress           maColFirstScPos;
    ScAddress           maColRelScPos;
    ScAddress           maRowFirstScPos;
    ScAddress           maRowRelScPos;
    bool                mbDblRefMode;       
};

class XclTokenArrayHelper
{
public:
    // token identifiers ------------------------------------------------------

    inline static sal_uInt8 GetTokenId( sal_uInt8 nBaseId, sal_uInt8 nTokenClass );

    static sal_uInt8 GetTokenClass( sal_uInt8 nTokenId ) { return nTokenId & EXC_TOKCLASS_MASK; }
    inline static void  ChangeTokenClass( sal_uInt8& rnTokenId, sal_uInt8 nTokenClass );

    // strings and string lists -----------------------------------------------

    static bool         GetTokenString( OUString& rString, const ::formula::FormulaToken& rScToken );

    static bool         GetString( OUString& rString, const ScTokenArray& rScTokArr );

    static bool         GetStringList( OUString& rStringList, const ScTokenArray& rScTokArr, sal_Unicode cSep );

    static void ConvertStringToList(
        ScTokenArray& rScTokArr, svl::SharedStringPool& rSPool, sal_Unicode cStringSep );

    // multiple operations ----------------------------------------------------

    static bool GetMultipleOpRefs( const ScDocument* pDoc, XclMultipleOpRefs& rRefs, const ScTokenArray& rScTokArr, const ScAddress& rScPos );
};

inline sal_uInt8 XclTokenArrayHelper::GetTokenId( sal_uInt8 nBaseId, sal_uInt8 nTokenClass )
{
    OSL_ENSURE( !::get_flag( nBaseId, static_cast< sal_uInt8 >( ~EXC_TOKID_MASK ) ), "XclTokenArrayHelper::GetTokenId - invalid token ID" );
    OSL_ENSURE( !::get_flag( nTokenClass, static_cast< sal_uInt8 >( ~EXC_TOKCLASS_MASK ) ), "XclTokenArrayHelper::GetTokenId - invalid token class" );
    return nBaseId | nTokenClass;
}

inline void XclTokenArrayHelper::ChangeTokenClass( sal_uInt8& rnTokenId, sal_uInt8 nTokenClass )
{
    OSL_ENSURE( !::get_flag( nTokenClass, static_cast< sal_uInt8 >( ~EXC_TOKCLASS_MASK ) ), "XclTokenArrayHelper::ChangeTokenClass - invalid token class" );
    ::set_flag( rnTokenId, EXC_TOKCLASS_MASK, false );
    ::set_flag( rnTokenId, nTokenClass );
}

#endif

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