Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include "funcdesc.hxx"
21 :
22 : #include "addincol.hxx"
23 : #include "appoptio.hxx"
24 : #include "callform.hxx"
25 : #include "compiler.hxx"
26 : #include "global.hxx"
27 : #include "sc.hrc"
28 : #include "scmod.hxx"
29 : #include "scresid.hxx"
30 :
31 : #include <rtl/ustring.hxx>
32 : #include <rtl/ustrbuf.hxx>
33 : #include <tools/rcid.h>
34 : #include <tools/resid.hxx>
35 : #include <unotools/collatorwrapper.hxx>
36 :
37 : #include <numeric>
38 : #include <boost/scoped_ptr.hpp>
39 :
40 1452 : class ScFuncRes : public Resource
41 : {
42 : public:
43 : ScFuncRes( ResId&, ScFuncDesc*, bool & rbSuppressed );
44 :
45 : private:
46 : sal_uInt16 GetNum();
47 : };
48 :
49 : class ScResourcePublisher : public Resource
50 : {
51 : private:
52 30 : void FreeResource() { Resource::FreeResource(); }
53 : public:
54 30 : ScResourcePublisher( const ScResId& rId ) : Resource( rId ) {}
55 30 : ~ScResourcePublisher() { FreeResource(); }
56 3776 : bool IsAvailableRes( const ResId& rId ) const
57 3776 : { return Resource::IsAvailableRes( rId ); }
58 :
59 : };
60 :
61 : // class ScFuncDesc:
62 :
63 1902 : ScFuncDesc::ScFuncDesc() :
64 : pFuncName (NULL),
65 : pFuncDesc (NULL),
66 : pDefArgFlags (NULL),
67 : nFIndex (0),
68 : nCategory (0),
69 : nArgCount (0),
70 : bIncomplete (false),
71 1902 : bHasSuppressedArgs(false)
72 1902 : {}
73 :
74 3456 : ScFuncDesc::~ScFuncDesc()
75 : {
76 1152 : Clear();
77 2304 : }
78 :
79 1402 : void ScFuncDesc::Clear()
80 : {
81 1402 : sal_uInt16 nArgs = nArgCount;
82 1402 : if (nArgs >= PAIRED_VAR_ARGS)
83 6 : nArgs -= PAIRED_VAR_ARGS - 2;
84 1396 : else if (nArgs >= VAR_ARGS)
85 100 : nArgs -= VAR_ARGS - 1;
86 1402 : if (nArgs)
87 : {
88 936 : delete [] pDefArgFlags;
89 : }
90 1402 : nArgCount = 0;
91 1402 : maDefArgNames.clear();
92 1402 : maDefArgDescs.clear();
93 1402 : pDefArgFlags = NULL;
94 :
95 1402 : delete pFuncName;
96 1402 : pFuncName = NULL;
97 :
98 1402 : delete pFuncDesc;
99 1402 : pFuncDesc = NULL;
100 :
101 1402 : nFIndex = 0;
102 1402 : nCategory = 0;
103 1402 : sHelpId = OString();
104 1402 : bIncomplete = false;
105 1402 : bHasSuppressedArgs = false;
106 1402 : }
107 :
108 0 : OUString ScFuncDesc::GetParamList() const
109 : {
110 0 : OUString sep(ScCompiler::GetNativeSymbol(ocSep));
111 :
112 0 : OUStringBuffer aSig;
113 :
114 0 : if ( nArgCount > 0 )
115 : {
116 0 : if ( nArgCount < VAR_ARGS )
117 : {
118 0 : sal_uInt16 nLastSuppressed = nArgCount;
119 0 : sal_uInt16 nLastAdded = nArgCount;
120 0 : for ( sal_uInt16 i=0; i<nArgCount; i++ )
121 : {
122 0 : if (pDefArgFlags[i].bSuppress)
123 0 : nLastSuppressed = i;
124 : else
125 : {
126 0 : nLastAdded = i;
127 0 : aSig.append(maDefArgNames[i]);
128 0 : if ( i != nArgCount-1 )
129 : {
130 0 : aSig.append(sep);
131 0 : aSig.appendAscii( " " );
132 : }
133 : }
134 : }
135 : // If only suppressed parameters follow the last added parameter,
136 : // remove one "; "
137 0 : if (nLastSuppressed < nArgCount && nLastAdded < nLastSuppressed &&
138 0 : aSig.getLength() >= 2)
139 0 : aSig.setLength(aSig.getLength() - 2);
140 : }
141 0 : else if ( nArgCount < PAIRED_VAR_ARGS)
142 : {
143 0 : sal_uInt16 nFix = nArgCount - VAR_ARGS;
144 0 : for ( sal_uInt16 nArg = 0; nArg < nFix; nArg++ )
145 : {
146 0 : if (!pDefArgFlags[nArg].bSuppress)
147 : {
148 0 : aSig.append(maDefArgNames[nArg]);
149 0 : aSig.append(sep);
150 0 : aSig.appendAscii( " " );
151 : }
152 : }
153 : /* NOTE: Currently there are no suppressed var args parameters. If
154 : * there were, we'd have to cope with it here and above for the fix
155 : * parameters. For now parameters are always added, so no special
156 : * treatment of a trailing "; " necessary. */
157 0 : aSig.append(maDefArgNames[nFix]);
158 0 : aSig.append('1');
159 0 : aSig.append(sep);
160 0 : aSig.append(' ');
161 0 : aSig.append(maDefArgNames[nFix]);
162 0 : aSig.append('2');
163 0 : aSig.append(sep);
164 0 : aSig.appendAscii(" ... ");
165 : }
166 : else
167 : {
168 0 : sal_uInt16 nFix = nArgCount - PAIRED_VAR_ARGS;
169 0 : for ( sal_uInt16 nArg = 0; nArg < nFix; nArg++ )
170 : {
171 0 : if (!pDefArgFlags[nArg].bSuppress)
172 : {
173 0 : aSig.append(maDefArgNames[nArg]);
174 0 : aSig.append(sep);
175 0 : aSig.appendAscii( " " );
176 : }
177 : }
178 :
179 0 : aSig.append(maDefArgNames[nFix]);
180 0 : aSig.append('1');
181 0 : aSig.append(sep);
182 0 : aSig.append(maDefArgNames[nFix+1]);
183 0 : aSig.append('1');
184 0 : aSig.append(sep);
185 0 : aSig.appendAscii( " " );
186 0 : aSig.append(maDefArgNames[nFix]);
187 0 : aSig.append('2');
188 0 : aSig.append(sep);
189 0 : aSig.append(maDefArgNames[nFix+1]);
190 0 : aSig.append('2');
191 0 : aSig.append(sep);
192 0 : aSig.appendAscii( " ... " );
193 : }
194 : }
195 :
196 0 : return aSig.makeStringAndClear();
197 : }
198 :
199 0 : OUString ScFuncDesc::getSignature() const
200 : {
201 0 : OUStringBuffer aSig;
202 :
203 0 : if(pFuncName)
204 : {
205 0 : aSig.append(*pFuncName);
206 :
207 0 : OUString aParamList = GetParamList();
208 0 : if( !aParamList.isEmpty() )
209 : {
210 0 : aSig.appendAscii( "( " );
211 0 : aSig.append(aParamList);
212 : // U+00A0 (NBSP) prevents automatic line break
213 0 : aSig.append( static_cast< sal_Unicode >(0xA0) );
214 0 : aSig.appendAscii( ")" );
215 : }
216 : else
217 0 : aSig.appendAscii( "()" );
218 : }
219 0 : return aSig.makeStringAndClear();
220 : }
221 :
222 0 : OUString ScFuncDesc::getFormula( const ::std::vector< OUString >& _aArguments ) const
223 : {
224 0 : OUString sep = ScCompiler::GetNativeSymbol(ocSep);
225 :
226 0 : OUStringBuffer aFormula;
227 :
228 0 : if(pFuncName)
229 : {
230 0 : aFormula.append( *pFuncName );
231 :
232 0 : aFormula.appendAscii( "(" );
233 0 : if ( nArgCount > 0 && !_aArguments.empty() && !_aArguments[0].isEmpty())
234 : {
235 0 : ::std::vector< OUString >::const_iterator aIter = _aArguments.begin();
236 0 : ::std::vector< OUString >::const_iterator aEnd = _aArguments.end();
237 :
238 0 : aFormula.append( *aIter );
239 0 : ++aIter;
240 0 : while( aIter != aEnd && !aIter->isEmpty() )
241 : {
242 0 : aFormula.append( sep );
243 0 : aFormula.append( *aIter );
244 0 : ++aIter;
245 : }
246 : }
247 :
248 0 : aFormula.appendAscii( ")" );
249 : }
250 0 : return aFormula.makeStringAndClear();
251 : }
252 :
253 948 : sal_uInt16 ScFuncDesc::GetSuppressedArgCount() const
254 : {
255 948 : if (!bHasSuppressedArgs || !pDefArgFlags)
256 948 : return nArgCount;
257 :
258 0 : sal_uInt16 nArgs = nArgCount;
259 0 : if (nArgs >= PAIRED_VAR_ARGS)
260 0 : nArgs -= PAIRED_VAR_ARGS - 2;
261 0 : else if (nArgs >= VAR_ARGS)
262 0 : nArgs -= VAR_ARGS - 1;
263 0 : sal_uInt16 nCount = nArgs;
264 0 : for (sal_uInt16 i=0; i < nArgs; ++i)
265 : {
266 0 : if (pDefArgFlags[i].bSuppress)
267 0 : --nCount;
268 : }
269 0 : if (nArgCount >= PAIRED_VAR_ARGS)
270 0 : nCount += PAIRED_VAR_ARGS - 2;
271 0 : else if (nArgCount >= VAR_ARGS)
272 0 : nCount += VAR_ARGS - 1;
273 0 : return nCount;
274 : }
275 :
276 750 : OUString ScFuncDesc::getFunctionName() const
277 : {
278 750 : OUString sRet;
279 750 : if ( pFuncName )
280 750 : sRet = *pFuncName;
281 750 : return sRet;
282 : }
283 :
284 0 : const formula::IFunctionCategory* ScFuncDesc::getCategory() const
285 : {
286 0 : return ScGlobal::GetStarCalcFunctionMgr()->getCategory(nCategory);
287 : }
288 :
289 0 : OUString ScFuncDesc::getDescription() const
290 : {
291 0 : OUString sRet;
292 0 : if ( pFuncDesc )
293 0 : sRet = *pFuncDesc;
294 0 : return sRet;
295 : }
296 :
297 0 : sal_Int32 ScFuncDesc::getSuppressedArgumentCount() const
298 : {
299 0 : return GetSuppressedArgCount();
300 : }
301 :
302 0 : void ScFuncDesc::fillVisibleArgumentMapping(::std::vector<sal_uInt16>& _rArguments) const
303 : {
304 0 : if (!bHasSuppressedArgs || !pDefArgFlags)
305 : {
306 0 : _rArguments.resize( nArgCount);
307 0 : ::std::vector<sal_uInt16>::iterator iter = _rArguments.begin();
308 0 : sal_uInt16 value = 0;
309 0 : while (iter != _rArguments.end())
310 0 : *iter++ = value++;
311 : }
312 :
313 0 : _rArguments.reserve( nArgCount);
314 0 : sal_uInt16 nArgs = nArgCount;
315 0 : if (nArgs >= PAIRED_VAR_ARGS)
316 0 : nArgs -= PAIRED_VAR_ARGS - 2;
317 0 : else if (nArgs >= VAR_ARGS)
318 0 : nArgs -= VAR_ARGS - 1;
319 0 : for (sal_uInt16 i=0; i < nArgs; ++i)
320 : {
321 0 : if (!pDefArgFlags || !pDefArgFlags[i].bSuppress)
322 0 : _rArguments.push_back(i);
323 : }
324 0 : }
325 :
326 964 : void ScFuncDesc::initArgumentInfo() const
327 : {
328 : // get the full argument description
329 : // (add-in has to be instantiated to get the type information)
330 :
331 964 : if ( bIncomplete && pFuncName )
332 : {
333 0 : ScUnoAddInCollection& rAddIns = *ScGlobal::GetAddInCollection();
334 0 : OUString aIntName(rAddIns.FindFunction( *pFuncName, true )); // pFuncName is upper-case
335 :
336 0 : if ( !aIntName.isEmpty() )
337 : {
338 : // GetFuncData with bComplete=true loads the component and updates
339 : // the global function list if needed.
340 :
341 0 : rAddIns.GetFuncData( aIntName, true );
342 : }
343 :
344 0 : if ( bIncomplete )
345 : {
346 : OSL_FAIL( "couldn't initialize add-in function" );
347 0 : const_cast<ScFuncDesc*>(this)->bIncomplete = false; // even if there was an error, don't try again
348 0 : }
349 : }
350 964 : }
351 :
352 0 : OString ScFuncDesc::getHelpId() const
353 : {
354 0 : return sHelpId;
355 : }
356 :
357 0 : sal_uInt32 ScFuncDesc::getParameterCount() const
358 : {
359 0 : return nArgCount;
360 : }
361 :
362 0 : OUString ScFuncDesc::getParameterName(sal_uInt32 _nPos) const
363 : {
364 0 : return maDefArgNames[_nPos];
365 : }
366 :
367 0 : OUString ScFuncDesc::getParameterDescription(sal_uInt32 _nPos) const
368 : {
369 0 : return maDefArgDescs[_nPos];
370 : }
371 :
372 0 : bool ScFuncDesc::isParameterOptional(sal_uInt32 _nPos) const
373 : {
374 0 : return pDefArgFlags[_nPos].bOptional;
375 : }
376 :
377 7858 : bool ScFuncDesc::compareByName(const ScFuncDesc* a, const ScFuncDesc* b)
378 : {
379 7858 : return (ScGlobal::GetCaseCollator()->compareString(*a->pFuncName, *b->pFuncName ) < 0);
380 : }
381 :
382 : // class ScFunctionList:
383 :
384 4 : ScFunctionList::ScFunctionList() :
385 4 : nMaxFuncNameLen ( 0 )
386 : {
387 4 : ScFuncDesc* pDesc = NULL;
388 4 : sal_Int32 nStrLen = 0;
389 4 : ::std::list<ScFuncDesc*> tmpFuncList;
390 : sal_uInt16 nDescBlock[] =
391 : {
392 : RID_SC_FUNCTION_DESCRIPTIONS1,
393 : RID_SC_FUNCTION_DESCRIPTIONS2
394 4 : };
395 :
396 12 : for (sal_uInt16 k = 0; k < SAL_N_ELEMENTS(nDescBlock); ++k)
397 : {
398 8 : boost::scoped_ptr<ScResourcePublisher> pBlock( new ScResourcePublisher( ScResId( nDescBlock[k] ) ) );
399 : // Browse for all possible OpCodes. This is not the fastest method, but
400 : // otherwise the sub resources within the resource blocks and the
401 : // resource blocks themselfs would had to be ordered according to
402 : // OpCodes, which is utopian..
403 3784 : for (sal_uInt16 i = 0; i <= SC_OPCODE_LAST_OPCODE_ID; ++i)
404 : {
405 3776 : ScResId aRes(i);
406 3776 : aRes.SetRT(RSC_RESOURCE);
407 : // Sub resource of OpCode available?
408 3776 : if (pBlock->IsAvailableRes(aRes))
409 : {
410 1452 : pDesc = new ScFuncDesc;
411 1452 : bool bSuppressed = false;
412 1452 : ScFuncRes aSubRes( aRes, pDesc, bSuppressed);
413 : // Instead of dealing with this exceptional case at 1001 places
414 : // we simply don't add an entirely suppressed function to the
415 : // list and delete it.
416 1452 : if (bSuppressed)
417 0 : delete pDesc;
418 : else
419 : {
420 1452 : pDesc->nFIndex = i;
421 1452 : tmpFuncList.push_back(pDesc);
422 :
423 1452 : nStrLen = (*(pDesc->pFuncName)).getLength();
424 1452 : if (nStrLen > nMaxFuncNameLen)
425 28 : nMaxFuncNameLen = nStrLen;
426 1452 : }
427 : }
428 : }
429 8 : }
430 :
431 4 : sal_uInt16 nNextId = SC_OPCODE_LAST_OPCODE_ID + 1; // FuncID for AddIn functions
432 :
433 : // Interpretation of AddIn list
434 8 : OUString aDefArgNameValue = "value";
435 8 : OUString aDefArgNameString = "string";
436 8 : OUString aDefArgNameValues = "values";
437 8 : OUString aDefArgNameStrings = "strings";
438 8 : OUString aDefArgNameCells = "cells";
439 8 : OUString aDefArgNameNone = "none";
440 8 : OUString aDefArgDescValue = "a value";
441 8 : OUString aDefArgDescString = "a string";
442 8 : OUString aDefArgDescValues = "array of values";
443 8 : OUString aDefArgDescStrings = "array of strings";
444 8 : OUString aDefArgDescCells = "range of cells";
445 8 : OUString aDefArgDescNone = "none";
446 :
447 8 : OUString aArgName, aArgDesc;
448 4 : const FuncCollection& rFuncColl = *ScGlobal::GetFuncCollection();
449 4 : FuncCollection::const_iterator it = rFuncColl.begin(), itEnd = rFuncColl.end();
450 4 : for (; it != itEnd; ++it)
451 : {
452 0 : const FuncData* pAddInFuncData = it->second;
453 0 : pDesc = new ScFuncDesc;
454 0 : sal_uInt16 nArgs = pAddInFuncData->GetParamCount() - 1;
455 0 : pAddInFuncData->getParamDesc( aArgName, aArgDesc, 0 );
456 0 : pDesc->nFIndex = nNextId++; // ??? OpCode vergeben
457 0 : pDesc->nCategory = ID_FUNCTION_GRP_ADDINS;
458 0 : pDesc->pFuncName = new OUString(pAddInFuncData->GetInternalName().toAsciiUpperCase());
459 :
460 0 : OUStringBuffer aBuf(aArgDesc);
461 0 : aBuf.append('\n');
462 0 : aBuf.appendAscii("( AddIn: ");
463 0 : aBuf.append(pAddInFuncData->GetModuleName());
464 0 : aBuf.appendAscii(" )");
465 0 : pDesc->pFuncDesc = new OUString(aBuf.makeStringAndClear());
466 :
467 0 : pDesc->nArgCount = nArgs;
468 0 : if (nArgs)
469 : {
470 0 : pDesc->maDefArgNames.clear();
471 0 : pDesc->maDefArgNames.resize(nArgs);
472 0 : pDesc->maDefArgDescs.clear();
473 0 : pDesc->maDefArgDescs.resize(nArgs);
474 0 : pDesc->pDefArgFlags = new ScFuncDesc::ParameterFlags[nArgs];
475 0 : for (sal_uInt16 j = 0; j < nArgs; ++j)
476 : {
477 0 : pDesc->pDefArgFlags[j].bOptional = false;
478 0 : pDesc->pDefArgFlags[j].bSuppress = false;
479 0 : pAddInFuncData->getParamDesc( aArgName, aArgDesc, j+1 );
480 0 : if ( !aArgName.isEmpty() )
481 0 : pDesc->maDefArgNames[j] = aArgName;
482 : else
483 : {
484 0 : switch (pAddInFuncData->GetParamType(j+1))
485 : {
486 : case ParamType::PTR_DOUBLE:
487 0 : pDesc->maDefArgNames[j] = aDefArgNameValue;
488 0 : break;
489 : case ParamType::PTR_STRING:
490 0 : pDesc->maDefArgNames[j] = aDefArgNameString;
491 0 : break;
492 : case ParamType::PTR_DOUBLE_ARR:
493 0 : pDesc->maDefArgNames[j] = aDefArgNameValues;
494 0 : break;
495 : case ParamType::PTR_STRING_ARR:
496 0 : pDesc->maDefArgNames[j] = aDefArgNameStrings;
497 0 : break;
498 : case ParamType::PTR_CELL_ARR:
499 0 : pDesc->maDefArgNames[j] = aDefArgNameCells;
500 0 : break;
501 : default:
502 0 : pDesc->maDefArgNames[j] = aDefArgNameNone;
503 0 : break;
504 : }
505 : }
506 0 : if ( !aArgDesc.isEmpty() )
507 0 : pDesc->maDefArgDescs[j] = aArgDesc;
508 : else
509 : {
510 0 : switch (pAddInFuncData->GetParamType(j+1))
511 : {
512 : case ParamType::PTR_DOUBLE:
513 0 : pDesc->maDefArgDescs[j] = aDefArgDescValue;
514 0 : break;
515 : case ParamType::PTR_STRING:
516 0 : pDesc->maDefArgDescs[j] = aDefArgDescString;
517 0 : break;
518 : case ParamType::PTR_DOUBLE_ARR:
519 0 : pDesc->maDefArgDescs[j] = aDefArgDescValues;
520 0 : break;
521 : case ParamType::PTR_STRING_ARR:
522 0 : pDesc->maDefArgDescs[j] = aDefArgDescStrings;
523 0 : break;
524 : case ParamType::PTR_CELL_ARR:
525 0 : pDesc->maDefArgDescs[j] = aDefArgDescCells;
526 0 : break;
527 : default:
528 0 : pDesc->maDefArgDescs[j] = aDefArgDescNone;
529 0 : break;
530 : }
531 : }
532 : }
533 : }
534 :
535 0 : tmpFuncList.push_back(pDesc);
536 0 : nStrLen = (*(pDesc->pFuncName)).getLength();
537 0 : if ( nStrLen > nMaxFuncNameLen)
538 0 : nMaxFuncNameLen = nStrLen;
539 0 : }
540 :
541 : // StarOne AddIns
542 :
543 4 : ScUnoAddInCollection* pUnoAddIns = ScGlobal::GetAddInCollection();
544 4 : long nUnoCount = pUnoAddIns->GetFuncCount();
545 454 : for (long nFunc=0; nFunc<nUnoCount; nFunc++)
546 : {
547 450 : pDesc = new ScFuncDesc;
548 450 : pDesc->nFIndex = nNextId++;
549 :
550 450 : if ( pUnoAddIns->FillFunctionDesc( nFunc, *pDesc ) )
551 : {
552 250 : tmpFuncList.push_back(pDesc);
553 250 : nStrLen = (*(pDesc->pFuncName)).getLength();
554 250 : if (nStrLen > nMaxFuncNameLen)
555 0 : nMaxFuncNameLen = nStrLen;
556 : }
557 : else
558 200 : delete pDesc;
559 : }
560 :
561 : //Move list to vector for better random access performance
562 4 : ::std::vector<const ScFuncDesc*> tmp(tmpFuncList.begin(), tmpFuncList.end());
563 4 : tmpFuncList.clear();
564 4 : aFunctionList.swap(tmp);
565 :
566 : //Initialize iterator
567 8 : aFunctionListIter = aFunctionList.end();
568 4 : }
569 :
570 4 : ScFunctionList::~ScFunctionList()
571 : {
572 2 : const ScFuncDesc* pDesc = First();
573 956 : while (pDesc)
574 : {
575 952 : delete pDesc;
576 952 : pDesc = Next();
577 : }
578 2 : }
579 :
580 4 : const ScFuncDesc* ScFunctionList::First()
581 : {
582 4 : const ScFuncDesc* pDesc = NULL;
583 4 : aFunctionListIter = aFunctionList.begin();
584 4 : if(aFunctionListIter != aFunctionList.end())
585 4 : pDesc = *aFunctionListIter;
586 :
587 4 : return pDesc;
588 : }
589 :
590 1702 : const ScFuncDesc* ScFunctionList::Next()
591 : {
592 1702 : const ScFuncDesc* pDesc = NULL;
593 1702 : if(aFunctionListIter != aFunctionList.end())
594 : {
595 1702 : if((++aFunctionListIter) != aFunctionList.end())
596 1698 : pDesc = *aFunctionListIter;
597 : }
598 1702 : return pDesc;
599 : }
600 :
601 5174 : const ScFuncDesc* ScFunctionList::GetFunction( sal_uInt32 nIndex ) const
602 : {
603 5174 : const ScFuncDesc* pDesc = NULL;
604 5174 : if(nIndex < aFunctionList.size())
605 5174 : pDesc = aFunctionList.at(nIndex);
606 :
607 5174 : return pDesc;
608 : }
609 :
610 : // class ScFunctionCategory:
611 :
612 22 : sal_uInt32 ScFunctionCategory::getCount() const
613 : {
614 22 : return m_pCategory->size();
615 : }
616 :
617 0 : const formula::IFunctionManager* ScFunctionCategory::getFunctionManager() const
618 : {
619 0 : return m_pMgr;
620 : }
621 :
622 22 : OUString ScFunctionCategory::getName() const
623 : {
624 22 : if ( m_sName.isEmpty() )
625 22 : m_sName = ScFunctionMgr::GetCategoryName(m_nCategory+1);
626 22 : return m_sName;
627 : }
628 :
629 750 : const formula::IFunctionDescription* ScFunctionCategory::getFunction(sal_uInt32 _nPos) const
630 : {
631 750 : const ScFuncDesc* pDesc = NULL;
632 750 : if(_nPos < m_pCategory->size())
633 750 : pDesc = m_pCategory->at(_nPos);
634 750 : return pDesc;
635 : }
636 :
637 0 : sal_uInt32 ScFunctionCategory::getNumber() const
638 : {
639 0 : return m_nCategory;
640 : }
641 :
642 : // class ScFunctionMgr:
643 :
644 2 : ScFunctionMgr::ScFunctionMgr() :
645 2 : pFuncList( ScGlobal::GetStarCalcFunctionList() )
646 : {
647 : OSL_ENSURE( pFuncList, "Functionlist not found." );
648 2 : sal_uInt32 catCount[MAX_FUNCCAT] = {0};
649 :
650 2 : aCatLists[0] = new ::std::vector<const ScFuncDesc*>();
651 2 : aCatLists[0]->reserve(pFuncList->GetCount());
652 :
653 : // Retrieve all functions, store in cumulative ("All") category, and count
654 : // number of functions in each category
655 752 : for(const ScFuncDesc* pDesc = pFuncList->First(); pDesc; pDesc = pFuncList->Next())
656 : {
657 : OSL_ENSURE((pDesc->nCategory) < MAX_FUNCCAT, "Unknown category");
658 750 : if ((pDesc->nCategory) < MAX_FUNCCAT)
659 750 : ++catCount[pDesc->nCategory];
660 750 : aCatLists[0]->push_back(pDesc);
661 : }
662 :
663 : // Sort functions in cumulative category by name
664 2 : ::std::sort(aCatLists[0]->begin(), aCatLists[0]->end(), ScFuncDesc::compareByName);
665 :
666 : // Allocate correct amount of space for categories
667 24 : for (sal_uInt16 i = 1; i < MAX_FUNCCAT; ++i)
668 : {
669 22 : aCatLists[i] = new ::std::vector<const ScFuncDesc*>();
670 22 : aCatLists[i]->reserve(catCount[i]);
671 : }
672 :
673 : // Fill categories with the corresponding functions (still sorted by name)
674 752 : for(::std::vector<const ScFuncDesc*>::iterator iter = aCatLists[0]->begin(); iter!=aCatLists[0]->end(); ++iter)
675 : {
676 750 : if (((*iter)->nCategory) < MAX_FUNCCAT)
677 750 : aCatLists[(*iter)->nCategory]->push_back(*iter);
678 : }
679 :
680 : // Initialize iterators
681 2 : pCurCatListIter = aCatLists[0]->end();
682 2 : pCurCatListEnd = aCatLists[0]->end();
683 2 : }
684 :
685 0 : ScFunctionMgr::~ScFunctionMgr()
686 : {
687 0 : for (sal_uInt16 i = 0; i < MAX_FUNCCAT; ++i)
688 0 : delete aCatLists[i];
689 0 : }
690 :
691 0 : const ScFuncDesc* ScFunctionMgr::Get( const OUString& rFName ) const
692 : {
693 0 : const ScFuncDesc* pDesc = NULL;
694 0 : if (rFName.getLength() <= pFuncList->GetMaxFuncNameLen())
695 : {
696 0 : ::boost::scoped_ptr<ScFuncDesc> dummy(new ScFuncDesc);
697 0 : dummy->pFuncName = new OUString(rFName);
698 : ::std::vector<const ScFuncDesc*>::iterator lower =
699 0 : ::std::lower_bound(aCatLists[0]->begin(), aCatLists[0]->end(),
700 0 : static_cast<const ScFuncDesc*>(dummy.get()), ScFuncDesc::compareByName);
701 :
702 0 : if(rFName.equalsIgnoreAsciiCase(*(*lower)->pFuncName))
703 0 : pDesc = *lower;
704 : }
705 0 : return pDesc;
706 : }
707 :
708 0 : const ScFuncDesc* ScFunctionMgr::Get( sal_uInt16 nFIndex ) const
709 : {
710 : const ScFuncDesc* pDesc;
711 0 : for (pDesc = First(0); pDesc; pDesc = Next())
712 0 : if (pDesc->nFIndex == nFIndex)
713 0 : break;
714 0 : return pDesc;
715 : }
716 :
717 0 : const ScFuncDesc* ScFunctionMgr::First( sal_uInt16 nCategory ) const
718 : {
719 : OSL_ENSURE( nCategory < MAX_FUNCCAT, "Unknown category" );
720 0 : const ScFuncDesc* pDesc = NULL;
721 0 : if ( nCategory < MAX_FUNCCAT )
722 : {
723 0 : pCurCatListIter = aCatLists[nCategory]->begin();
724 0 : pCurCatListEnd = aCatLists[nCategory]->end();
725 0 : pDesc = *pCurCatListIter;
726 : }
727 : else
728 : {
729 0 : pCurCatListIter = aCatLists[0]->end();
730 0 : pCurCatListEnd = aCatLists[0]->end();
731 : }
732 0 : return pDesc;
733 : }
734 :
735 0 : const ScFuncDesc* ScFunctionMgr::Next() const
736 : {
737 0 : const ScFuncDesc* pDesc = NULL;
738 0 : if ( pCurCatListIter != pCurCatListEnd )
739 : {
740 0 : if ( (++pCurCatListIter) != pCurCatListEnd )
741 : {
742 0 : pDesc = *pCurCatListIter;
743 : }
744 : }
745 0 : return pDesc;
746 : }
747 :
748 2 : sal_uInt32 ScFunctionMgr::getCount() const
749 : {
750 2 : return MAX_FUNCCAT - 1;
751 : }
752 :
753 22 : const formula::IFunctionCategory* ScFunctionMgr::getCategory(sal_uInt32 nCategory) const
754 : {
755 22 : formula::IFunctionCategory* pRet = NULL;
756 22 : if ( nCategory < (MAX_FUNCCAT-1) )
757 : {
758 22 : pRet = new ScFunctionCategory(const_cast<ScFunctionMgr*>(this),aCatLists[nCategory+1],nCategory); // aCatLists[0] is "all"
759 : }
760 22 : return pRet;
761 : }
762 :
763 0 : const formula::IFunctionDescription* ScFunctionMgr::getFunctionByName(const OUString& _sFunctionName) const
764 : {
765 0 : return Get(_sFunctionName);
766 : }
767 :
768 0 : void ScFunctionMgr::fillLastRecentlyUsedFunctions(::std::vector< const formula::IFunctionDescription*>& _rLastRUFunctions) const
769 : {
770 0 : const ScAppOptions& rAppOpt = SC_MOD()->GetAppOptions();
771 0 : sal_uInt16 nLRUFuncCount = std::min( rAppOpt.GetLRUFuncListCount(), (sal_uInt16)LRU_MAX );
772 0 : sal_uInt16* pLRUListIds = rAppOpt.GetLRUFuncList();
773 :
774 0 : if ( pLRUListIds )
775 : {
776 0 : for (sal_uInt16 i = 0; i < nLRUFuncCount; ++i)
777 0 : _rLastRUFunctions.push_back( Get( pLRUListIds[i] ) );
778 : }
779 0 : }
780 :
781 22 : OUString ScFunctionMgr::GetCategoryName(sal_uInt32 _nCategoryNumber )
782 : {
783 22 : if ( _nCategoryNumber > SC_FUNCGROUP_COUNT )
784 : {
785 : OSL_FAIL("Invalid category number!");
786 0 : return OUString();
787 : }
788 :
789 22 : boost::scoped_ptr<ScResourcePublisher> pCategories( new ScResourcePublisher( ScResId( RID_FUNCTION_CATEGORIES ) ) );
790 22 : return SC_RESSTR(static_cast<sal_uInt16>(_nCategoryNumber));
791 : }
792 :
793 0 : sal_Unicode ScFunctionMgr::getSingleToken(const formula::IFunctionManager::EToken _eToken) const
794 : {
795 0 : switch(_eToken)
796 : {
797 : case eOk:
798 0 : return ScCompiler::GetNativeSymbolChar(ocOpen);
799 : case eClose:
800 0 : return ScCompiler::GetNativeSymbolChar(ocClose);
801 : case eSep:
802 0 : return ScCompiler::GetNativeSymbolChar(ocSep);
803 : case eArrayOpen:
804 0 : return ScCompiler::GetNativeSymbolChar(ocArrayOpen);
805 : case eArrayClose:
806 0 : return ScCompiler::GetNativeSymbolChar(ocArrayClose);
807 : }
808 0 : return 0;
809 : }
810 :
811 : // class ScFuncRes:
812 :
813 1452 : ScFuncRes::ScFuncRes( ResId &aRes, ScFuncDesc* pDesc, bool & rbSuppressed )
814 1452 : : Resource(aRes)
815 : {
816 1452 : rbSuppressed = (bool)GetNum();
817 1452 : pDesc->nCategory = GetNum();
818 1452 : pDesc->sHelpId = ReadByteStringRes();
819 1452 : pDesc->nArgCount = GetNum();
820 1452 : sal_uInt16 nArgs = pDesc->nArgCount;
821 1452 : if (nArgs >= PAIRED_VAR_ARGS)
822 12 : nArgs -= PAIRED_VAR_ARGS - 2;
823 1440 : else if (nArgs >= VAR_ARGS)
824 180 : nArgs -= VAR_ARGS - 1;
825 1452 : if (nArgs)
826 : {
827 1420 : pDesc->pDefArgFlags = new ScFuncDesc::ParameterFlags[nArgs];
828 4528 : for (sal_uInt16 i = 0; i < nArgs; ++i)
829 : {
830 3108 : pDesc->pDefArgFlags[i].bOptional = (bool)GetNum();
831 : }
832 : }
833 : // Need to read the value from the resource even if nArgs==0 to advance the
834 : // resource position pointer, so this can't be in the if(nArgs) block above.
835 1452 : sal_uInt16 nSuppressed = GetNum();
836 1452 : if (nSuppressed)
837 : {
838 0 : if (nSuppressed > nArgs)
839 : {
840 : SAL_WARN("sc.core", "ScFuncRes: suppressed parameters count mismatch on OpCode " <<
841 : aRes.GetId() << ": suppressed " << nSuppressed << " > params " << nArgs);
842 0 : nSuppressed = nArgs; // sanitize
843 : }
844 0 : for (sal_uInt16 i = 0; i < nSuppressed; ++i)
845 : {
846 0 : sal_uInt16 nParam = GetNum();
847 0 : if (nParam < nArgs)
848 : {
849 0 : if (pDesc->nArgCount >= PAIRED_VAR_ARGS && nParam >= nArgs-2)
850 : {
851 : SAL_WARN("sc.core", "ScFuncRes: PAIRED_VAR_ARGS parameters can't be suppressed, on OpCode " <<
852 0 : aRes.GetId() << ": param " << nParam << " >= arg " << nArgs << "-2");
853 : }
854 0 : else if (pDesc->nArgCount >= VAR_ARGS && nParam == nArgs-1)
855 : {
856 : SAL_WARN("sc.core", "ScFuncRes: VAR_ARGS parameters can't be suppressed, on OpCode " <<
857 0 : aRes.GetId() << ": param " << nParam << " == arg " << nArgs << "-1");
858 : }
859 : else
860 : {
861 0 : pDesc->pDefArgFlags[nParam].bSuppress = true;
862 0 : pDesc->bHasSuppressedArgs = true;
863 : }
864 : }
865 : else
866 : {
867 : SAL_WARN("sc.core", "ScFuncRes: suppressed parameter exceeds count on OpCode " <<
868 : aRes.GetId() << ": param " << nParam << " >= args " << nArgs);
869 : }
870 : }
871 : }
872 :
873 1452 : pDesc->pFuncName = new OUString( ScCompiler::GetNativeSymbol( static_cast<OpCode>( aRes.GetId())));
874 1452 : pDesc->pFuncDesc = new OUString( SC_RESSTR(1) );
875 :
876 1452 : if (nArgs)
877 : {
878 1420 : pDesc->maDefArgNames.clear();
879 1420 : pDesc->maDefArgNames.resize(nArgs);
880 1420 : pDesc->maDefArgDescs.clear();
881 1420 : pDesc->maDefArgDescs.resize(nArgs);
882 4528 : for (sal_uInt16 i = 0; i < nArgs; ++i)
883 : {
884 3108 : pDesc->maDefArgNames[i] = SC_RESSTR(2*(i+1) );
885 3108 : pDesc->maDefArgDescs[i] = SC_RESSTR(2*(i+1)+1);
886 : }
887 : }
888 :
889 1452 : FreeResource();
890 1452 : }
891 :
892 8916 : sal_uInt16 ScFuncRes::GetNum()
893 : {
894 8916 : return ReadShortRes();
895 228 : }
896 :
897 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
