xref: /trunk/main/sc/source/filter/excel/xlformula.cxx (revision 195598447694ec8542914a9b51ae9942e8ebacd9) !
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_scfilt.hxx"
26 #include "xlformula.hxx"
27 
28 #include "compiler.hxx"
29 #include "rangenam.hxx"
30 #include "token.hxx"
31 #include "tokenarray.hxx"
32 #include "xestream.hxx"
33 #include "xistream.hxx"
34 #include "xlroot.hxx"
35 
36 using namespace ::formula;
37 
38 // Function data ==============================================================
39 
GetMacroFuncName() const40 String XclFunctionInfo::GetMacroFuncName() const
41 {
42     if( IsMacroFunc() )
43         return String( mpcMacroName, RTL_TEXTENCODING_UTF8 );
44     return EMPTY_STRING;
45 }
46 
47 // abbreviations for function return token class
48 const sal_uInt8 R = EXC_TOKCLASS_REF;
49 const sal_uInt8 V = EXC_TOKCLASS_VAL;
50 const sal_uInt8 A = EXC_TOKCLASS_ARR;
51 
52 // abbreviations for parameter infos
53 #define RO   { EXC_PARAM_REGULAR,   EXC_PARAMCONV_ORG, false }
54 #define RV   { EXC_PARAM_REGULAR,   EXC_PARAMCONV_VAL, false }
55 #define RA   { EXC_PARAM_REGULAR,   EXC_PARAMCONV_ARR, false }
56 #define RR   { EXC_PARAM_REGULAR,   EXC_PARAMCONV_RPT, false }
57 #define RX   { EXC_PARAM_REGULAR,   EXC_PARAMCONV_RPX, false }
58 #define VO   { EXC_PARAM_REGULAR,   EXC_PARAMCONV_ORG, true  }
59 #define VV   { EXC_PARAM_REGULAR,   EXC_PARAMCONV_VAL, true  }
60 #define VA   { EXC_PARAM_REGULAR,   EXC_PARAMCONV_ARR, true  }
61 #define VR   { EXC_PARAM_REGULAR,   EXC_PARAMCONV_RPT, true  }
62 #define VX   { EXC_PARAM_REGULAR,   EXC_PARAMCONV_RPX, true  }
63 #define RO_E { EXC_PARAM_EXCELONLY, EXC_PARAMCONV_ORG, false }
64 #define VR_E { EXC_PARAM_EXCELONLY, EXC_PARAMCONV_RPT, true  }
65 #define C    { EXC_PARAM_CALCONLY,  EXC_PARAMCONV_ORG, false }
66 
67 const sal_uInt16 NOID = SAL_MAX_UINT16;     /// No BIFF/OOBIN function identifier available.
68 const sal_uInt8 MX    = 30;                 /// Maximum parameter count.
69 
70 #define EXC_FUNCNAME( ascii )       "_xlfn." ascii
71 #define EXC_FUNCNAME_ODF( ascii )   "_xlfnodf." ascii
72 
73 /** Functions new in BIFF2. */
74 static const XclFunctionInfo saFuncTable_2[] =
75 {
76     { ocCount,              0,      0,  MX, V, { RX }, 0, 0 },
77     { ocIf,                 1,      2,  3,  R, { VO, RO }, 0, 0 },
78     { ocIsNA,               2,      1,  1,  V, { VR }, 0, 0 },
79     { ocIsError,            3,      1,  1,  V, { VR }, 0, 0 },
80     { ocSum,                4,      0,  MX, V, { RX }, 0, 0 },
81     { ocAverage,            5,      1,  MX, V, { RX }, 0, 0 },
82     { ocMin,                6,      1,  MX, V, { RX }, 0, 0 },
83     { ocMax,                7,      1,  MX, V, { RX }, 0, 0 },
84     { ocRow,                8,      0,  1,  V, { RO }, 0, 0 },
85     { ocColumn,             9,      0,  1,  V, { RO }, 0, 0 },
86     { ocNotAvail,           10,     0,  0,  V, {}, 0, 0 },
87     { ocNPV,                11,     2,  MX, V, { VR, RX }, 0, 0 },
88     { ocStDev,              12,     1,  MX, V, { RX }, 0, 0 },
89     { ocCurrency,           13,     1,  2,  V, { VR }, 0, 0 },
90     { ocFixed,              14,     1,  2,  V, { VR, VR, C }, 0, 0 },
91     { ocSin,                15,     1,  1,  V, { VR }, 0, 0 },
92     { ocCosecant,           15,     1,  1,  V, { VR }, EXC_FUNCFLAG_EXPORTONLY, 0 },
93     { ocCos,                16,     1,  1,  V, { VR }, 0, 0 },
94     { ocSecant,             16,     1,  1,  V, { VR }, EXC_FUNCFLAG_EXPORTONLY, 0 },
95     { ocTan,                17,     1,  1,  V, { VR }, 0, 0 },
96     { ocCot,                17,     1,  1,  V, { VR }, EXC_FUNCFLAG_EXPORTONLY, 0 },
97     { ocArcTan,             18,     1,  1,  V, { VR }, 0, 0 },
98     { ocArcCot,             18,     1,  1,  V, { VR }, EXC_FUNCFLAG_EXPORTONLY, 0 },
99     { ocPi,                 19,     0,  0,  V, {}, 0, 0 },
100     { ocSqrt,               20,     1,  1,  V, { VR }, 0, 0 },
101     { ocExp,                21,     1,  1,  V, { VR }, 0, 0 },
102     { ocLn,                 22,     1,  1,  V, { VR }, 0, 0 },
103     { ocLog10,              23,     1,  1,  V, { VR }, 0, 0 },
104     { ocAbs,                24,     1,  1,  V, { VR }, 0, 0 },
105     { ocInt,                25,     1,  1,  V, { VR }, 0, 0 },
106     { ocPlusMinus,          26,     1,  1,  V, { VR }, 0, 0 },
107     { ocRound,              27,     2,  2,  V, { VR }, 0, 0 },
108     { ocLookup,             28,     2,  3,  V, { VR, RA }, 0, 0 },
109     { ocIndex,              29,     2,  4,  R, { RA, VV }, 0, 0 },
110     { ocRept,               30,     2,  2,  V, { VR }, 0, 0 },
111     { ocMid,                31,     3,  3,  V, { VR }, 0, 0 },
112     { ocLen,                32,     1,  1,  V, { VR }, 0, 0 },
113     { ocValue,              33,     1,  1,  V, { VR }, 0, 0 },
114     { ocTrue,               34,     0,  0,  V, {}, 0, 0 },
115     { ocFalse,              35,     0,  0,  V, {}, 0, 0 },
116     { ocAnd,                36,     1,  MX, V, { RX }, 0, 0 },
117     { ocOr,                 37,     1,  MX, V, { RX }, 0, 0 },
118     { ocNot,                38,     1,  1,  V, { VR }, 0, 0 },
119     { ocMod,                39,     2,  2,  V, { VR }, 0, 0 },
120     { ocDBCount,            40,     3,  3,  V, { RO, RR }, 0, 0 },
121     { ocDBSum,              41,     3,  3,  V, { RO, RR }, 0, 0 },
122     { ocDBAverage,          42,     3,  3,  V, { RO, RR }, 0, 0 },
123     { ocDBMin,              43,     3,  3,  V, { RO, RR }, 0, 0 },
124     { ocDBMax,              44,     3,  3,  V, { RO, RR }, 0, 0 },
125     { ocDBStdDev,           45,     3,  3,  V, { RO, RR }, 0, 0 },
126     { ocVar,                46,     1,  MX, V, { RX }, 0, 0 },
127     { ocDBVar,              47,     3,  3,  V, { RO, RR }, 0, 0 },
128     { ocText,               48,     2,  2,  V, { VR }, 0, 0 },
129     { ocRGP,                49,     1,  2,  A, { RA, RA, C, C }, 0, 0 },
130     { ocTrend,              50,     1,  3,  A, { RA, RA, RA, C }, 0, 0 },
131     { ocRKP,                51,     1,  2,  A, { RA, RA, C, C }, 0, 0 },
132     { ocGrowth,             52,     1,  3,  A, { RA, RA, RA, C }, 0, 0 },
133     { ocBW,                 56,     3,  5,  V, { VR }, 0, 0 },
134     { ocZW,                 57,     3,  5,  V, { VR }, 0, 0 },
135     { ocZZR,                58,     3,  5,  V, { VR }, 0, 0 },
136     { ocRMZ,                59,     3,  5,  V, { VR }, 0, 0 },
137     { ocZins,               60,     3,  6,  V, { VR }, 0, 0 },
138     { ocMIRR,               61,     3,  3,  V, { RA, VR }, 0, 0 },
139     { ocIRR,                62,     1,  2,  V, { RA, VR }, 0, 0 },
140     { ocRandom,             63,     0,  0,  V, {}, EXC_FUNCFLAG_VOLATILE, 0 },
141     { ocMatch,              64,     2,  3,  V, { VR, RX, RR }, 0, 0 },
142     { ocGetDate,            65,     3,  3,  V, { VR }, 0, 0 },
143     { ocGetTime,            66,     3,  3,  V, { VR }, 0, 0 },
144     { ocGetDay,             67,     1,  1,  V, { VR }, 0, 0 },
145     { ocGetMonth,           68,     1,  1,  V, { VR }, 0, 0 },
146     { ocGetYear,            69,     1,  1,  V, { VR }, 0, 0 },
147     { ocGetDayOfWeek,       70,     1,  1,  V, { VR, C }, 0, 0 },
148     { ocGetHour,            71,     1,  1,  V, { VR }, 0, 0 },
149     { ocGetMin,             72,     1,  1,  V, { VR }, 0, 0 },
150     { ocGetSec,             73,     1,  1,  V, { VR }, 0, 0 },
151     { ocGetActTime,         74,     0,  0,  V, {}, EXC_FUNCFLAG_VOLATILE, 0 },
152     { ocAreas,              75,     1,  1,  V, { RO }, 0, 0 },
153     { ocRows,               76,     1,  1,  V, { RO }, 0, 0 },
154     { ocColumns,            77,     1,  1,  V, { RO }, 0, 0 },
155     { ocOffset,             78,     3,  5,  R, { RO, VR }, EXC_FUNCFLAG_VOLATILE, 0 },
156     { ocSearch,             82,     2,  3,  V, { VR }, 0, 0 },
157     { ocMatTrans,           83,     1,  1,  A, { VO }, 0, 0 },
158     { ocType,               86,     1,  1,  V, { VX }, 0, 0 },
159     { ocArcTan2,            97,     2,  2,  V, { VR }, 0, 0 },
160     { ocArcSin,             98,     1,  1,  V, { VR }, 0, 0 },
161     { ocArcCos,             99,     1,  1,  V, { VR }, 0, 0 },
162     { ocChose,              100,    2,  MX, R, { VO, RO }, 0, 0 },
163     { ocHLookup,            101,    3,  3,  V, { VV, RO, RO, C }, 0, 0 },
164     { ocVLookup,            102,    3,  3,  V, { VV, RO, RO, C }, 0, 0 },
165     { ocIsRef,              105,    1,  1,  V, { RX }, 0, 0 },
166     { ocLog,                109,    1,  2,  V, { VR }, 0, 0 },
167     { ocChar,               111,    1,  1,  V, { VR }, 0, 0 },
168     { ocLower,              112,    1,  1,  V, { VR }, 0, 0 },
169     { ocUpper,              113,    1,  1,  V, { VR }, 0, 0 },
170     { ocPropper,            114,    1,  1,  V, { VR }, 0, 0 },
171     { ocLeft,               115,    1,  2,  V, { VR }, 0, 0 },
172     { ocRight,              116,    1,  2,  V, { VR }, 0, 0 },
173     { ocExact,              117,    2,  2,  V, { VR }, 0, 0 },
174     { ocTrim,               118,    1,  1,  V, { VR }, 0, 0 },
175     { ocReplace,            119,    4,  4,  V, { VR }, 0, 0 },
176     { ocSubstitute,         120,    3,  4,  V, { VR }, 0, 0 },
177     { ocCode,               121,    1,  1,  V, { VR }, 0, 0 },
178     { ocFind,               124,    2,  3,  V, { VR }, 0, 0 },
179     { ocCell,               125,    1,  2,  V, { VV, RO }, EXC_FUNCFLAG_VOLATILE, 0 },
180     { ocIsErr,              126,    1,  1,  V, { VR }, 0, 0 },
181     { ocIsString,           127,    1,  1,  V, { VR }, 0, 0 },
182     { ocIsValue,            128,    1,  1,  V, { VR }, 0, 0 },
183     { ocIsEmpty,            129,    1,  1,  V, { VR }, 0, 0 },
184     { ocT,                  130,    1,  1,  V, { RO }, 0, 0 },
185     { ocN,                  131,    1,  1,  V, { RO }, 0, 0 },
186     { ocGetDateValue,       140,    1,  1,  V, { VR }, 0, 0 },
187     { ocGetTimeValue,       141,    1,  1,  V, { VR }, 0, 0 },
188     { ocLIA,                142,    3,  3,  V, { VR }, 0, 0 },
189     { ocDIA,                143,    4,  4,  V, { VR }, 0, 0 },
190     { ocGDA,                144,    4,  5,  V, { VR }, 0, 0 },
191     { ocIndirect,           148,    1,  2,  R, { VR }, EXC_FUNCFLAG_VOLATILE, 0 },
192     { ocClean,              162,    1,  1,  V, { VR }, 0, 0 },
193     { ocMatDet,             163,    1,  1,  V, { VA }, 0, 0 },
194     { ocMatInv,             164,    1,  1,  A, { VA }, 0, 0 },
195     { ocMatMult,            165,    2,  2,  A, { VA }, 0, 0 },
196     { ocZinsZ,              167,    4,  6,  V, { VR }, 0, 0 },
197     { ocKapz,               168,    4,  6,  V, { VR }, 0, 0 },
198     { ocCount2,             169,    0,  MX, V, { RX }, 0, 0 },
199     { ocProduct,            183,    0,  MX, V, { RX }, 0, 0 },
200     { ocFact,               184,    1,  1,  V, { VR }, 0, 0 },
201     { ocDBProduct,          189,    3,  3,  V, { RO, RR }, 0, 0 },
202     { ocIsNonString,        190,    1,  1,  V, { VR }, 0, 0 },
203     { ocStDevP,             193,    1,  MX, V, { RX }, 0, 0 },
204     { ocVarP,               194,    1,  MX, V, { RX }, 0, 0 },
205     { ocDBStdDevP,          195,    3,  3,  V, { RO, RR }, 0, 0 },
206     { ocDBVarP,             196,    3,  3,  V, { RO, RR }, 0, 0 },
207     { ocTrunc,              197,    1,  1,  V, { VR, C }, 0, 0 },
208     { ocIsLogical,          198,    1,  1,  V, { VR }, 0, 0 },
209     { ocDBCount2,           199,    3,  3,  V, { RO, RR }, 0, 0 },
210     { ocCurrency,           204,    1,  2,  V, { VR }, EXC_FUNCFLAG_IMPORTONLY, 0 },
211     { ocFindB,              205,    2,  3,  V, { VR }, 0, 0 },
212     { ocSearchB,            206,    2,  3,  V, { VR }, 0, 0 },
213     { ocReplaceB,           207,    4,  4,  V, { VR }, 0, 0 },
214     { ocLeftB,              208,    1,  2,  V, { VR }, 0, 0 },
215     { ocRightB,             209,    1,  2,  V, { VR }, 0, 0 },
216     { ocMidB,               210,    3,  3,  V, { VR }, 0, 0 },
217     { ocLenB,               211,    1,  1,  V, { VR }, 0, 0 },
218     { ocRoundUp,            212,    2,  2,  V, { VR }, 0, 0 },
219     { ocRoundDown,          213,    2,  2,  V, { VR }, 0, 0 },
220     { ocExternal,           255,    1,  MX, R, { RO_E, RO }, EXC_FUNCFLAG_IMPORTONLY, 0 }
221 };
222 
223 /** Functions new in BIFF3. */
224 static const XclFunctionInfo saFuncTable_3[] =
225 {
226     { ocRGP,                49,     1,  4,  A, { RA, RA, VV }, 0, 0 },          // BIFF2: 1-2, BIFF3: 1-4
227     { ocTrend,              50,     1,  4,  A, { RA, RA, RA, VV }, 0, 0 },      // BIFF2: 1-3, BIFF3: 1-4
228     { ocRKP,                51,     1,  4,  A, { RA, RA, VV }, 0, 0 },          // BIFF2: 1-2, BIFF3: 1-4
229     { ocGrowth,             52,     1,  4,  A, { RA, RA, RA, VV }, 0, 0 },      // BIFF2: 1-3, BIFF3: 1-4
230     { ocTrunc,              197,    1,  2,  V, { VR }, 0, 0 },                  // BIFF2: 1,   BIFF3: 1-2
231     { ocAddress,            219,    2,  5,  V, { VR }, 0, 0 },
232     { ocGetDiffDate360,     220,    2,  2,  V, { VR, VR, C }, 0, 0 },
233     { ocGetActDate,         221,    0,  0,  V, {}, EXC_FUNCFLAG_VOLATILE, 0 },
234     { ocVBD,                222,    5,  7,  V, { VR }, 0, 0 },
235     { ocMedian,             227,    1,  MX, V, { RX }, 0, 0 },
236     { ocSumProduct,         228,    1,  MX, V, { VA }, 0, 0 },
237     { ocSinHyp,             229,    1,  1,  V, { VR }, 0, 0 },
238     { ocCosecantHyp,        229,    1,  1,  V, { VR }, EXC_FUNCFLAG_EXPORTONLY, 0 },
239     { ocCosHyp,             230,    1,  1,  V, { VR }, 0, 0 },
240     { ocSecantHyp,          230,    1,  1,  V, { VR }, EXC_FUNCFLAG_EXPORTONLY, 0 },
241     { ocTanHyp,             231,    1,  1,  V, { VR }, 0, 0 },
242     { ocCotHyp,             231,    1,  1,  V, { VR }, EXC_FUNCFLAG_EXPORTONLY, 0 },
243     { ocArcSinHyp,          232,    1,  1,  V, { VR }, 0, 0 },
244     { ocArcCosHyp,          233,    1,  1,  V, { VR }, 0, 0 },
245     { ocArcTanHyp,          234,    1,  1,  V, { VR }, 0, 0 },
246     { ocArcCotHyp,          234,    1,  1,  V, { VR }, EXC_FUNCFLAG_EXPORTONLY, 0 },
247     { ocDBGet,              235,    3,  3,  V, { RO, RR }, 0, 0 },
248     { ocInfo,               244,    1,  1,  V, { VR }, EXC_FUNCFLAG_VOLATILE, 0 }
249 };
250 
251 /** Functions new in BIFF4. */
252 static const XclFunctionInfo saFuncTable_4[] =
253 {
254     { ocFixed,              14,     1,  3,  V, { VR }, 0, 0 },                  // BIFF2-3: 1-2, BIFF4: 1-3
255     { ocAsc,                214,    1,  1,  V, { VR }, 0, 0 },
256     { ocJis,                215,    1,  1,  V, { VR }, 0, 0 },
257     { ocRank,               216,    2,  3,  V, { VR, RO, VR }, 0, 0 },
258     { ocGDA2,               247,    4,  5,  V, { VR }, 0, 0 },
259     { ocFrequency,          252,    2,  2,  A, { RA }, 0, 0 },
260     { ocErrorTypeODF,       261,    1,  1,  V, { VR }, 0, 0 },
261     { ocErrorType,          261,    1,  1,  V, { VR }, EXC_FUNCFLAG_EXPORTONLY, 0 },
262     { ocAveDev,             269,    1,  MX, V, { RX }, 0, 0 },
263     { ocBetaDist,           270,    3,  5,  V, { VR }, 0, 0 },
264     { ocGammaLn,            271,    1,  1,  V, { VR }, 0, 0 },
265     { ocBetaInv,            272,    3,  5,  V, { VR }, 0, 0 },
266     { ocBinomDist,          273,    4,  4,  V, { VR }, 0, 0 },
267     { ocChiDist,            274,    2,  2,  V, { VR }, 0, 0 },
268     { ocChiInv,             275,    2,  2,  V, { VR }, 0, 0 },
269     { ocKombin,             276,    2,  2,  V, { VR }, 0, 0 },
270     { ocConfidence,         277,    3,  3,  V, { VR }, 0, 0 },
271     { ocKritBinom,          278,    3,  3,  V, { VR }, 0, 0 },
272     { ocEven,               279,    1,  1,  V, { VR }, 0, 0 },
273     { ocExpDist,            280,    3,  3,  V, { VR }, 0, 0 },
274     { ocFDist,              281,    3,  3,  V, { VR }, 0, 0 },
275     { ocFInv,               282,    3,  3,  V, { VR }, 0, 0 },
276     { ocFisher,             283,    1,  1,  V, { VR }, 0, 0 },
277     { ocFisherInv,          284,    1,  1,  V, { VR }, 0, 0 },
278     { ocFloor,              285,    2,  2,  V, { VR, VR, C }, 0, 0 },
279     { ocGammaDist,          286,    4,  4,  V, { VR }, 0, 0 },
280     { ocGammaInv,           287,    3,  3,  V, { VR }, 0, 0 },
281     { ocCeil,               288,    2,  2,  V, { VR, VR, C }, 0, 0 },
282     { ocHypGeomDist,        289,    4,  4,  V, { VR }, 0, 0 },
283     { ocLogNormDist,        290,    3,  3,  V, { VR }, 0, 0 },
284     { ocLogInv,             291,    3,  3,  V, { VR }, 0, 0 },
285     { ocNegBinomVert,       292,    3,  3,  V, { VR }, 0, 0 },
286     { ocNormDist,           293,    4,  4,  V, { VR }, 0, 0 },
287     { ocStdNormDist,        294,    1,  1,  V, { VR }, 0, 0 },
288     { ocNormInv,            295,    3,  3,  V, { VR }, 0, 0 },
289     { ocSNormInv,           296,    1,  1,  V, { VR }, 0, 0 },
290     { ocStandard,           297,    3,  3,  V, { VR }, 0, 0 },
291     { ocOdd,                298,    1,  1,  V, { VR }, 0, 0 },
292     { ocVariationen,        299,    2,  2,  V, { VR }, 0, 0 },
293     { ocPoissonDist,        300,    3,  3,  V, { VR }, 0, 0 },
294     { ocTDist,              301,    3,  3,  V, { VR }, 0, 0 },
295     { ocWeibull,            302,    4,  4,  V, { VR }, 0, 0 },
296     { ocSumXMY2,            303,    2,  2,  V, { VA }, 0, 0 },
297     { ocSumX2MY2,           304,    2,  2,  V, { VA }, 0, 0 },
298     { ocSumX2DY2,           305,    2,  2,  V, { VA }, 0, 0 },
299     { ocChiTest,            306,    2,  2,  V, { VA }, 0, 0 },
300     { ocCorrel,             307,    2,  2,  V, { VA }, 0, 0 },
301     { ocCovar,              308,    2,  2,  V, { VA }, 0, 0 },
302     { ocForecast,           309,    3,  3,  V, { VR, VA }, 0, 0 },
303     { ocFTest,              310,    2,  2,  V, { VA }, 0, 0 },
304     { ocIntercept,          311,    2,  2,  V, { VA }, 0, 0 },
305     { ocPearson,            312,    2,  2,  V, { VA }, 0, 0 },
306     { ocRSQ,                313,    2,  2,  V, { VA }, 0, 0 },
307     { ocSTEYX,              314,    2,  2,  V, { VA }, 0, 0 },
308     { ocSlope,              315,    2,  2,  V, { VA }, 0, 0 },
309     { ocTTest,              316,    4,  4,  V, { VA, VA, VR }, 0, 0 },
310     { ocProb,               317,    3,  4,  V, { VA, VA, VR }, 0, 0 },
311     { ocDevSq,              318,    1,  MX, V, { RX }, 0, 0 },
312     { ocGeoMean,            319,    1,  MX, V, { RX }, 0, 0 },
313     { ocHarMean,            320,    1,  MX, V, { RX }, 0, 0 },
314     { ocSumSQ,              321,    0,  MX, V, { RX }, 0, 0 },
315     { ocKurt,               322,    1,  MX, V, { RX }, 0, 0 },
316     { ocSchiefe,            323,    1,  MX, V, { RX }, 0, 0 },
317     { ocZTest,              324,    2,  3,  V, { RX, VR }, 0, 0 },
318     { ocLarge,              325,    2,  2,  V, { RX, VR }, 0, 0 },
319     { ocSmall,              326,    2,  2,  V, { RX, VR }, 0, 0 },
320     { ocQuartile,           327,    2,  2,  V, { RX, VR }, 0, 0 },
321     { ocPercentile,         328,    2,  2,  V, { RX, VR }, 0, 0 },
322     { ocPercentrank,        329,    2,  3,  V, { RX, VR, VR_E }, 0, 0 },
323     { ocModalValue,         330,    1,  MX, V, { VA }, 0, 0 },
324     { ocTrimMean,           331,    2,  2,  V, { RX, VR }, 0, 0 },
325     { ocTInv,               332,    2,  2,  V, { VR }, 0, 0 }
326 };
327 
328 /** Functions new in BIFF5/BIFF7. Unsupported functions: DATEDIF, DATESTRING, NUMBERSTRING. */
329 static const XclFunctionInfo saFuncTable_5[] =
330 {
331     { ocGetDayOfWeek,       70,     1,  2,  V, { VR }, 0, 0 },                  // BIFF2-4: 1, BIFF5: 1-2
332     { ocHLookup,            101,    3,  4,  V, { VV, RO, RO, VV }, 0, 0 },      // BIFF2-4: 3, BIFF5: 3-4
333     { ocVLookup,            102,    3,  4,  V, { VV, RO, RO, VV }, 0, 0 },      // BIFF2-4: 3, BIFF5: 3-4
334     { ocGetDiffDate360,     220,    2,  3,  V, { VR }, 0, 0 },                  // BIFF3-4: 2, BIFF5: 2-3
335     { ocMacro,              255,    1,  MX, R, { RO_E, RO }, EXC_FUNCFLAG_EXPORTONLY, 0 },
336     { ocExternal,           255,    1,  MX, R, { RO_E, RO }, EXC_FUNCFLAG_EXPORTONLY, 0 },
337     { ocConcat,             336,    0,  MX, V, { VR }, 0, 0 },
338     { ocPower,              337,    2,  2,  V, { VR }, 0, 0 },
339     { ocRad,                342,    1,  1,  V, { VR }, 0, 0 },
340     { ocDeg,                343,    1,  1,  V, { VR }, 0, 0 },
341     { ocSubTotal,           344,    2,  MX, V, { VR, RO }, 0, 0 },
342     { ocSumIf,              345,    2,  3,  V, { RO, VR, RO }, 0, 0 },
343     { ocCountIf,            346,    2,  2,  V, { RO, VR }, 0, 0 },
344     { ocCountEmptyCells,    347,    1,  1,  V, { RO }, 0, 0 },
345     { ocISPMT,              350,    4,  4,  V, { VR }, 0, 0 },
346     { ocDateDif,            351,    3,  3,  V, { VR }, 0, 0 },
347     { ocNoName,             352,    1,  1,  V, { VR }, EXC_FUNCFLAG_IMPORTONLY, 0 },    // DATESTRING
348     { ocNoName,             353,    2,  2,  V, { VR }, EXC_FUNCFLAG_IMPORTONLY, 0 },    // NUMBERSTRING
349     { ocRoman,              354,    1,  2,  V, { VR }, 0, 0 }
350 };
351 
352 /** Functions new in BIFF8. Unsupported functions: PHONETIC. */
353 static const XclFunctionInfo saFuncTable_8[] =
354 {
355     { ocGetPivotData,       358,    2,  MX, V, { RR, RR, VR }, 0, 0 },
356     { ocHyperLink,          359,    1,  2,  V, { VV, VO }, 0, 0 },
357     { ocNoName,             360,    1,  1,  V, { RO }, EXC_FUNCFLAG_IMPORTONLY, 0 },    // PHONETIC
358     { ocAverageA,           361,    1,  MX, V, { RX }, 0, 0 },
359     { ocMaxA,               362,    1,  MX, V, { RX }, 0, 0 },
360     { ocMinA,               363,    1,  MX, V, { RX }, 0, 0 },
361     { ocStDevPA,            364,    1,  MX, V, { RX }, 0, 0 },
362     { ocVarPA,              365,    1,  MX, V, { RX }, 0, 0 },
363     { ocStDevA,             366,    1,  MX, V, { RX }, 0, 0 },
364     { ocVarA,               367,    1,  MX, V, { RX }, 0, 0 },
365     { ocBahtText,           368,    1,  1,  V, { VR }, EXC_FUNCFLAG_IMPORTONLY, EXC_FUNCNAME( "BAHTTEXT" ) },
366     { ocBahtText,           255,    2,  2,  V, { RO_E, RO }, EXC_FUNCFLAG_EXPORTONLY, EXC_FUNCNAME( "BAHTTEXT" ) },
367     { ocEuroConvert,        255,    4,  6,  V, { RO_E, RO }, EXC_FUNCFLAG_EXPORTONLY, "EUROCONVERT" }
368 };
369 
370 /** Functions new in OOXML. */
371 static const XclFunctionInfo saFuncTable_Oox[] =
372 {
373     { ocCountIfs,           NOID,   2,  MX, V, { RO, VR }, EXC_FUNCFLAG_IMPORTONLY|EXC_FUNCFLAG_PARAMPAIRS, EXC_FUNCNAME( "COUNTIFS" ) },
374     { ocCountIfs,           255,    3,  MX, V, { RO_E, RO, VR }, EXC_FUNCFLAG_EXPORTONLY|EXC_FUNCFLAG_PARAMPAIRS, EXC_FUNCNAME( "COUNTIFS" ) },
375     { ocSumIfs,             NOID,   3,  MX, V, { RO, RO, VR }, EXC_FUNCFLAG_IMPORTONLY|EXC_FUNCFLAG_PARAMPAIRS, EXC_FUNCNAME( "SUMIFS" ) },
376     { ocSumIfs,             255,    4,  MX, V, { RO_E, RO, RO, VR }, EXC_FUNCFLAG_EXPORTONLY|EXC_FUNCFLAG_PARAMPAIRS, EXC_FUNCNAME( "SUMIFS" ) },
377     { ocAverageIf,          NOID,   2,  3,  V, { RO, VR, RO }, EXC_FUNCFLAG_IMPORTONLY, EXC_FUNCNAME( "AVERAGEIF" ) },
378     { ocAverageIf,          255,    3,  4,  V, { RO_E, RO, VR, RO }, EXC_FUNCFLAG_EXPORTONLY, EXC_FUNCNAME( "AVERAGEIF" ) },
379     { ocAverageIfs,         NOID,   3,  MX, V, { RO, RO, VR }, EXC_FUNCFLAG_IMPORTONLY|EXC_FUNCFLAG_PARAMPAIRS, EXC_FUNCNAME( "AVERAGEIFS" ) },
380     { ocAverageIfs,         255,    4,  MX, V, { RO_E, RO, RO, VR }, EXC_FUNCFLAG_EXPORTONLY|EXC_FUNCFLAG_PARAMPAIRS, EXC_FUNCNAME( "AVERAGEIFS" ) },
381     { ocIfna,               NOID,   2,  2,  V, { VR }, EXC_FUNCFLAG_IMPORTONLY, EXC_FUNCNAME( "IFNA" ) },
382     { ocIfna,               255,    3,  3,  V, { RO_E, VO, RO }, EXC_FUNCFLAG_EXPORTONLY, EXC_FUNCNAME( "IFNA" ) },
383     { ocIfError,            NOID,   2,  2,  V, { VR }, EXC_FUNCFLAG_IMPORTONLY, EXC_FUNCNAME( "IFERROR" ) },
384     { ocIfError,            255,    3,  3,  V, { RO_E, VO, RO }, EXC_FUNCFLAG_EXPORTONLY, EXC_FUNCNAME( "IFERROR" ) },
385     { ocFDistLeft,          NOID,   3,  4,  V, { VR }, EXC_FUNCFLAG_IMPORTONLY, EXC_FUNCNAME( "F.DIST" ) },
386     { ocFDistLeft,          255,    4,  5,  V, { RO_E, RO }, EXC_FUNCFLAG_EXPORTONLY, EXC_FUNCNAME( "F.DIST" ) },
387     { ocFInvLeft,           NOID,   3,  3,  V, { VR }, EXC_FUNCFLAG_IMPORTONLY, EXC_FUNCNAME( "F.INV" ) },
388     { ocFInvLeft,           255,    4,  4,  V, { RO_E, RO }, EXC_FUNCFLAG_EXPORTONLY, EXC_FUNCNAME( "F.INV" ) },
389     { ocIsoWeekNum,         NOID,   1,  1,  V, { VR }, EXC_FUNCFLAG_IMPORTONLY, EXC_FUNCNAME( "ISOWEEKNUM" ) },
390     { ocIsoWeekNum,         255,    2,  2,  V, { RO_E, RO }, EXC_FUNCFLAG_EXPORTONLY, EXC_FUNCNAME( "ISOWEEKNUM" ) },
391     { ocSkewP,              NOID,   1,  MX, V, { VR }, EXC_FUNCFLAG_IMPORTONLY, EXC_FUNCNAME( "SKEW.P" ) },
392     { ocSkewP,              255,    2,  MX, V, { RO_E, RO }, EXC_FUNCFLAG_EXPORTONLY, EXC_FUNCNAME( "SKEW.P" ) },
393     { ocBitAnd,             NOID,   2,  2,  V, { VR }, EXC_FUNCFLAG_IMPORTONLY, EXC_FUNCNAME( "BITAND" ) },
394     { ocBitAnd,             255,    3,  3,  V, { RO_E, RO }, EXC_FUNCFLAG_EXPORTONLY, EXC_FUNCNAME( "BITAND" ) },
395     { ocBitOr,              NOID,   2,  2,  V, { VR }, EXC_FUNCFLAG_IMPORTONLY, EXC_FUNCNAME( "BITOR" ) },
396     { ocBitOr,              255,    3,  3,  V, { RO_E, RO }, EXC_FUNCFLAG_EXPORTONLY, EXC_FUNCNAME( "BITOR" ) },
397     { ocBitXor,             NOID,   2,  2,  V, { VR }, EXC_FUNCFLAG_IMPORTONLY, EXC_FUNCNAME( "BITXOR" ) },
398     { ocBitXor,             255,    3,  3,  V, { RO_E, RO }, EXC_FUNCFLAG_EXPORTONLY, EXC_FUNCNAME( "BITXOR" ) },
399     { ocBitLShift,          NOID,   2,  2,  V, { VR }, EXC_FUNCFLAG_IMPORTONLY, EXC_FUNCNAME( "BITLSHIFT" ) },
400     { ocBitLShift,          255,    3,  3,  V, { RO_E, RO }, EXC_FUNCFLAG_EXPORTONLY, EXC_FUNCNAME( "BITLSHIFT" ) },
401     { ocBitRShift,          NOID,   2,  2,  V, { VR }, EXC_FUNCFLAG_IMPORTONLY, EXC_FUNCNAME( "BITRSHIFT" ) },
402     { ocBitRShift,          255,    3,  3,  V, { RO_E, RO }, EXC_FUNCFLAG_EXPORTONLY, EXC_FUNCNAME( "BITRSHIFT" ) }
403 };
404 
405 #define EXC_FUNCENTRY_ODF( opcode, minparam, maxparam, flags, asciiname ) \
406     { opcode, NOID, minparam,     maxparam,     V, { VR },       EXC_FUNCFLAG_IMPORTONLY|(flags), EXC_FUNCNAME_ODF( asciiname ) }, \
407     { opcode,  255, (minparam)+1, (maxparam)+1, V, { RO_E, RO }, EXC_FUNCFLAG_EXPORTONLY|(flags), EXC_FUNCNAME_ODF( asciiname ) }
408 
409 /** Functions defined by OpenFormula, but not supported by Calc (ocNoName) or by Excel (defined op-code). */
410 static const XclFunctionInfo saFuncTable_Odf[] =
411 {
412     EXC_FUNCENTRY_ODF( ocArabic,        1,  1,  0,  "ARABIC" ),
413     EXC_FUNCENTRY_ODF( ocB,             3,  4,  0,  "B" ),
414     EXC_FUNCENTRY_ODF( ocBase,          2,  3,  0,  "BASE" ),
415     EXC_FUNCENTRY_ODF( ocChiSqDist,     2,  3,  0,  "CHISQDIST" ),
416     EXC_FUNCENTRY_ODF( ocChiSqInv,      2,  2,  0,  "CHISQINV" ),
417     EXC_FUNCENTRY_ODF( ocKombin2,       2,  2,  0,  "COMBINA" ),
418     EXC_FUNCENTRY_ODF( ocGetDiffDate,   2,  2,  0,  "DAYS" ),
419     EXC_FUNCENTRY_ODF( ocDecimal,       2,  2,  0,  "DECIMAL" ),
420     // Older versions wrote the legacy right-tail FDIST and FINV under these names.
421     { ocFDist,              NOID,   3,  3,  V, { VR }, EXC_FUNCFLAG_IMPORTONLY, EXC_FUNCNAME_ODF( "FDIST" ) },
422     { ocFInv,               NOID,   3,  3,  V, { VR }, EXC_FUNCFLAG_IMPORTONLY, EXC_FUNCNAME_ODF( "FINV" ) },
423     EXC_FUNCENTRY_ODF( ocFormula,       1,  1,  0,  "FORMULA" ),
424     EXC_FUNCENTRY_ODF( ocGamma,         1,  1,  0,  "GAMMA" ),
425     EXC_FUNCENTRY_ODF( ocGauss,         1,  1,  0,  "GAUSS" ),
426     EXC_FUNCENTRY_ODF( ocIsFormula,     1,  1,  0,  "ISFORMULA" ),
427     EXC_FUNCENTRY_ODF( ocWeek,          1,  2,  0,  "ISOWEEKNUM" ),
428     EXC_FUNCENTRY_ODF( ocMatrixUnit,    1,  1,  0,  "MUNIT" ),
429     EXC_FUNCENTRY_ODF( ocNumberValue,   1,  3,  0,  "NUMBERVALUE" ),
430     EXC_FUNCENTRY_ODF( ocLaufz,         3,  3,  0,  "PDURATION" ),
431     EXC_FUNCENTRY_ODF( ocVariationen2,  2,  2,  0,  "PERMUTATIONA" ),
432     EXC_FUNCENTRY_ODF( ocPhi,           1,  1,  0,  "PHI" ),
433     EXC_FUNCENTRY_ODF( ocZGZ,           3,  3,  0,  "RRI" ),
434     EXC_FUNCENTRY_ODF( ocTable,         0,  1,  0,  "SHEET" ),
435     EXC_FUNCENTRY_ODF( ocTables,        0,  1,  0,  "SHEETS" ),
436     EXC_FUNCENTRY_ODF( ocUnichar,       1,  1,  0,  "UNICHAR" ),
437     EXC_FUNCENTRY_ODF( ocUnicode,       1,  1,  0,  "UNICODE" ),
438     EXC_FUNCENTRY_ODF( ocXor,           1,  MX, 0,  "XOR" )
439 };
440 
441 #undef EXC_FUNCENTRY_ODF
442 
443 // ----------------------------------------------------------------------------
444 
XclFunctionProvider(const XclRoot & rRoot)445 XclFunctionProvider::XclFunctionProvider( const XclRoot& rRoot )
446 {
447     void (XclFunctionProvider::*pFillFunc)( const XclFunctionInfo*, const XclFunctionInfo* ) =
448         rRoot.IsImport() ? &XclFunctionProvider::FillXclFuncMap : &XclFunctionProvider::FillScFuncMap;
449 
450     /*  Only read/write functions supported in the current BIFF version.
451         Function tables from later BIFF versions may overwrite single functions
452         from earlier tables. */
453     XclBiff eBiff = rRoot.GetBiff();
454     if( eBiff >= EXC_BIFF2 )
455         (this->*pFillFunc)( saFuncTable_2, STATIC_ARRAY_END( saFuncTable_2 ) );
456     if( eBiff >= EXC_BIFF3 )
457         (this->*pFillFunc)( saFuncTable_3, STATIC_ARRAY_END( saFuncTable_3 ) );
458     if( eBiff >= EXC_BIFF4 )
459         (this->*pFillFunc)( saFuncTable_4, STATIC_ARRAY_END( saFuncTable_4 ) );
460     if( eBiff >= EXC_BIFF5 )
461         (this->*pFillFunc)( saFuncTable_5, STATIC_ARRAY_END( saFuncTable_5 ) );
462     if( eBiff >= EXC_BIFF8 )
463         (this->*pFillFunc)( saFuncTable_8, STATIC_ARRAY_END( saFuncTable_8 ) );
464     (this->*pFillFunc)( saFuncTable_Oox, STATIC_ARRAY_END( saFuncTable_Oox ) );
465     (this->*pFillFunc)( saFuncTable_Odf, STATIC_ARRAY_END( saFuncTable_Odf ) );
466 }
467 
GetFuncInfoFromXclFunc(sal_uInt16 nXclFunc) const468 const XclFunctionInfo* XclFunctionProvider::GetFuncInfoFromXclFunc( sal_uInt16 nXclFunc ) const
469 {
470     // only in import filter allowed
471     DBG_ASSERT( !maXclFuncMap.empty(), "XclFunctionProvider::GetFuncInfoFromXclFunc - wrong filter" );
472     XclFuncMap::const_iterator aIt = maXclFuncMap.find( nXclFunc );
473     return (aIt == maXclFuncMap.end()) ? 0 : aIt->second;
474 }
475 
GetFuncInfoFromXclMacroName(const String & rXclMacroName) const476 const XclFunctionInfo* XclFunctionProvider::GetFuncInfoFromXclMacroName( const String& rXclMacroName ) const
477 {
478     // only in import filter allowed, but do not test maXclMacroNameMap, it may be empty for old BIFF versions
479     DBG_ASSERT( !maXclFuncMap.empty(), "XclFunctionProvider::GetFuncInfoFromXclMacroName - wrong filter" );
480     XclMacroNameMap::const_iterator aIt = maXclMacroNameMap.find( rXclMacroName );
481     return (aIt == maXclMacroNameMap.end()) ? 0 : aIt->second;
482 }
483 
GetFuncInfoFromOpCode(OpCode eOpCode) const484 const XclFunctionInfo* XclFunctionProvider::GetFuncInfoFromOpCode( OpCode eOpCode ) const
485 {
486     // only in export filter allowed
487     DBG_ASSERT( !maScFuncMap.empty(), "XclFunctionProvider::GetFuncInfoFromOpCode - wrong filter" );
488     ScFuncMap::const_iterator aIt = maScFuncMap.find( eOpCode );
489     return (aIt == maScFuncMap.end()) ? 0 : aIt->second;
490 }
491 
FillXclFuncMap(const XclFunctionInfo * pBeg,const XclFunctionInfo * pEnd)492 void XclFunctionProvider::FillXclFuncMap( const XclFunctionInfo* pBeg, const XclFunctionInfo* pEnd )
493 {
494     for( const XclFunctionInfo* pIt = pBeg; pIt != pEnd; ++pIt )
495     {
496         if( !::get_flag( pIt->mnFlags, EXC_FUNCFLAG_EXPORTONLY ) )
497         {
498             if( pIt->mnXclFunc != NOID )
499                 maXclFuncMap[ pIt->mnXclFunc ] = pIt;
500             if( pIt->IsMacroFunc() )
501                 maXclMacroNameMap[ pIt->GetMacroFuncName() ] = pIt;
502         }
503     }
504 }
505 
FillScFuncMap(const XclFunctionInfo * pBeg,const XclFunctionInfo * pEnd)506 void XclFunctionProvider::FillScFuncMap( const XclFunctionInfo* pBeg, const XclFunctionInfo* pEnd )
507 {
508     for( const XclFunctionInfo* pIt = pBeg; pIt != pEnd; ++pIt )
509         if( !::get_flag( pIt->mnFlags, EXC_FUNCFLAG_IMPORTONLY ) )
510             maScFuncMap[ pIt->meOpCode ] = pIt;
511 }
512 
513 // Token array ================================================================
514 
XclTokenArray(bool bVolatile)515 XclTokenArray::XclTokenArray( bool bVolatile ) :
516     mbVolatile( bVolatile )
517 {
518 }
519 
XclTokenArray(ScfUInt8Vec & rTokVec,bool bVolatile)520 XclTokenArray::XclTokenArray( ScfUInt8Vec& rTokVec, bool bVolatile ) :
521     mbVolatile( bVolatile )
522 {
523     maTokVec.swap( rTokVec );
524 }
525 
XclTokenArray(ScfUInt8Vec & rTokVec,ScfUInt8Vec & rExtDataVec,bool bVolatile)526 XclTokenArray::XclTokenArray( ScfUInt8Vec& rTokVec, ScfUInt8Vec& rExtDataVec, bool bVolatile ) :
527     mbVolatile( bVolatile )
528 {
529     maTokVec.swap( rTokVec );
530     maExtDataVec.swap( rExtDataVec );
531 }
532 
GetSize() const533 sal_uInt16 XclTokenArray::GetSize() const
534 {
535     DBG_ASSERT( maTokVec.size() <= 0xFFFF, "XclTokenArray::GetSize - array too long" );
536     return limit_cast< sal_uInt16 >( maTokVec.size() );
537 }
538 
ReadSize(XclImpStream & rStrm)539 void XclTokenArray::ReadSize( XclImpStream& rStrm )
540 {
541     sal_uInt16 nSize;
542     rStrm >> nSize;
543     maTokVec.resize( nSize );
544 }
545 
ReadArray(XclImpStream & rStrm)546 void XclTokenArray::ReadArray( XclImpStream& rStrm )
547 {
548     if( !maTokVec.empty() )
549         rStrm.Read( &maTokVec.front(), GetSize() );
550 }
551 
Read(XclImpStream & rStrm)552 void XclTokenArray::Read( XclImpStream& rStrm )
553 {
554     ReadSize( rStrm );
555     ReadArray( rStrm );
556 }
557 
WriteSize(XclExpStream & rStrm) const558 void XclTokenArray::WriteSize( XclExpStream& rStrm ) const
559 {
560     rStrm << GetSize();
561 }
562 
WriteArray(XclExpStream & rStrm) const563 void XclTokenArray::WriteArray( XclExpStream& rStrm ) const
564 {
565     if( !maTokVec.empty() )
566         rStrm.Write( &maTokVec.front(), GetSize() );
567     if( !maExtDataVec.empty() )
568         rStrm.Write( &maExtDataVec.front(), maExtDataVec.size() );
569 }
570 
Write(XclExpStream & rStrm) const571 void XclTokenArray::Write( XclExpStream& rStrm ) const
572 {
573     WriteSize( rStrm );
574     WriteArray( rStrm );
575 }
576 
operator ==(const XclTokenArray & rTokArr) const577 bool XclTokenArray::operator==( const XclTokenArray& rTokArr ) const
578 {
579     return (mbVolatile == rTokArr.mbVolatile) && (maTokVec == rTokArr.maTokVec) && (maExtDataVec == rTokArr.maExtDataVec);
580 }
581 
operator >>(XclImpStream & rStrm,XclTokenArray & rTokArr)582 XclImpStream& operator>>( XclImpStream& rStrm, XclTokenArray& rTokArr )
583 {
584     rTokArr.Read( rStrm );
585     return rStrm;
586 }
587 
operator >>(XclImpStream & rStrm,XclTokenArrayRef & rxTokArr)588 XclImpStream& operator>>( XclImpStream& rStrm, XclTokenArrayRef& rxTokArr )
589 {
590     if( !rxTokArr )
591         rxTokArr.reset( new XclTokenArray );
592     rxTokArr->Read( rStrm );
593     return rStrm;
594 }
595 
operator <<(XclExpStream & rStrm,const XclTokenArray & rTokArr)596 XclExpStream& operator<<( XclExpStream& rStrm, const XclTokenArray& rTokArr )
597 {
598     rTokArr.Write( rStrm );
599     return rStrm;
600 }
601 
operator <<(XclExpStream & rStrm,const XclTokenArrayRef & rxTokArr)602 XclExpStream& operator<<( XclExpStream& rStrm, const XclTokenArrayRef& rxTokArr )
603 {
604     if( rxTokArr.is() )
605         rxTokArr->Write( rStrm );
606     else
607         rStrm << sal_uInt16( 0 );
608     return rStrm;
609 }
610 
611 // ----------------------------------------------------------------------------
612 
XclTokenArrayIterator()613 XclTokenArrayIterator::XclTokenArrayIterator() :
614     mppScTokenBeg( 0 ),
615     mppScTokenEnd( 0 ),
616     mppScToken( 0 ),
617     mbSkipSpaces( false )
618 {
619 }
620 
XclTokenArrayIterator(const ScTokenArray & rScTokArr,bool bSkipSpaces)621 XclTokenArrayIterator::XclTokenArrayIterator( const ScTokenArray& rScTokArr, bool bSkipSpaces )
622 {
623     Init( rScTokArr, bSkipSpaces );
624 }
625 
XclTokenArrayIterator(const XclTokenArrayIterator & rTokArrIt,bool bSkipSpaces)626 XclTokenArrayIterator::XclTokenArrayIterator( const XclTokenArrayIterator& rTokArrIt, bool bSkipSpaces ) :
627     mppScTokenBeg( rTokArrIt.mppScTokenBeg ),
628     mppScTokenEnd( rTokArrIt.mppScTokenEnd ),
629     mppScToken( rTokArrIt.mppScToken ),
630     mbSkipSpaces( bSkipSpaces )
631 {
632     SkipSpaces();
633 }
634 
Init()635 void XclTokenArrayIterator::Init()
636 {
637     mppScTokenBeg = mppScTokenEnd = mppScToken = 0;
638 }
639 
Init(const ScTokenArray & rScTokArr,bool bSkipSpaces)640 void XclTokenArrayIterator::Init( const ScTokenArray& rScTokArr, bool bSkipSpaces )
641 {
642     sal_uInt16 nTokArrLen = rScTokArr.GetLen();
643     mppScTokenBeg = static_cast< const FormulaToken* const* >( nTokArrLen ? rScTokArr.GetArray() : 0 );
644     mppScTokenEnd = mppScTokenBeg ? (mppScTokenBeg + nTokArrLen) : 0;
645     mppScToken = (mppScTokenBeg != mppScTokenEnd) ? mppScTokenBeg : 0;
646     mbSkipSpaces = bSkipSpaces;
647     SkipSpaces();
648 }
649 
operator ++()650 XclTokenArrayIterator& XclTokenArrayIterator::operator++()
651 {
652     NextRawToken();
653     SkipSpaces();
654     return *this;
655 }
656 
NextRawToken()657 void XclTokenArrayIterator::NextRawToken()
658 {
659     if( mppScToken )
660         if( (++mppScToken == mppScTokenEnd) || !*mppScToken )
661             mppScToken = 0;
662 }
663 
SkipSpaces()664 void XclTokenArrayIterator::SkipSpaces()
665 {
666     if( mbSkipSpaces )
667         while( Is() && ((*this)->GetOpCode() == ocSpaces) )
668             NextRawToken();
669 }
670 
671 // strings and string lists ---------------------------------------------------
672 
GetTokenString(String & rString,const FormulaToken & rScToken)673 bool XclTokenArrayHelper::GetTokenString( String& rString, const FormulaToken& rScToken )
674 {
675     bool bIsStr = (rScToken.GetType() == svString) && (rScToken.GetOpCode() == ocPush);
676     if( bIsStr ) rString = rScToken.GetString();
677     return bIsStr;
678 }
679 
GetString(String & rString,const ScTokenArray & rScTokArr)680 bool XclTokenArrayHelper::GetString( String& rString, const ScTokenArray& rScTokArr )
681 {
682     XclTokenArrayIterator aIt( rScTokArr, true );
683     // something is following the string token -> error
684     return aIt.Is() && GetTokenString( rString, *aIt ) && !++aIt;
685 }
686 
GetStringList(String & rStringList,const ScTokenArray & rScTokArr,sal_Unicode cSep)687 bool XclTokenArrayHelper::GetStringList( String& rStringList, const ScTokenArray& rScTokArr, sal_Unicode cSep )
688 {
689     bool bRet = true;
690     String aString;
691     XclTokenArrayIterator aIt( rScTokArr, true );
692     enum { STATE_START, STATE_STR, STATE_SEP, STATE_END } eState = STATE_START;
693     while( eState != STATE_END ) switch( eState )
694     {
695         case STATE_START:
696             eState = aIt.Is() ? STATE_STR : STATE_END;
697         break;
698         case STATE_STR:
699             bRet = GetTokenString( aString, *aIt );
700             if( bRet ) rStringList.Append( aString );
701             eState = (bRet && (++aIt).Is()) ? STATE_SEP : STATE_END;
702         break;
703         case STATE_SEP:
704             bRet = aIt->GetOpCode() == ocSep;
705             if( bRet ) rStringList.Append( cSep );
706             eState = (bRet && (++aIt).Is()) ? STATE_STR : STATE_END;
707         break;
708         default:;
709     }
710     return bRet;
711 }
712 
ConvertStringToList(ScTokenArray & rScTokArr,sal_Unicode cStringSep,bool bTrimLeadingSpaces)713 void XclTokenArrayHelper::ConvertStringToList( ScTokenArray& rScTokArr, sal_Unicode cStringSep, bool bTrimLeadingSpaces )
714 {
715     String aString;
716     if( GetString( aString, rScTokArr ) )
717     {
718         rScTokArr.Clear();
719         xub_StrLen nTokenCnt = aString.GetTokenCount( cStringSep );
720         xub_StrLen nStringIx = 0;
721         for( xub_StrLen nToken = 0; nToken < nTokenCnt; ++nToken )
722         {
723             String aToken( aString.GetToken( 0, cStringSep, nStringIx ) );
724             if( bTrimLeadingSpaces )
725                 aToken.EraseLeadingChars( ' ' );
726             if( nToken > 0 )
727                 rScTokArr.AddOpCode( ocSep );
728             rScTokArr.AddString( aToken );
729         }
730     }
731 }
732 
733 // shared formulas ------------------------------------------------------------
734 
GetSharedFormula(const XclRoot & rRoot,const ScTokenArray & rScTokArr)735 const ScTokenArray* XclTokenArrayHelper::GetSharedFormula( const XclRoot& rRoot, const ScTokenArray& rScTokArr )
736 {
737     if( rScTokArr.GetLen() == 1 )
738         if( const FormulaToken* pScToken = rScTokArr.GetArray()[ 0 ] )
739             if( pScToken->GetOpCode() == ocName )
740                 if( ScRangeData* pData = rRoot.GetNamedRanges().FindIndex( pScToken->GetIndex() ) )
741                     if( pData->HasType( RT_SHARED ) )
742                         return pData->GetCode();
743     return 0;
744 }
745 
746 // multiple operations --------------------------------------------------------
747 
748 namespace {
749 
lclGetAddress(ScAddress & rAddress,const FormulaToken & rToken)750 inline bool lclGetAddress( ScAddress& rAddress, const FormulaToken& rToken )
751 {
752     OpCode eOpCode = rToken.GetOpCode();
753     bool bIsSingleRef = (eOpCode == ocPush) && (rToken.GetType() == svSingleRef);
754     if( bIsSingleRef )
755     {
756         const ScSingleRefData& rRef = static_cast<const ScToken&>(rToken).GetSingleRef();
757         rAddress.Set( rRef.nCol, rRef.nRow, rRef.nTab );
758         bIsSingleRef = !rRef.IsDeleted();
759     }
760     return bIsSingleRef;
761 }
762 
763 } // namespace
764 
GetMultipleOpRefs(XclMultipleOpRefs & rRefs,const ScTokenArray & rScTokArr)765 bool XclTokenArrayHelper::GetMultipleOpRefs( XclMultipleOpRefs& rRefs, const ScTokenArray& rScTokArr )
766 {
767     rRefs.mbDblRefMode = false;
768     enum
769     {
770         stBegin, stTableOp, stOpen, stFormula, stFormulaSep,
771         stColFirst, stColFirstSep, stColRel, stColRelSep,
772         stRowFirst, stRowFirstSep, stRowRel, stClose, stError
773     } eState = stBegin;     // last read token
774     for( XclTokenArrayIterator aIt( rScTokArr, true ); aIt.Is() && (eState != stError); ++aIt )
775     {
776         OpCode eOpCode = aIt->GetOpCode();
777         bool bIsSep = eOpCode == ocSep;
778         switch( eState )
779         {
780             case stBegin:
781                 eState = (eOpCode == ocTableOp) ? stTableOp : stError;
782             break;
783             case stTableOp:
784                 eState = (eOpCode == ocOpen) ? stOpen : stError;
785             break;
786             case stOpen:
787                 eState = lclGetAddress( rRefs.maFmlaScPos, *aIt ) ? stFormula : stError;
788             break;
789             case stFormula:
790                 eState = bIsSep ? stFormulaSep : stError;
791             break;
792             case stFormulaSep:
793                 eState = lclGetAddress( rRefs.maColFirstScPos, *aIt ) ? stColFirst : stError;
794             break;
795             case stColFirst:
796                 eState = bIsSep ? stColFirstSep : stError;
797             break;
798             case stColFirstSep:
799                 eState = lclGetAddress( rRefs.maColRelScPos, *aIt ) ? stColRel : stError;
800             break;
801             case stColRel:
802                 eState = bIsSep ? stColRelSep : ((eOpCode == ocClose) ? stClose : stError);
803             break;
804             case stColRelSep:
805                 eState = lclGetAddress( rRefs.maRowFirstScPos, *aIt ) ? stRowFirst : stError;
806                 rRefs.mbDblRefMode = true;
807             break;
808             case stRowFirst:
809                 eState = bIsSep ? stRowFirstSep : stError;
810             break;
811             case stRowFirstSep:
812                 eState = lclGetAddress( rRefs.maRowRelScPos, *aIt ) ? stRowRel : stError;
813             break;
814             case stRowRel:
815                 eState = (eOpCode == ocClose) ? stClose : stError;
816             break;
817             default:
818                 eState = stError;
819         }
820     }
821     return eState == stClose;
822 }
823 
824 // ============================================================================
825