?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update ooo320-m1
[ooovba.git] / sc / source / core / tool / parclass.cxx
blob7f5a9c82a505a2dbc6d89755d6de469cc63d4d2c
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: parclass.cxx,v $
10 * $Revision: 1.12.148.1 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_sc.hxx"
33
34
35 #include "parclass.hxx"
36 #include "token.hxx"
37 #include "global.hxx"
38 #include "callform.hxx"
39 #include "addincol.hxx"
40 #include "funcdesc.hxx"
41 #include <unotools/charclass.hxx>
42 #include <tools/debug.hxx>
43 #include <string.h>
44
45 #if OSL_DEBUG_LEVEL > 1
46 // the documentation thingy
47 #include <stdio.h>
48 #include <com/sun/star/sheet/FormulaLanguage.hpp>
49 #include "compiler.hxx"
50 #include "sc.hrc" // VAR_ARGS
51 #endif
52
53
54 /* Following assumptions are made:
55 * - OpCodes not specified at all will have at least one and only parameters of
56 * type Value, no check is done on the count of parameters => no Bounds type
57 * is returned.
58 * - For OpCodes with a variable number of parameters the type of the last
59 * parameter specified determines the type of all following parameters.
60 */
61
62 const ScParameterClassification::RawData ScParameterClassification::pRawData[] =
63 {
64 // IF() and CHOOSE() are somewhat special, since the ScJumpMatrix is
65 // created inside those functions and ConvertMatrixParameters() is not
66 // called for them.
67 { ocIf, {{ Array, Reference, Reference }, false }},
68 { ocChose, {{ Array, Reference }, true }},
69 // Other specials.
70 { ocOpen, {{ Bounds }, false }},
71 { ocClose, {{ Bounds }, false }},
72 { ocSep, {{ Bounds }, false }},
73 { ocNoName, {{ Bounds }, false }},
74 { ocErrCell, {{ Bounds }, false }},
75 { ocStop, {{ Bounds }, false }},
76 { ocUnion, {{ Reference, Reference }, false }},
77 { ocRange, {{ Reference, Reference }, false }},
78 // Functions with Value parameters only but not in resource.
79 { ocBackSolver, {{ Value, Value, Value }, false }},
80 { ocTableOp, {{ Value, Value, Value, Value, Value }, false }},
81 // Operators and functions.
82 { ocAdd, {{ Array, Array }, false }},
83 { ocAmpersand, {{ Array, Array }, false }},
84 { ocAnd, {{ Reference }, true }},
85 { ocAreas, {{ Reference }, false }},
86 { ocAveDev, {{ Reference }, true }},
87 { ocAverage, {{ Reference }, true }},
88 { ocAverageA, {{ Reference }, true }},
89 { ocCell, {{ Value, Reference }, false }},
90 { ocColumn, {{ Reference }, false }},
91 { ocColumns, {{ Reference }, true }},
92 { ocCorrel, {{ ForceArray, ForceArray }, false }},
93 { ocCount, {{ Reference }, true }},
94 { ocCount2, {{ Reference }, true }},
95 { ocCountEmptyCells, {{ Reference }, false }},
96 { ocCountIf, {{ Reference, Value }, false }},
97 { ocCovar, {{ ForceArray, ForceArray }, false }},
98 { ocDBAverage, {{ Reference, Reference, Reference }, false }},
99 { ocDBCount, {{ Reference, Reference, Reference }, false }},
100 { ocDBCount2, {{ Reference, Reference, Reference }, false }},
101 { ocDBGet, {{ Reference, Reference, Reference }, false }},
102 { ocDBMax, {{ Reference, Reference, Reference }, false }},
103 { ocDBMin, {{ Reference, Reference, Reference }, false }},
104 { ocDBProduct, {{ Reference, Reference, Reference }, false }},
105 { ocDBStdDev, {{ Reference, Reference, Reference }, false }},
106 { ocDBStdDevP, {{ Reference, Reference, Reference }, false }},
107 { ocDBSum, {{ Reference, Reference, Reference }, false }},
108 { ocDBVar, {{ Reference, Reference, Reference }, false }},
109 { ocDBVarP, {{ Reference, Reference, Reference }, false }},
110 { ocDevSq, {{ Reference }, true }},
111 { ocDiv, {{ Array, Array }, false }},
112 { ocEqual, {{ Array, Array }, false }},
113 { ocForecast, {{ Value, ForceArray, ForceArray }, false }},
114 { ocFrequency, {{ Reference, Reference }, false }},
115 { ocFTest, {{ ForceArray, ForceArray }, false }},
116 { ocGeoMean, {{ Reference }, true }},
117 { ocGCD, {{ Reference }, true }},
118 { ocGreater, {{ Array, Array }, false }},
119 { ocGreaterEqual, {{ Array, Array }, false }},
120 { ocGrowth, {{ Reference, Reference, Reference, Value }, false }},
121 { ocHarMean, {{ Reference }, true }},
122 { ocHLookup, {{ Value, Reference, Value, Value }, false }},
123 { ocIRR, {{ Reference, Value }, false }},
124 { ocIndex, {{ Reference, Value, Value, Value }, false }},
125 { ocIntercept, {{ ForceArray, ForceArray }, false }},
126 { ocIntersect, {{ Reference, Reference }, false }},
127 { ocIsRef, {{ Reference }, false }},
128 { ocLCM, {{ Reference }, true }},
129 { ocKurt, {{ Reference }, true }},
130 { ocLarge, {{ Reference, Value }, false }},
131 { ocLess, {{ Array, Array }, false }},
132 { ocLessEqual, {{ Array, Array }, false }},
133 { ocLookup, {{ Value, ReferenceOrForceArray, ReferenceOrForceArray }, false }},
134 { ocMatch, {{ Value, Reference, Reference }, false }},
135 { ocMatDet, {{ ForceArray }, false }},
136 { ocMatInv, {{ ForceArray }, false }},
137 { ocMatMult, {{ ForceArray, ForceArray }, false }},
138 { ocMatTrans, {{ Array }, false }}, // strange, but Xcl doesn't force MatTrans array
139 { ocMatValue, {{ Reference, Value, Value }, false }},
140 { ocMax, {{ Reference }, true }},
141 { ocMaxA, {{ Reference }, true }},
142 { ocMedian, {{ Reference }, true }},
143 { ocMin, {{ Reference }, true }},
144 { ocMinA, {{ Reference }, true }},
145 { ocMIRR, {{ Reference, Value, Value }, false }},
146 { ocModalValue, {{ ForceArray }, true }},
147 { ocMul, {{ Array, Array }, false }},
148 { ocMultiArea, {{ Reference }, true }},
149 { ocN, {{ Reference }, false }},
150 { ocNPV, {{ Value, Reference }, true }},
151 { ocNeg, {{ Array }, false }},
152 { ocNegSub, {{ Array }, false }},
153 { ocNot, {{ Array }, false }},
154 { ocNotEqual, {{ Array, Array }, false }},
155 { ocOffset, {{ Reference, Value, Value, Value, Value }, false }},
156 { ocOr, {{ Reference }, true }},
157 { ocPearson, {{ ForceArray, ForceArray }, false }},
158 { ocPercentile, {{ Reference, Value }, false }},
159 { ocPercentrank, {{ Reference, Value }, false }},
160 { ocPow, {{ Array, Array }, false }},
161 { ocPower, {{ Array, Array }, false }},
162 { ocProb, {{ ForceArray, ForceArray, Value, Value }, false }},
163 { ocProduct, {{ Reference }, true }},
164 { ocQuartile, {{ Reference, Value }, false }},
165 { ocRank, {{ Value, Reference, Value }, false }},
166 { ocRGP, {{ Reference, Reference, Value, Value }, false }},
167 { ocRKP, {{ Reference, Reference, Value, Value }, false }},
168 { ocRow, {{ Reference }, false }},
169 { ocRows, {{ Reference }, true }},
170 { ocRSQ, {{ ForceArray, ForceArray }, false }},
171 { ocSchiefe, {{ Reference }, true }},
172 { ocSlope, {{ ForceArray, ForceArray }, false }},
173 { ocSmall, {{ Reference, Value }, false }},
174 { ocStDev, {{ Reference }, true }},
175 { ocStDevA, {{ Reference }, true }},
176 { ocStDevP, {{ Reference }, true }},
177 { ocStDevPA, {{ Reference }, true }},
178 { ocSTEYX, {{ ForceArray, ForceArray }, false }},
179 { ocSub, {{ Array, Array }, false }},
180 { ocSubTotal, {{ Value, Reference }, true }},
181 { ocSum, {{ Reference }, true }},
182 { ocSumIf, {{ Reference, Value, Reference }, false }},
183 { ocSumProduct, {{ ForceArray }, true }},
184 { ocSumSQ, {{ Reference }, true }},
185 { ocSumX2MY2, {{ ForceArray, ForceArray }, false }},
186 { ocSumX2DY2, {{ ForceArray, ForceArray }, false }},
187 { ocSumXMY2, {{ ForceArray, ForceArray }, false }},
188 { ocTable, {{ Reference }, false }},
189 { ocTables, {{ Reference }, true }},
190 { ocTrend, {{ Reference, Reference, Reference, Value }, false }},
191 { ocTrimMean, {{ Reference, Value }, false }},
192 { ocTTest, {{ ForceArray, ForceArray, Value, Value }, false }},
193 { ocVar, {{ Reference }, true }},
194 { ocVarA, {{ Reference }, true }},
195 { ocVarP, {{ Reference }, true }},
196 { ocVarPA, {{ Reference }, true }},
197 { ocVLookup, {{ Value, Reference, Value, Value }, false }},
198 { ocZTest, {{ Reference, Value, Value }, false }},
199 // Excel doubts:
200 // ocT: Excel says (and handles) Reference, error? This means no position
201 // dependent SingleRef if DoubleRef, and no array calculation, just the
202 // upper left corner. We never did that.
203 { ocT, {{ Value }, false }},
204 // The stopper.
205 { ocNone, {{ Bounds }, false } }
206 };
207
208 ScParameterClassification::RunData * ScParameterClassification::pData = NULL;
209
210
211 void ScParameterClassification::Init()
212 {
213 if ( pData )
214 return;
215 pData = new RunData[ SC_OPCODE_LAST_OPCODE_ID + 1 ];
216 memset( pData, 0, sizeof(RunData) * (SC_OPCODE_LAST_OPCODE_ID + 1));
217
218 // init from specified static data above
219 for ( size_t i=0; i < sizeof(pRawData) / sizeof(RawData); ++i )
220 {
221 const RawData* pRaw = &pRawData[i];
222 if ( pRaw->eOp > SC_OPCODE_LAST_OPCODE_ID )
223 {
224 DBG_ASSERT( pRaw->eOp == ocNone, "RawData OpCode error");
225 }
226 else
227 {
228 RunData* pRun = &pData[ pRaw->eOp ];
229 #ifdef DBG_UTIL
230 if ( pRun->aData.nParam[0] != Unknown )
231 {
232 DBG_ERROR1( "already assigned: %d", pRaw->eOp);
233 }
234 #endif
235 memcpy( &(pRun->aData), &(pRaw->aData), sizeof(CommonData));
236 // fill 0-initialized fields with real values
237 if ( pRun->aData.bRepeatLast )
238 {
239 Type eLast = Unknown;
240 for ( size_t j=0; j < CommonData::nMaxParams; ++j )
241 {
242 if ( pRun->aData.nParam[j] )
243 {
244 eLast = pRun->aData.nParam[j];
245 pRun->nMinParams = sal::static_int_cast<BYTE>( j+1 );
246 }
247 else
248 pRun->aData.nParam[j] = eLast;
249 }
250 }
251 else
252 {
253 for ( size_t j=0; j < CommonData::nMaxParams; ++j )
254 {
255 if ( !pRun->aData.nParam[j] )
256 {
257 if ( j == 0 || pRun->aData.nParam[j-1] != Bounds )
258 pRun->nMinParams = sal::static_int_cast<BYTE>( j );
259 pRun->aData.nParam[j] = Bounds;
260 }
261 }
262 if ( !pRun->nMinParams &&
263 pRun->aData.nParam[CommonData::nMaxParams-1] != Bounds)
264 pRun->nMinParams = CommonData::nMaxParams;
265 }
266 for ( size_t j=0; j < CommonData::nMaxParams; ++j )
267 {
268 if ( pRun->aData.nParam[j] == ForceArray || pRun->aData.nParam[j] == ReferenceOrForceArray )
269 {
270 pRun->bHasForceArray = true;
271 break; // for
272 }
273 }
274 }
275 }
276
277 #if OSL_DEBUG_LEVEL > 1
278 GenerateDocumentation();
279 #endif
280 }
281
282
283 void ScParameterClassification::Exit()
284 {
285 delete [] pData;
286 pData = NULL;
287 }
288
289
290 ScParameterClassification::Type ScParameterClassification::GetParameterType(
291 const formula::FormulaToken* pToken, USHORT nParameter)
292 {
293 OpCode eOp = pToken->GetOpCode();
294 switch ( eOp )
295 {
296 case ocExternal:
297 return GetExternalParameterType( pToken, nParameter);
298 //break;
299 case ocMacro:
300 return Reference;
301 //break;
302 default:
303 {
304 // added to avoid warnings
305 }
306 }
307 if ( 0 <= (short)eOp && eOp <= SC_OPCODE_LAST_OPCODE_ID )
308 {
309 if ( nParameter < CommonData::nMaxParams )
310 {
311 Type eT = pData[eOp].aData.nParam[nParameter];
312 return eT == Unknown ? Value : eT;
313 }
314 else if ( pData[eOp].aData.bRepeatLast )
315 return pData[eOp].aData.nParam[CommonData::nMaxParams-1];
316 else
317 return Bounds;
318 }
319 return Unknown;
320 }
321
322
323 ScParameterClassification::Type
324 ScParameterClassification::GetExternalParameterType( const formula::FormulaToken* pToken,
325 USHORT nParameter)
326 {
327 Type eRet = Unknown;
328 // similar to ScInterpreter::ScExternal()
329 USHORT nIndex;
330 String aUnoName;
331 String aFuncName( ScGlobal::pCharClass->upper( pToken->GetExternal()));
332 if ( ScGlobal::GetFuncCollection()->SearchFunc( aFuncName, nIndex) )
333 {
334 FuncData* pFuncData = (FuncData*)ScGlobal::GetFuncCollection()->At(
335 nIndex);
336 if ( nParameter >= pFuncData->GetParamCount() )
337 eRet = Bounds;
338 else
339 {
340 switch ( pFuncData->GetParamType( nParameter) )
341 {
342 case PTR_DOUBLE:
343 case PTR_STRING:
344 eRet = Value;
345 break;
346 default:
347 eRet = Reference;
348 // also array types are created using an area reference
349 }
350 }
351 }
352 else if ( (aUnoName = ScGlobal::GetAddInCollection()->FindFunction(
353 aFuncName, FALSE)).Len() )
354 {
355 // the relevant parts of ScUnoAddInCall without having to create one
356 const ScUnoAddInFuncData* pFuncData =
357 ScGlobal::GetAddInCollection()->GetFuncData( aUnoName, true ); // need fully initialized data
358 if ( pFuncData )
359 {
360 long nCount = pFuncData->GetArgumentCount();
361 if ( nCount <= 0 )
362 eRet = Bounds;
363 else
364 {
365 const ScAddInArgDesc* pArgs = pFuncData->GetArguments();
366 if ( nParameter >= nCount &&
367 pArgs[nCount-1].eType == SC_ADDINARG_VARARGS )
368 eRet = Value;
369 // last arg is sequence, optional "any"s, we simply can't
370 // determine the type
371 if ( eRet == Unknown )
372 {
373 if ( nParameter >= nCount )
374 eRet = Bounds;
375 else
376 {
377 switch ( pArgs[nParameter].eType )
378 {
379 case SC_ADDINARG_INTEGER:
380 case SC_ADDINARG_DOUBLE:
381 case SC_ADDINARG_STRING:
382 eRet = Value;
383 break;
384 default:
385 eRet = Reference;
386 }
387 }
388 }
389 }
390 }
391 }
392 return eRet;
393 }
394
395 //-----------------------------------------------------------------------------
396
397 #if OSL_DEBUG_LEVEL > 1
398
399 // add remaining functions, all Value parameters
400 void ScParameterClassification::MergeArgumentsFromFunctionResource()
401 {
402 ScFunctionList* pFuncList = ScGlobal::GetStarCalcFunctionList();
403 for ( const ScFuncDesc* pDesc = pFuncList->First(); pDesc;
404 pDesc = pFuncList->Next() )
405 {
406 if ( pDesc->nFIndex > SC_OPCODE_LAST_OPCODE_ID ||
407 pData[pDesc->nFIndex].aData.nParam[0] != Unknown )
408 continue; // not an internal opcode or already done
409
410 RunData* pRun = &pData[ pDesc->nFIndex ];
411 USHORT nArgs = pDesc->GetSuppressedArgCount();
412 if ( nArgs >= VAR_ARGS )
413 {
414 nArgs -= VAR_ARGS - 1;
415 pRun->aData.bRepeatLast = true;
416 }
417 if ( nArgs > CommonData::nMaxParams )
418 {
419 DBG_ERROR2( "ScParameterClassification::Init: too many arguments in listed function: %s: %d",
420 ByteString( *(pDesc->pFuncName),
421 RTL_TEXTENCODING_UTF8).GetBuffer(), nArgs);
422 nArgs = CommonData::nMaxParams;
423 pRun->aData.bRepeatLast = true;
424 }
425 pRun->nMinParams = static_cast< BYTE >( nArgs );
426 for ( size_t j=0; j < nArgs; ++j )
427 {
428 pRun->aData.nParam[j] = Value;
429 }
430 if ( pRun->aData.bRepeatLast )
431 {
432 for ( size_t j = nArgs; j < CommonData::nMaxParams; ++j )
433 {
434 pRun->aData.nParam[j] = Value;
435 }
436 }
437 else
438 {
439 for ( size_t j = nArgs; j < CommonData::nMaxParams; ++j )
440 {
441 pRun->aData.nParam[j] = Bounds;
442 }
443 }
444 }
445 }
446
447
448 void ScParameterClassification::GenerateDocumentation()
449 {
450 static const sal_Char aEnvVarName[] = "OOO_CALC_GENPARCLASSDOC";
451 if ( !getenv( aEnvVarName) )
452 return;
453 MergeArgumentsFromFunctionResource();
454 ScAddress aAddress;
455 ScCompiler aComp(NULL,aAddress);
456 ScCompiler::OpCodeMapPtr xMap( aComp.GetOpCodeMap(::com::sun::star::sheet::FormulaLanguage::ENGLISH));
457 if (!xMap)
458 return;
459 fflush( stderr);
460 size_t nCount = xMap->getSymbolCount();
461 for ( size_t i=0; i<nCount; ++i )
462 {
463 OpCode eOp = OpCode(i);
464 if ( xMap->getSymbol(eOp).Len() )
465 {
466 fprintf( stdout, "%s: ", aEnvVarName);
467 ByteString aStr( xMap->getSymbol(eOp), RTL_TEXTENCODING_UTF8);
468 aStr += "(";
469 formula::FormulaByteToken aToken( eOp);
470 BYTE nParams = GetMinimumParameters( eOp);
471 // preset parameter count according to opcode value, with some
472 // special handling
473 if ( eOp < SC_OPCODE_STOP_DIV )
474 {
475 switch ( eOp )
476 {
477 case ocIf:
478 aToken.SetByte(3);
479 break;
480 case ocChose:
481 aToken.SetByte(2);
482 break;
483 case ocPercentSign:
484 aToken.SetByte(1);
485 break;
486 default:;
487 }
488 }
489 else if ( eOp < SC_OPCODE_STOP_ERRORS )
490 aToken.SetByte(0);
491 else if ( eOp < SC_OPCODE_STOP_BIN_OP )
492 {
493 switch ( eOp )
494 {
495 case ocAnd:
496 case ocOr:
497 aToken.SetByte(1); // (r1)AND(r2) --> AND( r1, ...)
498 break;
499 default:
500 aToken.SetByte(2);
501 }
502 }
503 else if ( eOp < SC_OPCODE_STOP_UN_OP )
504 aToken.SetByte(1);
505 else if ( eOp < SC_OPCODE_STOP_NO_PAR )
506 aToken.SetByte(0);
507 else if ( eOp < SC_OPCODE_STOP_1_PAR )
508 aToken.SetByte(1);
509 else
510 aToken.SetByte( nParams);
511 // compare (this is a mere test for opcode order Div, BinOp, UnOp,
512 // NoPar, 1Par, ...) and override parameter count with
513 // classification
514 if ( nParams != aToken.GetByte() )
515 fprintf( stdout, "(parameter count differs, token Byte: %d classification: %d) ",
516 aToken.GetByte(), nParams);
517 aToken.SetByte( nParams);
518 if ( nParams != aToken.GetParamCount() )
519 fprintf( stdout, "(parameter count differs, token ParamCount: %d classification: %d) ",
520 aToken.GetParamCount(), nParams);
521 for ( USHORT j=0; j < nParams; ++j )
522 {
523 if ( j > 0 )
524 aStr += ",";
525 Type eType = GetParameterType( &aToken, j);
526 switch ( eType )
527 {
528 case Value :
529 aStr += " Value";
530 break;
531 case Reference :
532 aStr += " Reference";
533 break;
534 case Array :
535 aStr += " Array";
536 break;
537 case ForceArray :
538 aStr += " ForceArray";
539 break;
540 case ReferenceOrForceArray :
541 aStr += " ReferenceOrForceArray";
542 break;
543 case Bounds :
544 aStr += " (Bounds, classification error?)";
545 break;
546 default:
547 aStr += " (???, classification error?)";
548 }
549 }
550 if ( HasRepeatParameters( eOp) )
551 aStr += ", ...";
552 if ( nParams )
553 aStr += " ";
554 aStr += ")";
555 switch ( eOp )
556 {
557 case ocZGZ:
558 aStr += " // RRI in English resource, but ZGZ in English-only section";
559 break;
560 case ocMultiArea:
561 aStr += " // e.g. combined first parameter of INDEX() function, not a real function";
562 break;
563 case ocBackSolver:
564 aStr += " // goal seek via menu, not a real function";
565 break;
566 case ocTableOp:
567 aStr += " // MULTIPLE.OPERATIONS in English resource, but TABLE in English-only section";
568 break;
569 case ocNoName:
570 aStr += " // error function, not a real function";
571 break;
572 default:;
573 }
574 fprintf( stdout, "%s\n", aStr.GetBuffer());
575 }
576 }
577 fflush( stdout);
578 }
579
580 #endif // OSL_DEBUG_LEVEL
581
vba interoperability for OOo