formulabase.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_FORMULABASE_HXX
#define INCLUDED_SC_SOURCE_FILTER_INC_FORMULABASE_HXX

#include <com/sun/star/beans/Pair.hpp>
#include <com/sun/star/sheet/FormulaToken.hpp>
#include <com/sun/star/table/CellAddress.hpp>
#include <oox/helper/propertyset.hxx>
#include <oox/helper/refvector.hxx>
#include "workbookhelper.hxx"

namespace com::sun::star {
    namespace lang { class XMultiServiceFactory; }
    namespace sheet { class XFormulaParser; }
}

namespace oox { template< typename Type > class Matrix; }
namespace com::sun::star::sheet { struct FormulaOpCodeMapEntry; }
namespace oox { class SequenceInputStream; }
namespace oox::xls { struct BinAddress; }
class ScRangeList;

namespace oox::xls {

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

const size_t BIFF_TOKARR_MAXLEN                 = 4096;     

// token class flags ----------------------------------------------------------

const sal_uInt8 BIFF_TOKCLASS_MASK              = 0x60;
const sal_uInt8 BIFF_TOKCLASS_NONE              = 0x00;     
const sal_uInt8 BIFF_TOKCLASS_REF               = 0x20;     
const sal_uInt8 BIFF_TOKCLASS_VAL               = 0x40;     
const sal_uInt8 BIFF_TOKCLASS_ARR               = 0x60;     

const sal_uInt8 BIFF_TOKFLAG_INVALID            = 0x80;     

// base token identifiers -----------------------------------------------------

const sal_uInt8 BIFF_TOKID_MASK                 = 0x1F;

const sal_uInt8 BIFF_TOKID_NONE                 = 0x00;     
const sal_uInt8 BIFF_TOKID_EXP                  = 0x01;     
const sal_uInt8 BIFF_TOKID_TBL                  = 0x02;     
const sal_uInt8 BIFF_TOKID_ADD                  = 0x03;     
const sal_uInt8 BIFF_TOKID_SUB                  = 0x04;     
const sal_uInt8 BIFF_TOKID_MUL                  = 0x05;     
const sal_uInt8 BIFF_TOKID_DIV                  = 0x06;     
const sal_uInt8 BIFF_TOKID_POWER                = 0x07;     
const sal_uInt8 BIFF_TOKID_CONCAT               = 0x08;     
const sal_uInt8 BIFF_TOKID_LT                   = 0x09;     
const sal_uInt8 BIFF_TOKID_LE                   = 0x0A;     
const sal_uInt8 BIFF_TOKID_EQ                   = 0x0B;     
const sal_uInt8 BIFF_TOKID_GE                   = 0x0C;     
const sal_uInt8 BIFF_TOKID_GT                   = 0x0D;     
const sal_uInt8 BIFF_TOKID_NE                   = 0x0E;     
const sal_uInt8 BIFF_TOKID_ISECT                = 0x0F;     
const sal_uInt8 BIFF_TOKID_LIST                 = 0x10;     
const sal_uInt8 BIFF_TOKID_RANGE                = 0x11;     
const sal_uInt8 BIFF_TOKID_UPLUS                = 0x12;     
const sal_uInt8 BIFF_TOKID_UMINUS               = 0x13;     
const sal_uInt8 BIFF_TOKID_PERCENT              = 0x14;     
const sal_uInt8 BIFF_TOKID_PAREN                = 0x15;     
const sal_uInt8 BIFF_TOKID_MISSARG              = 0x16;     
const sal_uInt8 BIFF_TOKID_STR                  = 0x17;     
const sal_uInt8 BIFF_TOKID_NLR                  = 0x18;     
const sal_uInt8 BIFF_TOKID_ATTR                 = 0x19;     
const sal_uInt8 BIFF_TOKID_SHEET                = 0x1A;     
const sal_uInt8 BIFF_TOKID_ENDSHEET             = 0x1B;     
const sal_uInt8 BIFF_TOKID_ERR                  = 0x1C;     
const sal_uInt8 BIFF_TOKID_BOOL                 = 0x1D;     
const sal_uInt8 BIFF_TOKID_INT                  = 0x1E;     
const sal_uInt8 BIFF_TOKID_NUM                  = 0x1F;     

// base identifiers of classified tokens --------------------------------------

const sal_uInt8 BIFF_TOKID_ARRAY                = 0x00;     
const sal_uInt8 BIFF_TOKID_FUNC                 = 0x01;     
const sal_uInt8 BIFF_TOKID_FUNCVAR              = 0x02;     
const sal_uInt8 BIFF_TOKID_NAME                 = 0x03;     
const sal_uInt8 BIFF_TOKID_REF                  = 0x04;     
const sal_uInt8 BIFF_TOKID_AREA                 = 0x05;     
const sal_uInt8 BIFF_TOKID_MEMAREA              = 0x06;     
const sal_uInt8 BIFF_TOKID_MEMERR               = 0x07;     
const sal_uInt8 BIFF_TOKID_MEMNOMEM             = 0x08;     
const sal_uInt8 BIFF_TOKID_MEMFUNC              = 0x09;     
const sal_uInt8 BIFF_TOKID_REFERR               = 0x0A;     
const sal_uInt8 BIFF_TOKID_AREAERR              = 0x0B;     
const sal_uInt8 BIFF_TOKID_REFN                 = 0x0C;     
const sal_uInt8 BIFF_TOKID_AREAN                = 0x0D;     
const sal_uInt8 BIFF_TOKID_MEMAREAN             = 0x0E;     
const sal_uInt8 BIFF_TOKID_MEMNOMEMN            = 0x0F;     
const sal_uInt8 BIFF_TOKID_FUNCCE               = 0x18;
const sal_uInt8 BIFF_TOKID_NAMEX                = 0x19;     
const sal_uInt8 BIFF_TOKID_REF3D                = 0x1A;     
const sal_uInt8 BIFF_TOKID_AREA3D               = 0x1B;     
const sal_uInt8 BIFF_TOKID_REFERR3D             = 0x1C;     
const sal_uInt8 BIFF_TOKID_AREAERR3D            = 0x1D;     

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

const sal_uInt8 BIFF_TOK_ARRAY_DOUBLE           = 0;        
const sal_uInt8 BIFF_TOK_ARRAY_STRING           = 1;        
const sal_uInt8 BIFF_TOK_ARRAY_BOOL             = 2;        
const sal_uInt8 BIFF_TOK_ARRAY_ERROR            = 4;        

const sal_uInt8 BIFF_TOK_BOOL_FALSE             = 0;        
const sal_uInt8 BIFF_TOK_BOOL_TRUE              = 1;        

const sal_uInt8 BIFF_TOK_ATTR_VOLATILE          = 0x01;     
const sal_uInt8 BIFF_TOK_ATTR_IF                = 0x02;     
const sal_uInt8 BIFF_TOK_ATTR_CHOOSE            = 0x04;     
const sal_uInt8 BIFF_TOK_ATTR_SKIP              = 0x08;     
const sal_uInt8 BIFF_TOK_ATTR_SUM               = 0x10;     
const sal_uInt8 BIFF_TOK_ATTR_ASSIGN            = 0x20;     
const sal_uInt8 BIFF_TOK_ATTR_SPACE             = 0x40;     
const sal_uInt8 BIFF_TOK_ATTR_SPACE_VOLATILE    = 0x41;     
const sal_uInt8 BIFF_TOK_ATTR_IFERROR           = 0x80;     

const sal_uInt8 BIFF_TOK_ATTR_SPACE_SP          = 0x00;     
const sal_uInt8 BIFF_TOK_ATTR_SPACE_BR          = 0x01;     
const sal_uInt8 BIFF_TOK_ATTR_SPACE_SP_OPEN     = 0x02;     
const sal_uInt8 BIFF_TOK_ATTR_SPACE_BR_OPEN     = 0x03;     
const sal_uInt8 BIFF_TOK_ATTR_SPACE_SP_CLOSE    = 0x04;     
const sal_uInt8 BIFF_TOK_ATTR_SPACE_BR_CLOSE    = 0x05;     
const sal_uInt8 BIFF_TOK_ATTR_SPACE_SP_PRE      = 0x06;     

const sal_uInt16 BIFF_TOK_FUNCVAR_CMD           = 0x8000;   
const sal_uInt16 BIFF_TOK_FUNCVAR_FUNCIDMASK    = 0x7FFF;   
const sal_uInt8 BIFF_TOK_FUNCVAR_CMDPROMPT      = 0x80;     
const sal_uInt8 BIFF_TOK_FUNCVAR_COUNTMASK      = 0x7F;     

const sal_uInt16 BIFF12_TOK_REF_COLMASK         = 0x3FFF;   
const sal_Int32 BIFF12_TOK_REF_ROWMASK          = 0xFFFFF;  
const sal_uInt16 BIFF12_TOK_REF_COLREL          = 0x4000;   
const sal_uInt16 BIFF12_TOK_REF_ROWREL          = 0x8000;   

const sal_uInt16 BIFF_TOK_REF_COLMASK           = 0x00FF;   
const sal_uInt16 BIFF_TOK_REF_ROWMASK           = 0x3FFF;   
const sal_uInt16 BIFF_TOK_REF_COLREL            = 0x4000;   
const sal_uInt16 BIFF_TOK_REF_ROWREL            = 0x8000;   

const sal_uInt16 BIFF12_TOK_TABLE_COLUMN         = 0x0001;   
const sal_uInt16 BIFF12_TOK_TABLE_COLRANGE       = 0x0002;   
const sal_uInt16 BIFF12_TOK_TABLE_ALL            = 0x0004;   
const sal_uInt16 BIFF12_TOK_TABLE_HEADERS        = 0x0008;   
const sal_uInt16 BIFF12_TOK_TABLE_DATA           = 0x0010;   
const sal_uInt16 BIFF12_TOK_TABLE_TOTALS         = 0x0020;   
const sal_uInt16 BIFF12_TOK_TABLE_THISROW        = 0x0040;   
const sal_uInt16 BIFF12_TOK_TABLE_SP_BRACKETS    = 0x0080;   
const sal_uInt16 BIFF12_TOK_TABLE_SP_SEP         = 0x0100;   
const sal_uInt16 BIFF12_TOK_TABLE_ROW            = 0x0200;   
const sal_uInt16 BIFF12_TOK_TABLE_CELL           = 0x0400;   

const sal_uInt8 BIFF_TOK_NLR_ERR                = 0x01;     
const sal_uInt8 BIFF_TOK_NLR_ROWR               = 0x02;     
const sal_uInt8 BIFF_TOK_NLR_COLR               = 0x03;     
const sal_uInt8 BIFF_TOK_NLR_ROWV               = 0x06;     
const sal_uInt8 BIFF_TOK_NLR_COLV               = 0x07;     
const sal_uInt8 BIFF_TOK_NLR_RANGE              = 0x0A;     
const sal_uInt8 BIFF_TOK_NLR_SRANGE             = 0x0B;     
const sal_uInt8 BIFF_TOK_NLR_SROWR              = 0x0C;     
const sal_uInt8 BIFF_TOK_NLR_SCOLR              = 0x0D;     
const sal_uInt8 BIFF_TOK_NLR_SROWV              = 0x0E;     
const sal_uInt8 BIFF_TOK_NLR_SCOLV              = 0x0F;     
const sal_uInt8 BIFF_TOK_NLR_RANGEERR           = 0x10;     
const sal_uInt8 BIFF_TOK_NLR_SXNAME             = 0x1D;     
const sal_uInt16 BIFF_TOK_NLR_REL               = 0x8000;   
const sal_uInt16 BIFF_TOK_NLR_MASK              = 0x3FFF;   

const sal_uInt32 BIFF_TOK_NLR_ADDREL            = 0x80000000;   
const sal_uInt32 BIFF_TOK_NLR_ADDMASK           = 0x3FFFFFFF;   

// function constants ---------------------------------------------------------

const sal_uInt8 OOX_MAX_PARAMCOUNT              = 255;      
const sal_uInt8 BIFF_MAX_PARAMCOUNT             = 30;       

const sal_uInt16 BIFF_FUNC_IF                   = 1;        
const sal_uInt16 BIFF_FUNC_SUM                  = 4;        
const sal_uInt16 BIFF_FUNC_TRUE                 = 34;       
const sal_uInt16 BIFF_FUNC_FALSE                = 35;       
const sal_uInt16 BIFF_FUNC_ROWS                 = 76;       
const sal_uInt16 BIFF_FUNC_COLUMNS              = 77;       
const sal_uInt16 BIFF_FUNC_OFFSET               = 78;       
const sal_uInt16 BIFF_FUNC_EXTERNCALL           = 255;      
const sal_uInt16 BIFF_FUNC_FLOOR                = 285;      
const sal_uInt16 BIFF_FUNC_CEILING              = 288;      
const sal_uInt16 BIFF_FUNC_HYPERLINK            = 359;      
const sal_uInt16 BIFF_FUNC_WEEKNUM              = 465;      

// Formula type ===============================================================

enum class FormulaType
{
    Cell,           
    Array,          
    SharedFormula,  
    CondFormat,     
    Validation      
};

// Reference helpers ==========================================================

struct BinSingleRef2d
{
    sal_Int32           mnCol;              
    sal_Int32           mnRow;              
    bool                mbColRel;           
    bool                mbRowRel;           

    explicit            BinSingleRef2d();

    void                setBiff12Data( sal_uInt16 nCol, sal_Int32 nRow, bool bRelativeAsOffset );

    void                readBiff12Data( SequenceInputStream& rStrm, bool bRelativeAsOffset );
};

struct BinComplexRef2d
{
    BinSingleRef2d      maRef1;             
    BinSingleRef2d      maRef2;             

    void                readBiff12Data( SequenceInputStream& rStrm, bool bRelativeAsOffset );
};

// Token vector, token sequence ===============================================

typedef css::sheet::FormulaToken       ApiToken;
typedef css::uno::Sequence< ApiToken > ApiTokenSequence;

typedef css::beans::Pair< css::table::CellAddress, sal_Bool > ApiSpecialTokenInfo;

class ApiTokenVector
{
public:
    explicit            ApiTokenVector();

    ApiToken& operator[]( size_t i ) { return mvTokens[i]; }

    size_t size() const { return mvTokens.size(); }

    ApiToken& back() { return mvTokens.back(); }
    const ApiToken& back() const { return mvTokens.back(); }

    void clear() { mvTokens.clear(); }

    void pop_back() { mvTokens.pop_back(); }

    void push_back( const ApiToken& rToken ) { mvTokens.push_back( rToken ); }

    void reserve( size_t n ) { mvTokens.reserve( n ); }

    void resize( size_t n ) { mvTokens.resize( n ); }

    css::uno::Any&      append( sal_Int32 nOpCode );

    template< typename Type >
    void         append( sal_Int32 nOpCode, const Type& rData ) { append( nOpCode ) <<= rData; }

    ApiTokenSequence toSequence() const;

private:
    ::std::vector< ApiToken > mvTokens;
};

// Token sequence iterator ====================================================

class ApiTokenIterator
{
public:
    explicit            ApiTokenIterator( const ApiTokenSequence& rTokens, sal_Int32 nSpacesOpCode );
    bool         is() const { return mpToken != mpTokenEnd; }
    const ApiToken* operator->() const { return mpToken; }

    ApiTokenIterator&   operator++();

private:
    void                skipSpaces();

private:
    const ApiToken*     mpToken;            
    const ApiToken*     mpTokenEnd;         
    const sal_Int32     mnSpacesOpCode;     
};

// List of API op-codes =======================================================

struct ApiOpCodes
{
    // special
    sal_Int32           OPCODE_UNKNOWN;         
    sal_Int32           OPCODE_EXTERNAL;        
    // formula structure
    sal_Int32           OPCODE_PUSH;            
    sal_Int32           OPCODE_MISSING;         
    sal_Int32           OPCODE_SPACES;          
    sal_Int32           OPCODE_NAME;            
    sal_Int32           OPCODE_DBAREA;          
    sal_Int32           OPCODE_NLR;             
    sal_Int32           OPCODE_DDE;             
    sal_Int32           OPCODE_MACRO;           
    sal_Int32           OPCODE_BAD;             
    sal_Int32           OPCODE_NONAME;          
    // separators
    sal_Int32           OPCODE_OPEN;            
    sal_Int32           OPCODE_CLOSE;           
    sal_Int32           OPCODE_SEP;             
    // array separators
    sal_Int32           OPCODE_ARRAY_OPEN;      
    sal_Int32           OPCODE_ARRAY_CLOSE;     
    sal_Int32           OPCODE_ARRAY_ROWSEP;    
    sal_Int32           OPCODE_ARRAY_COLSEP;    
    // unary operators
    sal_Int32           OPCODE_PLUS_SIGN;       
    sal_Int32           OPCODE_MINUS_SIGN;      
    sal_Int32           OPCODE_PERCENT;         
    // binary operators
    sal_Int32           OPCODE_ADD;             
    sal_Int32           OPCODE_SUB;             
    sal_Int32           OPCODE_MULT;            
    sal_Int32           OPCODE_DIV;             
    sal_Int32           OPCODE_POWER;           
    sal_Int32           OPCODE_CONCAT;          
    sal_Int32           OPCODE_EQUAL;           
    sal_Int32           OPCODE_NOT_EQUAL;       
    sal_Int32           OPCODE_LESS;            
    sal_Int32           OPCODE_LESS_EQUAL;      
    sal_Int32           OPCODE_GREATER;         
    sal_Int32           OPCODE_GREATER_EQUAL;   
    sal_Int32           OPCODE_INTERSECT;       
    sal_Int32           OPCODE_LIST;            
    sal_Int32           OPCODE_RANGE;           
};

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

enum class FuncParamValidity
{
    Regular,         
    CalcOnly,        
    ExcelOnly        
};

struct FunctionParamInfo
{
    FuncParamValidity   meValid;        
};

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

enum FunctionLibraryType
{
    FUNCLIB_UNKNOWN = 0,        
    FUNCLIB_EUROTOOL            
};

struct FunctionInfo
{
    OUString     maOdfFuncName;      
    OUString     maOoxFuncName;      
    OUString     maBiffMacroName;    
    OUString     maExtProgName;      
    FunctionLibraryType meFuncLibType;      
    sal_Int32           mnApiOpCode;        
    sal_uInt16          mnBiff12FuncId;     
    sal_uInt16          mnBiffFuncId;       
    sal_uInt8           mnMinParamCount;    
    sal_uInt8           mnMaxParamCount;    
    sal_uInt8           mnRetClass;         
    const FunctionParamInfo* mpParamInfos;  
    bool                mbParamPairs;       
    bool                mbVolatile;         
    bool                mbExternal;         
    bool                mbInternal;         
    bool                mbMacroFunc;        
    bool                mbVarParam;         
};

typedef RefVector< FunctionInfo > FunctionInfoVector;

// Function info parameter class iterator =====================================

class FunctionParamInfoIterator
{
public:
    explicit            FunctionParamInfoIterator( const FunctionInfo& rFuncInfo );

    bool                isCalcOnlyParam() const;
    bool                isExcelOnlyParam() const;
    FunctionParamInfoIterator& operator++();

private:
    const FunctionParamInfo* mpParamInfo;
    const FunctionParamInfo* mpParamInfoEnd;
    bool                mbParamPairs;
};

// Base function provider =====================================================

struct FunctionProviderImpl;

class FunctionProvider  // not derived from WorkbookHelper to make it usable in file dumpers
{
public:
    explicit            FunctionProvider(bool bImportFilter);
    virtual             ~FunctionProvider();

    FunctionProvider(FunctionProvider const &) = default;
    FunctionProvider(FunctionProvider &&) = default;
    FunctionProvider & operator =(FunctionProvider const &) = delete;
    FunctionProvider & operator =(FunctionProvider &&) = delete;

    const FunctionInfo* getFuncInfoFromOoxFuncName( const OUString& rFuncName ) const;

    const FunctionInfo* getFuncInfoFromBiff12FuncId( sal_uInt16 nFuncId ) const;

    const FunctionInfo* getFuncInfoFromMacroName( const OUString& rFuncName ) const;

    static FunctionLibraryType getFuncLibTypeFromLibraryName( const OUString& rLibraryName );

protected:
    const FunctionInfoVector& getFuncs() const;

private:
    typedef std::shared_ptr< FunctionProviderImpl > FunctionProviderImplRef;
    FunctionProviderImplRef mxFuncImpl;     
};

// Op-code and function provider ==============================================

struct OpCodeProviderImpl;

class OpCodeProvider : public FunctionProvider // not derived from WorkbookHelper to make it usable as UNO service
{
public:
    explicit            OpCodeProvider(const css::uno::Reference<css::lang::XMultiServiceFactory>& rxModelFactory,
                                       bool bImportFilter);
    virtual             ~OpCodeProvider() override;

    OpCodeProvider(OpCodeProvider const &) = default;
    OpCodeProvider(OpCodeProvider &&) = default;
    OpCodeProvider & operator =(OpCodeProvider const &) = delete;
    OpCodeProvider & operator =(OpCodeProvider &&) = delete;

    const ApiOpCodes&   getOpCodes() const;

    const FunctionInfo* getFuncInfoFromApiToken( const ApiToken& rToken ) const;

    css::uno::Sequence< css::sheet::FormulaOpCodeMapEntry >
                        getOoxParserMap() const;

private:
    typedef std::shared_ptr< OpCodeProviderImpl > OpCodeProviderImplRef;
    OpCodeProviderImplRef mxOpCodeImpl;     
};

// API formula parser wrapper =================================================

class ApiParserWrapper : public OpCodeProvider
{
public:
    explicit            ApiParserWrapper(
                            const css::uno::Reference< css::lang::XMultiServiceFactory >& rxModelFactory,
                            const OpCodeProvider& rOpCodeProv );

    PropertySet& getParserProperties() { return maParserProps; }

    ApiTokenSequence    parseFormula(
                            const OUString& rFormula,
                            const ScAddress& rRefPos );

private:
    css::uno::Reference< css::sheet::XFormulaParser >
                        mxParser;
    PropertySet         maParserProps;
};

// Formula parser/printer base class for filters ==============================

class FormulaProcessorBase : public OpCodeProvider, protected ApiOpCodes, public WorkbookHelper
{
public:
    explicit            FormulaProcessorBase( const WorkbookHelper& rHelper );

    static OUString generateAddress2dString(
                            const ScAddress& rAddress,
                            bool bAbsolute );

    static OUString generateAddress2dString(
                            const BinAddress& rAddress,
                            bool bAbsolute );

    static OUString generateApiString( const OUString& rString );

    static OUString generateApiArray( const Matrix< css::uno::Any >& rMatrix );

    css::uno::Any
                        extractReference( const ApiTokenSequence& rTokens ) const;

    bool                extractCellRange(
                            ScRange& orRange,
                            const ApiTokenSequence& rTokens ) const;

    void                extractCellRangeList(
                            ScRangeList& orRanges,
                            const ApiTokenSequence& rTokens,
                            sal_Int32 nFilterBySheet ) const;

    bool                extractString(
                            OUString& orString,
                            const ApiTokenSequence& rTokens ) const;

    bool                extractSpecialTokenInfo(
                            ApiSpecialTokenInfo& orTokenInfo,
                            const ApiTokenSequence& rTokens ) const;

    void                convertStringToStringList(
                            ApiTokenSequence& orTokens,
                            sal_Unicode cStringSep,
                            bool bTrimLeadingSpaces ) const;
};

} // namespace oox::xls

#endif

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