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