LCOV - code coverage report
Current view: top level - usr/local/src/libreoffice/sc/source/filter/oox - formulabase.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 316 515 61.4 %
Date: 2013-07-09 Functions: 43 70 61.4 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include "formulabase.hxx"
      21             : 
      22             : #include <map>
      23             : #include <com/sun/star/lang/XMultiServiceFactory.hpp>
      24             : #include <com/sun/star/table/XCellRange.hpp>
      25             : #include <com/sun/star/sheet/AddressConvention.hpp>
      26             : #include <com/sun/star/sheet/ReferenceFlags.hpp>
      27             : #include <com/sun/star/sheet/SingleReference.hpp>
      28             : #include <com/sun/star/sheet/ComplexReference.hpp>
      29             : #include <com/sun/star/sheet/FormulaLanguage.hpp>
      30             : #include <com/sun/star/sheet/FormulaMapGroup.hpp>
      31             : #include <com/sun/star/sheet/FormulaMapGroupSpecialOffset.hpp>
      32             : #include <com/sun/star/sheet/XFormulaOpCodeMapper.hpp>
      33             : #include <com/sun/star/sheet/XFormulaParser.hpp>
      34             : #include <rtl/strbuf.hxx>
      35             : #include <rtl/ustrbuf.hxx>
      36             : #include <sal/log.hxx>
      37             : #include "oox/core/filterbase.hxx"
      38             : #include "oox/helper/containerhelper.hxx"
      39             : #include "oox/token/properties.hxx"
      40             : #include "biffinputstream.hxx"
      41             : 
      42             : namespace oox {
      43             : namespace xls {
      44             : 
      45             : // ============================================================================
      46             : 
      47             : using namespace ::com::sun::star::lang;
      48             : using namespace ::com::sun::star::sheet;
      49             : using namespace ::com::sun::star::table;
      50             : using namespace ::com::sun::star::uno;
      51             : 
      52             : 
      53             : // reference helpers ==========================================================
      54             : 
      55           0 : BinSingleRef2d::BinSingleRef2d() :
      56             :     mnCol( 0 ),
      57             :     mnRow( 0 ),
      58             :     mbColRel( false ),
      59           0 :     mbRowRel( false )
      60             : {
      61           0 : }
      62             : 
      63           0 : void BinSingleRef2d::setBiff12Data( sal_uInt16 nCol, sal_Int32 nRow, bool bRelativeAsOffset )
      64             : {
      65           0 :     mnCol = nCol & BIFF12_TOK_REF_COLMASK;
      66           0 :     mnRow = nRow & BIFF12_TOK_REF_ROWMASK;
      67           0 :     mbColRel = getFlag( nCol, BIFF12_TOK_REF_COLREL );
      68           0 :     mbRowRel = getFlag( nCol, BIFF12_TOK_REF_ROWREL );
      69           0 :     if( bRelativeAsOffset && mbColRel && (mnCol > (BIFF12_TOK_REF_COLMASK >> 1)) )
      70           0 :         mnCol -= (BIFF12_TOK_REF_COLMASK + 1);
      71           0 :     if( bRelativeAsOffset && mbRowRel && (mnRow > (BIFF12_TOK_REF_ROWMASK >> 1)) )
      72           0 :         mnRow -= (BIFF12_TOK_REF_ROWMASK + 1);
      73           0 : }
      74             : 
      75           0 : void BinSingleRef2d::setBiff2Data( sal_uInt8 nCol, sal_uInt16 nRow, bool bRelativeAsOffset )
      76             : {
      77           0 :     mnCol = nCol;
      78           0 :     mnRow = nRow & BIFF_TOK_REF_ROWMASK;
      79           0 :     mbColRel = getFlag( nRow, BIFF_TOK_REF_COLREL );
      80           0 :     mbRowRel = getFlag( nRow, BIFF_TOK_REF_ROWREL );
      81           0 :     if( bRelativeAsOffset && mbColRel && (mnCol >= 0x80) )
      82           0 :         mnCol -= 0x100;
      83           0 :     if( bRelativeAsOffset && mbRowRel && (mnRow > (BIFF_TOK_REF_ROWMASK >> 1)) )
      84           0 :         mnRow -= (BIFF_TOK_REF_ROWMASK + 1);
      85           0 : }
      86             : 
      87           0 : void BinSingleRef2d::setBiff8Data( sal_uInt16 nCol, sal_uInt16 nRow, bool bRelativeAsOffset )
      88             : {
      89           0 :     mnCol = nCol & BIFF_TOK_REF_COLMASK;
      90           0 :     mnRow = nRow;
      91           0 :     mbColRel = getFlag( nCol, BIFF_TOK_REF_COLREL );
      92           0 :     mbRowRel = getFlag( nCol, BIFF_TOK_REF_ROWREL );
      93           0 :     if( bRelativeAsOffset && mbColRel && (mnCol > (BIFF_TOK_REF_COLMASK >> 1)) )
      94           0 :         mnCol -= (BIFF_TOK_REF_COLMASK + 1);
      95           0 :     if( bRelativeAsOffset && mbRowRel && (mnRow >= 0x8000) )
      96           0 :         mnRow -= 0x10000;
      97           0 : }
      98             : 
      99           0 : void BinSingleRef2d::readBiff12Data( SequenceInputStream& rStrm, bool bRelativeAsOffset )
     100             : {
     101             :     sal_Int32 nRow;
     102             :     sal_uInt16 nCol;
     103           0 :     rStrm >> nRow >> nCol;
     104           0 :     setBiff12Data( nCol, nRow, bRelativeAsOffset );
     105           0 : }
     106             : 
     107           0 : void BinSingleRef2d::readBiff2Data( BiffInputStream& rStrm, bool bRelativeAsOffset )
     108             : {
     109             :     sal_uInt16 nRow;
     110             :     sal_uInt8 nCol;
     111           0 :     rStrm >> nRow >> nCol;
     112           0 :     setBiff2Data( nCol, nRow, bRelativeAsOffset );
     113           0 : }
     114             : 
     115           0 : void BinSingleRef2d::readBiff8Data( BiffInputStream& rStrm, bool bRelativeAsOffset )
     116             : {
     117             :     sal_uInt16 nRow, nCol;
     118           0 :     rStrm >> nRow >> nCol;
     119           0 :     setBiff8Data( nCol, nRow, bRelativeAsOffset );
     120           0 : }
     121             : 
     122             : // ----------------------------------------------------------------------------
     123             : 
     124           0 : void BinComplexRef2d::readBiff12Data( SequenceInputStream& rStrm, bool bRelativeAsOffset )
     125             : {
     126             :     sal_Int32 nRow1, nRow2;
     127             :     sal_uInt16 nCol1, nCol2;
     128           0 :     rStrm >> nRow1 >> nRow2 >> nCol1 >> nCol2;
     129           0 :     maRef1.setBiff12Data( nCol1, nRow1, bRelativeAsOffset );
     130           0 :     maRef2.setBiff12Data( nCol2, nRow2, bRelativeAsOffset );
     131           0 : }
     132             : 
     133           0 : void BinComplexRef2d::readBiff2Data( BiffInputStream& rStrm, bool bRelativeAsOffset )
     134             : {
     135             :     sal_uInt16 nRow1, nRow2;
     136             :     sal_uInt8 nCol1, nCol2;
     137           0 :     rStrm >> nRow1 >> nRow2 >> nCol1 >> nCol2;
     138           0 :     maRef1.setBiff2Data( nCol1, nRow1, bRelativeAsOffset );
     139           0 :     maRef2.setBiff2Data( nCol2, nRow2, bRelativeAsOffset );
     140           0 : }
     141             : 
     142           0 : void BinComplexRef2d::readBiff8Data( BiffInputStream& rStrm, bool bRelativeAsOffset )
     143             : {
     144             :     sal_uInt16 nRow1, nRow2, nCol1, nCol2;
     145           0 :     rStrm >> nRow1 >> nRow2 >> nCol1 >> nCol2;
     146           0 :     maRef1.setBiff8Data( nCol1, nRow1, bRelativeAsOffset );
     147           0 :     maRef2.setBiff8Data( nCol2, nRow2, bRelativeAsOffset );
     148           0 : }
     149             : 
     150             : // token vector, sequence =====================================================
     151             : 
     152          42 : ApiTokenVector::ApiTokenVector()
     153             : {
     154          42 : }
     155             : 
     156          26 : Any& ApiTokenVector::append( sal_Int32 nOpCode )
     157             : {
     158          26 :     resize( size() + 1 );
     159          26 :     back().OpCode = nOpCode;
     160          26 :     return back().Data;
     161             : }
     162             : 
     163             : // token sequence iterator ====================================================
     164             : 
     165           1 : ApiTokenIterator::ApiTokenIterator( const ApiTokenSequence& rTokens, sal_Int32 nSpacesOpCode, bool bSkipSpaces ) :
     166           1 :     mpToken( rTokens.getConstArray() ),
     167           1 :     mpTokenEnd( rTokens.getConstArray() + rTokens.getLength() ),
     168             :     mnSpacesOpCode( nSpacesOpCode ),
     169           2 :     mbSkipSpaces( bSkipSpaces )
     170             : {
     171           1 :     skipSpaces();
     172           1 : }
     173             : 
     174           1 : ApiTokenIterator& ApiTokenIterator::operator++()
     175             : {
     176           1 :     if( is() )
     177             :     {
     178           1 :         ++mpToken;
     179           1 :         skipSpaces();
     180             :     }
     181           1 :     return *this;
     182             : }
     183             : 
     184           2 : void ApiTokenIterator::skipSpaces()
     185             : {
     186           2 :     if( mbSkipSpaces )
     187           4 :         while( is() && (mpToken->OpCode == mnSpacesOpCode) )
     188           0 :             ++mpToken;
     189           2 : }
     190             : 
     191             : // function data ==============================================================
     192             : 
     193             : namespace {
     194             : 
     195             : const size_t FUNCINFO_PARAMINFOCOUNT        = 5;        /// Number of parameter type entries.
     196             : 
     197             : const sal_uInt16 FUNCFLAG_VOLATILE          = 0x0001;   /// Result is volatile (e.g. NOW() function).
     198             : const sal_uInt16 FUNCFLAG_IMPORTONLY        = 0x0002;   /// Only used in import filter.
     199             : const sal_uInt16 FUNCFLAG_EXPORTONLY        = 0x0004;   /// Only used in export filter.
     200             : const sal_uInt16 FUNCFLAG_MACROCALL         = 0x0008;   /// Function is stored as macro call in Excel (_xlfn. prefix). OOXML name MUST exist.
     201             : const sal_uInt16 FUNCFLAG_MACROCALLODF      = 0x0010;   /// ODF-only function stored as macro call in Excel (_xlfnodf. prefix). ODF name MUST exist.
     202             : const sal_uInt16 FUNCFLAG_EXTERNAL          = 0x0020;   /// Function is external in Calc.
     203             : const sal_uInt16 FUNCFLAG_MACROFUNC         = 0x0040;   /// Function is a macro-sheet function.
     204             : const sal_uInt16 FUNCFLAG_MACROCMD          = 0x0080;   /// Function is a macro-sheet command.
     205             : const sal_uInt16 FUNCFLAG_ALWAYSVAR         = 0x0100;   /// Function is always represented by a tFuncVar token.
     206             : const sal_uInt16 FUNCFLAG_PARAMPAIRS        = 0x0200;   /// Optional parameters are expected to appear in pairs.
     207             : const sal_uInt16 FUNCFLAG_MACROCALL_FN      = 0x0400;   /** Function is stored as macro call in Excel (_xlfn. prefix)
     208             :                                                             for OOXML. OOXML name MUST exist. Do not use without
     209             :                                                             FUNCFLAG_MACROCALL. */
     210             : const sal_uInt16 FUNCFLAG_MACROCALL_NEW     = FUNCFLAG_MACROCALL | FUNCFLAG_MACROCALL_FN;   /** New Excel functions not
     211             :                                                             defined in OOXML, _xlfn. prefix in all formats. OOXML name
     212             :                                                             must exist. */
     213             : const sal_uInt16 FUNCFLAG_BIFFIMPORTONLY    = 0x0800;   /// Only used in BIFF binary import filter.
     214             : const sal_uInt16 FUNCFLAG_BIFFEXPORTONLY    = 0x1000;   /// Only used in BIFF binary export filter.
     215             : 
     216             : /// Converts a function library index (value of enum FunctionLibraryType) to function flags.
     217             : #define FUNCLIB_TO_FUNCFLAGS( funclib_index ) static_cast< sal_uInt16 >( static_cast< sal_uInt8 >( funclib_index ) << 12 )
     218             : /// Extracts a function library index (value of enum FunctionLibraryType) from function flags.
     219             : #define FUNCFLAGS_TO_FUNCLIB( func_flags ) extractValue< FunctionLibraryType >( func_flags, 12, 4 )
     220             : 
     221             : typedef ::boost::shared_ptr< FunctionInfo > FunctionInfoRef;
     222             : 
     223             : struct FunctionData
     224             : {
     225             :     const sal_Char*     mpcOdfFuncName;     /// ODF function name.
     226             :     const sal_Char*     mpcOoxFuncName;     /// OOXML function name.
     227             :     sal_uInt16          mnBiff12FuncId;     /// BIFF12 function identifier.
     228             :     sal_uInt16          mnBiffFuncId;       /// BIFF2-BIFF8 function identifier.
     229             :     sal_uInt8           mnMinParamCount;    /// Minimum number of parameters.
     230             :     sal_uInt8           mnMaxParamCount;    /// Maximum number of parameters.
     231             :     sal_uInt8           mnRetClass;         /// BIFF token class of the return value.
     232             :     FunctionParamInfo   mpParamInfos[ FUNCINFO_PARAMINFOCOUNT ]; /// Information about all parameters.
     233             :     sal_uInt16          mnFlags;            /// Additional flags.
     234             : 
     235             :     inline bool         isSupported( bool bImportFilter, FilterType eFilter ) const;
     236             : };
     237             : 
     238       12420 : inline bool FunctionData::isSupported( bool bImportFilter, FilterType eFilter ) const
     239             : {
     240             :     /*  For import filters: the FUNCFLAG_EXPORTONLY and FUNCFLAG_BIFFEXPORTONLY flag must not be set.
     241             :         For OOXML import:   the FUNCFLAG_BIFFIMPORTONLY flag must not be set.
     242             :         For export filters: the FUNCFLAG_IMPORTONLY and FUNCFLAG_BIFFIMPORTONLY flag must not be set.
     243             :         For OOXML export:   the FUNCFLAG_BIFFEXPORTONLY flag must not be set. */
     244             :     bool bSupported = !getFlag( mnFlags, static_cast<sal_uInt16>(bImportFilter ?
     245             :                 (FUNCFLAG_EXPORTONLY | FUNCFLAG_BIFFEXPORTONLY) :
     246       12420 :                 (FUNCFLAG_IMPORTONLY | FUNCFLAG_BIFFIMPORTONLY)));
     247       12420 :     if (bSupported && eFilter == FILTER_OOXML)
     248       12174 :         bSupported = !getFlag( mnFlags, bImportFilter ? FUNCFLAG_BIFFIMPORTONLY : FUNCFLAG_BIFFEXPORTONLY );
     249       12420 :     return bSupported;
     250             : }
     251             : 
     252             : const sal_uInt16 NOID = SAL_MAX_UINT16;     /// No BIFF function identifier available.
     253             : const sal_uInt8 MX    = SAL_MAX_UINT8;      /// Maximum parameter count.
     254             : 
     255             : // abbreviations for function return token class
     256             : const sal_uInt8 R = BIFF_TOKCLASS_REF;
     257             : const sal_uInt8 V = BIFF_TOKCLASS_VAL;
     258             : const sal_uInt8 A = BIFF_TOKCLASS_ARR;
     259             : 
     260             : // abbreviations for parameter infos
     261             : #define RO   { FUNC_PARAM_REGULAR,   FUNC_PARAMCONV_ORG, false }
     262             : #define RA   { FUNC_PARAM_REGULAR,   FUNC_PARAMCONV_ARR, false }
     263             : #define RR   { FUNC_PARAM_REGULAR,   FUNC_PARAMCONV_RPT, false }
     264             : #define RX   { FUNC_PARAM_REGULAR,   FUNC_PARAMCONV_RPX, false }
     265             : #define VO   { FUNC_PARAM_REGULAR,   FUNC_PARAMCONV_ORG, true  }
     266             : #define VV   { FUNC_PARAM_REGULAR,   FUNC_PARAMCONV_VAL, true  }
     267             : #define VA   { FUNC_PARAM_REGULAR,   FUNC_PARAMCONV_ARR, true  }
     268             : #define VR   { FUNC_PARAM_REGULAR,   FUNC_PARAMCONV_RPT, true  }
     269             : #define VX   { FUNC_PARAM_REGULAR,   FUNC_PARAMCONV_RPX, true  }
     270             : #define RO_E { FUNC_PARAM_EXCELONLY, FUNC_PARAMCONV_ORG, false }
     271             : #define VR_E { FUNC_PARAM_EXCELONLY, FUNC_PARAMCONV_RPT, true  }
     272             : #define C    { FUNC_PARAM_CALCONLY,  FUNC_PARAMCONV_ORG, false }
     273             : 
     274             : // Note: parameter types of all macro sheet functions (FUNCFLAG_MACROFUNC/FUNCFLAG_MACROCMD) untested!
     275             : 
     276             : /** Functions new in BIFF2. */
     277             : static const FunctionData saFuncTableBiff2[] =
     278             : {
     279             :     { "COUNT",                  "COUNT",                0,      0,      0,  MX, V, { RX }, 0 },
     280             :     { "IF",                     "IF",                   1,      1,      2,  3,  R, { VO, RO }, 0 },
     281             :     { "ISNA",                   "ISNA",                 2,      2,      1,  1,  V, { VR }, 0 },
     282             :     { "ISERROR",                "ISERROR",              3,      3,      1,  1,  V, { VR }, 0 },
     283             :     { "SUM",                    "SUM",                  4,      4,      0,  MX, V, { RX }, 0 },
     284             :     { "AVERAGE",                "AVERAGE",              5,      5,      1,  MX, V, { RX }, 0 },
     285             :     { "MIN",                    "MIN",                  6,      6,      1,  MX, V, { RX }, 0 },
     286             :     { "MAX",                    "MAX",                  7,      7,      1,  MX, V, { RX }, 0 },
     287             :     { "ROW",                    "ROW",                  8,      8,      0,  1,  V, { RO }, 0 },
     288             :     { "COLUMN",                 "COLUMN",               9,      9,      0,  1,  V, { RO }, 0 },
     289             :     { "NA",                     "NA",                   10,     10,     0,  0,  V, {}, 0 },
     290             :     { "NPV",                    "NPV",                  11,     11,     2,  MX, V, { VR, RX }, 0 },
     291             :     { "STDEV",                  "STDEV",                12,     12,     1,  MX, V, { RX }, 0 },
     292             :     { "DOLLAR",                 "DOLLAR",               13,     13,     1,  2,  V, { VR }, 0 },
     293             :     { "FIXED",                  "FIXED",                14,     14,     1,  2,  V, { VR, VR, C }, 0 },
     294             :     { "SIN",                    "SIN",                  15,     15,     1,  1,  V, { VR }, 0 },
     295             :     { "CSC",                    "SIN",                  15,     15,     1,  1,  V, { VR }, FUNCFLAG_BIFFEXPORTONLY },
     296             :     { "COS",                    "COS",                  16,     16,     1,  1,  V, { VR }, 0 },
     297             :     { "SEC",                    "COS",                  16,     16,     1,  1,  V, { VR }, FUNCFLAG_BIFFEXPORTONLY },
     298             :     { "TAN",                    "TAN",                  17,     17,     1,  1,  V, { VR }, 0 },
     299             :     { "COT",                    "TAN",                  17,     17,     1,  1,  V, { VR }, FUNCFLAG_BIFFEXPORTONLY },
     300             :     { "ATAN",                   "ATAN",                 18,     18,     1,  1,  V, { VR }, 0 },
     301             :     { "ACOT",                   "ATAN",                 18,     18,     1,  1,  V, { VR }, FUNCFLAG_BIFFEXPORTONLY },
     302             :     { "PI",                     "PI",                   19,     19,     0,  0,  V, {}, 0 },
     303             :     { "SQRT",                   "SQRT",                 20,     20,     1,  1,  V, { VR }, 0 },
     304             :     { "EXP",                    "EXP",                  21,     21,     1,  1,  V, { VR }, 0 },
     305             :     { "LN",                     "LN",                   22,     22,     1,  1,  V, { VR }, 0 },
     306             :     { "LOG10",                  "LOG10",                23,     23,     1,  1,  V, { VR }, 0 },
     307             :     { "ABS",                    "ABS",                  24,     24,     1,  1,  V, { VR }, 0 },
     308             :     { "INT",                    "INT",                  25,     25,     1,  1,  V, { VR }, 0 },
     309             :     { "SIGN",                   "SIGN",                 26,     26,     1,  1,  V, { VR }, 0 },
     310             :     { "ROUND",                  "ROUND",                27,     27,     2,  2,  V, { VR }, 0 },
     311             :     { "LOOKUP",                 "LOOKUP",               28,     28,     2,  3,  V, { VR, RA }, 0 },
     312             :     { "INDEX",                  "INDEX",                29,     29,     2,  4,  R, { RA, VV }, 0 },
     313             :     { "REPT",                   "REPT",                 30,     30,     2,  2,  V, { VR }, 0 },
     314             :     { "MID",                    "MID",                  31,     31,     3,  3,  V, { VR }, 0 },
     315             :     { "LEN",                    "LEN",                  32,     32,     1,  1,  V, { VR }, 0 },
     316             :     { "VALUE",                  "VALUE",                33,     33,     1,  1,  V, { VR }, 0 },
     317             :     { "TRUE",                   "TRUE",                 34,     34,     0,  0,  V, {}, 0 },
     318             :     { "FALSE",                  "FALSE",                35,     35,     0,  0,  V, {}, 0 },
     319             :     { "AND",                    "AND",                  36,     36,     1,  MX, V, { RX }, 0 },
     320             :     { "OR",                     "OR",                   37,     37,     1,  MX, V, { RX }, 0 },
     321             :     { "NOT",                    "NOT",                  38,     38,     1,  1,  V, { VR }, 0 },
     322             :     { "MOD",                    "MOD",                  39,     39,     2,  2,  V, { VR }, 0 },
     323             :     { "DCOUNT",                 "DCOUNT",               40,     40,     3,  3,  V, { RO, RR }, 0 },
     324             :     { "DSUM",                   "DSUM",                 41,     41,     3,  3,  V, { RO, RR }, 0 },
     325             :     { "DAVERAGE",               "DAVERAGE",             42,     42,     3,  3,  V, { RO, RR }, 0 },
     326             :     { "DMIN",                   "DMIN",                 43,     43,     3,  3,  V, { RO, RR }, 0 },
     327             :     { "DMAX",                   "DMAX",                 44,     44,     3,  3,  V, { RO, RR }, 0 },
     328             :     { "DSTDEV",                 "DSTDEV",               45,     45,     3,  3,  V, { RO, RR }, 0 },
     329             :     { "VAR",                    "VAR",                  46,     46,     1,  MX, V, { RX }, 0 },
     330             :     { "DVAR",                   "DVAR",                 47,     47,     3,  3,  V, { RO, RR }, 0 },
     331             :     { "TEXT",                   "TEXT",                 48,     48,     2,  2,  V, { VR }, 0 },
     332             :     { "LINEST",                 "LINEST",               49,     49,     1,  2,  A, { RA, RA, C, C }, 0 },
     333             :     { "TREND",                  "TREND",                50,     50,     1,  3,  A, { RA, RA, RA, C }, 0 },
     334             :     { "LOGEST",                 "LOGEST",               51,     51,     1,  2,  A, { RA, RA, C, C }, 0 },
     335             :     { "GROWTH",                 "GROWTH",               52,     52,     1,  3,  A, { RA, RA, RA, C }, 0 },
     336             :     { "PV",                     "PV",                   56,     56,     3,  5,  V, { VR }, 0 },
     337             :     { "FV",                     "FV",                   57,     57,     3,  5,  V, { VR }, 0 },
     338             :     { "NPER",                   "NPER",                 58,     58,     3,  5,  V, { VR }, 0 },
     339             :     { "PMT",                    "PMT",                  59,     59,     3,  5,  V, { VR }, 0 },
     340             :     { "RATE",                   "RATE",                 60,     60,     3,  6,  V, { VR }, 0 },
     341             :     { "MIRR",                   "MIRR",                 61,     61,     3,  3,  V, { RA, VR }, 0 },
     342             :     { "IRR",                    "IRR",                  62,     62,     1,  2,  V, { RA, VR }, 0 },
     343             :     { "RAND",                   "RAND",                 63,     63,     0,  0,  V, {}, FUNCFLAG_VOLATILE },
     344             :     { "MATCH",                  "MATCH",                64,     64,     2,  3,  V, { VR, RX, RR }, 0 },
     345             :     { "DATE",                   "DATE",                 65,     65,     3,  3,  V, { VR }, 0 },
     346             :     { "TIME",                   "TIME",                 66,     66,     3,  3,  V, { VR }, 0 },
     347             :     { "DAY",                    "DAY",                  67,     67,     1,  1,  V, { VR }, 0 },
     348             :     { "MONTH",                  "MONTH",                68,     68,     1,  1,  V, { VR }, 0 },
     349             :     { "YEAR",                   "YEAR",                 69,     69,     1,  1,  V, { VR }, 0 },
     350             :     { "WEEKDAY",                "WEEKDAY",              70,     70,     1,  1,  V, { VR, C }, 0 },
     351             :     { "HOUR",                   "HOUR",                 71,     71,     1,  1,  V, { VR }, 0 },
     352             :     { "MINUTE",                 "MINUTE",               72,     72,     1,  1,  V, { VR }, 0 },
     353             :     { "SECOND",                 "SECOND",               73,     73,     1,  1,  V, { VR }, 0 },
     354             :     { "NOW",                    "NOW",                  74,     74,     0,  0,  V, {}, FUNCFLAG_VOLATILE },
     355             :     { "AREAS",                  "AREAS",                75,     75,     1,  1,  V, { RO }, 0 },
     356             :     { "ROWS",                   "ROWS",                 76,     76,     1,  1,  V, { RO }, 0 },
     357             :     { "COLUMNS",                "COLUMNS",              77,     77,     1,  1,  V, { RO }, 0 },
     358             :     { "OFFSET",                 "OFFSET",               78,     78,     3,  5,  R, { RO, VR }, FUNCFLAG_VOLATILE },
     359             :     { "SEARCH",                 "SEARCH",               82,     82,     2,  3,  V, { VR }, 0 },
     360             :     { "TRANSPOSE",              "TRANSPOSE",            83,     83,     1,  1,  A, { VO }, 0 },
     361             :     { "TYPE",                   "TYPE",                 86,     86,     1,  1,  V, { VX }, 0 },
     362             :     { "ATAN2",                  "ATAN2",                97,     97,     2,  2,  V, { VR }, 0 },
     363             :     { "ASIN",                   "ASIN",                 98,     98,     1,  1,  V, { VR }, 0 },
     364             :     { "ACOS",                   "ACOS",                 99,     99,     1,  1,  V, { VR }, 0 },
     365             :     { "CHOOSE",                 "CHOOSE",               100,    100,    2,  MX, R, { VO, RO }, 0 },
     366             :     { "HLOOKUP",                "HLOOKUP",              101,    101,    3,  3,  V, { VV, RO, RO, C }, 0 },
     367             :     { "VLOOKUP",                "VLOOKUP",              102,    102,    3,  3,  V, { VV, RO, RO, C }, 0 },
     368             :     { "ISREF",                  "ISREF",                105,    105,    1,  1,  V, { RX }, 0 },
     369             :     { "LOG",                    "LOG",                  109,    109,    1,  2,  V, { VR }, 0 },
     370             :     { "CHAR",                   "CHAR",                 111,    111,    1,  1,  V, { VR }, 0 },
     371             :     { "LOWER",                  "LOWER",                112,    112,    1,  1,  V, { VR }, 0 },
     372             :     { "UPPER",                  "UPPER",                113,    113,    1,  1,  V, { VR }, 0 },
     373             :     { "PROPER",                 "PROPER",               114,    114,    1,  1,  V, { VR }, 0 },
     374             :     { "LEFT",                   "LEFT",                 115,    115,    1,  2,  V, { VR }, 0 },
     375             :     { "RIGHT",                  "RIGHT",                116,    116,    1,  2,  V, { VR }, 0 },
     376             :     { "EXACT",                  "EXACT",                117,    117,    2,  2,  V, { VR }, 0 },
     377             :     { "TRIM",                   "TRIM",                 118,    118,    1,  1,  V, { VR }, 0 },
     378             :     { "REPLACE",                "REPLACE",              119,    119,    4,  4,  V, { VR }, 0 },
     379             :     { "SUBSTITUTE",             "SUBSTITUTE",           120,    120,    3,  4,  V, { VR }, 0 },
     380             :     { "CODE",                   "CODE",                 121,    121,    1,  1,  V, { VR }, 0 },
     381             :     { "FIND",                   "FIND",                 124,    124,    2,  3,  V, { VR }, 0 },
     382             :     { "CELL",                   "CELL",                 125,    125,    1,  2,  V, { VV, RO }, FUNCFLAG_VOLATILE },
     383             :     { "ISERR",                  "ISERR",                126,    126,    1,  1,  V, { VR }, 0 },
     384             :     { "ISTEXT",                 "ISTEXT",               127,    127,    1,  1,  V, { VR }, 0 },
     385             :     { "ISNUMBER",               "ISNUMBER",             128,    128,    1,  1,  V, { VR }, 0 },
     386             :     { "ISBLANK",                "ISBLANK",              129,    129,    1,  1,  V, { VR }, 0 },
     387             :     { "T",                      "T",                    130,    130,    1,  1,  V, { RO }, 0 },
     388             :     { "N",                      "N",                    131,    131,    1,  1,  V, { RO }, 0 },
     389             :     { "DATEVALUE",              "DATEVALUE",            140,    140,    1,  1,  V, { VR }, 0 },
     390             :     { "TIMEVALUE",              "TIMEVALUE",            141,    141,    1,  1,  V, { VR }, 0 },
     391             :     { "SLN",                    "SLN",                  142,    142,    3,  3,  V, { VR }, 0 },
     392             :     { "SYD",                    "SYD",                  143,    143,    4,  4,  V, { VR }, 0 },
     393             :     { "DDB",                    "DDB",                  144,    144,    4,  5,  V, { VR }, 0 },
     394             :     { "INDIRECT",               "INDIRECT",             148,    148,    1,  2,  R, { VR }, FUNCFLAG_VOLATILE },
     395             :     { "CLEAN",                  "CLEAN",                162,    162,    1,  1,  V, { VR }, 0 },
     396             :     { "MDETERM",                "MDETERM",              163,    163,    1,  1,  V, { VA }, 0 },
     397             :     { "MINVERSE",               "MINVERSE",             164,    164,    1,  1,  A, { VA }, 0 },
     398             :     { "MMULT",                  "MMULT",                165,    165,    2,  2,  A, { VA }, 0 },
     399             :     { "IPMT",                   "IPMT",                 167,    167,    4,  6,  V, { VR }, 0 },
     400             :     { "PPMT",                   "PPMT",                 168,    168,    4,  6,  V, { VR }, 0 },
     401             :     { "COUNTA",                 "COUNTA",               169,    169,    0,  MX, V, { RX }, 0 },
     402             :     { "PRODUCT",                "PRODUCT",              183,    183,    0,  MX, V, { RX }, 0 },
     403             :     { "FACT",                   "FACT",                 184,    184,    1,  1,  V, { VR }, 0 },
     404             :     { "DPRODUCT",               "DPRODUCT",             189,    189,    3,  3,  V, { RO, RR }, 0 },
     405             :     { "ISNONTEXT",              "ISNONTEXT",            190,    190,    1,  1,  V, { VR }, 0 },
     406             :     { "STDEVP",                 "STDEVP",               193,    193,    1,  MX, V, { RX }, 0 },
     407             :     { "VARP",                   "VARP",                 194,    194,    1,  MX, V, { RX }, 0 },
     408             :     { "DSTDEVP",                "DSTDEVP",              195,    195,    3,  3,  V, { RO, RR }, 0 },
     409             :     { "DVARP",                  "DVARP",                196,    196,    3,  3,  V, { RO, RR }, 0 },
     410             :     { "TRUNC",                  "TRUNC",                197,    197,    1,  1,  V, { VR, C }, 0 },
     411             :     { "ISLOGICAL",              "ISLOGICAL",            198,    198,    1,  1,  V, { VR }, 0 },
     412             :     { "DCOUNTA",                "DCOUNTA",              199,    199,    3,  3,  V, { RO, RR }, 0 },
     413             :     { 0,                        "EXTERN.CALL",          255,    255,    1,  MX, R, { RO_E, RO }, FUNCFLAG_IMPORTONLY },
     414             : 
     415             :     // *** macro sheet commands ***
     416             : 
     417             :     { 0,                        "A1.R1C1",              30,     30,     0,  1,  V, { VR }, FUNCFLAG_MACROCMD },
     418             :     { 0,                        "RETURN",               55,     55,     0,  1,  R, { RO }, FUNCFLAG_MACROFUNC },
     419             :     { 0,                        "ABSREF",               79,     79,     2,  2,  R, { VR, RO }, FUNCFLAG_MACROFUNC },
     420             :     { 0,                        "ADD.ARROW",            81,     81,     0,  0,  V, {}, FUNCFLAG_MACROCMD },
     421             :     { 0,                        "ACTIVE.CELL",          94,     94,     0,  0,  R, {}, FUNCFLAG_MACROFUNC },
     422             :     { 0,                        "ACTIVATE",             103,    103,    0,  2,  V, { VR }, FUNCFLAG_MACROCMD },
     423             :     { 0,                        "ACTIVATE.NEXT",        104,    104,    0,  0,  V, {}, FUNCFLAG_MACROCMD },
     424             :     { 0,                        "ACTIVATE.PREV",        105,    105,    0,  0,  V, {}, FUNCFLAG_MACROCMD },
     425             :     { 0,                        "ADD.BAR",              151,    151,    0,  0,  V, {}, FUNCFLAG_MACROFUNC | FUNCFLAG_ALWAYSVAR },
     426             :     { 0,                        "ADD.MENU",             152,    152,    2,  2,  V, { VR, RO }, FUNCFLAG_MACROFUNC | FUNCFLAG_ALWAYSVAR },
     427             :     { 0,                        "ADD.COMMAND",          153,    153,    3,  3,  V, { VR, RO }, FUNCFLAG_MACROFUNC | FUNCFLAG_ALWAYSVAR }
     428             : };
     429             : 
     430             : /** Functions new in BIFF3. */
     431             : static const FunctionData saFuncTableBiff3[] =
     432             : {
     433             :     { "LINEST",                 "LINEST",               49,     49,     1,  4,  A, { RA, RA, VV }, 0 },             // BIFF2: 1-2, BIFF3: 1-4
     434             :     { "TREND",                  "TREND",                50,     50,     1,  4,  A, { RA, RA, RA, VV }, 0 },             // BIFF2: 1-3, BIFF3: 1-4
     435             :     { "LOGEST",                 "LOGEST",               51,     51,     1,  4,  A, { RA, RA, VV }, 0 },             // BIFF2: 1-2, BIFF3: 1-4
     436             :     { "GROWTH",                 "GROWTH",               52,     52,     1,  4,  A, { RA, RA, RA, VV }, 0 },             // BIFF2: 1-3, BIFF3: 1-4
     437             :     { "TRUNC",                  "TRUNC",                197,    197,    1,  2,  V, { VR }, 0 },                      // BIFF2: 1,   BIFF3: 1-2
     438             :     { "DOLLAR",                 "USDOLLAR",             204,    204,    1,  2,  V, { VR }, FUNCFLAG_IMPORTONLY },
     439             :     { 0/*"FIND"*/,              "FINDB",                205,    205,    2,  3,  V, { VR }, 0 },
     440             :     { 0/*"SEARCH"*/,            "SEARCHB",              206,    206,    2,  3,  V, { VR }, 0 },
     441             :     { 0/*"REPLACE"*/,           "REPLACEB",             207,    207,    4,  4,  V, { VR }, 0 },
     442             :     { "LEFTB",                  "LEFTB",                208,    208,    1,  2,  V, { VR }, 0 },
     443             :     { "RIGHTB",                 "RIGHTB",               209,    209,    1,  2,  V, { VR }, 0 },
     444             :     { "MIDB",                   "MIDB",                 210,    210,    3,  3,  V, { VR }, 0 },
     445             :     { "LENB",                   "LENB",                 211,    211,    1,  1,  V, { VR }, 0 },
     446             :     { "ROUNDUP",                "ROUNDUP",              212,    212,    2,  2,  V, { VR }, 0 },
     447             :     { "ROUNDDOWN",              "ROUNDDOWN",            213,    213,    2,  2,  V, { VR }, 0 },
     448             :     { "ASC",                    "ASC",                  214,    214,    1,  1,  V, { VR }, 0 },
     449             :     { "JIS",                    "DBCS",                 215,    215,    1,  1,  V, { VR }, 0 },
     450             :     { "ADDRESS",                "ADDRESS",              219,    219,    2,  5,  V, { VR }, 0 },
     451             :     { "DAYS360",                "DAYS360",              220,    220,    2,  2,  V, { VR, VR, C }, 0 },
     452             :     { "TODAY",                  "TODAY",                221,    221,    0,  0,  V, {}, FUNCFLAG_VOLATILE },
     453             :     { "VDB",                    "VDB",                  222,    222,    5,  7,  V, { VR }, 0 },
     454             :     { "MEDIAN",                 "MEDIAN",               227,    227,    1,  MX, V, { RX }, 0 },
     455             :     { "SUMPRODUCT",             "SUMPRODUCT",           228,    228,    1,  MX, V, { VA }, 0 },
     456             :     { "SINH",                   "SINH",                 229,    229,    1,  1,  V, { VR }, 0 },
     457             :     { "CSCH",                   "SINH",                 229,    229,    1,  1,  V, { VR }, FUNCFLAG_BIFFEXPORTONLY },
     458             :     { "COSH",                   "COSH",                 230,    230,    1,  1,  V, { VR }, 0 },
     459             :     { "SECH",                   "COSH",                 230,    230,    1,  1,  V, { VR }, FUNCFLAG_BIFFEXPORTONLY },
     460             :     { "TANH",                   "TANH",                 231,    231,    1,  1,  V, { VR }, 0 },
     461             :     { "COTH",                   "TANH",                 231,    231,    1,  1,  V, { VR }, FUNCFLAG_BIFFEXPORTONLY },
     462             :     { "ASINH",                  "ASINH",                232,    232,    1,  1,  V, { VR }, 0 },
     463             :     { "ACOSH",                  "ACOSH",                233,    233,    1,  1,  V, { VR }, 0 },
     464             :     { "ATANH",                  "ATANH",                234,    234,    1,  1,  V, { VR }, 0 },
     465             :     { "ACOTH",                  "ATANH",                234,    234,    1,  1,  V, { VR }, FUNCFLAG_BIFFEXPORTONLY },
     466             :     { "DGET",                   "DGET",                 235,    235,    3,  3,  V, { RO, RR }, 0 },
     467             :     { "INFO",                   "INFO",                 244,    244,    1,  1,  V, { VR }, FUNCFLAG_VOLATILE },
     468             : 
     469             :     // *** macro sheet commands ***
     470             : 
     471             :     { 0,                        "ADD.BAR",              151,    151,    0,  1,  V, { VR }, FUNCFLAG_MACROFUNC },    // BIFF2: 0,   BIFF3: 0-1
     472             :     { 0,                        "ADD.MENU",             152,    152,    2,  3,  V, { VR, RO }, FUNCFLAG_MACROFUNC },  // BIFF2: 2,   BIFF3: 2-3
     473             :     { 0,                        "ADD.COMMAND",          153,    153,    3,  4,  V, { VR, RO }, FUNCFLAG_MACROFUNC }   // BIFF2: 3,   BIFF3: 3-4
     474             : };
     475             : 
     476             : /** Functions new in BIFF4. */
     477             : static const FunctionData saFuncTableBiff4[] =
     478             : {
     479             :     { "FIXED",                  "FIXED",                14,     14,     1,  3,  V, { VR }, 0 },       // BIFF2-3: 1-2, BIFF4: 1-3
     480             :     { "RANK",                   "RANK",                 216,    216,    2,  3,  V, { VR, RO, VR }, 0 },
     481             :     { "DB",                     "DB",                   247,    247,    4,  5,  V, { VR }, 0 },
     482             :     { "FREQUENCY",              "FREQUENCY",            252,    252,    2,  2,  A, { RA }, 0 },
     483             :     { "ORG.OPENOFFICE.ERRORTYPE","ERROR.TYPE",          261,    261,    1,  1,  V, { VR }, 0 },
     484             :     { "AVEDEV",                 "AVEDEV",               269,    269,    1,  MX, V, { RX }, 0 },
     485             :     { "BETADIST",               "BETADIST",             270,    270,    3,  5,  V, { VR }, 0 },
     486             :     { "GAMMALN",                "GAMMALN",              271,    271,    1,  1,  V, { VR }, 0 },
     487             :     { "BETAINV",                "BETAINV",              272,    272,    3,  5,  V, { VR }, 0 },
     488             :     { "BINOMDIST",              "BINOMDIST",            273,    273,    4,  4,  V, { VR }, 0 },
     489             :     { "LEGACY.CHIDIST",         "CHIDIST",              274,    274,    2,  2,  V, { VR }, 0 },
     490             :     { "LEGACY.CHIINV",          "CHIINV",               275,    275,    2,  2,  V, { VR }, 0 },
     491             :     { "COMBIN",                 "COMBIN",               276,    276,    2,  2,  V, { VR }, 0 },
     492             :     { "CONFIDENCE",             "CONFIDENCE",           277,    277,    3,  3,  V, { VR }, 0 },
     493             :     { "CRITBINOM",              "CRITBINOM",            278,    278,    3,  3,  V, { VR }, 0 },
     494             :     { "EVEN",                   "EVEN",                 279,    279,    1,  1,  V, { VR }, 0 },
     495             :     { "EXPONDIST",              "EXPONDIST",            280,    280,    3,  3,  V, { VR }, 0 },
     496             :     { "LEGACY.FDIST",           "FDIST",                281,    281,    3,  3,  V, { VR }, 0 },
     497             :     { "LEGACY.FINV",            "FINV",                 282,    282,    3,  3,  V, { VR }, 0 },
     498             :     { "FISHER",                 "FISHER",               283,    283,    1,  1,  V, { VR }, 0 },
     499             :     { "FISHERINV",              "FISHERINV",            284,    284,    1,  1,  V, { VR }, 0 },
     500             :     { "FLOOR",                  "FLOOR",                285,    285,    2,  2,  V, { VR, VR, C }, 0 },
     501             :     { "GAMMADIST",              "GAMMADIST",            286,    286,    4,  4,  V, { VR }, 0 },
     502             :     { "GAMMAINV",               "GAMMAINV",             287,    287,    3,  3,  V, { VR }, 0 },
     503             :     { "CEILING",                "CEILING",              288,    288,    2,  2,  V, { VR, VR, C }, 0 },
     504             :     { "HYPGEOMDIST",            "HYPGEOMDIST",          289,    289,    4,  4,  V, { VR }, 0 },
     505             :     { "LOGNORMDIST",            "LOGNORMDIST",          290,    290,    3,  3,  V, { VR }, 0 },
     506             :     { "LOGINV",                 "LOGINV",               291,    291,    3,  3,  V, { VR }, 0 },
     507             :     { "NEGBINOMDIST",           "NEGBINOMDIST",         292,    292,    3,  3,  V, { VR }, 0 },
     508             :     { "NORMDIST",               "NORMDIST",             293,    293,    4,  4,  V, { VR }, 0 },
     509             :     { "LEGACY.NORMSDIST",       "NORMSDIST",            294,    294,    1,  1,  V, { VR }, 0 },
     510             :     { "NORMINV",                "NORMINV",              295,    295,    3,  3,  V, { VR }, 0 },
     511             :     { "LEGACY.NORMSINV",        "NORMSINV",             296,    296,    1,  1,  V, { VR }, 0 },
     512             :     { "STANDARDIZE",            "STANDARDIZE",          297,    297,    3,  3,  V, { VR }, 0 },
     513             :     { "ODD",                    "ODD",                  298,    298,    1,  1,  V, { VR }, 0 },
     514             :     { "PERMUT",                 "PERMUT",               299,    299,    2,  2,  V, { VR }, 0 },
     515             :     { "POISSON",                "POISSON",              300,    300,    3,  3,  V, { VR }, 0 },
     516             :     { "LEGACY.TDIST",           "TDIST",                301,    301,    3,  3,  V, { VR }, 0 },
     517             :     { "WEIBULL",                "WEIBULL",              302,    302,    4,  4,  V, { VR }, 0 },
     518             :     { "SUMXMY2",                "SUMXMY2",              303,    303,    2,  2,  V, { VA }, 0 },
     519             :     { "SUMX2MY2",               "SUMX2MY2",             304,    304,    2,  2,  V, { VA }, 0 },
     520             :     { "SUMX2PY2",               "SUMX2PY2",             305,    305,    2,  2,  V, { VA }, 0 },
     521             :     { "LEGACY.CHITEST",         "CHITEST",              306,    306,    2,  2,  V, { VA }, 0 },
     522             :     { "CORREL",                 "CORREL",               307,    307,    2,  2,  V, { VA }, 0 },
     523             :     { "COVAR",                  "COVAR",                308,    308,    2,  2,  V, { VA }, 0 },
     524             :     { "FORECAST",               "FORECAST",             309,    309,    3,  3,  V, { VR, VA }, 0 },
     525             :     { "FTEST",                  "FTEST",                310,    310,    2,  2,  V, { VA }, 0 },
     526             :     { "INTERCEPT",              "INTERCEPT",            311,    311,    2,  2,  V, { VA }, 0 },
     527             :     { "PEARSON",                "PEARSON",              312,    312,    2,  2,  V, { VA }, 0 },
     528             :     { "RSQ",                    "RSQ",                  313,    313,    2,  2,  V, { VA }, 0 },
     529             :     { "STEYX",                  "STEYX",                314,    314,    2,  2,  V, { VA }, 0 },
     530             :     { "SLOPE",                  "SLOPE",                315,    315,    2,  2,  V, { VA }, 0 },
     531             :     { "TTEST",                  "TTEST",                316,    316,    4,  4,  V, { VA, VA, VR }, 0 },
     532             :     { "PROB",                   "PROB",                 317,    317,    3,  4,  V, { VA, VA, VR }, 0 },
     533             :     { "DEVSQ",                  "DEVSQ",                318,    318,    1,  MX, V, { RX }, 0 },
     534             :     { "GEOMEAN",                "GEOMEAN",              319,    319,    1,  MX, V, { RX }, 0 },
     535             :     { "HARMEAN",                "HARMEAN",              320,    320,    1,  MX, V, { RX }, 0 },
     536             :     { "SUMSQ",                  "SUMSQ",                321,    321,    0,  MX, V, { RX }, 0 },
     537             :     { "KURT",                   "KURT",                 322,    322,    1,  MX, V, { RX }, 0 },
     538             :     { "SKEW",                   "SKEW",                 323,    323,    1,  MX, V, { RX }, 0 },
     539             :     { "ZTEST",                  "ZTEST",                324,    324,    2,  3,  V, { RX, VR }, 0 },
     540             :     { "LARGE",                  "LARGE",                325,    325,    2,  2,  V, { RX, VR }, 0 },
     541             :     { "SMALL",                  "SMALL",                326,    326,    2,  2,  V, { RX, VR }, 0 },
     542             :     { "QUARTILE",               "QUARTILE",             327,    327,    2,  2,  V, { RX, VR }, 0 },
     543             :     { "PERCENTILE",             "PERCENTILE",           328,    328,    2,  2,  V, { RX, VR }, 0 },
     544             :     { "PERCENTRANK",            "PERCENTRANK",          329,    329,    2,  3,  V, { RX, VR, VR_E }, 0 },
     545             :     { "MODE",                   "MODE",                 330,    330,    1,  MX, V, { VA }, 0 },
     546             :     { "TRIMMEAN",               "TRIMMEAN",             331,    331,    2,  2,  V, { RX, VR }, 0 },
     547             :     { "TINV",                   "TINV",                 332,    332,    2,  2,  V, { VR }, 0 },
     548             : 
     549             :     // *** Analysis add-in ***
     550             : 
     551             :     { "HEX2BIN",                "HEX2BIN",              384,    NOID,   1,  2,  V, { RR }, FUNCFLAG_EXTERNAL },
     552             :     { "HEX2DEC",                "HEX2DEC",              385,    NOID,   1,  1,  V, { RR }, FUNCFLAG_EXTERNAL },
     553             :     { "HEX2OCT",                "HEX2OCT",              386,    NOID,   1,  2,  V, { RR }, FUNCFLAG_EXTERNAL },
     554             :     { "DEC2BIN",                "DEC2BIN",              387,    NOID,   1,  2,  V, { RR }, FUNCFLAG_EXTERNAL },
     555             :     { "DEC2HEX",                "DEC2HEX",              388,    NOID,   1,  2,  V, { RR }, FUNCFLAG_EXTERNAL },
     556             :     { "DEC2OCT",                "DEC2OCT",              389,    NOID,   1,  2,  V, { RR }, FUNCFLAG_EXTERNAL },
     557             :     { "OCT2BIN",                "OCT2BIN",              390,    NOID,   1,  2,  V, { RR }, FUNCFLAG_EXTERNAL },
     558             :     { "OCT2HEX",                "OCT2HEX",              391,    NOID,   1,  2,  V, { RR }, FUNCFLAG_EXTERNAL },
     559             :     { "OCT2DEC",                "OCT2DEC",              392,    NOID,   1,  1,  V, { RR }, FUNCFLAG_EXTERNAL },
     560             :     { "BIN2DEC",                "BIN2DEC",              393,    NOID,   1,  1,  V, { RR }, FUNCFLAG_EXTERNAL },
     561             :     { "BIN2OCT",                "BIN2OCT",              394,    NOID,   1,  2,  V, { RR }, FUNCFLAG_EXTERNAL },
     562             :     { "BIN2HEX",                "BIN2HEX",              395,    NOID,   1,  2,  V, { RR }, FUNCFLAG_EXTERNAL },
     563             :     { "IMSUB",                  "IMSUB",                396,    NOID,   2,  2,  V, { RR }, FUNCFLAG_EXTERNAL },
     564             :     { "IMDIV",                  "IMDIV",                397,    NOID,   2,  2,  V, { RR }, FUNCFLAG_EXTERNAL },
     565             :     { "IMPOWER",                "IMPOWER",              398,    NOID,   2,  2,  V, { RR }, FUNCFLAG_EXTERNAL },
     566             :     { "IMABS",                  "IMABS",                399,    NOID,   1,  1,  V, { RR }, FUNCFLAG_EXTERNAL },
     567             :     { "IMSQRT",                 "IMSQRT",               400,    NOID,   1,  1,  V, { RR }, FUNCFLAG_EXTERNAL },
     568             :     { "IMLN",                   "IMLN",                 401,    NOID,   1,  1,  V, { RR }, FUNCFLAG_EXTERNAL },
     569             :     { "IMLOG2",                 "IMLOG2",               402,    NOID,   1,  1,  V, { RR }, FUNCFLAG_EXTERNAL },
     570             :     { "IMLOG10",                "IMLOG10",              403,    NOID,   1,  1,  V, { RR }, FUNCFLAG_EXTERNAL },
     571             :     { "IMSIN",                  "IMSIN",                404,    NOID,   1,  1,  V, { RR }, FUNCFLAG_EXTERNAL },
     572             :     { "IMCOS",                  "IMCOS",                405,    NOID,   1,  1,  V, { RR }, FUNCFLAG_EXTERNAL },
     573             :     { "IMEXP",                  "IMEXP",                406,    NOID,   1,  1,  V, { RR }, FUNCFLAG_EXTERNAL },
     574             :     { "IMARGUMENT",             "IMARGUMENT",           407,    NOID,   1,  1,  V, { RR }, FUNCFLAG_EXTERNAL },
     575             :     { "IMCONJUGATE",            "IMCONJUGATE",          408,    NOID,   1,  1,  V, { RR }, FUNCFLAG_EXTERNAL },
     576             :     { "IMAGINARY",              "IMAGINARY",            409,    NOID,   1,  1,  V, { RR }, FUNCFLAG_EXTERNAL },
     577             :     { "IMREAL",                 "IMREAL",               410,    NOID,   1,  1,  V, { RR }, FUNCFLAG_EXTERNAL },
     578             :     { "COMPLEX",                "COMPLEX",              411,    NOID,   2,  3,  V, { RR }, FUNCFLAG_EXTERNAL },
     579             :     { "IMSUM",                  "IMSUM",                412,    NOID,   1,  MX, V, { RX }, FUNCFLAG_EXTERNAL },
     580             :     { "IMPRODUCT",              "IMPRODUCT",            413,    NOID,   1,  MX, V, { RX }, FUNCFLAG_EXTERNAL },
     581             :     { "SERIESSUM",              "SERIESSUM",            414,    NOID,   4,  4,  V, { RR, RR, RR, RX }, FUNCFLAG_EXTERNAL },
     582             :     { "FACTDOUBLE",             "FACTDOUBLE",           415,    NOID,   1,  1,  V, { RR }, FUNCFLAG_EXTERNAL },
     583             :     { "SQRTPI",                 "SQRTPI",               416,    NOID,   1,  1,  V, { RR }, FUNCFLAG_EXTERNAL },
     584             :     { "QUOTIENT",               "QUOTIENT",             417,    NOID,   2,  2,  V, { RR }, FUNCFLAG_EXTERNAL },
     585             :     { "DELTA",                  "DELTA",                418,    NOID,   1,  2,  V, { RR }, FUNCFLAG_EXTERNAL },
     586             :     { "GESTEP",                 "GESTEP",               419,    NOID,   1,  2,  V, { RR }, FUNCFLAG_EXTERNAL },
     587             :     { "ISEVEN",                 "ISEVEN",               420,    NOID,   1,  1,  V, { RR }, FUNCFLAG_EXTERNAL },       // Calc: builtin and add-in
     588             :     { "ISODD",                  "ISODD",                421,    NOID,   1,  1,  V, { RR }, FUNCFLAG_EXTERNAL },       // Calc: builtin and add-in
     589             :     { "MROUND",                 "MROUND",               422,    NOID,   2,  2,  V, { RR }, FUNCFLAG_EXTERNAL },
     590             :     { "ERF",                    "ERF",                  423,    NOID,   1,  2,  V, { RR }, FUNCFLAG_EXTERNAL },
     591             :     { "ERFC",                   "ERFC",                 424,    NOID,   1,  1,  V, { RR }, FUNCFLAG_EXTERNAL },
     592             :     { "BESSELJ",                "BESSELJ",              425,    NOID,   2,  2,  V, { RR }, FUNCFLAG_EXTERNAL },
     593             :     { "BESSELK",                "BESSELK",              426,    NOID,   2,  2,  V, { RR }, FUNCFLAG_EXTERNAL },
     594             :     { "BESSELY",                "BESSELY",              427,    NOID,   2,  2,  V, { RR }, FUNCFLAG_EXTERNAL },
     595             :     { "BESSELI",                "BESSELI",              428,    NOID,   2,  2,  V, { RR }, FUNCFLAG_EXTERNAL },
     596             :     { "XIRR",                   "XIRR",                 429,    NOID,   2,  3,  V, { RX, RX, RR }, FUNCFLAG_EXTERNAL },
     597             :     { "XNPV",                   "XNPV",                 430,    NOID,   3,  3,  V, { RR, RX, RX }, FUNCFLAG_EXTERNAL },
     598             :     { "PRICEMAT",               "PRICEMAT",             431,    NOID,   5,  6,  V, { RR }, FUNCFLAG_EXTERNAL },
     599             :     { "YIELDMAT",               "YIELDMAT",             432,    NOID,   5,  6,  V, { RR }, FUNCFLAG_EXTERNAL },
     600             :     { "INTRATE",                "INTRATE",              433,    NOID,   4,  5,  V, { RR }, FUNCFLAG_EXTERNAL },
     601             :     { "RECEIVED",               "RECEIVED",             434,    NOID,   4,  5,  V, { RR }, FUNCFLAG_EXTERNAL },
     602             :     { "DISC",                   "DISC",                 435,    NOID,   4,  5,  V, { RR }, FUNCFLAG_EXTERNAL },
     603             :     { "PRICEDISC",              "PRICEDISC",            436,    NOID,   4,  5,  V, { RR }, FUNCFLAG_EXTERNAL },
     604             :     { "YIELDDISC",              "YIELDDISC",            437,    NOID,   4,  5,  V, { RR }, FUNCFLAG_EXTERNAL },
     605             :     { "TBILLEQ",                "TBILLEQ",              438,    NOID,   3,  3,  V, { RR }, FUNCFLAG_EXTERNAL },
     606             :     { "TBILLPRICE",             "TBILLPRICE",           439,    NOID,   3,  3,  V, { RR }, FUNCFLAG_EXTERNAL },
     607             :     { "TBILLYIELD",             "TBILLYIELD",           440,    NOID,   3,  3,  V, { RR }, FUNCFLAG_EXTERNAL },
     608             :     { "PRICE",                  "PRICE",                441,    NOID,   6,  7,  V, { RR }, FUNCFLAG_EXTERNAL },
     609             :     { "YIELD",                  "YIELD",                442,    NOID,   6,  7,  V, { RR }, FUNCFLAG_EXTERNAL },
     610             :     { "DOLLARDE",               "DOLLARDE",             443,    NOID,   2,  2,  V, { RR }, FUNCFLAG_EXTERNAL },
     611             :     { "DOLLARFR",               "DOLLARFR",             444,    NOID,   2,  2,  V, { RR }, FUNCFLAG_EXTERNAL },
     612             :     { "NOMINAL",                "NOMINAL",              445,    NOID,   2,  2,  V, { RR }, FUNCFLAG_EXTERNAL },       // Calc: builtin and add-in
     613             :     { "EFFECT",                 "EFFECT",               446,    NOID,   2,  2,  V, { RR }, FUNCFLAG_EXTERNAL },       // Calc: builtin and add-in
     614             :     { "CUMPRINC",               "CUMPRINC",             447,    NOID,   6,  6,  V, { RR }, FUNCFLAG_EXTERNAL },       // Calc: builtin and add-in
     615             :     { "CUMIPMT",                "CUMIPMT",              448,    NOID,   6,  6,  V, { RR }, FUNCFLAG_EXTERNAL },       // Calc: builtin and add-in
     616             :     { "EDATE",                  "EDATE",                449,    NOID,   2,  2,  V, { RR }, FUNCFLAG_EXTERNAL },
     617             :     { "EOMONTH",                "EOMONTH",              450,    NOID,   2,  2,  V, { RR }, FUNCFLAG_EXTERNAL },
     618             :     { "YEARFRAC",               "YEARFRAC",             451,    NOID,   2,  3,  V, { RR }, FUNCFLAG_EXTERNAL },
     619             :     { "COUPDAYBS",              "COUPDAYBS",            452,    NOID,   3,  4,  V, { RR }, FUNCFLAG_EXTERNAL },
     620             :     { "COUPDAYS",               "COUPDAYS",             453,    NOID,   3,  4,  V, { RR }, FUNCFLAG_EXTERNAL },
     621             :     { "COUPDAYSNC",             "COUPDAYSNC",           454,    NOID,   3,  4,  V, { RR }, FUNCFLAG_EXTERNAL },
     622             :     { "COUPNCD",                "COUPNCD",              455,    NOID,   3,  4,  V, { RR }, FUNCFLAG_EXTERNAL },
     623             :     { "COUPNUM",                "COUPNUM",              456,    NOID,   3,  4,  V, { RR }, FUNCFLAG_EXTERNAL },
     624             :     { "COUPPCD",                "COUPPCD",              457,    NOID,   3,  4,  V, { RR }, FUNCFLAG_EXTERNAL },
     625             :     { "DURATION",               "DURATION",             458,    NOID,   5,  6,  V, { RR }, FUNCFLAG_EXTERNAL },       // Calc: builtin and add-in
     626             :     { "MDURATION",              "MDURATION",            459,    NOID,   5,  6,  V, { RR }, FUNCFLAG_EXTERNAL },
     627             :     { "ODDLPRICE",              "ODDLPRICE",            460,    NOID,   7,  8,  V, { RR }, FUNCFLAG_EXTERNAL },
     628             :     { "ODDLYIELD",              "ODDLYIELD",            461,    NOID,   8,  9,  V, { RR }, FUNCFLAG_EXTERNAL },
     629             :     { "ODDFPRICE",              "ODDFPRICE",            462,    NOID,   8,  9,  V, { RR }, FUNCFLAG_EXTERNAL },
     630             :     { "ODDFYIELD",              "ODDFYIELD",            463,    NOID,   8,  9,  V, { RR }, FUNCFLAG_EXTERNAL },
     631             :     { "RANDBETWEEN",            "RANDBETWEEN",          464,    NOID,   2,  2,  V, { RR }, FUNCFLAG_VOLATILE | FUNCFLAG_EXTERNAL },
     632             :     { "WEEKNUM",                "WEEKNUM",              465,    NOID,   1,  2,  V, { RR }, FUNCFLAG_EXTERNAL },
     633             :     { "AMORDEGRC",              "AMORDEGRC",            466,    NOID,   6,  7,  V, { RR }, FUNCFLAG_EXTERNAL },
     634             :     { "AMORLINC",               "AMORLINC",             467,    NOID,   6,  7,  V, { RR }, FUNCFLAG_EXTERNAL },
     635             :     { "CONVERT",                "CONVERT",              468,    NOID,   3,  3,  V, { RR }, FUNCFLAG_EXTERNAL },       // Calc: builtin and add-in
     636             :     { "ACCRINT",                "ACCRINT",              469,    NOID,   6,  7,  V, { RR }, FUNCFLAG_EXTERNAL },
     637             :     { "ACCRINTM",               "ACCRINTM",             470,    NOID,   4,  5,  V, { RR }, FUNCFLAG_EXTERNAL },
     638             :     { "WORKDAY",                "WORKDAY",              471,    NOID,   2,  3,  V, { RR, RR, RX, C }, FUNCFLAG_EXTERNAL },
     639             :     { "NETWORKDAYS",            "NETWORKDAYS",          472,    NOID,   2,  3,  V, { RR, RR, RX, C }, FUNCFLAG_EXTERNAL },
     640             :     { "GCD",                    "GCD",                  473,    NOID,   1,  MX, V, { RX }, FUNCFLAG_EXTERNAL },       // Calc: builtin and add-in
     641             :     { "MULTINOMIAL",            "MULTINOMIAL",          474,    NOID,   1,  MX, V, { RX }, FUNCFLAG_EXTERNAL },
     642             :     { "LCM",                    "LCM",                  475,    NOID,   1,  MX, V, { RX }, FUNCFLAG_EXTERNAL },       // Calc: builtin and add-in
     643             :     { "FVSCHEDULE",             "FVSCHEDULE",           476,    NOID,   2,  2,  V, { RR, RX }, FUNCFLAG_EXTERNAL },
     644             : 
     645             :     // *** macro sheet commands ***
     646             : 
     647             :     { 0,                        "ACTIVATE.NEXT",        104,    104,    0,  1,  V, { VR }, FUNCFLAG_MACROCMD },      // BIFF2-3: 0, BIFF4: 0-1
     648             :     { 0,                        "ACTIVATE.PREV",        105,    105,    0,  1,  V, { VR }, FUNCFLAG_MACROCMD }       // BIFF2-3: 0, BIFF4: 0-1
     649             : };
     650             : 
     651             : /** Functions new in BIFF5/BIFF7. */
     652             : static const FunctionData saFuncTableBiff5[] =
     653             : {
     654             :     { "WEEKDAY",                "WEEKDAY",              70,     70,     1,  2,  V, { VR }, 0 },                              // BIFF2-4: 1,   BIFF5: 1-2
     655             :     { "HLOOKUP",                "HLOOKUP",              101,    101,    3,  4,  V, { VV, RO, RO, VV }, 0 },                     // BIFF2-4: 3,   BIFF5: 3-4
     656             :     { "VLOOKUP",                "VLOOKUP",              102,    102,    3,  4,  V, { VV, RO, RO, VV }, 0 },                     // BIFF2-4: 3,   BIFF5: 3-4
     657             :     { "DAYS360",                "DAYS360",              220,    220,    2,  3,  V, { VR }, 0 },                              // BIFF3-4: 2,   BIFF5: 2-3
     658             :     { 0,                        "EXTERN.CALL",          255,    255,    1,  MX, R, { RO_E, RO }, FUNCFLAG_EXPORTONLY },        // MACRO or EXTERNAL
     659             :     { "CONCATENATE",            "CONCATENATE",          336,    336,    0,  MX, V, { VR }, 0 },
     660             :     { "POWER",                  "POWER",                337,    337,    2,  2,  V, { VR }, 0 },
     661             :     { "RADIANS",                "RADIANS",              342,    342,    1,  1,  V, { VR }, 0 },
     662             :     { "DEGREES",                "DEGREES",              343,    343,    1,  1,  V, { VR }, 0 },
     663             :     { "SUBTOTAL",               "SUBTOTAL",             344,    344,    2,  MX, V, { VR, RO }, 0 },
     664             :     { "SUMIF",                  "SUMIF",                345,    345,    2,  3,  V, { RO, VR, RO }, 0 },
     665             :     { "COUNTIF",                "COUNTIF",              346,    346,    2,  2,  V, { RO, VR }, 0 },
     666             :     { "COUNTBLANK",             "COUNTBLANK",           347,    347,    1,  1,  V, { RO }, 0 },
     667             :     { "ISPMT",                  "ISPMT",                350,    350,    4,  4,  V, { VR }, 0 },
     668             :     { "DATEDIF",                "DATEDIF",              351,    351,    3,  3,  V, { VR }, 0 },
     669             :     { 0,                        "DATESTRING",           352,    352,    1,  1,  V, { VR }, FUNCFLAG_IMPORTONLY },   // not supported in Calc, missing in OOXML spec
     670             :     { 0,                        "NUMBERSTRING",         353,    353,    2,  2,  V, { VR }, FUNCFLAG_IMPORTONLY },   // not supported in Calc, missing in OOXML spec
     671             :     { "ROMAN",                  "ROMAN",                354,    354,    1,  2,  V, { VR }, 0 },
     672             : 
     673             :     // *** EuroTool add-in ***
     674             : 
     675             :     { "EUROCONVERT",            "EUROCONVERT",          NOID,   NOID,   3,  5,  V, { VR }, FUNCLIB_TO_FUNCFLAGS( FUNCLIB_EUROTOOL ) },
     676             : 
     677             :     // *** macro sheet commands ***
     678             : 
     679             :     { 0,                        "ADD.MENU",             152,    152,    2,  4,  V, { VR, RO, RO, VR }, FUNCFLAG_MACROFUNC },    // BIFF3-4: 2-3, BIFF5: 2-4
     680             :     { 0,                        "ADD.COMMAND",          153,    153,    3,  5,  V, { VR, RO, RO, RO, VR }, FUNCFLAG_MACROFUNC }, // BIFF3-4: 3-4, BIFF5: 3-5
     681             :     { 0,                        "ADD.CHART.AUTOFORMAT", 390,    390,    0,  2,  V, { VR }, FUNCFLAG_MACROCMD },
     682             :     { 0,                        "ADD.LIST.ITEM",        451,    451,    0,  2,  V, { VR }, FUNCFLAG_MACROCMD },
     683             :     { 0,                        "ACTIVE.CELL.FONT",     476,    476,    0,  14, V, { VR }, FUNCFLAG_MACROCMD }
     684             : };
     685             : 
     686             : /** Functions new in BIFF8. */
     687             : static const FunctionData saFuncTableBiff8[] =
     688             : {
     689             :     { "GETPIVOTDATA",           "GETPIVOTDATA",         358,    358,    2,  MX, V, { RR, RR, VR, VR }, FUNCFLAG_IMPORTONLY | FUNCFLAG_PARAMPAIRS },
     690             :     { "HYPERLINK",              "HYPERLINK",            359,    359,    1,  2,  V, { VV, VO }, 0 },
     691             :     { 0,                        "PHONETIC",             360,    360,    1,  1,  V, { RO }, FUNCFLAG_IMPORTONLY },
     692             :     { "AVERAGEA",               "AVERAGEA",             361,    361,    1,  MX, V, { RX }, 0 },
     693             :     { "MAXA",                   "MAXA",                 362,    362,    1,  MX, V, { RX }, 0 },
     694             :     { "MINA",                   "MINA",                 363,    363,    1,  MX, V, { RX }, 0 },
     695             :     { "STDEVPA",                "STDEVPA",              364,    364,    1,  MX, V, { RX }, 0 },
     696             :     { "VARPA",                  "VARPA",                365,    365,    1,  MX, V, { RX }, 0 },
     697             :     { "STDEVA",                 "STDEVA",               366,    366,    1,  MX, V, { RX }, 0 },
     698             :     { "VARA",                   "VARA",                 367,    367,    1,  MX, V, { RX }, 0 },
     699             :     { "COM.MICROSOFT.BAHTTEXT", "BAHTTEXT",             368,    368,    1,  1,  V, { VR }, FUNCFLAG_MACROCALL },
     700             :     { 0,                        "THAIDAYOFWEEK",        369,    369,    1,  1,  V, { VR }, FUNCFLAG_MACROCALL },
     701             :     { 0,                        "THAIDIGIT",            370,    370,    1,  1,  V, { VR }, FUNCFLAG_MACROCALL },
     702             :     { 0,                        "THAIMONTHOFYEAR",      371,    371,    1,  1,  V, { VR }, FUNCFLAG_MACROCALL },
     703             :     { 0,                        "THAINUMSOUND",         372,    372,    1,  1,  V, { VR }, FUNCFLAG_MACROCALL },
     704             :     { 0,                        "THAINUMSTRING",        373,    373,    1,  1,  V, { VR }, FUNCFLAG_MACROCALL },
     705             :     { 0,                        "THAISTRINGLENGTH",     374,    374,    1,  1,  V, { VR }, FUNCFLAG_MACROCALL },
     706             :     { 0,                        "ISTHAIDIGIT",          375,    375,    1,  1,  V, { VR }, FUNCFLAG_MACROCALL },
     707             :     { 0,                        "ROUNDBAHTDOWN",        376,    376,    1,  1,  V, { VR }, FUNCFLAG_MACROCALL },
     708             :     { 0,                        "ROUNDBAHTUP",          377,    377,    1,  1,  V, { VR }, FUNCFLAG_MACROCALL },
     709             :     { 0,                        "THAIYEAR",             378,    378,    1,  1,  V, { VR }, FUNCFLAG_MACROCALL },
     710             :     { 0,                        "RTD",                  379,    379,    3,  3,  A, { VR, VR, RO }, 0 }
     711             : };
     712             : 
     713             : /** Functions new in OOXML. */
     714             : static const FunctionData saFuncTableOox[] =
     715             : {
     716             :     { 0,                        "CUBEVALUE",            380,    NOID,   1,  MX, V, { VR, RX }, 0 },
     717             :     { 0,                        "CUBEMEMBER",           381,    NOID,   2,  3,  V, { VR, RX, VR }, 0 },
     718             :     { 0,                        "CUBEMEMBERPROPERTY",   382,    NOID,   3,  3,  V, { VR }, 0 },
     719             :     { 0,                        "CUBERANKEDMEMBER",     383,    NOID,   3,  4,  V, { VR }, 0 },
     720             :     { 0,                        "CUBEKPIMEMBER",        477,    NOID,   3,  4,  V, { VR }, 0 },
     721             :     { 0,                        "CUBESET",              478,    NOID,   2,  5,  V, { VR, RX, VR }, 0 },
     722             :     { 0,                        "CUBESETCOUNT",         479,    NOID,   1,  1,  V, { VR }, 0 },
     723             :     { "IFERROR",                "IFERROR",              480,    NOID,   2,  2,  V, { VO, RO }, FUNCFLAG_MACROCALL },
     724             :     { "COUNTIFS",               "COUNTIFS",             481,    NOID,   2,  MX, V, { RO, VR }, FUNCFLAG_MACROCALL | FUNCFLAG_PARAMPAIRS },
     725             :     { "SUMIFS",                 "SUMIFS",               482,    NOID,   3,  MX, V, { RO, RO, VR }, FUNCFLAG_MACROCALL | FUNCFLAG_PARAMPAIRS },
     726             :     { "AVERAGEIF",              "AVERAGEIF",            483,    NOID,   2,  3,  V, { RO, VR, RO }, FUNCFLAG_MACROCALL },
     727             :     { "AVERAGEIFS",             "AVERAGEIFS",           484,    NOID,   3,  MX, V, { RO, RO, VR }, FUNCFLAG_MACROCALL | FUNCFLAG_PARAMPAIRS }
     728             : };
     729             : 
     730             : /** Functions new in Excel 2013.
     731             : 
     732             :     See http://office.microsoft.com/en-us/excel-help/new-functions-in-excel-2013-HA103980604.aspx
     733             :     Most functions apparently were added for ODF1.2 ODFF / OpenFormula
     734             :     compatibility.
     735             : 
     736             :     Functions with FUNCFLAG_IMPORTONLY are rewritten in
     737             :     sc/source/filter/excel/xeformula.cxx during export for
     738             :     BIFF, OOXML export uses this different mapping here but still uses the
     739             :     mapping there to determine the feature set.
     740             : 
     741             :     FIXME: either have the exporter determine the feature set from the active
     742             :     mapping, preferred, or enhance that mapping there such that for OOXML the
     743             :     rewrite can be overridden.
     744             : 
     745             :     @See sc/source/filter/excel/xlformula.cxx saFuncTable_2013
     746             :  */
     747             : /* FIXME: BIFF12 function identifiers available? Where to obtain? */
     748             : static const FunctionData saFuncTable2013[] =
     749             : {
     750             :     { "ACOT",                   "ACOT",                 NOID,   NOID,   1,  1,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     751             :     { "ACOTH",                  "ACOTH",                NOID,   NOID,   1,  1,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     752             :     { "ARABIC",                 "ARABIC",               NOID,   NOID,   1,  1,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     753             :     { "BASE",                   "BASE",                 NOID,   NOID,   2,  3,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     754             :     { "BINOM.DIST.RANGE",       "BINOM.DIST.RANGE",     NOID,   NOID,   3,  4,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     755             :     { "BITAND",                 "BITAND",               NOID,   NOID,   2,  2,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     756             :     { "BITLSHIFT",              "BITLSHIFT",            NOID,   NOID,   2,  2,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     757             :     { "BITOR",                  "BITOR",                NOID,   NOID,   2,  2,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     758             :     { "BITRSHIFT",              "BITRSHIFT",            NOID,   NOID,   2,  2,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     759             :     { "BITXOR",                 "BITXOR",               NOID,   NOID,   2,  2,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     760             :     /* FIXME: CEILING.MATH is our/ODFF CEILING, but we have special handling
     761             :      * for the weird Excel CEILING behavior, check that and unify or diversify.
     762             :      * */
     763             :     { 0/*"CEILING"*/,           "CEILING.MATH",         NOID,   NOID,   1,  3,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     764             :     { "COMBINA",                "COMBINA",              NOID,   NOID,   2,  2,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     765             :     { "COT",                    "COT",                  NOID,   NOID,   1,  1,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     766             :     { "COTH",                   "COTH",                 NOID,   NOID,   1,  1,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     767             :     { "CSC",                    "CSC",                  NOID,   NOID,   1,  1,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     768             :     { "CSCH",                   "CSCH",                 NOID,   NOID,   1,  1,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     769             :     { "DAYS",                   "DAYS",                 NOID,   NOID,   2,  2,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     770             :     { "DECIMAL",                "DECIMAL",              NOID,   NOID,   2,  2,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     771             :     { 0,                        "ENCODEURL",            NOID,   NOID,   1,  1,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     772             :     { 0,                        "FILTERXML",            NOID,   NOID,   2,  2,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     773             :     /* FIXME: FLOOR.MATH is our/ODFF FLOOR, but we have special handling for
     774             :      * the weird Excel FLOOR behavior, check that and unify or diversify. */
     775             :     { 0/*"FLOOR"*/,             "FLOOR.MATH",           NOID,   NOID,   1,  3,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     776             :     // NOTE: this FDIST is not our LEGACY.FDIST
     777             :     { 0/*"FDIST"*/,             "FDIST",                NOID,   NOID,   3,  4,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     778             :     // NOTE: this FINV is not our LEGACY.FINV
     779             :     { 0/*"FINV"*/,              "FINV",                 NOID,   NOID,   3,  3,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     780             :     { "FORMULA",                "FORMULATEXT",          NOID,   NOID,   1,  1,  V, { RO }, FUNCFLAG_MACROCALL_NEW },
     781             :     { "GAMMA",                  "GAMMA",                NOID,   NOID,   1,  1,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     782             :     { "GAUSS",                  "GAUSS",                NOID,   NOID,   1,  1,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     783             :     { "IFNA",                   "IFNA",                 NOID,   NOID,   2,  2,  V, { VO, RO }, FUNCFLAG_MACROCALL_NEW },
     784             :     { "IMCOSH",                 "IMCOSH",               NOID,   NOID,   1,  1,  V, { VR }, FUNCFLAG_MACROCALL_NEW | FUNCFLAG_EXTERNAL },
     785             :     { "IMCOT",                  "IMCOT",                NOID,   NOID,   1,  1,  V, { VR }, FUNCFLAG_MACROCALL_NEW | FUNCFLAG_EXTERNAL },
     786             :     { "IMCSC",                  "IMCSC",                NOID,   NOID,   1,  1,  V, { VR }, FUNCFLAG_MACROCALL_NEW | FUNCFLAG_EXTERNAL },
     787             :     { "IMCSCH",                 "IMCSCH",               NOID,   NOID,   1,  1,  V, { VR }, FUNCFLAG_MACROCALL_NEW | FUNCFLAG_EXTERNAL },
     788             :     { "IMSEC",                  "IMSEC",                NOID,   NOID,   1,  1,  V, { VR }, FUNCFLAG_MACROCALL_NEW | FUNCFLAG_EXTERNAL },
     789             :     { "IMSECH",                 "IMSECH",               NOID,   NOID,   1,  1,  V, { VR }, FUNCFLAG_MACROCALL_NEW | FUNCFLAG_EXTERNAL },
     790             :     { "IMSINH",                 "IMSINH",               NOID,   NOID,   1,  1,  V, { VR }, FUNCFLAG_MACROCALL_NEW | FUNCFLAG_EXTERNAL },
     791             :     { "IMTAN",                  "IMTAN",                NOID,   NOID,   1,  1,  V, { VR }, FUNCFLAG_MACROCALL_NEW | FUNCFLAG_EXTERNAL },
     792             :     { "ISFORMULA",              "ISFORMULA",            NOID,   NOID,   1,  1,  V, { RO }, FUNCFLAG_MACROCALL_NEW },
     793             :     /* FIXME: ISOWEEKNUM vs. WEEKNUM mess needs to be sorted out before we can
     794             :      * import. */
     795             :     { 0/*"ISOWEEKNUM"*/,        "ISOWEEKNUM",           NOID,   NOID,   1,  2,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     796             :     { "MUNIT",                  "MUNIT",                NOID,   NOID,   1,  1,  A, { VR }, FUNCFLAG_MACROCALL_NEW },
     797             :     { "NUMBERVALUE",            "NUMBERVALUE",          NOID,   NOID,   1,  3,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     798             :     { "PDURATION",              "PDURATION",            NOID,   NOID,   3,  3,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     799             :     { "PERMUTATIONA",           "PERMUTATIONA",         NOID,   NOID,   2,  2,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     800             :     { "PHI",                    "PHI",                  NOID,   NOID,   1,  1,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     801             :     { "RRI",                    "RRI",                  NOID,   NOID,   3,  3,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     802             :     { "SEC",                    "SEC",                  NOID,   NOID,   1,  1,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     803             :     { "SECH",                   "SECH",                 NOID,   NOID,   1,  1,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     804             :     { "SHEET",                  "SHEET",                NOID,   NOID,   0,  1,  V, { RO }, FUNCFLAG_MACROCALL_NEW },
     805             :     { "SHEETS",                 "SHEETS",               NOID,   NOID,   0,  1,  V, { RO }, FUNCFLAG_MACROCALL_NEW },
     806             :     { "SKEWP",                  "SKEW.P",               NOID,   NOID,   1,  MX, V, { RX }, FUNCFLAG_MACROCALL_NEW },
     807             :     { "UNICHAR",                "UNICHAR",              NOID,   NOID,   1,  1,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     808             :     { "UNICODE",                "UNICODE",              NOID,   NOID,   1,  1,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     809             :     { 0,                        "WEBSERVICE",           NOID,   NOID,   1,  1,  V, { VR }, FUNCFLAG_MACROCALL_NEW },
     810             :     { "XOR",                    "XOR",                  NOID,   NOID,   1,  MX, V, { RX }, FUNCFLAG_MACROCALL_NEW }
     811             : };
     812             : 
     813             : /** Functions defined by OpenFormula, but not supported by Calc or by Excel. */
     814             : static const FunctionData saFuncTableOdf[] =
     815             : {
     816             :     { "CHISQDIST",              0,                      NOID,   NOID,   2,  3,  V, { VR }, FUNCFLAG_MACROCALLODF },
     817             :     { "CHISQINV",               0,                      NOID,   NOID,   2,  2,  V, { VR }, FUNCFLAG_MACROCALLODF }
     818             : };
     819             : 
     820             : // ----------------------------------------------------------------------------
     821             : 
     822             : const sal_Unicode API_TOKEN_OPEN            = '(';
     823             : const sal_Unicode API_TOKEN_CLOSE           = ')';
     824             : const sal_Unicode API_TOKEN_SEP             = ';';
     825             : 
     826             : const sal_Unicode API_TOKEN_ARRAY_OPEN      = '{';
     827             : const sal_Unicode API_TOKEN_ARRAY_CLOSE     = '}';
     828             : const sal_Unicode API_TOKEN_ARRAY_ROWSEP    = '|';
     829             : const sal_Unicode API_TOKEN_ARRAY_COLSEP    = ';';
     830             : 
     831             : } // namespace
     832             : 
     833             : // function info parameter class iterator =====================================
     834             : 
     835           6 : FunctionParamInfoIterator::FunctionParamInfoIterator( const FunctionInfo& rFuncInfo ) :
     836             :     mpParamInfo( rFuncInfo.mpParamInfos ),
     837           6 :     mpParamInfoEnd( rFuncInfo.mpParamInfos + FUNCINFO_PARAMINFOCOUNT ),
     838          12 :     mbParamPairs( rFuncInfo.mbParamPairs )
     839             : {
     840           6 : }
     841             : 
     842          29 : bool FunctionParamInfoIterator::isCalcOnlyParam() const
     843             : {
     844          29 :     return mpParamInfo && (mpParamInfo->meValid == FUNC_PARAM_CALCONLY);
     845             : }
     846             : 
     847          23 : bool FunctionParamInfoIterator::isExcelOnlyParam() const
     848             : {
     849          23 :     return mpParamInfo && (mpParamInfo->meValid == FUNC_PARAM_EXCELONLY);
     850             : }
     851             : 
     852          14 : FunctionParamInfoIterator& FunctionParamInfoIterator::operator++()
     853             : {
     854          14 :     if( mpParamInfo )
     855             :     {
     856             :         // move pointer to next entry, if something explicit follows
     857          14 :         if( (mpParamInfo + 1 < mpParamInfoEnd) && (mpParamInfo[ 1 ].meValid != FUNC_PARAM_NONE) )
     858           5 :             ++mpParamInfo;
     859             :         // if last parameter type is 'Excel-only' or 'Calc-only', do not repeat it
     860           9 :         else if( isExcelOnlyParam() || isCalcOnlyParam() )
     861           0 :             mpParamInfo = 0;
     862             :         // points to last info, but parameter pairs expected, move to previous info
     863           9 :         else if( mbParamPairs )
     864           0 :             --mpParamInfo;
     865             :         // otherwise: repeat last parameter class
     866             :     }
     867          14 :     return *this;
     868             : }
     869             : 
     870             : // function provider ==========================================================
     871             : 
     872          27 : struct FunctionProviderImpl
     873             : {
     874             :     typedef RefMap< OUString, FunctionInfo >    FuncNameMap;
     875             :     typedef RefMap< sal_uInt16, FunctionInfo >  FuncIdMap;
     876             : 
     877             :     FunctionInfoVector  maFuncs;            /// All function infos in one list.
     878             :     FuncNameMap         maOoxFuncs;         /// Maps OOXML function names to function data.
     879             :     FuncIdMap           maBiff12Funcs;      /// Maps BIFF12 function indexes to function data.
     880             :     FuncIdMap           maBiffFuncs;        /// Maps BIFF2-BIFF8 function indexes to function data.
     881             :     FuncNameMap         maMacroFuncs;       /// Maps macro function names to function data.
     882             : 
     883             :     explicit            FunctionProviderImpl( FilterType eFilter, BiffType eBiff, bool bImportFilter,
     884             :                                               bool bCallerKnowsAboutMacroExport );
     885             : 
     886             : private:
     887             :     /** Creates and inserts a function info struct from the passed function data. */
     888             :     void                initFunc( const FunctionData& rFuncData, sal_uInt8 nMaxParam );
     889             : 
     890             :     /** Initializes the members from the passed function data list. */
     891             :     void                initFuncs(
     892             :                             const FunctionData* pBeg, const FunctionData* pEnd,
     893             :                             sal_uInt8 nMaxParam, bool bImportFilter, FilterType eFilter );
     894             : };
     895             : 
     896             : // ----------------------------------------------------------------------------
     897             : 
     898          27 : FunctionProviderImpl::FunctionProviderImpl( FilterType eFilter, BiffType eBiff, bool bImportFilter,
     899          27 :         bool bCallerKnowsAboutMacroExport )
     900             : {
     901             :     // NOTE: this warning is only applicable if called for not yet existing
     902             :     // external export filter, not the Calc internal conversion from binary to
     903             :     // OOXML that also uses this mapping. Which is the only reason for
     904             :     // bCallerKnowsAboutMacroExport, to suppress this warning then.
     905             :     OSL_ENSURE( bImportFilter || bCallerKnowsAboutMacroExport,
     906             :             "FunctionProviderImpl::FunctionProviderImpl - need special handling for macro call functions" );
     907             :     (void)bCallerKnowsAboutMacroExport;
     908          27 :     sal_uInt8 nMaxParam = 0;
     909          27 :     switch( eFilter )
     910             :     {
     911             :         case FILTER_OOXML:
     912          27 :             nMaxParam = OOX_MAX_PARAMCOUNT;
     913          27 :             eBiff = BIFF8;  // insert all BIFF function tables, then the OOXML table
     914          27 :         break;
     915             :         case FILTER_BIFF:
     916           0 :             nMaxParam = BIFF_MAX_PARAMCOUNT;
     917           0 :         break;
     918             :         case FILTER_UNKNOWN:
     919             :             OSL_FAIL( "FunctionProviderImpl::FunctionProviderImpl - invalid filter type" );
     920           0 :         break;
     921             :     }
     922             :     OSL_ENSURE( eBiff != BIFF_UNKNOWN, "FunctionProviderImpl::FunctionProviderImpl - invalid BIFF type" );
     923             : 
     924             :     /*  Add functions supported in the current BIFF version only. Function
     925             :         tables from later BIFF versions may overwrite single functions from
     926             :         earlier tables. */
     927          27 :     if( eBiff >= BIFF2 )
     928          27 :         initFuncs( saFuncTableBiff2, STATIC_ARRAY_END( saFuncTableBiff2 ), nMaxParam, bImportFilter, eFilter );
     929          27 :     if( eBiff >= BIFF3 )
     930          27 :         initFuncs( saFuncTableBiff3, STATIC_ARRAY_END( saFuncTableBiff3 ), nMaxParam, bImportFilter, eFilter );
     931          27 :     if( eBiff >= BIFF4 )
     932          27 :         initFuncs( saFuncTableBiff4, STATIC_ARRAY_END( saFuncTableBiff4 ), nMaxParam, bImportFilter, eFilter );
     933          27 :     if( eBiff >= BIFF5 )
     934          27 :         initFuncs( saFuncTableBiff5, STATIC_ARRAY_END( saFuncTableBiff5 ), nMaxParam, bImportFilter, eFilter );
     935          27 :     if( eBiff >= BIFF8 )
     936          27 :         initFuncs( saFuncTableBiff8, STATIC_ARRAY_END( saFuncTableBiff8 ), nMaxParam, bImportFilter, eFilter );
     937          27 :     initFuncs( saFuncTableOox, STATIC_ARRAY_END( saFuncTableOox ), nMaxParam, bImportFilter, eFilter );
     938          27 :     initFuncs( saFuncTable2013, STATIC_ARRAY_END( saFuncTable2013 ), nMaxParam, bImportFilter, eFilter );
     939          27 :     initFuncs( saFuncTableOdf, STATIC_ARRAY_END( saFuncTableOdf ), nMaxParam, bImportFilter, eFilter );
     940          27 : }
     941             : 
     942       12120 : void FunctionProviderImpl::initFunc( const FunctionData& rFuncData, sal_uInt8 nMaxParam )
     943             : {
     944             :     // create a function info object
     945       12120 :     FunctionInfoRef xFuncInfo( new FunctionInfo );
     946       12120 :     if( rFuncData.mpcOdfFuncName )
     947       10680 :         xFuncInfo->maOdfFuncName = OUString::createFromAscii( rFuncData.mpcOdfFuncName );
     948       12120 :     if( rFuncData.mpcOoxFuncName )
     949       12066 :         xFuncInfo->maOoxFuncName = OUString::createFromAscii( rFuncData.mpcOoxFuncName );
     950             : 
     951       12120 :     if( getFlag( rFuncData.mnFlags, FUNCFLAG_MACROCALL ) )
     952             :     {
     953             :         OSL_ENSURE( !xFuncInfo->maOoxFuncName.isEmpty(), "FunctionProviderImpl::initFunc - missing OOXML function name" );
     954             :         OSL_ENSURE( !getFlag( rFuncData.mnFlags, FUNCFLAG_MACROCALLODF ), "FunctionProviderImpl::initFunc - unexpected flag FUNCFLAG_MACROCALLODF" );
     955        1836 :         xFuncInfo->maBiffMacroName = "_xlfn." + xFuncInfo->maOoxFuncName;
     956        1836 :         if( getFlag( rFuncData.mnFlags, FUNCFLAG_MACROCALL_FN ) )
     957             :         {
     958        1404 :             xFuncInfo->maOoxFuncName = "_xlfn." + xFuncInfo->maOoxFuncName;
     959             :             //! From here on maOoxFuncName contains the _xlfn. prefix!
     960             :         }
     961             :     }
     962       10284 :     else if( getFlag( rFuncData.mnFlags, FUNCFLAG_MACROCALLODF ) )
     963             :     {
     964             :         OSL_ENSURE( !xFuncInfo->maOdfFuncName.isEmpty(), "FunctionProviderImpl::initFunc - missing ODF function name" );
     965          54 :         xFuncInfo->maBiffMacroName = "_xlfnodf." + xFuncInfo->maOdfFuncName;
     966             :     }
     967             : 
     968       12120 :     xFuncInfo->meFuncLibType = FUNCFLAGS_TO_FUNCLIB( rFuncData.mnFlags );
     969       12120 :     xFuncInfo->mnApiOpCode = -1;
     970       12120 :     xFuncInfo->mnBiff12FuncId = rFuncData.mnBiff12FuncId;
     971       12120 :     xFuncInfo->mnBiffFuncId = rFuncData.mnBiffFuncId;
     972       12120 :     xFuncInfo->mnMinParamCount = rFuncData.mnMinParamCount;
     973       12120 :     xFuncInfo->mnMaxParamCount = (rFuncData.mnMaxParamCount == MX) ? nMaxParam : rFuncData.mnMaxParamCount;
     974       12120 :     xFuncInfo->mnRetClass = rFuncData.mnRetClass;
     975       12120 :     xFuncInfo->mpParamInfos = rFuncData.mpParamInfos;
     976       12120 :     xFuncInfo->mbParamPairs = getFlag( rFuncData.mnFlags, FUNCFLAG_PARAMPAIRS );
     977       12120 :     xFuncInfo->mbVolatile = getFlag( rFuncData.mnFlags, FUNCFLAG_VOLATILE );
     978       12120 :     xFuncInfo->mbExternal = getFlag( rFuncData.mnFlags, FUNCFLAG_EXTERNAL );
     979       12120 :     bool bMacroCmd = getFlag( rFuncData.mnFlags, FUNCFLAG_MACROCMD );
     980       12120 :     xFuncInfo->mbMacroFunc = bMacroCmd || getFlag( rFuncData.mnFlags, FUNCFLAG_MACROFUNC );
     981       12120 :     xFuncInfo->mbVarParam = bMacroCmd || (rFuncData.mnMinParamCount != rFuncData.mnMaxParamCount) || getFlag( rFuncData.mnFlags, FUNCFLAG_ALWAYSVAR );
     982             : 
     983       12120 :     setFlag( xFuncInfo->mnBiff12FuncId, BIFF_TOK_FUNCVAR_CMD, bMacroCmd );
     984       12120 :     setFlag( xFuncInfo->mnBiffFuncId, BIFF_TOK_FUNCVAR_CMD, bMacroCmd );
     985             : 
     986             :     // insert the function info into the member maps
     987       12120 :     maFuncs.push_back( xFuncInfo );
     988       12120 :     if( !xFuncInfo->maOoxFuncName.isEmpty() )
     989       12066 :         maOoxFuncs[ xFuncInfo->maOoxFuncName ] = xFuncInfo;
     990       12120 :     if( xFuncInfo->mnBiff12FuncId != NOID )
     991       12120 :         maBiff12Funcs[ xFuncInfo->mnBiff12FuncId ] = xFuncInfo;
     992       12120 :     if( xFuncInfo->mnBiffFuncId != NOID )
     993       12120 :         maBiffFuncs[ xFuncInfo->mnBiffFuncId ] = xFuncInfo;
     994       12120 :     if( !xFuncInfo->maBiffMacroName.isEmpty() )
     995        1890 :         maMacroFuncs[ xFuncInfo->maBiffMacroName ] = xFuncInfo;
     996       12120 : }
     997             : 
     998         216 : void FunctionProviderImpl::initFuncs( const FunctionData* pBeg, const FunctionData* pEnd, sal_uInt8 nMaxParam,
     999             :         bool bImportFilter, FilterType eFilter )
    1000             : {
    1001       12636 :     for( const FunctionData* pIt = pBeg; pIt != pEnd; ++pIt )
    1002       12420 :         if( pIt->isSupported( bImportFilter, eFilter ) )
    1003       12120 :             initFunc( *pIt, nMaxParam );
    1004         216 : }
    1005             : 
    1006             : // ----------------------------------------------------------------------------
    1007             : 
    1008          27 : FunctionProvider::FunctionProvider( FilterType eFilter, BiffType eBiff, bool bImportFilter,
    1009             :         bool bCallerKnowsAboutMacroExport ) :
    1010          27 :     mxFuncImpl( new FunctionProviderImpl( eFilter, eBiff, bImportFilter, bCallerKnowsAboutMacroExport ) )
    1011             : {
    1012          27 : }
    1013             : 
    1014          69 : FunctionProvider::~FunctionProvider()
    1015             : {
    1016          69 : }
    1017             : 
    1018           2 : const FunctionInfo* FunctionProvider::getFuncInfoFromOoxFuncName( const OUString& rFuncName ) const
    1019             : {
    1020           2 :     return mxFuncImpl->maOoxFuncs.get( rFuncName ).get();
    1021             : }
    1022             : 
    1023           0 : const FunctionInfo* FunctionProvider::getFuncInfoFromBiff12FuncId( sal_uInt16 nFuncId ) const
    1024             : {
    1025           0 :     return mxFuncImpl->maBiff12Funcs.get( nFuncId ).get();
    1026             : }
    1027             : 
    1028           0 : const FunctionInfo* FunctionProvider::getFuncInfoFromBiffFuncId( sal_uInt16 nFuncId ) const
    1029             : {
    1030           0 :     return mxFuncImpl->maBiffFuncs.get( nFuncId ).get();
    1031             : }
    1032             : 
    1033           0 : const FunctionInfo* FunctionProvider::getFuncInfoFromMacroName( const OUString& rFuncName ) const
    1034             : {
    1035           0 :     return mxFuncImpl->maMacroFuncs.get( rFuncName ).get();
    1036             : }
    1037             : 
    1038           0 : FunctionLibraryType FunctionProvider::getFuncLibTypeFromLibraryName( const OUString& rLibraryName ) const
    1039             : {
    1040             : #define OOX_XLS_IS_LIBNAME( libname, basename ) (libname.equalsIgnoreAsciiCase( basename ".XLA" ) || libname.equalsIgnoreAsciiCase( basename ".XLAM" ))
    1041             : 
    1042             :     // the EUROTOOL add-in containing the EUROCONVERT function
    1043           0 :     if( OOX_XLS_IS_LIBNAME( rLibraryName, "EUROTOOL" ) )
    1044           0 :         return FUNCLIB_EUROTOOL;
    1045             : 
    1046             : #undef OOX_XLS_IS_LIBNAME
    1047             : 
    1048             :     // default: unknown library
    1049           0 :     return FUNCLIB_UNKNOWN;
    1050             : }
    1051             : 
    1052          27 : const FunctionInfoVector& FunctionProvider::getFuncs() const
    1053             : {
    1054          27 :     return mxFuncImpl->maFuncs;
    1055             : }
    1056             : 
    1057             : // op-code and function provider ==============================================
    1058             : 
    1059          27 : struct OpCodeProviderImpl : public ApiOpCodes
    1060             : {
    1061             :     typedef RefMap< sal_Int32, FunctionInfo >       OpCodeFuncMap;
    1062             :     typedef RefMap< OUString, FunctionInfo >        FuncNameMap;
    1063             :     typedef ::std::vector< FormulaOpCodeMapEntry >  OpCodeEntryVector;
    1064             : 
    1065             :     OpCodeFuncMap       maOpCodeFuncs;      /// Maps API function op-codes to function data.
    1066             :     FuncNameMap         maExtProgFuncs;     /// Maps programmatical API function names to function data.
    1067             :     OpCodeEntryVector   maParserMap;        /// OOXML token mapping for formula parser service.
    1068             : 
    1069             :     explicit            OpCodeProviderImpl(
    1070             :                             const FunctionInfoVector& rFuncInfos,
    1071             :                             const Reference< XMultiServiceFactory >& rxModelFactory );
    1072             : 
    1073             : private:
    1074             :     typedef ::std::map< OUString, ApiToken >    ApiTokenMap;
    1075             :     typedef Sequence< FormulaOpCodeMapEntry >   OpCodeEntrySequence;
    1076             : 
    1077             :     static bool         fillEntrySeq( OpCodeEntrySequence& orEntrySeq, const Reference< XFormulaOpCodeMapper >& rxMapper, sal_Int32 nMapGroup );
    1078             :     static bool         fillTokenMap( ApiTokenMap& orTokenMap, OpCodeEntrySequence& orEntrySeq, const Reference< XFormulaOpCodeMapper >& rxMapper, sal_Int32 nMapGroup );
    1079             :     bool                fillFuncTokenMaps( ApiTokenMap& orIntFuncTokenMap, ApiTokenMap& orExtFuncTokenMap, OpCodeEntrySequence& orEntrySeq, const Reference< XFormulaOpCodeMapper >& rxMapper ) const;
    1080             : 
    1081             :     static bool         initOpCode( sal_Int32& ornOpCode, const OpCodeEntrySequence& rEntrySeq, sal_Int32 nSpecialId );
    1082             :     bool                initOpCode( sal_Int32& ornOpCode, const ApiTokenMap& rTokenMap, const OUString& rOdfName, const OUString& rOoxName );
    1083             :     bool                initOpCode( sal_Int32& ornOpCode, const ApiTokenMap& rTokenMap, const sal_Char* pcOdfName, const sal_Char* pcOoxName );
    1084             :     bool                initOpCode( sal_Int32& ornOpCode, const ApiTokenMap& rTokenMap, sal_Unicode cOdfName, sal_Unicode cOoxName );
    1085             : 
    1086             :     bool                initFuncOpCode( FunctionInfo& orFuncInfo, const ApiTokenMap& rFuncTokenMap );
    1087             :     bool                initFuncOpCodes( const ApiTokenMap& rIntFuncTokenMap, const ApiTokenMap& rExtFuncTokenMap, const FunctionInfoVector& rFuncInfos );
    1088             : };
    1089             : 
    1090             : // ----------------------------------------------------------------------------
    1091             : 
    1092          27 : OpCodeProviderImpl::OpCodeProviderImpl( const FunctionInfoVector& rFuncInfos,
    1093          27 :         const Reference< XMultiServiceFactory >& rxModelFactory )
    1094             : {
    1095          27 :     if( rxModelFactory.is() ) try
    1096             :     {
    1097          27 :         Reference< XFormulaOpCodeMapper > xMapper( rxModelFactory->createInstance(
    1098          27 :             "com.sun.star.sheet.FormulaOpCodeMapper" ), UNO_QUERY_THROW );
    1099             : 
    1100             :         // op-codes provided as attributes
    1101          27 :         OPCODE_UNKNOWN = xMapper->getOpCodeUnknown();
    1102          27 :         OPCODE_EXTERNAL = xMapper->getOpCodeExternal();
    1103             : 
    1104             :         using namespace ::com::sun::star::sheet::FormulaMapGroup;
    1105             :         using namespace ::com::sun::star::sheet::FormulaMapGroupSpecialOffset;
    1106             : 
    1107          54 :         OpCodeEntrySequence aEntrySeq;
    1108          54 :         ApiTokenMap aTokenMap, aExtFuncTokenMap;
    1109             :         bool bIsValid =
    1110             :             // special
    1111          54 :             fillEntrySeq( aEntrySeq, xMapper, SPECIAL ) &&
    1112          54 :             initOpCode( OPCODE_PUSH,          aEntrySeq, PUSH ) &&
    1113          54 :             initOpCode( OPCODE_MISSING,       aEntrySeq, MISSING ) &&
    1114          54 :             initOpCode( OPCODE_SPACES,        aEntrySeq, SPACES ) &&
    1115          54 :             initOpCode( OPCODE_NAME,          aEntrySeq, NAME ) &&
    1116          54 :             initOpCode( OPCODE_DBAREA,        aEntrySeq, DB_AREA ) &&
    1117          54 :             initOpCode( OPCODE_NLR,           aEntrySeq, COL_ROW_NAME ) &&
    1118          54 :             initOpCode( OPCODE_MACRO,         aEntrySeq, MACRO ) &&
    1119          54 :             initOpCode( OPCODE_BAD,           aEntrySeq, BAD ) &&
    1120          54 :             initOpCode( OPCODE_NONAME,        aEntrySeq, NO_NAME ) &&
    1121             :             // separators
    1122          54 :             fillTokenMap( aTokenMap, aEntrySeq, xMapper, SEPARATORS ) &&
    1123          54 :             initOpCode( OPCODE_OPEN,          aTokenMap, API_TOKEN_OPEN,  '('  ) &&
    1124          54 :             initOpCode( OPCODE_CLOSE,         aTokenMap, API_TOKEN_CLOSE, ')'  ) &&
    1125          54 :             initOpCode( OPCODE_SEP,           aTokenMap, API_TOKEN_SEP,   ','  ) &&
    1126             :             // array separators
    1127          54 :             fillTokenMap( aTokenMap, aEntrySeq, xMapper, ARRAY_SEPARATORS ) &&
    1128          54 :             initOpCode( OPCODE_ARRAY_OPEN,    aTokenMap, API_TOKEN_ARRAY_OPEN,   '{'  ) &&
    1129          54 :             initOpCode( OPCODE_ARRAY_CLOSE,   aTokenMap, API_TOKEN_ARRAY_CLOSE,  '}'  ) &&
    1130          54 :             initOpCode( OPCODE_ARRAY_ROWSEP,  aTokenMap, API_TOKEN_ARRAY_ROWSEP, ';'  ) &&
    1131          54 :             initOpCode( OPCODE_ARRAY_COLSEP,  aTokenMap, API_TOKEN_ARRAY_COLSEP, ','  ) &&
    1132             :             // unary operators
    1133          54 :             fillTokenMap( aTokenMap, aEntrySeq, xMapper, UNARY_OPERATORS ) &&
    1134          54 :             initOpCode( OPCODE_PLUS_SIGN,     aTokenMap, '+',  '\0' ) && // same op-code as OPCODE_ADD
    1135          54 :             initOpCode( OPCODE_MINUS_SIGN,    aTokenMap, '-',  '-'  ) &&
    1136          54 :             initOpCode( OPCODE_PERCENT,       aTokenMap, '%',  '%'  ) &&
    1137             :             // binary operators
    1138          54 :             fillTokenMap( aTokenMap, aEntrySeq, xMapper, BINARY_OPERATORS ) &&
    1139          54 :             initOpCode( OPCODE_ADD,           aTokenMap, '+',  '+'  ) &&
    1140          54 :             initOpCode( OPCODE_SUB,           aTokenMap, '-',  '-'  ) &&
    1141          54 :             initOpCode( OPCODE_MULT,          aTokenMap, '*',  '*'  ) &&
    1142          54 :             initOpCode( OPCODE_DIV,           aTokenMap, '/',  '/'  ) &&
    1143          54 :             initOpCode( OPCODE_POWER,         aTokenMap, '^',  '^'  ) &&
    1144          54 :             initOpCode( OPCODE_CONCAT,        aTokenMap, '&',  '&'  ) &&
    1145          54 :             initOpCode( OPCODE_EQUAL,         aTokenMap, '=',  '='  ) &&
    1146          54 :             initOpCode( OPCODE_NOT_EQUAL,     aTokenMap, "<>", "<>" ) &&
    1147          54 :             initOpCode( OPCODE_LESS,          aTokenMap, '<',  '<'  ) &&
    1148          54 :             initOpCode( OPCODE_LESS_EQUAL,    aTokenMap, "<=", "<=" ) &&
    1149          54 :             initOpCode( OPCODE_GREATER,       aTokenMap, '>',  '>'  ) &&
    1150          54 :             initOpCode( OPCODE_GREATER_EQUAL, aTokenMap, ">=", ">=" ) &&
    1151          54 :             initOpCode( OPCODE_INTERSECT,     aTokenMap, '!',  ' '  ) &&
    1152          54 :             initOpCode( OPCODE_LIST,          aTokenMap, '~',  ','  ) &&
    1153          54 :             initOpCode( OPCODE_RANGE,         aTokenMap, ':',  ':'  ) &&
    1154             :             // functions
    1155          54 :             fillFuncTokenMaps( aTokenMap, aExtFuncTokenMap, aEntrySeq, xMapper ) &&
    1156          54 :             initFuncOpCodes( aTokenMap, aExtFuncTokenMap, rFuncInfos ) &&
    1157          27 :             initOpCode( OPCODE_DDE,           aTokenMap, "DDE", 0 );
    1158             : 
    1159             :         OSL_ENSURE( bIsValid, "OpCodeProviderImpl::OpCodeProviderImpl - opcodes not initialized" );
    1160             :         (void)bIsValid;
    1161             : 
    1162             :         // OPCODE_PLUS_SIGN and OPCODE_ADD should be equal, otherwise "+" has to be passed above
    1163          27 :         OSL_ENSURE( OPCODE_PLUS_SIGN == OPCODE_ADD, "OpCodeProviderImpl::OpCodeProviderImpl - need opcode mapping for OPCODE_PLUS_SIGN" );
    1164             :     }
    1165           0 :     catch( Exception& )
    1166             :     {
    1167             :         OSL_FAIL( "OpCodeProviderImpl::OpCodeProviderImpl - cannot receive formula opcode mapper" );
    1168             :     }
    1169          27 : }
    1170             : 
    1171         162 : bool OpCodeProviderImpl::fillEntrySeq( OpCodeEntrySequence& orEntrySeq,
    1172             :         const Reference< XFormulaOpCodeMapper >& rxMapper, sal_Int32 nMapGroup )
    1173             : {
    1174             :     try
    1175             :     {
    1176         162 :         orEntrySeq = rxMapper->getAvailableMappings( ::com::sun::star::sheet::FormulaLanguage::ODFF, nMapGroup );
    1177         162 :         return orEntrySeq.hasElements();
    1178             :     }
    1179           0 :     catch( Exception& )
    1180             :     {
    1181             :     }
    1182           0 :     return false;
    1183             : }
    1184             : 
    1185         108 : bool OpCodeProviderImpl::fillTokenMap( ApiTokenMap& orTokenMap, OpCodeEntrySequence& orEntrySeq,
    1186             :         const Reference< XFormulaOpCodeMapper >& rxMapper, sal_Int32 nMapGroup )
    1187             : {
    1188         108 :     orTokenMap.clear();
    1189         108 :     if( fillEntrySeq( orEntrySeq, rxMapper, nMapGroup ) )
    1190             :     {
    1191         108 :         const FormulaOpCodeMapEntry* pEntry = orEntrySeq.getConstArray();
    1192         108 :         const FormulaOpCodeMapEntry* pEntryEnd = pEntry + orEntrySeq.getLength();
    1193         783 :         for( ; pEntry != pEntryEnd; ++pEntry )
    1194         675 :             orTokenMap[ pEntry->Name ] = pEntry->Token;
    1195             :     }
    1196         108 :     return orEntrySeq.hasElements();
    1197             : }
    1198             : 
    1199          27 : bool OpCodeProviderImpl::fillFuncTokenMaps( ApiTokenMap& orIntFuncTokenMap, ApiTokenMap& orExtFuncTokenMap, OpCodeEntrySequence& orEntrySeq, const Reference< XFormulaOpCodeMapper >& rxMapper ) const
    1200             : {
    1201          27 :     orIntFuncTokenMap.clear();
    1202          27 :     orExtFuncTokenMap.clear();
    1203          27 :     if( fillEntrySeq( orEntrySeq, rxMapper, ::com::sun::star::sheet::FormulaMapGroup::FUNCTIONS ) )
    1204             :     {
    1205          27 :         const FormulaOpCodeMapEntry* pEntry = orEntrySeq.getConstArray();
    1206          27 :         const FormulaOpCodeMapEntry* pEntryEnd = pEntry + orEntrySeq.getLength();
    1207       11151 :         for( ; pEntry != pEntryEnd; ++pEntry )
    1208       11124 :             ((pEntry->Token.OpCode == OPCODE_EXTERNAL) ? orExtFuncTokenMap : orIntFuncTokenMap)[ pEntry->Name ] = pEntry->Token;
    1209             :     }
    1210          27 :     return orEntrySeq.hasElements();
    1211             : }
    1212             : 
    1213         243 : bool OpCodeProviderImpl::initOpCode( sal_Int32& ornOpCode, const OpCodeEntrySequence& rEntrySeq, sal_Int32 nSpecialId )
    1214             : {
    1215         243 :     if( (0 <= nSpecialId) && (nSpecialId < rEntrySeq.getLength()) )
    1216             :     {
    1217         243 :         ornOpCode = rEntrySeq[ nSpecialId ].Token.OpCode;
    1218         243 :         return true;
    1219             :     }
    1220             :     OSL_FAIL( OStringBuffer( "OpCodeProviderImpl::initOpCode - opcode for special offset " ).
    1221             :         append( nSpecialId ).append( " not found" ).getStr() );
    1222           0 :     return false;
    1223             : }
    1224             : 
    1225         675 : bool OpCodeProviderImpl::initOpCode( sal_Int32& ornOpCode, const ApiTokenMap& rTokenMap, const OUString& rOdfName, const OUString& rOoxName )
    1226             : {
    1227         675 :     ApiTokenMap::const_iterator aIt = rTokenMap.find( rOdfName );
    1228         675 :     if( aIt != rTokenMap.end() )
    1229             :     {
    1230         675 :         ornOpCode = aIt->second.OpCode;
    1231         675 :         if( !rOoxName.isEmpty() )
    1232             :         {
    1233         648 :             FormulaOpCodeMapEntry aEntry;
    1234         648 :             aEntry.Name = rOoxName;
    1235         648 :             aEntry.Token.OpCode = ornOpCode;
    1236         648 :             maParserMap.push_back( aEntry );
    1237             :         }
    1238         675 :         return true;
    1239             :     }
    1240             :     OSL_FAIL( OStringBuffer( "OpCodeProviderImpl::initOpCode - opcode for \"" ).
    1241             :         append( OUStringToOString( rOdfName, RTL_TEXTENCODING_ASCII_US ) ).
    1242             :         append( "\" not found" ).getStr() );
    1243           0 :     return false;
    1244             : }
    1245             : 
    1246          81 : bool OpCodeProviderImpl::initOpCode( sal_Int32& ornOpCode, const ApiTokenMap& rTokenMap, const sal_Char* pcOdfName, const sal_Char* pcOoxName )
    1247             : {
    1248          81 :     OUString aOoxName;
    1249          81 :     if( pcOoxName ) aOoxName = OUString::createFromAscii( pcOoxName );
    1250          81 :     return initOpCode( ornOpCode, rTokenMap, OUString::createFromAscii( pcOdfName ), aOoxName );
    1251             : }
    1252             : 
    1253         594 : bool OpCodeProviderImpl::initOpCode( sal_Int32& ornOpCode, const ApiTokenMap& rTokenMap, sal_Unicode cOdfName, sal_Unicode cOoxName )
    1254             : {
    1255         594 :     OUString aOoxName;
    1256         594 :     if( cOoxName ) aOoxName = OUString( cOoxName );
    1257         594 :     return initOpCode( ornOpCode, rTokenMap, OUString( cOdfName ), aOoxName );
    1258             : }
    1259             : 
    1260       12120 : bool OpCodeProviderImpl::initFuncOpCode( FunctionInfo& orFuncInfo, const ApiTokenMap& rFuncTokenMap )
    1261             : {
    1262       12120 :     bool bIsValid = false;
    1263       12120 :     if( !orFuncInfo.maOdfFuncName.isEmpty() )
    1264             :     {
    1265       10680 :         ApiTokenMap::const_iterator aIt = rFuncTokenMap.find( orFuncInfo.maOdfFuncName );
    1266       10680 :         if( aIt != rFuncTokenMap.end() )
    1267             :         {
    1268       10572 :             orFuncInfo.mnApiOpCode = aIt->second.OpCode;
    1269             :             bIsValid =
    1270       21144 :                 (orFuncInfo.mnApiOpCode >= 0) &&
    1271       21144 :                 (orFuncInfo.mnApiOpCode != OPCODE_UNKNOWN) &&
    1272       21144 :                 (orFuncInfo.mnApiOpCode != OPCODE_NONAME);
    1273             :             OSL_ENSURE( bIsValid,
    1274             :                 OStringBuffer( "OpCodeProviderImpl::initFuncOpCode - no valid opcode for ODF function \"" ).
    1275             :                 append( OUStringToOString( orFuncInfo.maOdfFuncName, RTL_TEXTENCODING_ASCII_US ) ).
    1276             :                 append( '"' ).getStr() );
    1277             : 
    1278       10572 :             if( bIsValid && (orFuncInfo.mnApiOpCode == OPCODE_EXTERNAL) )
    1279             :             {
    1280        2727 :                 bIsValid = (aIt->second.Data >>= orFuncInfo.maExtProgName) && !orFuncInfo.maExtProgName.isEmpty();
    1281             :                 OSL_ENSURE( bIsValid,
    1282             :                     OStringBuffer( "OpCodeProviderImpl::initFuncOpCode - no programmatical name for external function \"" ).
    1283             :                     append( OUStringToOString( orFuncInfo.maOdfFuncName, RTL_TEXTENCODING_ASCII_US ) ).
    1284             :                     append( '"' ).getStr() );
    1285             :             }
    1286             : 
    1287             :             // add to parser map, if OOXML function name exists
    1288       10572 :             if( bIsValid && !orFuncInfo.maOoxFuncName.isEmpty() )
    1289             :             {
    1290             :                 // create the parser map entry
    1291       10518 :                 FormulaOpCodeMapEntry aEntry;
    1292       10518 :                 aEntry.Name = orFuncInfo.maOoxFuncName;
    1293       10518 :                 aEntry.Token = aIt->second;
    1294       10518 :                 maParserMap.push_back( aEntry );
    1295             :             }
    1296             :         }
    1297             :         else
    1298             :         {
    1299             :             // ignore entries for functions unknown by Calc *and* by Excel
    1300         108 :             bIsValid = orFuncInfo.maOoxFuncName.isEmpty();
    1301             :             SAL_WARN_IF( !bIsValid, "sc",
    1302             :                     "OpCodeProviderImpl::initFuncOpCode - no opcode mapping for function ODF '" <<
    1303             :                     orFuncInfo.maOdfFuncName << "' <-> OOXML '" << orFuncInfo.maOoxFuncName << "'");
    1304             :         }
    1305             :     }
    1306        1440 :     else if( orFuncInfo.mnBiffFuncId == BIFF_FUNC_EXTERNCALL )
    1307             :     {
    1308          27 :         orFuncInfo.mnApiOpCode = OPCODE_EXTERNAL;
    1309          27 :         bIsValid = true;
    1310             :     }
    1311        1413 :     else if( !orFuncInfo.maOoxFuncName.isEmpty() )
    1312             :     {
    1313        1413 :         orFuncInfo.mnApiOpCode = OPCODE_BAD;
    1314        1413 :         bIsValid = true;
    1315             :     }
    1316             : 
    1317       12120 :     if( !bIsValid || (orFuncInfo.mnApiOpCode == OPCODE_UNKNOWN) || (orFuncInfo.mnApiOpCode < 0) )
    1318         108 :         orFuncInfo.mnApiOpCode = OPCODE_NONAME;
    1319       12120 :     return bIsValid;
    1320             : }
    1321             : 
    1322          27 : bool OpCodeProviderImpl::initFuncOpCodes( const ApiTokenMap& rIntFuncTokenMap, const ApiTokenMap& rExtFuncTokenMap, const FunctionInfoVector& rFuncInfos )
    1323             : {
    1324          27 :     bool bIsValid = true;
    1325       12147 :     for( FunctionInfoVector::const_iterator aIt = rFuncInfos.begin(), aEnd = rFuncInfos.end(); aIt != aEnd; ++aIt )
    1326             :     {
    1327       12120 :         FunctionInfoRef xFuncInfo = *aIt;
    1328             :         // set API opcode from ODF function name
    1329       12120 :         bIsValid &= initFuncOpCode( *xFuncInfo, xFuncInfo->mbExternal ? rExtFuncTokenMap : rIntFuncTokenMap );
    1330             :         // insert the function info into the maps
    1331       12120 :         if( (xFuncInfo->mnApiOpCode != OPCODE_NONAME) && (xFuncInfo->mnApiOpCode != OPCODE_BAD) )
    1332             :         {
    1333       10599 :             if( (xFuncInfo->mnApiOpCode == OPCODE_EXTERNAL) && !xFuncInfo->maExtProgName.isEmpty() )
    1334        2727 :                 maExtProgFuncs[ xFuncInfo->maExtProgName ] = xFuncInfo;
    1335             :             else
    1336        7872 :                 maOpCodeFuncs[ xFuncInfo->mnApiOpCode ] = xFuncInfo;
    1337             :         }
    1338       12120 :     }
    1339          27 :     return bIsValid;
    1340             : }
    1341             : 
    1342             : // ----------------------------------------------------------------------------
    1343             : 
    1344          27 : OpCodeProvider::OpCodeProvider( const Reference< XMultiServiceFactory >& rxModelFactory,
    1345             :         FilterType eFilter, BiffType eBiff, bool bImportFilter, bool bCallerKnowsAboutMacroExport ) :
    1346             :     FunctionProvider( eFilter, eBiff, bImportFilter, bCallerKnowsAboutMacroExport ),
    1347          27 :     mxOpCodeImpl( new OpCodeProviderImpl( getFuncs(), rxModelFactory ) )
    1348             : {
    1349          27 : }
    1350             : 
    1351          69 : OpCodeProvider::~OpCodeProvider()
    1352             : {
    1353          69 : }
    1354             : 
    1355          42 : const ApiOpCodes& OpCodeProvider::getOpCodes() const
    1356             : {
    1357          42 :     return *mxOpCodeImpl;
    1358             : }
    1359             : 
    1360          75 : const FunctionInfo* OpCodeProvider::getFuncInfoFromApiToken( const ApiToken& rToken ) const
    1361             : {
    1362          75 :     const FunctionInfo* pFuncInfo = 0;
    1363          75 :     if( (rToken.OpCode == mxOpCodeImpl->OPCODE_EXTERNAL) && rToken.Data.has< OUString >() )
    1364           0 :         pFuncInfo = mxOpCodeImpl->maExtProgFuncs.get( rToken.Data.get< OUString >() ).get();
    1365          75 :     else if( (rToken.OpCode == mxOpCodeImpl->OPCODE_MACRO) && rToken.Data.has< OUString >() )
    1366           0 :         pFuncInfo = getFuncInfoFromMacroName( rToken.Data.get< OUString >() );
    1367          75 :     else if( (rToken.OpCode == mxOpCodeImpl->OPCODE_BAD) && rToken.Data.has< OUString >() )
    1368           2 :         pFuncInfo = getFuncInfoFromOoxFuncName( rToken.Data.get< OUString >() );
    1369             :     else
    1370          73 :         pFuncInfo = mxOpCodeImpl->maOpCodeFuncs.get( rToken.OpCode ).get();
    1371          75 :     return pFuncInfo;
    1372             : }
    1373             : 
    1374          27 : Sequence< FormulaOpCodeMapEntry > OpCodeProvider::getOoxParserMap() const
    1375             : {
    1376          27 :     return ContainerHelper::vectorToSequence( mxOpCodeImpl->maParserMap );
    1377             : }
    1378             : 
    1379             : // API formula parser wrapper =================================================
    1380             : 
    1381          21 : ApiParserWrapper::ApiParserWrapper(
    1382             :         const Reference< XMultiServiceFactory >& rxModelFactory, const OpCodeProvider& rOpCodeProv ) :
    1383          21 :     OpCodeProvider( rOpCodeProv )
    1384             : {
    1385          21 :     if( rxModelFactory.is() ) try
    1386             :     {
    1387          21 :         mxParser.set( rxModelFactory->createInstance( "com.sun.star.sheet.FormulaParser" ), UNO_QUERY_THROW );
    1388             :     }
    1389           0 :     catch( Exception& )
    1390             :     {
    1391             :     }
    1392             :     OSL_ENSURE( mxParser.is(), "ApiParserWrapper::ApiParserWrapper - cannot create API formula parser object" );
    1393          21 :     maParserProps.set( mxParser );
    1394          21 :     maParserProps.setProperty( PROP_CompileEnglish, true );
    1395          21 :     maParserProps.setProperty( PROP_FormulaConvention, ::com::sun::star::sheet::AddressConvention::XL_OOX );
    1396          21 :     maParserProps.setProperty( PROP_IgnoreLeadingSpaces, false );
    1397          21 :     maParserProps.setProperty( PROP_OpCodeMap, getOoxParserMap() );
    1398          21 : }
    1399             : 
    1400          47 : ApiTokenSequence ApiParserWrapper::parseFormula( const OUString& rFormula, const CellAddress& rRefPos )
    1401             : {
    1402          47 :     ApiTokenSequence aTokenSeq;
    1403          47 :     if( mxParser.is() ) try
    1404             :     {
    1405          47 :         aTokenSeq = mxParser->parseFormula( rFormula, rRefPos );
    1406             :     }
    1407           0 :     catch( Exception& )
    1408             :     {
    1409             :     }
    1410          47 :     return aTokenSeq;
    1411             : }
    1412             : 
    1413             : // formula parser/printer base class for filters ==============================
    1414             : 
    1415             : namespace {
    1416             : 
    1417           0 : bool lclConvertToCellAddress( CellAddress& orAddress, const SingleReference& rSingleRef, sal_Int32 nForbiddenFlags, sal_Int32 nFilterBySheet )
    1418             : {
    1419             :     orAddress = CellAddress( static_cast< sal_Int16 >( rSingleRef.Sheet ),
    1420           0 :         rSingleRef.Column, rSingleRef.Row );
    1421             :     return
    1422           0 :         !getFlag( rSingleRef.Flags, nForbiddenFlags ) &&
    1423           0 :         ((nFilterBySheet < 0) || (nFilterBySheet == rSingleRef.Sheet));
    1424             : }
    1425             : 
    1426           1 : bool lclConvertToCellRange( CellRangeAddress& orRange, const ComplexReference& rComplexRef, sal_Int32 nForbiddenFlags, sal_Int32 nFilterBySheet )
    1427             : {
    1428             :     orRange = CellRangeAddress( static_cast< sal_Int16 >( rComplexRef.Reference1.Sheet ),
    1429             :         rComplexRef.Reference1.Column, rComplexRef.Reference1.Row,
    1430           1 :         rComplexRef.Reference2.Column, rComplexRef.Reference2.Row );
    1431             :     return
    1432           2 :         !getFlag( rComplexRef.Reference1.Flags, nForbiddenFlags ) &&
    1433           2 :         !getFlag( rComplexRef.Reference2.Flags, nForbiddenFlags ) &&
    1434           4 :         (rComplexRef.Reference1.Sheet == rComplexRef.Reference2.Sheet) &&
    1435           1 :         ((nFilterBySheet < 0) || (nFilterBySheet == rComplexRef.Reference1.Sheet));
    1436             : }
    1437             : 
    1438             : enum TokenToRangeListState { STATE_REF, STATE_SEP, STATE_OPEN, STATE_CLOSE, STATE_ERROR };
    1439             : 
    1440           1 : TokenToRangeListState lclProcessRef( ApiCellRangeList& orRanges, const Any& rData, bool bAllowRelative, sal_Int32 nFilterBySheet )
    1441             : {
    1442             :     using namespace ::com::sun::star::sheet::ReferenceFlags;
    1443           1 :     const sal_Int32 FORBIDDEN_FLAGS_DEL = COLUMN_DELETED | ROW_DELETED | SHEET_DELETED;
    1444           1 :     const sal_Int32 FORBIDDEN_FLAGS_REL = FORBIDDEN_FLAGS_DEL | COLUMN_RELATIVE | ROW_RELATIVE | SHEET_RELATIVE | RELATIVE_NAME;
    1445             : 
    1446           1 :     sal_Int32 nForbiddenFlags = bAllowRelative ? FORBIDDEN_FLAGS_DEL : FORBIDDEN_FLAGS_REL;
    1447           1 :     SingleReference aSingleRef;
    1448           1 :     if( rData >>= aSingleRef )
    1449             :     {
    1450           0 :         CellAddress aAddress;
    1451             :         // ignore invalid addresses (with #REF! errors), but do not stop parsing
    1452           0 :         if( lclConvertToCellAddress( aAddress, aSingleRef, nForbiddenFlags, nFilterBySheet ) )
    1453           0 :             orRanges.push_back( CellRangeAddress( aAddress.Sheet, aAddress.Column, aAddress.Row, aAddress.Column, aAddress.Row ) );
    1454           0 :         return STATE_REF;
    1455             :     }
    1456           1 :     ComplexReference aComplexRef;
    1457           1 :     if( rData >>= aComplexRef )
    1458             :     {
    1459           1 :         CellRangeAddress aRange;
    1460             :         // ignore invalid ranges (with #REF! errors), but do not stop parsing
    1461           1 :         if( lclConvertToCellRange( aRange, aComplexRef, nForbiddenFlags, nFilterBySheet ) )
    1462           1 :             orRanges.push_back( aRange );
    1463           1 :         return STATE_REF;
    1464             :     }
    1465           0 :     return STATE_ERROR;
    1466             : }
    1467             : 
    1468           0 : TokenToRangeListState lclProcessOpen( sal_Int32& ornParenLevel )
    1469             : {
    1470           0 :     ++ornParenLevel;
    1471           0 :     return STATE_OPEN;
    1472             : }
    1473             : 
    1474           0 : TokenToRangeListState lclProcessClose( sal_Int32& ornParenLevel )
    1475             : {
    1476           0 :     --ornParenLevel;
    1477           0 :     return (ornParenLevel >= 0) ? STATE_CLOSE : STATE_ERROR;
    1478             : }
    1479             : 
    1480             : } // namespace
    1481             : 
    1482             : // ----------------------------------------------------------------------------
    1483             : 
    1484          21 : FormulaProcessorBase::FormulaProcessorBase( const WorkbookHelper& rHelper ) :
    1485          42 :     OpCodeProvider( rHelper.getBaseFilter().getModelFactory(), rHelper.getFilterType(), rHelper.getBiff(), rHelper.getBaseFilter().isImportFilter() ),
    1486          21 :     ApiOpCodes( getOpCodes() ),
    1487          63 :     WorkbookHelper( rHelper )
    1488             : {
    1489          21 : }
    1490             : 
    1491             : // ----------------------------------------------------------------------------
    1492             : 
    1493           0 : OUString FormulaProcessorBase::generateAddress2dString( const CellAddress& rAddress, bool bAbsolute )
    1494             : {
    1495           0 :     return generateAddress2dString( BinAddress( rAddress ), bAbsolute );
    1496             : }
    1497             : 
    1498           0 : OUString FormulaProcessorBase::generateAddress2dString( const BinAddress& rAddress, bool bAbsolute )
    1499             : {
    1500           0 :     OUStringBuffer aBuffer;
    1501             :     // column
    1502           0 :     for( sal_Int32 nTemp = rAddress.mnCol; nTemp >= 0; (nTemp /= 26) -= 1 )
    1503           0 :         aBuffer.insert( 0, sal_Unicode( 'A' + (nTemp % 26) ) );
    1504           0 :     if( bAbsolute )
    1505           0 :         aBuffer.insert( 0, sal_Unicode( '$' ) );
    1506             :     // row
    1507           0 :     if( bAbsolute )
    1508           0 :         aBuffer.append( sal_Unicode( '$' ) );
    1509           0 :     aBuffer.append( static_cast< sal_Int32 >( rAddress.mnRow + 1 ) );
    1510           0 :     return aBuffer.makeStringAndClear();
    1511             : }
    1512             : 
    1513             : // ----------------------------------------------------------------------------
    1514             : 
    1515           0 : OUString FormulaProcessorBase::generateApiString( const OUString& rString )
    1516             : {
    1517           0 :     OUString aRetString = rString;
    1518           0 :     sal_Int32 nQuotePos = aRetString.getLength();
    1519           0 :     while( (nQuotePos = aRetString.lastIndexOf( '"', nQuotePos )) >= 0 )
    1520           0 :         aRetString = aRetString.replaceAt( nQuotePos, 1, OUString( "\"\"" ) );
    1521           0 :     return OUStringBuffer().append( sal_Unicode( '"' ) ).append( aRetString ).append( sal_Unicode( '"' ) ).makeStringAndClear();
    1522             : }
    1523             : 
    1524           0 : OUString FormulaProcessorBase::generateApiArray( const Matrix< Any >& rMatrix )
    1525             : {
    1526             :     OSL_ENSURE( !rMatrix.empty(), "FormulaProcessorBase::generateApiArray - missing matrix values" );
    1527           0 :     OUStringBuffer aBuffer;
    1528           0 :     aBuffer.append( API_TOKEN_ARRAY_OPEN );
    1529           0 :     for( size_t nRow = 0, nHeight = rMatrix.height(); nRow < nHeight; ++nRow )
    1530             :     {
    1531           0 :         if( nRow > 0 )
    1532           0 :             aBuffer.append( API_TOKEN_ARRAY_ROWSEP );
    1533           0 :         for( Matrix< Any >::const_iterator aBeg = rMatrix.row_begin( nRow ), aIt = aBeg, aEnd = rMatrix.row_end( nRow ); aIt != aEnd; ++aIt )
    1534             :         {
    1535           0 :             double fValue = 0.0;
    1536           0 :             OUString aString;
    1537           0 :             if( aIt != aBeg )
    1538           0 :                 aBuffer.append( API_TOKEN_ARRAY_COLSEP );
    1539           0 :             if( *aIt >>= fValue )
    1540           0 :                 aBuffer.append( fValue );
    1541           0 :             else if( *aIt >>= aString )
    1542           0 :                 aBuffer.append( generateApiString( aString ) );
    1543             :             else
    1544           0 :                 aBuffer.appendAscii( "\"\"" );
    1545           0 :         }
    1546             :     }
    1547           0 :     aBuffer.append( API_TOKEN_ARRAY_CLOSE );
    1548           0 :     return aBuffer.makeStringAndClear();
    1549             : }
    1550             : 
    1551             : // ----------------------------------------------------------------------------
    1552             : 
    1553           1 : Any FormulaProcessorBase::extractReference( const ApiTokenSequence& rTokens ) const
    1554             : {
    1555           1 :     ApiTokenIterator aTokenIt( rTokens, OPCODE_SPACES, true );
    1556           1 :     if( aTokenIt.is() && (aTokenIt->OpCode == OPCODE_PUSH) )
    1557             :     {
    1558           1 :         Any aRefAny = aTokenIt->Data;
    1559           1 :         if( !(++aTokenIt).is() && (aRefAny.has< SingleReference >() || aRefAny.has< ComplexReference >()) )
    1560           1 :             return aRefAny;
    1561             :     }
    1562           0 :     return Any();
    1563             : }
    1564             : 
    1565           1 : bool FormulaProcessorBase::extractCellRange( CellRangeAddress& orRange,
    1566             :         const ApiTokenSequence& rTokens, bool bAllowRelative ) const
    1567             : {
    1568           1 :     ApiCellRangeList aRanges;
    1569           1 :     lclProcessRef( aRanges, extractReference( rTokens ), bAllowRelative, -1 );
    1570           1 :     if( !aRanges.empty() )
    1571             :     {
    1572           1 :         orRange = aRanges.front();
    1573           1 :         return true;
    1574             :     }
    1575           0 :     return false;
    1576             : }
    1577             : 
    1578           0 : void FormulaProcessorBase::extractCellRangeList( ApiCellRangeList& orRanges,
    1579             :         const ApiTokenSequence& rTokens, bool bAllowRelative, sal_Int32 nFilterBySheet ) const
    1580             : {
    1581           0 :     orRanges.clear();
    1582           0 :     TokenToRangeListState eState = STATE_OPEN;
    1583           0 :     sal_Int32 nParenLevel = 0;
    1584           0 :     for( ApiTokenIterator aIt( rTokens, OPCODE_SPACES, true ); aIt.is() && (eState != STATE_ERROR); ++aIt )
    1585             :     {
    1586           0 :         sal_Int32 nOpCode = aIt->OpCode;
    1587           0 :         switch( eState )
    1588             :         {
    1589             :             // #i107275# accept OPCODE_SEP and OPCODE_LIST as separator token
    1590             :             case STATE_REF:
    1591           0 :                      if( nOpCode == OPCODE_SEP )   eState = STATE_SEP;
    1592           0 :                 else if( nOpCode == OPCODE_LIST )  eState = STATE_SEP;
    1593           0 :                 else if( nOpCode == OPCODE_CLOSE ) eState = lclProcessClose( nParenLevel );
    1594           0 :                 else                               eState = STATE_ERROR;
    1595           0 :             break;
    1596             :             case STATE_SEP:
    1597           0 :                      if( nOpCode == OPCODE_PUSH )  eState = lclProcessRef( orRanges, aIt->Data, bAllowRelative, nFilterBySheet );
    1598           0 :                 else if( nOpCode == OPCODE_SEP )   eState = STATE_SEP;
    1599           0 :                 else if( nOpCode == OPCODE_LIST )  eState = STATE_SEP;
    1600           0 :                 else if( nOpCode == OPCODE_OPEN )  eState = lclProcessOpen( nParenLevel );
    1601           0 :                 else if( nOpCode == OPCODE_CLOSE ) eState = lclProcessClose( nParenLevel );
    1602           0 :                 else                               eState = STATE_ERROR;
    1603           0 :             break;
    1604             :             case STATE_OPEN:
    1605           0 :                      if( nOpCode == OPCODE_PUSH )  eState = lclProcessRef( orRanges, aIt->Data, bAllowRelative, nFilterBySheet );
    1606           0 :                 else if( nOpCode == OPCODE_SEP )   eState = STATE_SEP;
    1607           0 :                 else if( nOpCode == OPCODE_LIST )  eState = STATE_SEP;
    1608           0 :                 else if( nOpCode == OPCODE_OPEN )  eState = lclProcessOpen( nParenLevel );
    1609           0 :                 else if( nOpCode == OPCODE_CLOSE ) eState = lclProcessClose( nParenLevel );
    1610           0 :                 else                               eState = STATE_ERROR;
    1611           0 :             break;
    1612             :             case STATE_CLOSE:
    1613           0 :                      if( nOpCode == OPCODE_SEP )   eState = STATE_SEP;
    1614           0 :                 else if( nOpCode == OPCODE_LIST )  eState = STATE_SEP;
    1615           0 :                 else if( nOpCode == OPCODE_CLOSE ) eState = lclProcessClose( nParenLevel );
    1616           0 :                 else                               eState = STATE_ERROR;
    1617           0 :             break;
    1618             :             default:;
    1619             :         }
    1620             :     }
    1621             : 
    1622           0 :     if( eState == STATE_ERROR )
    1623           0 :         orRanges.clear();
    1624             :     else
    1625           0 :         getAddressConverter().validateCellRangeList( orRanges, false );
    1626           0 : }
    1627             : 
    1628           0 : bool FormulaProcessorBase::extractString( OUString& orString, const ApiTokenSequence& rTokens ) const
    1629             : {
    1630           0 :     ApiTokenIterator aTokenIt( rTokens, OPCODE_SPACES, true );
    1631           0 :     return aTokenIt.is() && (aTokenIt->OpCode == OPCODE_PUSH) && (aTokenIt->Data >>= orString) && !(++aTokenIt).is();
    1632             : }
    1633             : 
    1634           0 : bool FormulaProcessorBase::extractSpecialTokenInfo( ApiSpecialTokenInfo& orTokenInfo, const ApiTokenSequence& rTokens ) const
    1635             : {
    1636           0 :     ApiTokenIterator aTokenIt( rTokens, OPCODE_SPACES, true );
    1637           0 :     return aTokenIt.is() && (aTokenIt->OpCode == OPCODE_BAD) && (aTokenIt->Data >>= orTokenInfo);
    1638             : }
    1639             : 
    1640           0 : void FormulaProcessorBase::convertStringToStringList(
    1641             :         ApiTokenSequence& orTokens, sal_Unicode cStringSep, bool bTrimLeadingSpaces ) const
    1642             : {
    1643           0 :     OUString aString;
    1644           0 :     if( extractString( aString, orTokens ) && !aString.isEmpty() )
    1645             :     {
    1646           0 :         ::std::vector< ApiToken > aNewTokens;
    1647           0 :         sal_Int32 nPos = 0;
    1648           0 :         sal_Int32 nLen = aString.getLength();
    1649           0 :         while( (0 <= nPos) && (nPos < nLen) )
    1650             :         {
    1651           0 :             OUString aEntry = aString.getToken( 0, cStringSep, nPos );
    1652           0 :             if( bTrimLeadingSpaces )
    1653             :             {
    1654           0 :                 sal_Int32 nStart = 0;
    1655           0 :                 while( (nStart < aEntry.getLength()) && (aEntry[ nStart ] == ' ') ) ++nStart;
    1656           0 :                 aEntry = aEntry.copy( nStart );
    1657             :             }
    1658           0 :             if( !aNewTokens.empty() )
    1659           0 :                 aNewTokens.push_back( ApiToken( OPCODE_SEP, Any() ) );
    1660           0 :             aNewTokens.push_back( ApiToken( OPCODE_PUSH, Any( aEntry ) ) );
    1661           0 :         }
    1662           0 :         orTokens = ContainerHelper::vectorToSequence( aNewTokens );
    1663           0 :     }
    1664           0 : }
    1665             : 
    1666             : // ============================================================================
    1667             : 
    1668             : } // namespace xls
    1669          15 : } // namespace oox
    1670             : 
    1671             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10