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_sc.hxx"
26
27 // INCLUDE ---------------------------------------------------------------
28
29 #include <sfx2/linkmgr.hxx>
30 #include <sfx2/dispatch.hxx>
31 #include <sfx2/objsh.hxx>
32 #include <svl/stritem.hxx>
33 #include <svl/zforlist.hxx>
34 #include <rtl/logfile.hxx>
35
36 #include "interpre.hxx"
37 #include "attrib.hxx"
38 #include "sc.hrc"
39 #include "ddelink.hxx"
40 #include "scmatrix.hxx"
41 #include "compiler.hxx"
42 #include "cell.hxx"
43 #include "document.hxx"
44 #include "dociter.hxx"
45 #include "docoptio.hxx"
46 #include "unitconv.hxx"
47 #include "globstr.hrc"
48 #include "hints.hxx"
49 #include "dpobject.hxx"
50 #include "postit.hxx"
51
52 #include <string.h>
53 #include <math.h>
54
55 #include <boost/math/special_functions/expm1.hpp>
56 #include <boost/math/special_functions/log1p.hpp>
57
58 using namespace formula;
59 // STATIC DATA -----------------------------------------------------------
60
61 #define D_TIMEFACTOR 86400.0
62 #define SCdEpsilon 1.0E-7
63
64 //-----------------------------------------------------------------------------
65 // Datum und Zeit
66 //-----------------------------------------------------------------------------
67
GetDateSerial(sal_Int16 nYear,sal_Int16 nMonth,sal_Int16 nDay,bool bStrict)68 double ScInterpreter::GetDateSerial( sal_Int16 nYear, sal_Int16 nMonth, sal_Int16 nDay, bool bStrict )
69 {
70 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::GetDateSerial" );
71 if ( nYear < 100 && !bStrict )
72 nYear = pFormatter->ExpandTwoDigitYear( nYear );
73 // Do not use a default Date ctor here because it asks system time with a
74 // performance penalty.
75 sal_Int16 nY, nM, nD;
76 if (bStrict)
77 nY = nYear, nM = nMonth, nD = nDay;
78 else
79 {
80 if (nMonth > 0)
81 {
82 nY = nYear + (nMonth-1) / 12;
83 nM = ((nMonth-1) % 12) + 1;
84 }
85 else
86 {
87 nY = nYear + (nMonth-12) / 12;
88 nM = 12 - (-nMonth) % 12;
89 }
90 nD = 1;
91 }
92 Date aDate( nD, nM, nY);
93 if (!bStrict)
94 aDate += nDay - 1;
95 if (aDate.IsValid())
96 return (double) (aDate - *(pFormatter->GetNullDate()));
97 else
98 {
99 SetError(errNoValue);
100 return 0;
101 }
102 }
103
104 //-----------------------------------------------------------------------------
105 // Funktionen
106 //-----------------------------------------------------------------------------
107
ScGetActDate()108 void ScInterpreter::ScGetActDate()
109 {
110 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScGetActDate" );
111 nFuncFmtType = NUMBERFORMAT_DATE;
112 Date aActDate;
113 long nDiff = aActDate - *(pFormatter->GetNullDate());
114 PushDouble((double) nDiff);
115 }
116
ScGetActTime()117 void ScInterpreter::ScGetActTime()
118 {
119 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScGetActTime" );
120 nFuncFmtType = NUMBERFORMAT_DATETIME;
121 Date aActDate;
122 long nDiff = aActDate - *(pFormatter->GetNullDate());
123 Time aActTime;
124 double nTime = ((double)aActTime.Get100Sec() / 100 +
125 (double)(aActTime.GetSec() +
126 (aActTime.GetMin() * 60) +
127 (aActTime.GetHour() * 3600))) / D_TIMEFACTOR;
128 PushDouble( (double) nDiff + nTime );
129 }
130
ScGetYear()131 void ScInterpreter::ScGetYear()
132 {
133 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScGetYear" );
134 Date aDate = *(pFormatter->GetNullDate());
135 aDate += (long) ::rtl::math::approxFloor(GetDouble());
136 PushDouble( (double) aDate.GetYear() );
137 }
138
ScGetMonth()139 void ScInterpreter::ScGetMonth()
140 {
141 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScGetMonth" );
142 Date aDate = *(pFormatter->GetNullDate());
143 aDate += (long) ::rtl::math::approxFloor(GetDouble());
144 PushDouble( (double) aDate.GetMonth() );
145 }
146
ScGetDay()147 void ScInterpreter::ScGetDay()
148 {
149 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScGetDay" );
150 Date aDate = *(pFormatter->GetNullDate());
151 aDate += (long)::rtl::math::approxFloor(GetDouble());
152 PushDouble((double) aDate.GetDay());
153 }
154
ScGetMin()155 void ScInterpreter::ScGetMin()
156 {
157 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScGetMin" );
158 double fTime = GetDouble();
159 fTime -= ::rtl::math::approxFloor(fTime); // Datumsanteil weg
160 long nVal = (long)::rtl::math::approxFloor(fTime*D_TIMEFACTOR+0.5) % 3600;
161 PushDouble( (double) (nVal/60) );
162 }
163
ScGetSec()164 void ScInterpreter::ScGetSec()
165 {
166 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScGetSec" );
167 double fTime = GetDouble();
168 fTime -= ::rtl::math::approxFloor(fTime); // Datumsanteil weg
169 long nVal = (long)::rtl::math::approxFloor(fTime*D_TIMEFACTOR+0.5) % 60;
170 PushDouble( (double) nVal );
171 }
172
ScGetHour()173 void ScInterpreter::ScGetHour()
174 {
175 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScGetHour" );
176 double fTime = GetDouble();
177 fTime -= ::rtl::math::approxFloor(fTime); // Datumsanteil weg
178 long nVal = (long)::rtl::math::approxFloor(fTime*D_TIMEFACTOR+0.5) / 3600;
179 PushDouble((double) nVal);
180 }
181
ScGetDateValue()182 void ScInterpreter::ScGetDateValue()
183 {
184 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScGetDateValue" );
185 String aInputString = GetString();
186 sal_uInt32 nFIndex = 0; // damit default Land/Spr.
187 double fVal;
188 if (pFormatter->IsNumberFormat(aInputString, nFIndex, fVal))
189 {
190 short eType = pFormatter->GetType(nFIndex);
191 if (eType == NUMBERFORMAT_DATE || eType == NUMBERFORMAT_DATETIME)
192 PushDouble(::rtl::math::approxFloor(fVal));
193 else
194 PushIllegalArgument();
195 }
196 else
197 PushIllegalArgument();
198 }
199
ScGetDayOfWeek()200 void ScInterpreter::ScGetDayOfWeek()
201 {
202 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScGetDayOfWeek" );
203 sal_uInt8 nParamCount = GetByte();
204 if ( MustHaveParamCount( nParamCount, 1, 2 ) )
205 {
206 short nFlag;
207 if (nParamCount == 2)
208 nFlag = (short) ::rtl::math::approxFloor(GetDouble());
209 else
210 nFlag = 1;
211
212 Date aDate = *(pFormatter->GetNullDate());
213 aDate += (long)::rtl::math::approxFloor(GetDouble());
214 int nVal = (int) aDate.GetDayOfWeek();
215 if (nFlag == 1)
216 {
217 if (nVal == 6)
218 nVal = 1;
219 else
220 nVal += 2;
221 }
222 else if (nFlag == 2)
223 nVal += 1;
224 PushInt( nVal );
225 }
226 }
227
ScGetWeekOfYear()228 void ScInterpreter::ScGetWeekOfYear()
229 {
230 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScGetWeekOfYear" );
231 if ( MustHaveParamCount( GetByte(), 2 ) )
232 {
233 short nFlag = (short) ::rtl::math::approxFloor(GetDouble());
234
235 Date aDate = *(pFormatter->GetNullDate());
236 aDate += (long)::rtl::math::approxFloor(GetDouble());
237 PushInt( (int) aDate.GetWeekOfYear( nFlag == 1 ? SUNDAY : MONDAY ));
238 }
239 }
240
ScEasterSunday()241 void ScInterpreter::ScEasterSunday()
242 {
243 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScEasterSunday" );
244 nFuncFmtType = NUMBERFORMAT_DATE;
245 if ( MustHaveParamCount( GetByte(), 1 ) )
246 {
247 sal_Int16 nDay, nMonth, nYear;
248 nYear = (sal_Int16) ::rtl::math::approxFloor( GetDouble() );
249 if ( nYear < 100 )
250 nYear = pFormatter->ExpandTwoDigitYear( nYear );
251 // don't worry, be happy :)
252 int B,C,D,E,F,G,H,I,K,L,M,N,O;
253 N = nYear % 19;
254 B = int(nYear / 100);
255 C = nYear % 100;
256 D = int(B / 4);
257 E = B % 4;
258 F = int((B + 8) / 25);
259 G = int((B - F + 1) / 3);
260 H = (19 * N + B - D - G + 15) % 30;
261 I = int(C / 4);
262 K = C % 4;
263 L = (32 + 2 * E + 2 * I - H - K) % 7;
264 M = int((N + 11 * H + 22 * L) / 451);
265 O = H + L - 7 * M + 114;
266 nDay = sal::static_int_cast<sal_Int16>( O % 31 + 1 );
267 nMonth = sal::static_int_cast<sal_Int16>( int(O / 31) );
268 PushDouble( GetDateSerial( nYear, nMonth, nDay, true ) );
269 }
270 }
271
ScGetDate()272 void ScInterpreter::ScGetDate()
273 {
274 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScGetDate" );
275 nFuncFmtType = NUMBERFORMAT_DATE;
276 if ( MustHaveParamCount( GetByte(), 3 ) )
277 {
278 sal_Int16 nDay = (sal_Int16) ::rtl::math::approxFloor(GetDouble());
279 sal_Int16 nMonth = (sal_Int16) ::rtl::math::approxFloor(GetDouble());
280 sal_Int16 nYear = (sal_Int16) ::rtl::math::approxFloor(GetDouble());
281 if (nYear < 0)
282 PushIllegalArgument();
283 else
284 {
285 PushDouble(GetDateSerial(nYear, nMonth, nDay, false));
286 }
287 }
288 }
289
ScGetTime()290 void ScInterpreter::ScGetTime()
291 {
292 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScGetTime" );
293 nFuncFmtType = NUMBERFORMAT_TIME;
294 if ( MustHaveParamCount( GetByte(), 3 ) )
295 {
296 double nSec = GetDouble();
297 double nMin = GetDouble();
298 double nHour = GetDouble();
299 double fTime = fmod( (nHour * 3600) + (nMin * 60) + nSec, D_TIMEFACTOR) / D_TIMEFACTOR;
300 if (fTime < 0)
301 PushIllegalArgument();
302 else
303 PushDouble( fTime);
304 }
305 }
306
ScGetDiffDate()307 void ScInterpreter::ScGetDiffDate()
308 {
309 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScGetDiffDate" );
310 if ( MustHaveParamCount( GetByte(), 2 ) )
311 {
312 double nDate2 = GetDouble();
313 double nDate1 = GetDouble();
314 PushDouble(nDate1 - nDate2);
315 }
316 }
317
ScGetDiffDate360()318 void ScInterpreter::ScGetDiffDate360()
319 {
320 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScGetDiffDate360" );
321 /* Implementation follows
322 * http://www.bondmarkets.com/eCommerce/SMD_Fields_030802.pdf
323 * Appendix B: Day-Count Bases, there are 7 different ways to calculate the
324 * 30-days count. That document also claims that Excel implements the "PSA
325 * 30" or "NASD 30" method (funny enough they also state that Excel is the
326 * only tool that does so).
327 *
328 * Note that the definition given in
329 * http://msdn.microsoft.com/library/en-us/office97/html/SEB7C.asp
330 * is _not_ the way how it is actually calculated by Excel (that would not
331 * even match any of the 7 methods mentioned above) and would result in the
332 * following test cases producing wrong results according to that appendix B:
333 *
334 * 28-Feb-95 31-Aug-95 181 instead of 180
335 * 29-Feb-96 31-Aug-96 181 instead of 180
336 * 30-Jan-96 31-Mar-96 61 instead of 60
337 * 31-Jan-96 31-Mar-96 61 instead of 60
338 *
339 * Still, there is a difference between OOoCalc and Excel:
340 * In Excel:
341 * 02-Feb-99 31-Mar-00 results in 419
342 * 31-Mar-00 02-Feb-99 results in -418
343 * In Calc the result is 419 respectively -419. I consider the -418 a bug in Excel.
344 */
345
346 sal_uInt8 nParamCount = GetByte();
347 if ( MustHaveParamCount( nParamCount, 2, 3 ) )
348 {
349 sal_Bool bFlag;
350 if (nParamCount == 3)
351 bFlag = GetBool();
352 else
353 bFlag = sal_False;
354 double nDate2 = GetDouble();
355 double nDate1 = GetDouble();
356 double fSign;
357 if (nGlobalError)
358 PushError( nGlobalError);
359 else
360 {
361 // #i84934# only for non-US European algorithm swap dates. Else
362 // follow Excel's meaningless extrapolation for "interoperability".
363 if (bFlag && (nDate2 < nDate1))
364 {
365 fSign = nDate1;
366 nDate1 = nDate2;
367 nDate2 = fSign;
368 fSign = -1.0;
369 }
370 else
371 fSign = 1.0;
372 Date aDate1 = *(pFormatter->GetNullDate());
373 aDate1 += (long) ::rtl::math::approxFloor(nDate1);
374 Date aDate2 = *(pFormatter->GetNullDate());
375 aDate2 += (long) ::rtl::math::approxFloor(nDate2);
376 if (aDate1.GetDay() == 31)
377 aDate1 -= (sal_uLong) 1;
378 else if (!bFlag)
379 {
380 if (aDate1.GetMonth() == 2)
381 {
382 switch ( aDate1.GetDay() )
383 {
384 case 28 :
385 if ( !aDate1.IsLeapYear() )
386 aDate1.SetDay(30);
387 break;
388 case 29 :
389 aDate1.SetDay(30);
390 break;
391 }
392 }
393 }
394 if (aDate2.GetDay() == 31)
395 {
396 if (!bFlag )
397 {
398 if (aDate1.GetDay() == 30)
399 aDate2 -= (sal_uLong) 1;
400 }
401 else
402 aDate2.SetDay(30);
403 }
404 PushDouble( fSign * (double)
405 ( (double) aDate2.GetDay() + (double) aDate2.GetMonth() * 30.0 +
406 (double) aDate2.GetYear() * 360.0
407 - (double) aDate1.GetDay() - (double) aDate1.GetMonth() * 30.0
408 - (double)aDate1.GetYear() * 360.0) );
409 }
410 }
411 }
412
ScGetTimeValue()413 void ScInterpreter::ScGetTimeValue()
414 {
415 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScGetTimeValue" );
416 String aInputString = GetString();
417 sal_uInt32 nFIndex = 0; // damit default Land/Spr.
418 double fVal;
419 if (pFormatter->IsNumberFormat(aInputString, nFIndex, fVal))
420 {
421 short eType = pFormatter->GetType(nFIndex);
422 if (eType == NUMBERFORMAT_TIME || eType == NUMBERFORMAT_DATETIME)
423 {
424 double fDateVal = rtl::math::approxFloor(fVal);
425 double fTimeVal = fVal - fDateVal;
426 PushDouble(fTimeVal);
427 }
428 else
429 PushIllegalArgument();
430 }
431 else
432 PushIllegalArgument();
433 }
434
ScPlusMinus()435 void ScInterpreter::ScPlusMinus()
436 {
437 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScPlusMinus" );
438 double nVal = GetDouble();
439 short n = 0;
440 if (nVal < 0.0)
441 n = -1;
442 else if (nVal > 0.0)
443 n = 1;
444 PushInt( n );
445 }
446
ScAbs()447 void ScInterpreter::ScAbs()
448 {
449 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScAbs" );
450 PushDouble(fabs(GetDouble()));
451 }
452
ScInt()453 void ScInterpreter::ScInt()
454 {
455 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScInt" );
456 PushDouble(::rtl::math::approxFloor(GetDouble()));
457 }
458
459
RoundNumber(rtl_math_RoundingMode eMode)460 void ScInterpreter::RoundNumber( rtl_math_RoundingMode eMode )
461 {
462 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::RoundNumber" );
463 sal_uInt8 nParamCount = GetByte();
464 if ( MustHaveParamCount( nParamCount, 1, 2 ) )
465 {
466 double fVal = 0.0;
467 if (nParamCount == 1)
468 fVal = ::rtl::math::round( GetDouble(), 0, eMode );
469 else
470 {
471 sal_Int32 nDec = (sal_Int32) ::rtl::math::approxFloor(GetDouble());
472 if( nDec < -20 || nDec > 20 )
473 PushIllegalArgument();
474 else
475 fVal = ::rtl::math::round( GetDouble(), (short)nDec, eMode );
476 }
477 PushDouble(fVal);
478 }
479 }
480
ScRound()481 void ScInterpreter::ScRound()
482 {
483 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScRound" );
484 RoundNumber( rtl_math_RoundingMode_Corrected );
485 }
486
ScRoundDown()487 void ScInterpreter::ScRoundDown()
488 {
489 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScRoundDown" );
490 RoundNumber( rtl_math_RoundingMode_Down );
491 }
492
ScRoundUp()493 void ScInterpreter::ScRoundUp()
494 {
495 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScRoundUp" );
496 RoundNumber( rtl_math_RoundingMode_Up );
497 }
498
ScCeil()499 void ScInterpreter::ScCeil()
500 {
501 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScCeil" );
502 sal_uInt8 nParamCount = GetByte();
503 if ( MustHaveParamCount( nParamCount, 2, 3 ) )
504 {
505 sal_Bool bAbs = ( nParamCount == 3 ? GetBool() : sal_False );
506 double fDec = GetDouble();
507 double fVal = GetDouble();
508 if ( fDec == 0.0 )
509 PushInt(0);
510 else if (fVal*fDec < 0.0)
511 PushIllegalArgument();
512 else
513 {
514 if ( !bAbs && fVal < 0.0 )
515 PushDouble(::rtl::math::approxFloor(fVal/fDec) * fDec);
516 else
517 PushDouble(::rtl::math::approxCeil(fVal/fDec) * fDec);
518 }
519 }
520 }
521
ScFloor()522 void ScInterpreter::ScFloor()
523 {
524 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScFloor" );
525 sal_uInt8 nParamCount = GetByte();
526 if ( MustHaveParamCount( nParamCount, 2, 3 ) )
527 {
528 sal_Bool bAbs = ( nParamCount == 3 ? GetBool() : sal_False );
529 double fDec = GetDouble();
530 double fVal = GetDouble();
531 if ( fDec == 0.0 )
532 PushInt(0);
533 else if (fVal*fDec < 0.0)
534 PushIllegalArgument();
535 else
536 {
537 if ( !bAbs && fVal < 0.0 )
538 PushDouble(::rtl::math::approxCeil(fVal/fDec) * fDec);
539 else
540 PushDouble(::rtl::math::approxFloor(fVal/fDec) * fDec);
541 }
542 }
543 }
544
ScEven()545 void ScInterpreter::ScEven()
546 {
547 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScEven" );
548 double fVal = GetDouble();
549 if (fVal < 0.0)
550 PushDouble(::rtl::math::approxFloor(fVal/2.0) * 2.0);
551 else
552 PushDouble(::rtl::math::approxCeil(fVal/2.0) * 2.0);
553 }
554
ScOdd()555 void ScInterpreter::ScOdd()
556 {
557 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScOdd" );
558 double fVal = GetDouble();
559 if (fVal >= 0.0)
560 {
561 fVal = ::rtl::math::approxCeil(fVal);
562 if (fmod(fVal, 2.0) == 0.0)
563 fVal += 1.0;
564 }
565 else
566 {
567 fVal = ::rtl::math::approxFloor(fVal);
568 if (fmod(fVal, 2.0) == 0.0)
569 fVal -= 1.0;
570 }
571 PushDouble(fVal);
572 }
573
ScArcTan2()574 void ScInterpreter::ScArcTan2()
575 {
576 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScArcTan2" );
577 if ( MustHaveParamCount( GetByte(), 2 ) )
578 {
579 double nVal2 = GetDouble();
580 double nVal1 = GetDouble();
581 PushDouble(atan2(nVal2, nVal1));
582 }
583 }
584
ScLog()585 void ScInterpreter::ScLog()
586 {
587 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScLog" );
588 sal_uInt8 nParamCount = GetByte();
589 if ( MustHaveParamCount( nParamCount, 1, 2 ) )
590 {
591 double nBase;
592 if (nParamCount == 2)
593 nBase = GetDouble();
594 else
595 nBase = 10.0;
596 double nVal = GetDouble();
597 if (nVal > 0.0 && nBase > 0.0 && nBase != 1.0)
598 PushDouble(log(nVal) / log(nBase));
599 else
600 PushIllegalArgument();
601 }
602 }
603
ScLn()604 void ScInterpreter::ScLn()
605 {
606 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScLn" );
607 double fVal = GetDouble();
608 if (fVal > 0.0)
609 PushDouble(log(fVal));
610 else
611 PushIllegalArgument();
612 }
613
ScLog10()614 void ScInterpreter::ScLog10()
615 {
616 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScLog10" );
617 double fVal = GetDouble();
618 if (fVal > 0.0)
619 PushDouble(log10(fVal));
620 else
621 PushIllegalArgument();
622 }
623
ScNPV()624 void ScInterpreter::ScNPV()
625 {
626 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScNPV" );
627 nFuncFmtType = NUMBERFORMAT_CURRENCY;
628 short nParamCount = GetByte();
629 if ( MustHaveParamCount( nParamCount, 2, 31 ) )
630 {
631 double nVal = 0.0;
632 // Wir drehen den Stack um!!
633 FormulaToken* pTemp[ 31 ];
634 for( short i = 0; i < nParamCount; i++ )
635 pTemp[ i ] = pStack[ sp - i - 1 ];
636 memcpy( &pStack[ sp - nParamCount ], pTemp, nParamCount * sizeof( FormulaToken* ) );
637 if (nGlobalError == 0)
638 {
639 double nCount = 1.0;
640 double nZins = GetDouble();
641 --nParamCount;
642 size_t nRefInList = 0;
643 ScRange aRange;
644 while (nParamCount-- > 0)
645 {
646 switch (GetStackType())
647 {
648 case svDouble :
649 {
650 nVal += (GetDouble() / pow(1.0 + nZins, (double)nCount));
651 nCount++;
652 }
653 break;
654 case svSingleRef :
655 {
656 ScAddress aAdr;
657 PopSingleRef( aAdr );
658 ScBaseCell* pCell = GetCell( aAdr );
659 if (!HasCellEmptyData(pCell) && HasCellValueData(pCell))
660 {
661 double nCellVal = GetCellValue( aAdr, pCell );
662 nVal += (nCellVal / pow(1.0 + nZins, (double)nCount));
663 nCount++;
664 }
665 }
666 break;
667 case svDoubleRef :
668 case svRefList :
669 {
670 sal_uInt16 nErr = 0;
671 double nCellVal;
672 PopDoubleRef( aRange, nParamCount, nRefInList);
673 ScHorizontalValueIterator aValIter( pDok, aRange, glSubTotal);
674 while ((nErr == 0) && aValIter.GetNext(nCellVal, nErr))
675 {
676 nVal += (nCellVal / pow(1.0 + nZins, (double)nCount));
677 nCount++;
678 }
679 if ( nErr != 0 )
680 SetError(nErr);
681 }
682 break;
683 default : SetError(errIllegalParameter); break;
684 }
685 }
686 }
687 PushDouble(nVal);
688 }
689 }
690
ScIRR()691 void ScInterpreter::ScIRR()
692 {
693 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScIRR" );
694 double fSchaetzwert;
695 nFuncFmtType = NUMBERFORMAT_PERCENT;
696 sal_uInt8 nParamCount = GetByte();
697 if ( !MustHaveParamCount( nParamCount, 1, 2 ) )
698 return;
699 if (nParamCount == 2)
700 fSchaetzwert = GetDouble();
701 else
702 fSchaetzwert = 0.1;
703 sal_uInt16 sPos = sp; // Stack-Position merken
704 double fEps = 1.0;
705 double x, xNeu, fWert, fZaehler, fNenner, nCount;
706 if (fSchaetzwert == -1.0)
707 x = 0.1; // default gegen Nulldivisionen
708 else
709 x = fSchaetzwert; // Startwert
710 switch (GetStackType())
711 {
712 case svDoubleRef :
713 break;
714 default:
715 {
716 PushIllegalParameter();
717 return;
718 }
719 }
720 const sal_uInt16 nIterationsMax = 20;
721 sal_uInt16 nItCount = 0;
722 ScRange aRange;
723 while (fEps > SCdEpsilon && nItCount < nIterationsMax)
724 { // Newton-Verfahren:
725 sp = sPos; // Stack zuruecksetzen
726 nCount = 0.0;
727 fZaehler = 0.0;
728 fNenner = 0.0;
729 sal_uInt16 nErr = 0;
730 PopDoubleRef( aRange );
731 ScValueIterator aValIter(pDok, aRange, glSubTotal);
732 if (aValIter.GetFirst(fWert, nErr))
733 {
734 fZaehler += fWert / pow(1.0+x,(double)nCount);
735 fNenner += -nCount * fWert / pow(1.0+x,nCount+1.0);
736 nCount++;
737 while ((nErr == 0) && aValIter.GetNext(fWert, nErr))
738 {
739 fZaehler += fWert / pow(1.0+x,(double)nCount);
740 fNenner += -nCount * fWert / pow(1.0+x,nCount+1.0);
741 nCount++;
742 }
743 SetError(nErr);
744 }
745 xNeu = x - fZaehler / fNenner; // x(i+1) = x(i)-f(x(i))/f'(x(i))
746 nItCount++;
747 fEps = fabs(xNeu - x);
748 x = xNeu;
749 }
750 if (fSchaetzwert == 0.0 && fabs(x) < SCdEpsilon)
751 x = 0.0; // auf Null normieren
752 if (fEps < SCdEpsilon)
753 PushDouble(x);
754 else
755 PushError( errNoConvergence);
756 }
757
ScMIRR()758 void ScInterpreter::ScMIRR()
759 { // range_of_values ; rate_invest ; rate_reinvest
760 nFuncFmtType = NUMBERFORMAT_PERCENT;
761 if( MustHaveParamCount( GetByte(), 3 ) )
762 {
763 double fRate1_reinvest = GetDouble() + 1;
764 double fNPV_reinvest = 0.0;
765 double fPow_reinvest = 1.0;
766
767 double fRate1_invest = GetDouble() + 1;
768 double fNPV_invest = 0.0;
769 double fPow_invest = 1.0;
770
771 ScRange aRange;
772 PopDoubleRef( aRange );
773
774 if( nGlobalError )
775 PushError( nGlobalError);
776 else
777 {
778 ScValueIterator aValIter( pDok, aRange, glSubTotal );
779 double fCellValue;
780 sal_uLong nCount = 0;
781 sal_uInt16 nIterError = 0;
782
783 sal_Bool bLoop = aValIter.GetFirst( fCellValue, nIterError );
784 while( bLoop )
785 {
786 if( fCellValue > 0.0 ) // reinvestments
787 fNPV_reinvest += fCellValue * fPow_reinvest;
788 else if( fCellValue < 0.0 ) // investments
789 fNPV_invest += fCellValue * fPow_invest;
790 fPow_reinvest /= fRate1_reinvest;
791 fPow_invest /= fRate1_invest;
792 nCount++;
793
794 bLoop = aValIter.GetNext( fCellValue, nIterError );
795 }
796 if( nIterError )
797 PushError( nIterError );
798 else
799 {
800 double fResult = -fNPV_reinvest / fNPV_invest;
801 fResult *= pow( fRate1_reinvest, (double) nCount - 1 );
802 fResult = pow( fResult, 1.0 / (nCount - 1) );
803 PushDouble( fResult - 1.0 );
804 }
805 }
806 }
807 }
808
809
ScISPMT()810 void ScInterpreter::ScISPMT()
811 { // rate ; period ; total_periods ; invest
812 if( MustHaveParamCount( GetByte(), 4 ) )
813 {
814 double fInvest = GetDouble();
815 double fTotal = GetDouble();
816 double fPeriod = GetDouble();
817 double fRate = GetDouble();
818
819 if( nGlobalError )
820 PushError( nGlobalError);
821 else
822 PushDouble( fInvest * fRate * (fPeriod / fTotal - 1.0) );
823 }
824 }
825
826
827 //----------------------- Finanzfunktionen ------------------------------------
828
ScGetBw(double fZins,double fZzr,double fRmz,double fZw,double fF)829 double ScInterpreter::ScGetBw(double fZins, double fZzr, double fRmz,
830 double fZw, double fF)
831 {
832 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScMIRR" );
833 double fBw;
834 if (fZins == 0.0)
835 fBw = fZw + fRmz * fZzr;
836 else if (fF > 0.0)
837 fBw = (fZw * pow(1.0 + fZins, -fZzr))
838 + (fRmz * (1.0 - pow(1.0 + fZins, -fZzr + 1.0)) / fZins)
839 + fRmz;
840 else
841 fBw = (fZw * pow(1.0 + fZins, -fZzr))
842 + (fRmz * (1.0 - pow(1.0 + fZins, -fZzr)) / fZins);
843 return -fBw;
844 }
845
ScBW()846 void ScInterpreter::ScBW()
847 {
848 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScBW" );
849 nFuncFmtType = NUMBERFORMAT_CURRENCY;
850 double nRmz, nZzr, nZins, nZw = 0, nFlag = 0;
851 sal_uInt8 nParamCount = GetByte();
852 if ( !MustHaveParamCount( nParamCount, 3, 5 ) )
853 return;
854 if (nParamCount == 5)
855 nFlag = GetDouble();
856 if (nParamCount >= 4)
857 nZw = GetDouble();
858 nRmz = GetDouble();
859 nZzr = GetDouble();
860 nZins = GetDouble();
861 PushDouble(ScGetBw(nZins, nZzr, nRmz, nZw, nFlag));
862 }
863
ScDIA()864 void ScInterpreter::ScDIA()
865 {
866 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScDIA" );
867 nFuncFmtType = NUMBERFORMAT_CURRENCY;
868 if ( MustHaveParamCount( GetByte(), 4 ) )
869 {
870 double nZr = GetDouble();
871 double nDauer = GetDouble();
872 double nRest = GetDouble();
873 double nWert = GetDouble();
874 double nDia = ((nWert - nRest) * (nDauer - nZr + 1.0)) /
875 ((nDauer * (nDauer + 1.0)) / 2.0);
876 PushDouble(nDia);
877 }
878 }
879
ScGetGDA(double fWert,double fRest,double fDauer,double fPeriode,double fFaktor)880 double ScInterpreter::ScGetGDA(double fWert, double fRest, double fDauer,
881 double fPeriode, double fFaktor)
882 {
883 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScGetGDA" );
884 double fGda, fZins, fAlterWert, fNeuerWert;
885 fZins = fFaktor / fDauer;
886 if (fZins >= 1.0)
887 {
888 fZins = 1.0;
889 if (fPeriode == 1.0)
890 fAlterWert = fWert;
891 else
892 fAlterWert = 0.0;
893 }
894 else
895 fAlterWert = fWert * pow(1.0 - fZins, fPeriode - 1.0);
896 fNeuerWert = fWert * pow(1.0 - fZins, fPeriode);
897
898 if (fNeuerWert < fRest)
899 fGda = fAlterWert - fRest;
900 else
901 fGda = fAlterWert - fNeuerWert;
902 if (fGda < 0.0)
903 fGda = 0.0;
904 return fGda;
905 }
906
ScGDA()907 void ScInterpreter::ScGDA()
908 {
909 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScGDA" );
910 nFuncFmtType = NUMBERFORMAT_CURRENCY;
911 sal_uInt8 nParamCount = GetByte();
912 if ( MustHaveParamCount( nParamCount, 4, 5 ) )
913 {
914 double nFaktor;
915 if (nParamCount == 5)
916 nFaktor = GetDouble();
917 else
918 nFaktor = 2.0;
919 double nPeriode = GetDouble();
920 double nDauer = GetDouble();
921 double nRest = GetDouble();
922 double nWert = GetDouble();
923 if (nWert < 0.0 || nRest < 0.0 || nFaktor <= 0.0 || nRest > nWert
924 || nPeriode < 1.0 || nPeriode > nDauer)
925 PushIllegalArgument();
926 else
927 PushDouble(ScGetGDA(nWert, nRest, nDauer, nPeriode, nFaktor));
928 }
929 }
930
ScGDA2()931 void ScInterpreter::ScGDA2()
932 {
933 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScGDA2" );
934 nFuncFmtType = NUMBERFORMAT_CURRENCY;
935 sal_uInt8 nParamCount = GetByte();
936 if ( !MustHaveParamCount( nParamCount, 4, 5 ) )
937 return ;
938 double nMonate;
939 if (nParamCount == 4)
940 nMonate = 12.0;
941 else
942 nMonate = ::rtl::math::approxFloor(GetDouble());
943 double nPeriode = GetDouble();
944 double nDauer = GetDouble();
945 double nRest = GetDouble();
946 double nWert = GetDouble();
947 if (nMonate < 1.0 || nMonate > 12.0 || nDauer > 1200.0 || nRest < 0.0 ||
948 nPeriode > (nDauer + 1.0) || nRest > nWert || nWert < 0.0)
949 {
950 PushIllegalArgument();
951 return;
952 }
953 double nAbRate = 1.0 - pow(nRest / nWert, 1.0 / nDauer);
954 nAbRate = ::rtl::math::approxFloor((nAbRate * 1000.0) + 0.5) / 1000.0;
955 double nErsteAbRate = nWert * nAbRate * nMonate / 12.0;
956 double nGda2 = 0.0;
957 if (::rtl::math::approxFloor(nPeriode) == 1)
958 nGda2 = nErsteAbRate;
959 else
960 {
961 double nSummAbRate = nErsteAbRate;
962 double nMin = nDauer;
963 if (nMin > nPeriode) nMin = nPeriode;
964 sal_uInt16 iMax = (sal_uInt16)::rtl::math::approxFloor(nMin);
965 for (sal_uInt16 i = 2; i <= iMax; i++)
966 {
967 nGda2 = (nWert - nSummAbRate) * nAbRate;
968 nSummAbRate += nGda2;
969 }
970 if (nPeriode > nDauer)
971 nGda2 = ((nWert - nSummAbRate) * nAbRate * (12.0 - nMonate)) / 12.0;
972 }
973 PushDouble(nGda2);
974 }
975
976
ScInterVDB(double fWert,double fRest,double fDauer,double fDauer1,double fPeriode,double fFaktor)977 double ScInterpreter::ScInterVDB(double fWert,double fRest,double fDauer,
978 double fDauer1,double fPeriode,double fFaktor)
979 {
980 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScInterVDB" );
981 double fVdb=0;
982 double fIntEnd = ::rtl::math::approxCeil(fPeriode);
983 sal_uLong nLoopEnd = (sal_uLong) fIntEnd;
984
985 double fTerm, fLia;
986 double fRestwert = fWert - fRest;
987 sal_Bool bNowLia = sal_False;
988
989 double fGda;
990 sal_uLong i;
991 fLia=0;
992 for ( i = 1; i <= nLoopEnd; i++)
993 {
994 if(!bNowLia)
995 {
996 fGda = ScGetGDA(fWert, fRest, fDauer, (double) i, fFaktor);
997 fLia = fRestwert/ (fDauer1 - (double) (i-1));
998
999 if (fLia > fGda)
1000 {
1001 fTerm = fLia;
1002 bNowLia = sal_True;
1003 }
1004 else
1005 {
1006 fTerm = fGda;
1007 fRestwert -= fGda;
1008 }
1009 }
1010 else
1011 {
1012 fTerm = fLia;
1013 }
1014
1015 if ( i == nLoopEnd)
1016 fTerm *= ( fPeriode + 1.0 - fIntEnd );
1017
1018 fVdb += fTerm;
1019 }
1020 return fVdb;
1021 }
1022
1023
DblMin(double a,double b)1024 inline double DblMin( double a, double b )
1025 {
1026 return (a < b) ? a : b;
1027 }
1028
ScVDB()1029 void ScInterpreter::ScVDB()
1030 {
1031 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScVDB" );
1032 nFuncFmtType = NUMBERFORMAT_CURRENCY;
1033 sal_uInt8 nParamCount = GetByte();
1034 if ( MustHaveParamCount( nParamCount, 5, 7 ) )
1035 {
1036 double fWert, fRest, fDauer, fAnfang, fEnde, fFaktor, fVdb = 0.0;
1037 sal_Bool bFlag;
1038 if (nParamCount == 7)
1039 bFlag = GetBool();
1040 else
1041 bFlag = sal_False;
1042 if (nParamCount >= 6)
1043 fFaktor = GetDouble();
1044 else
1045 fFaktor = 2.0;
1046 fEnde = GetDouble();
1047 fAnfang = GetDouble();
1048 fDauer = GetDouble();
1049 fRest = GetDouble();
1050 fWert = GetDouble();
1051 if (fAnfang < 0.0 || fEnde < fAnfang || fEnde > fDauer || fWert < 0.0
1052 || fRest > fWert || fFaktor <= 0.0)
1053 PushIllegalArgument();
1054 else
1055 {
1056 double fIntStart = ::rtl::math::approxFloor(fAnfang);
1057 double fIntEnd = ::rtl::math::approxCeil(fEnde);
1058 sal_uLong nLoopStart = (sal_uLong) fIntStart;
1059 sal_uLong nLoopEnd = (sal_uLong) fIntEnd;
1060
1061 fVdb = 0.0;
1062 if (bFlag)
1063 {
1064 for (sal_uLong i = nLoopStart + 1; i <= nLoopEnd; i++)
1065 {
1066 double fTerm = ScGetGDA(fWert, fRest, fDauer, (double) i, fFaktor);
1067
1068 // Teilperioden am Anfang / Ende beruecksichtigen:
1069 if ( i == nLoopStart+1 )
1070 fTerm *= ( DblMin( fEnde, fIntStart + 1.0 ) - fAnfang );
1071 else if ( i == nLoopEnd )
1072 fTerm *= ( fEnde + 1.0 - fIntEnd );
1073
1074 fVdb += fTerm;
1075 }
1076 }
1077 else
1078 {
1079
1080 double fDauer1=fDauer;
1081 double fPart;
1082
1083 //@Die Frage aller Fragen: "Ist das hier richtig"
1084 if(!::rtl::math::approxEqual(fAnfang,::rtl::math::approxFloor(fAnfang)))
1085 {
1086 if(fFaktor>1)
1087 {
1088 if(fAnfang>fDauer/2 || ::rtl::math::approxEqual(fAnfang,fDauer/2))
1089 {
1090 fPart=fAnfang-fDauer/2;
1091 fAnfang=fDauer/2;
1092 fEnde-=fPart;
1093 fDauer1+=1;
1094 }
1095 }
1096 }
1097
1098 fWert-=ScInterVDB(fWert,fRest,fDauer,fDauer1,fAnfang,fFaktor);
1099 fVdb=ScInterVDB(fWert,fRest,fDauer,fDauer-fAnfang,fEnde-fAnfang,fFaktor);
1100 }
1101 }
1102 PushDouble(fVdb);
1103 }
1104 }
1105
ScLaufz()1106 void ScInterpreter::ScLaufz()
1107 {
1108 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScLaufz" );
1109 if ( MustHaveParamCount( GetByte(), 3 ) )
1110 {
1111 double nZukunft = GetDouble();
1112 double nGegenwart = GetDouble();
1113 double nZins = GetDouble();
1114 PushDouble(log(nZukunft / nGegenwart) / log(1.0 + nZins));
1115 }
1116 }
1117
ScLIA()1118 void ScInterpreter::ScLIA()
1119 {
1120 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScLIA" );
1121 nFuncFmtType = NUMBERFORMAT_CURRENCY;
1122 if ( MustHaveParamCount( GetByte(), 3 ) )
1123 {
1124 double nDauer = GetDouble();
1125 double nRest = GetDouble();
1126 double nWert = GetDouble();
1127 PushDouble((nWert - nRest) / nDauer);
1128 }
1129 }
1130
ScGetRmz(double fRate,double fNper,double fPv,double fFv,double fPaytype)1131 double ScInterpreter::ScGetRmz(double fRate, double fNper, double fPv,
1132 double fFv, double fPaytype)
1133 {
1134 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScGetRmz" );
1135 double fPayment;
1136 if (fRate == 0.0)
1137 fPayment = (fPv + fFv) / fNper;
1138 else
1139 {
1140 if (fPaytype > 0.0) // payment in advance
1141 fPayment = (fFv + fPv * exp( fNper * ::boost::math::log1p(fRate) ) ) * fRate /
1142 (::boost::math::expm1( (fNper + 1) * ::boost::math::log1p(fRate) ) - fRate);
1143 else // payment in arrear
1144 fPayment = (fFv + fPv * exp(fNper * ::boost::math::log1p(fRate) ) ) * fRate /
1145 ::boost::math::expm1( fNper * ::boost::math::log1p(fRate) );
1146 }
1147 return -fPayment;
1148 }
1149
ScRMZ()1150 void ScInterpreter::ScRMZ()
1151 {
1152 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScRMZ" );
1153 double nZins, nZzr, nBw, nZw = 0, nFlag = 0;
1154 nFuncFmtType = NUMBERFORMAT_CURRENCY;
1155 sal_uInt8 nParamCount = GetByte();
1156 if ( !MustHaveParamCount( nParamCount, 3, 5 ) )
1157 return;
1158 if (nParamCount == 5)
1159 nFlag = GetDouble();
1160 if (nParamCount >= 4)
1161 nZw = GetDouble();
1162 nBw = GetDouble();
1163 nZzr = GetDouble();
1164 nZins = GetDouble();
1165 PushDouble(ScGetRmz(nZins, nZzr, nBw, nZw, nFlag));
1166 }
1167
ScZGZ()1168 void ScInterpreter::ScZGZ()
1169 {
1170 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScZGZ" );
1171 nFuncFmtType = NUMBERFORMAT_PERCENT;
1172 if ( MustHaveParamCount( GetByte(), 3 ) )
1173 {
1174 double nZukunftswert = GetDouble();
1175 double nGegenwartswert = GetDouble();
1176 double nZeitraum = GetDouble();
1177 PushDouble(pow(nZukunftswert / nGegenwartswert, 1.0 / nZeitraum) - 1.0);
1178 }
1179 }
1180
ScGetZw(double fZins,double fZzr,double fRmz,double fBw,double fF)1181 double ScInterpreter::ScGetZw(double fZins, double fZzr, double fRmz,
1182 double fBw, double fF)
1183 {
1184 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScGetZw" );
1185 double fZw;
1186 if (fZins == 0.0)
1187 fZw = fBw + fRmz * fZzr;
1188 else
1189 {
1190 double fTerm = pow(1.0 + fZins, fZzr);
1191 if (fF > 0.0)
1192 fZw = fBw * fTerm + fRmz*(1.0 + fZins)*(fTerm - 1.0)/fZins;
1193 else
1194 fZw = fBw * fTerm + fRmz*(fTerm - 1.0)/fZins;
1195 }
1196 return -fZw;
1197 }
1198
ScZW()1199 void ScInterpreter::ScZW()
1200 {
1201 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScZW" );
1202 double nZins, nZzr, nRmz, nBw = 0, nFlag = 0;
1203 nFuncFmtType = NUMBERFORMAT_CURRENCY;
1204 sal_uInt8 nParamCount = GetByte();
1205 if ( !MustHaveParamCount( nParamCount, 3, 5 ) )
1206 return;
1207 if (nParamCount == 5)
1208 nFlag = GetDouble();
1209 if (nParamCount >= 4)
1210 nBw = GetDouble();
1211 nRmz = GetDouble();
1212 nZzr = GetDouble();
1213 nZins = GetDouble();
1214 PushDouble(ScGetZw(nZins, nZzr, nRmz, nBw, nFlag));
1215 }
1216
ScZZR()1217 void ScInterpreter::ScZZR()
1218 {
1219 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScZZR" );
1220 double nZins, nRmz, nBw, nZw = 0, nFlag = 0;
1221 sal_uInt8 nParamCount = GetByte();
1222 if ( !MustHaveParamCount( nParamCount, 3, 5 ) )
1223 return;
1224 if (nParamCount == 5)
1225 nFlag = GetDouble();
1226 if (nParamCount >= 4)
1227 nZw = GetDouble();
1228 nBw = GetDouble();
1229 nRmz = GetDouble();
1230 nZins = GetDouble();
1231 if (nZins == 0.0)
1232 PushDouble(-(nBw + nZw)/nRmz);
1233 else if (nFlag > 0.0)
1234 PushDouble(log(-(nZins*nZw-nRmz*(1.0+nZins))/(nZins*nBw+nRmz*(1.0+nZins)))
1235 /log(1.0+nZins));
1236 else
1237 PushDouble(log(-(nZins*nZw-nRmz)/(nZins*nBw+nRmz))/log(1.0+nZins));
1238 }
1239
RateIteration(double fNper,double fPayment,double fPv,double fFv,double fPayType,double & fGuess)1240 bool ScInterpreter::RateIteration( double fNper, double fPayment, double fPv,
1241 double fFv, double fPayType, double & fGuess )
1242 {
1243 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::RateIteration" );
1244 // See also #i15090#
1245 // Newton-Raphson method: x(i+1) = x(i) - f(x(i)) / f'(x(i))
1246 // This solution handles integer and non-integer values of Nper different.
1247 // If ODFF will constraint Nper to integer, the distinction of cases can be
1248 // removed; only the integer-part is needed then.
1249 bool bValid = true, bFound = false;
1250 double fX, fXnew, fTerm, fTermDerivation;
1251 double fGeoSeries, fGeoSeriesDerivation;
1252 const sal_uInt16 nIterationsMax = 150;
1253 sal_uInt16 nCount = 0;
1254 const double fEpsilonSmall = 1.0E-14;
1255 // convert any fPayType situation to fPayType == zero situation
1256 fFv = fFv - fPayment * fPayType;
1257 fPv = fPv + fPayment * fPayType;
1258 if (fNper == ::rtl::math::round( fNper, 0, rtl_math_RoundingMode_Corrected ))
1259 { // Nper is an integer value
1260 fX = fGuess;
1261 double fPowN, fPowNminus1; // for (1.0+fX)^Nper and (1.0+fX)^(Nper-1)
1262 while (!bFound && nCount < nIterationsMax)
1263 {
1264 fPowNminus1 = pow( 1.0+fX, fNper-1.0);
1265 fPowN = fPowNminus1 * (1.0+fX);
1266 if (rtl::math::approxEqual( fabs(fX), 0.0))
1267 {
1268 fGeoSeries = fNper;
1269 fGeoSeriesDerivation = fNper * (fNper-1.0)/2.0;
1270 }
1271 else
1272 {
1273 fGeoSeries = (fPowN-1.0)/fX;
1274 fGeoSeriesDerivation = fNper * fPowNminus1 / fX - fGeoSeries / fX;
1275 }
1276 fTerm = fFv + fPv *fPowN+ fPayment * fGeoSeries;
1277 fTermDerivation = fPv * fNper * fPowNminus1 + fPayment * fGeoSeriesDerivation;
1278 if (fabs(fTerm) < fEpsilonSmall)
1279 bFound = true; // will catch root which is at an extreme
1280 else
1281 {
1282 if (rtl::math::approxEqual( fabs(fTermDerivation), 0.0))
1283 fXnew = fX + 1.1 * SCdEpsilon; // move away from zero slope
1284 else
1285 fXnew = fX - fTerm / fTermDerivation;
1286 nCount++;
1287 // more accuracy not possible in oscillating cases
1288 bFound = (fabs(fXnew - fX) < SCdEpsilon);
1289 fX = fXnew;
1290 }
1291 }
1292 // Gnumeric returns roots < -1, Excel gives an error in that cases,
1293 // ODFF says nothing about it. Enable the statement, if you want Excel's
1294 // behavior
1295 //bValid =(fX >=-1.0);
1296 }
1297 else
1298 { // Nper is not an integer value.
1299 fX = (fGuess < -1.0) ? -1.0 : fGuess; // start with a valid fX
1300 while (bValid && !bFound && nCount < nIterationsMax)
1301 {
1302 if (rtl::math::approxEqual( fabs(fX), 0.0))
1303 {
1304 fGeoSeries = fNper;
1305 fGeoSeriesDerivation = fNper * (fNper-1.0)/2.0;
1306 }
1307 else
1308 {
1309 fGeoSeries = (pow( 1.0+fX, fNper) - 1.0) / fX;
1310 fGeoSeriesDerivation = fNper * pow( 1.0+fX, fNper-1.0) / fX - fGeoSeries / fX;
1311 }
1312 fTerm = fFv + fPv *pow(1.0 + fX,fNper)+ fPayment * fGeoSeries;
1313 fTermDerivation = fPv * fNper * pow( 1.0+fX, fNper-1.0) + fPayment * fGeoSeriesDerivation;
1314 if (fabs(fTerm) < fEpsilonSmall)
1315 bFound = true; // will catch root which is at an extreme
1316 else
1317 {
1318 if (rtl::math::approxEqual( fabs(fTermDerivation), 0.0))
1319 fXnew = fX + 1.1 * SCdEpsilon; // move away from zero slope
1320 else
1321 fXnew = fX - fTerm / fTermDerivation;
1322 nCount++;
1323 // more accuracy not possible in oscillating cases
1324 bFound = (fabs(fXnew - fX) < SCdEpsilon);
1325 fX = fXnew;
1326 bValid = (fX >= -1.0); // otherwise pow(1.0+fX,fNper) will fail
1327 }
1328 }
1329 }
1330 fGuess = fX; // return approximate root
1331 return bValid && bFound;
1332 }
1333
1334 // In Calc UI it is the function RATE(Nper;Pmt;Pv;Fv;Type;Guess)
ScZins()1335 void ScInterpreter::ScZins()
1336 {
1337 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScZins" );
1338 double fPv, fPayment, fNper;
1339 // defaults for missing arguments, see ODFF spec
1340 double fFv = 0, fPayType = 0, fGuess = 0.1;
1341 bool bValid = true;
1342 nFuncFmtType = NUMBERFORMAT_PERCENT;
1343 sal_uInt8 nParamCount = GetByte();
1344 if ( !MustHaveParamCount( nParamCount, 3, 6 ) )
1345 return;
1346 if (nParamCount == 6)
1347 fGuess = GetDouble();
1348 if (nParamCount >= 5)
1349 fPayType = GetDouble();
1350 if (nParamCount >= 4)
1351 fFv = GetDouble();
1352 fPv = GetDouble();
1353 fPayment = GetDouble();
1354 fNper = GetDouble();
1355 if (fNper <= 0.0) // constraint from ODFF spec
1356 {
1357 PushIllegalArgument();
1358 return;
1359 }
1360 // other values for fPayType might be meaningful,
1361 // ODFF spec is not clear yet, enable statement if you want only 0 and 1
1362 //if (fPayType != 0.0) fPayType = 1.0;
1363 bValid = RateIteration(fNper, fPayment, fPv, fFv, fPayType, fGuess);
1364 if (!bValid)
1365 SetError(errNoConvergence);
1366 PushDouble(fGuess);
1367 }
1368
ScGetZinsZ(double fZins,double fZr,double fZzr,double fBw,double fZw,double fF,double & fRmz)1369 double ScInterpreter::ScGetZinsZ(double fZins, double fZr, double fZzr, double fBw,
1370 double fZw, double fF, double& fRmz)
1371 {
1372 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScGetZinsZ" );
1373 fRmz = ScGetRmz(fZins, fZzr, fBw, fZw, fF); // fuer kapz auch bei fZr == 1
1374 double fZinsZ;
1375 nFuncFmtType = NUMBERFORMAT_CURRENCY;
1376 if (fZr == 1.0)
1377 {
1378 if (fF > 0.0)
1379 fZinsZ = 0.0;
1380 else
1381 fZinsZ = -fBw;
1382 }
1383 else
1384 {
1385 if (fF > 0.0)
1386 fZinsZ = ScGetZw(fZins, fZr-2.0, fRmz, fBw, 1.0) - fRmz;
1387 else
1388 fZinsZ = ScGetZw(fZins, fZr-1.0, fRmz, fBw, 0.0);
1389 }
1390 return fZinsZ * fZins;
1391 }
1392
ScZinsZ()1393 void ScInterpreter::ScZinsZ()
1394 {
1395 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScZinsZ" );
1396 double nZins, nZr, nRmz, nZzr, nBw, nZw = 0, nFlag = 0;
1397 nFuncFmtType = NUMBERFORMAT_CURRENCY;
1398 sal_uInt8 nParamCount = GetByte();
1399 if ( !MustHaveParamCount( nParamCount, 4, 6 ) )
1400 return;
1401 if (nParamCount == 6)
1402 nFlag = GetDouble();
1403 if (nParamCount >= 5)
1404 nZw = GetDouble();
1405 nBw = GetDouble();
1406 nZzr = GetDouble();
1407 nZr = GetDouble();
1408 nZins = GetDouble();
1409 if (nZr < 1.0 || nZr > nZzr)
1410 PushIllegalArgument();
1411 else
1412 PushDouble(ScGetZinsZ(nZins, nZr, nZzr, nBw, nZw, nFlag, nRmz));
1413 }
1414
ScKapz()1415 void ScInterpreter::ScKapz()
1416 {
1417 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScKapz" );
1418 double nZins, nZr, nZzr, nBw, nZw = 0, nFlag = 0, nRmz, nZinsz;
1419 nFuncFmtType = NUMBERFORMAT_CURRENCY;
1420 sal_uInt8 nParamCount = GetByte();
1421 if ( !MustHaveParamCount( nParamCount, 4, 6 ) )
1422 return;
1423 if (nParamCount == 6)
1424 nFlag = GetDouble();
1425 if (nParamCount >= 5)
1426 nZw = GetDouble();
1427 nBw = GetDouble();
1428 nZzr = GetDouble();
1429 nZr = GetDouble();
1430 nZins = GetDouble();
1431 if (nZr < 1.0 || nZr > nZzr)
1432 PushIllegalArgument();
1433 else
1434 {
1435 nZinsz = ScGetZinsZ(nZins, nZr, nZzr, nBw, nZw, nFlag, nRmz);
1436 PushDouble(nRmz - nZinsz);
1437 }
1438 }
1439
ScKumZinsZ()1440 void ScInterpreter::ScKumZinsZ()
1441 {
1442 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScKumZinsZ" );
1443 nFuncFmtType = NUMBERFORMAT_CURRENCY;
1444 if ( MustHaveParamCount( GetByte(), 6 ) )
1445 {
1446 double fZins, fZzr, fBw, fAnfang, fEnde, fF, fRmz, fZinsZ;
1447 fF = GetDouble();
1448 fEnde = ::rtl::math::approxFloor(GetDouble());
1449 fAnfang = ::rtl::math::approxFloor(GetDouble());
1450 fBw = GetDouble();
1451 fZzr = GetDouble();
1452 fZins = GetDouble();
1453 if (fAnfang < 1.0 || fEnde < fAnfang || fZins <= 0.0 ||
1454 fEnde > fZzr || fZzr <= 0.0 || fBw <= 0.0)
1455 PushIllegalArgument();
1456 else
1457 {
1458 sal_uLong nAnfang = (sal_uLong) fAnfang;
1459 sal_uLong nEnde = (sal_uLong) fEnde ;
1460 fRmz = ScGetRmz(fZins, fZzr, fBw, 0.0, fF);
1461 fZinsZ = 0.0;
1462 if (nAnfang == 1)
1463 {
1464 if (fF <= 0.0)
1465 fZinsZ = -fBw;
1466 nAnfang++;
1467 }
1468 for (sal_uLong i = nAnfang; i <= nEnde; i++)
1469 {
1470 if (fF > 0.0)
1471 fZinsZ += ScGetZw(fZins, (double)(i-2), fRmz, fBw, 1.0) - fRmz;
1472 else
1473 fZinsZ += ScGetZw(fZins, (double)(i-1), fRmz, fBw, 0.0);
1474 }
1475 fZinsZ *= fZins;
1476 PushDouble(fZinsZ);
1477 }
1478 }
1479 }
1480
ScKumKapZ()1481 void ScInterpreter::ScKumKapZ()
1482 {
1483 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScKumKapZ" );
1484 nFuncFmtType = NUMBERFORMAT_CURRENCY;
1485 if ( MustHaveParamCount( GetByte(), 6 ) )
1486 {
1487 double fZins, fZzr, fBw, fAnfang, fEnde, fF, fRmz, fKapZ;
1488 fF = GetDouble();
1489 fEnde = ::rtl::math::approxFloor(GetDouble());
1490 fAnfang = ::rtl::math::approxFloor(GetDouble());
1491 fBw = GetDouble();
1492 fZzr = GetDouble();
1493 fZins = GetDouble();
1494 if (fAnfang < 1.0 || fEnde < fAnfang || fZins <= 0.0 ||
1495 fEnde > fZzr || fZzr <= 0.0 || fBw <= 0.0)
1496 PushIllegalArgument();
1497 else
1498 {
1499 fRmz = ScGetRmz(fZins, fZzr, fBw, 0.0, fF);
1500 fKapZ = 0.0;
1501 sal_uLong nAnfang = (sal_uLong) fAnfang;
1502 sal_uLong nEnde = (sal_uLong) fEnde;
1503 if (nAnfang == 1)
1504 {
1505 if (fF <= 0.0)
1506 fKapZ = fRmz + fBw * fZins;
1507 else
1508 fKapZ = fRmz;
1509 nAnfang++;
1510 }
1511 for (sal_uLong i = nAnfang; i <= nEnde; i++)
1512 {
1513 if (fF > 0.0)
1514 fKapZ += fRmz - (ScGetZw(fZins, (double)(i-2), fRmz, fBw, 1.0) - fRmz) * fZins;
1515 else
1516 fKapZ += fRmz - ScGetZw(fZins, (double)(i-1), fRmz, fBw, 0.0) * fZins;
1517 }
1518 PushDouble(fKapZ);
1519 }
1520 }
1521 }
1522
ScEffektiv()1523 void ScInterpreter::ScEffektiv()
1524 {
1525 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScEffektiv" );
1526 nFuncFmtType = NUMBERFORMAT_PERCENT;
1527 if ( MustHaveParamCount( GetByte(), 2 ) )
1528 {
1529 double fPerioden = GetDouble();
1530 double fNominal = GetDouble();
1531 if (fPerioden < 1.0 || fNominal <= 0.0)
1532 PushIllegalArgument();
1533 else
1534 {
1535 fPerioden = ::rtl::math::approxFloor(fPerioden);
1536 PushDouble(pow(1.0 + fNominal/fPerioden, fPerioden) - 1.0);
1537 }
1538 }
1539 }
1540
ScNominal()1541 void ScInterpreter::ScNominal()
1542 {
1543 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScNominal" );
1544 nFuncFmtType = NUMBERFORMAT_PERCENT;
1545 if ( MustHaveParamCount( GetByte(), 2 ) )
1546 {
1547 double fPerioden = GetDouble();
1548 double fEffektiv = GetDouble();
1549 if (fPerioden < 1.0 || fEffektiv <= 0.0)
1550 PushIllegalArgument();
1551 else
1552 {
1553 fPerioden = ::rtl::math::approxFloor(fPerioden);
1554 PushDouble( (pow(fEffektiv + 1.0, 1.0 / fPerioden) - 1.0) * fPerioden );
1555 }
1556 }
1557 }
1558
ScMod()1559 void ScInterpreter::ScMod()
1560 {
1561 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScMod" );
1562 if ( MustHaveParamCount( GetByte(), 2 ) )
1563 {
1564 double fVal2 = GetDouble(); // Denominator
1565 double fVal1 = GetDouble(); // Numerator
1566 if (fVal2 == floor(fVal2)) // a pure integral number stored in double
1567 {
1568 double fResult = fmod(fVal1,fVal2);
1569 if ( (fResult != 0.0) &&
1570 ((fVal1 > 0.0 && fVal2 < 0.0) || (fVal1 < 0.0 && fVal2 > 0.0)))
1571 fResult += fVal2 ;
1572 PushDouble( fResult );
1573 }
1574 else
1575 {
1576 PushDouble( ::rtl::math::approxSub( fVal1,
1577 ::rtl::math::approxFloor(fVal1 / fVal2) * fVal2));
1578 }
1579 }
1580 }
1581
1582 /** (Goal Seek) Find a value of x that is a root of f(x)
1583
1584 This function is used internally for the goal seek operation. It uses the
1585 Regula Falsi (aka false position) algorithm to find a root of f(x). The
1586 start value and the target value are to be given by the user in the
1587 goal seek dialog. The f(x) in this case is defined as the formula in the
1588 formula cell minus target value. This function may also perform additional
1589 search in the horizontal directions when the f(x) is discrete in order to
1590 ensure a non-zero slope necessary for deriving a subsequent x that is
1591 reasonably close to the root of interest.
1592
1593 @change 24.10.2004 by Kohei Yoshida (kohei@openoffice.org)
1594
1595 @see #i28955#
1596 */
ScBackSolver()1597 void ScInterpreter::ScBackSolver()
1598 {
1599 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScBackSolver" );
1600 if ( MustHaveParamCount( GetByte(), 3 ) )
1601 {
1602 sal_Bool bDoneIteration = sal_False;
1603 ScAddress aValueAdr, aFormulaAdr;
1604 double fTargetVal = GetDouble();
1605 PopSingleRef( aFormulaAdr );
1606 PopSingleRef( aValueAdr );
1607
1608 if (nGlobalError == 0)
1609 {
1610 ScBaseCell* pVCell = GetCell( aValueAdr );
1611 // CELLTYPE_NOTE: kein Value aber von Formel referiert
1612 sal_Bool bTempCell = (!pVCell || pVCell->GetCellType() == CELLTYPE_NOTE);
1613 ScBaseCell* pFCell = GetCell( aFormulaAdr );
1614
1615 if ( ((pVCell && pVCell->GetCellType() == CELLTYPE_VALUE) || bTempCell)
1616 && pFCell && pFCell->GetCellType() == CELLTYPE_FORMULA )
1617 {
1618 ScRange aVRange( aValueAdr, aValueAdr ); // fuer SetDirty
1619 double fSaveVal; // Original value to be restored later if necessary
1620 ScPostIt* pNote = 0;
1621
1622 if ( bTempCell )
1623 {
1624 pNote = pVCell ? pVCell->ReleaseNote() : 0;
1625 fSaveVal = 0.0;
1626 pVCell = new ScValueCell( fSaveVal );
1627 pDok->PutCell( aValueAdr, pVCell );
1628 }
1629 else
1630 fSaveVal = GetCellValue( aValueAdr, pVCell );
1631
1632 const sal_uInt16 nMaxIter = 100;
1633 const double fEps = 1E-10;
1634 const double fDelta = 1E-6;
1635
1636 double fBestX, fXPrev;
1637 double fBestF, fFPrev;
1638 fBestX = fXPrev = fSaveVal;
1639
1640 ScFormulaCell* pFormula = (ScFormulaCell*) pFCell;
1641 ScValueCell* pValue = (ScValueCell*) pVCell;
1642
1643 pFormula->Interpret();
1644 sal_Bool bError = ( pFormula->GetErrCode() != 0 );
1645 // bError always corresponds with fF
1646
1647 fFPrev = pFormula->GetValue() - fTargetVal;
1648
1649 fBestF = fabs( fFPrev );
1650 if ( fBestF < fDelta )
1651 bDoneIteration = sal_True;
1652
1653 double fX = fXPrev + fEps;
1654 double fF = fFPrev;
1655 double fSlope;
1656
1657 sal_uInt16 nIter = 0;
1658
1659 sal_Bool bHorMoveError = sal_False;
1660 // Nach der Regula Falsi Methode
1661 while ( !bDoneIteration && ( nIter++ < nMaxIter ) )
1662 {
1663 pValue->SetValue( fX );
1664 pDok->SetDirty( aVRange );
1665 pFormula->Interpret();
1666 bError = ( pFormula->GetErrCode() != 0 );
1667 fF = pFormula->GetValue() - fTargetVal;
1668
1669 if ( fF == fFPrev && !bError )
1670 {
1671 // HORIZONTAL SEARCH: Keep moving x in both directions until the f(x)
1672 // becomes different from the previous f(x). This routine is needed
1673 // when a given function is discrete, in which case the resulting slope
1674 // may become zero which ultimately causes the goal seek operation
1675 // to fail. #i28955#
1676
1677 sal_uInt16 nHorIter = 0;
1678 const double fHorStepAngle = 5.0;
1679 const double fHorMaxAngle = 80.0;
1680 int nHorMaxIter = static_cast<int>( fHorMaxAngle / fHorStepAngle );
1681 sal_Bool bDoneHorMove = sal_False;
1682
1683 while ( !bDoneHorMove && !bHorMoveError && nHorIter++ < nHorMaxIter )
1684 {
1685 double fHorAngle = fHorStepAngle * static_cast<double>( nHorIter );
1686 double fHorTangent = ::rtl::math::tan( fHorAngle * F_PI / 180 );
1687
1688 sal_uInt16 nIdx = 0;
1689 while( nIdx++ < 2 && !bDoneHorMove )
1690 {
1691 double fHorX;
1692 if ( nIdx == 1 )
1693 fHorX = fX + fabs(fF)*fHorTangent;
1694 else
1695 fHorX = fX - fabs(fF)*fHorTangent;
1696
1697 pValue->SetValue( fHorX );
1698 pDok->SetDirty( aVRange );
1699 pFormula->Interpret();
1700 bHorMoveError = ( pFormula->GetErrCode() != 0 );
1701 if ( bHorMoveError )
1702 break;
1703
1704 fF = pFormula->GetValue() - fTargetVal;
1705 if ( fF != fFPrev )
1706 {
1707 fX = fHorX;
1708 bDoneHorMove = sal_True;
1709 }
1710 }
1711 }
1712 if ( !bDoneHorMove )
1713 bHorMoveError = sal_True;
1714 }
1715
1716 if ( bError )
1717 {
1718 // move closer to last valid value (fXPrev), keep fXPrev & fFPrev
1719 double fDiff = ( fXPrev - fX ) / 2;
1720 if (fabs(fDiff) < fEps)
1721 fDiff = (fDiff < 0.0) ? - fEps : fEps;
1722 fX += fDiff;
1723 }
1724 else if ( bHorMoveError )
1725 break;
1726 else if ( fabs(fF) < fDelta )
1727 {
1728 // converged to root
1729 fBestX = fX;
1730 bDoneIteration = sal_True;
1731 }
1732 else
1733 {
1734 if ( fabs(fF) + fDelta < fBestF )
1735 {
1736 fBestX = fX;
1737 fBestF = fabs(fF);
1738 }
1739
1740 if ( ( fXPrev - fX ) != 0 )
1741 {
1742 fSlope = ( fFPrev - fF ) / ( fXPrev - fX );
1743 if ( fabs( fSlope ) < fEps )
1744 fSlope = fSlope < 0.0 ? -fEps : fEps;
1745 }
1746 else
1747 fSlope = fEps;
1748
1749 fXPrev = fX;
1750 fFPrev = fF;
1751 fX = fX - ( fF / fSlope );
1752 }
1753 }
1754
1755 // Try a nice rounded input value if possible.
1756 const double fNiceDelta = (bDoneIteration && fabs(fBestX) >= 1e-3 ? 1e-3 : fDelta);
1757 double nX = ::rtl::math::approxFloor((fBestX / fNiceDelta) + 0.5) * fNiceDelta;
1758 // double nX = ::rtl::math::approxFloor((fBestX / fDelta) + 0.5) * fDelta;
1759
1760 if ( bDoneIteration )
1761 {
1762 pValue->SetValue( nX );
1763 pDok->SetDirty( aVRange );
1764 pFormula->Interpret();
1765 if ( fabs( pFormula->GetValue() - fTargetVal ) > fabs( fF ) )
1766 nX = fBestX;
1767 }
1768 else if ( bError || bHorMoveError )
1769 {
1770 nX = fBestX;
1771 }
1772 if ( bTempCell )
1773 {
1774 pVCell = pNote ? new ScNoteCell( pNote ) : 0;
1775 pDok->PutCell( aValueAdr, pVCell );
1776 }
1777 else
1778 pValue->SetValue( fSaveVal );
1779 pDok->SetDirty( aVRange );
1780 pFormula->Interpret();
1781 if ( !bDoneIteration )
1782 SetError(NOTAVAILABLE);
1783 PushDouble(nX);
1784 }
1785 else
1786 {
1787 if ( !bDoneIteration )
1788 SetError(NOTAVAILABLE);
1789 PushInt(0); // falsche Zelltypen
1790 }
1791 }
1792 else
1793 {
1794 if ( !bDoneIteration )
1795 SetError(NOTAVAILABLE);
1796 PushInt(0); // nGlobalError
1797 }
1798 }
1799 }
1800
ScIntersect()1801 void ScInterpreter::ScIntersect()
1802 {
1803 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScIntersect" );
1804 formula::FormulaTokenRef p2nd = PopToken();
1805 formula::FormulaTokenRef p1st = PopToken();
1806
1807 if (nGlobalError || !p2nd || !p1st)
1808 {
1809 PushIllegalArgument();
1810 return;
1811 } // if (nGlobalError || !xT2 || !xT1)
1812
1813 StackVar sv1 = p1st->GetType();
1814 StackVar sv2 = p2nd->GetType();
1815 if ((sv1 != svSingleRef && sv1 != svDoubleRef && sv1 != svRefList) ||
1816 (sv2 != svSingleRef && sv2 != svDoubleRef && sv2 != svRefList))
1817 {
1818 PushIllegalArgument();
1819 return;
1820 }
1821
1822 ScToken* x1 = static_cast<ScToken*>(p1st.get());
1823 ScToken* x2 = static_cast<ScToken*>(p2nd.get());
1824 if (sv1 == svRefList || sv2 == svRefList)
1825 {
1826 // Now this is a bit nasty but it simplifies things, and having
1827 // intersections with lists isn't too common, if at all..
1828 // Convert a reference to list.
1829 ScToken* xt[2] = { x1, x2 };
1830 StackVar sv[2] = { sv1, sv2 };
1831 for (size_t i=0; i<2; ++i)
1832 {
1833 if (sv[i] == svSingleRef)
1834 {
1835 ScComplexRefData aRef;
1836 aRef.Ref1 = aRef.Ref2 = xt[i]->GetSingleRef();
1837 xt[i] = new ScRefListToken;
1838 xt[i]->GetRefList()->push_back( aRef);
1839 }
1840 else if (sv[i] == svDoubleRef)
1841 {
1842 ScComplexRefData aRef = xt[i]->GetDoubleRef();
1843 xt[i] = new ScRefListToken;
1844 xt[i]->GetRefList()->push_back( aRef);
1845 }
1846 }
1847 x1 = xt[0], x2 = xt[1];
1848
1849 x1->CalcAbsIfRel( aPos);
1850 x2->CalcAbsIfRel( aPos);
1851 ScTokenRef xRes = new ScRefListToken;
1852 ScRefList* pRefList = xRes->GetRefList();
1853 ScRefList::const_iterator end1( x1->GetRefList()->end());
1854 ScRefList::const_iterator end2( x2->GetRefList()->end());
1855 for (ScRefList::const_iterator it1( x1->GetRefList()->begin());
1856 it1 != end1; ++it1)
1857 {
1858 const ScSingleRefData& r11 = (*it1).Ref1;
1859 const ScSingleRefData& r12 = (*it1).Ref2;
1860 for (ScRefList::const_iterator it2( x2->GetRefList()->begin());
1861 it2 != end2; ++it2)
1862 {
1863 const ScSingleRefData& r21 = (*it2).Ref1;
1864 const ScSingleRefData& r22 = (*it2).Ref2;
1865 SCCOL nCol1 = ::std::max( r11.nCol, r21.nCol);
1866 SCROW nRow1 = ::std::max( r11.nRow, r21.nRow);
1867 SCTAB nTab1 = ::std::max( r11.nTab, r21.nTab);
1868 SCCOL nCol2 = ::std::min( r12.nCol, r22.nCol);
1869 SCROW nRow2 = ::std::min( r12.nRow, r22.nRow);
1870 SCTAB nTab2 = ::std::min( r12.nTab, r22.nTab);
1871 if (nCol2 < nCol1 || nRow2 < nRow1 || nTab2 < nTab1)
1872 ; // nothing
1873 else
1874 {
1875 ScComplexRefData aRef;
1876 aRef.InitRange( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2);
1877 pRefList->push_back( aRef);
1878 }
1879 }
1880 }
1881 size_t n = pRefList->size();
1882 if (!n)
1883 PushError( errNoRef);
1884 else if (n == 1)
1885 {
1886 const ScComplexRefData& rRef = (*pRefList)[0];
1887 if (rRef.Ref1 == rRef.Ref2)
1888 PushTempToken( new ScSingleRefToken( rRef.Ref1));
1889 else
1890 PushTempToken( new ScDoubleRefToken( rRef));
1891 }
1892 else
1893 PushTempToken( xRes);
1894 }
1895 else
1896 {
1897 ScToken* pt[2] = { x1, x2 };
1898 StackVar sv[2] = { sv1, sv2 };
1899 SCCOL nC1[2], nC2[2];
1900 SCROW nR1[2], nR2[2];
1901 SCTAB nT1[2], nT2[2];
1902 for (size_t i=0; i<2; ++i)
1903 {
1904 switch (sv[i])
1905 {
1906 case svSingleRef:
1907 case svDoubleRef:
1908 pt[i]->CalcAbsIfRel( aPos);
1909 {
1910 const ScSingleRefData& r = pt[i]->GetSingleRef();
1911 nC1[i] = r.nCol;
1912 nR1[i] = r.nRow;
1913 nT1[i] = r.nTab;
1914 }
1915 if (sv[i] == svDoubleRef)
1916 {
1917 const ScSingleRefData& r = pt[i]->GetSingleRef2();
1918 nC2[i] = r.nCol;
1919 nR2[i] = r.nRow;
1920 nT2[i] = r.nTab;
1921 }
1922 else
1923 {
1924 nC2[i] = nC1[i];
1925 nR2[i] = nR1[i];
1926 nT2[i] = nT1[i];
1927 }
1928 break;
1929 default:
1930 ; // nothing, prevent compiler warning
1931 }
1932 }
1933 SCCOL nCol1 = ::std::max( nC1[0], nC1[1]);
1934 SCROW nRow1 = ::std::max( nR1[0], nR1[1]);
1935 SCTAB nTab1 = ::std::max( nT1[0], nT1[1]);
1936 SCCOL nCol2 = ::std::min( nC2[0], nC2[1]);
1937 SCROW nRow2 = ::std::min( nR2[0], nR2[1]);
1938 SCTAB nTab2 = ::std::min( nT2[0], nT2[1]);
1939 if (nCol2 < nCol1 || nRow2 < nRow1 || nTab2 < nTab1)
1940 PushError( errNoRef);
1941 else if (nCol2 == nCol1 && nRow2 == nRow1 && nTab2 == nTab1)
1942 PushSingleRef( nCol1, nRow1, nTab1);
1943 else
1944 PushDoubleRef( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2);
1945 }
1946 }
1947
1948
ScRangeFunc()1949 void ScInterpreter::ScRangeFunc()
1950 {
1951 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScRangeFunc" );
1952 formula::FormulaTokenRef x2 = PopToken();
1953 formula::FormulaTokenRef x1 = PopToken();
1954
1955 if (nGlobalError || !x2 || !x1)
1956 {
1957 PushIllegalArgument();
1958 return;
1959 } // if (nGlobalError || !xT2 || !xT1)
1960 FormulaTokenRef xRes = ScToken::ExtendRangeReference( *x1, *x2, aPos, false);
1961 if (!xRes)
1962 PushIllegalArgument();
1963 else
1964 PushTempToken( xRes);
1965 }
1966
1967
ScUnionFunc()1968 void ScInterpreter::ScUnionFunc()
1969 {
1970 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScUnionFunc" );
1971 formula::FormulaTokenRef p2nd = PopToken();
1972 formula::FormulaTokenRef p1st = PopToken();
1973
1974 if (nGlobalError || !p2nd || !p1st)
1975 {
1976 PushIllegalArgument();
1977 return;
1978 } // if (nGlobalError || !xT2 || !xT1)
1979
1980 StackVar sv1 = p1st->GetType();
1981 StackVar sv2 = p2nd->GetType();
1982 if ((sv1 != svSingleRef && sv1 != svDoubleRef && sv1 != svRefList) ||
1983 (sv2 != svSingleRef && sv2 != svDoubleRef && sv2 != svRefList))
1984 {
1985 PushIllegalArgument();
1986 return;
1987 }
1988
1989 ScToken* x1 = static_cast<ScToken*>(p1st.get());
1990 ScToken* x2 = static_cast<ScToken*>(p2nd.get());
1991
1992
1993 ScTokenRef xRes;
1994 // Append to an existing RefList if there is one.
1995 if (sv1 == svRefList)
1996 {
1997 xRes = x1;
1998 sv1 = svUnknown; // mark as handled
1999 }
2000 else if (sv2 == svRefList)
2001 {
2002 xRes = x2;
2003 sv2 = svUnknown; // mark as handled
2004 }
2005 else
2006 xRes = new ScRefListToken;
2007 ScRefList* pRes = xRes->GetRefList();
2008 ScToken* pt[2] = { x1, x2 };
2009 StackVar sv[2] = { sv1, sv2 };
2010 for (size_t i=0; i<2; ++i)
2011 {
2012 if (pt[i] == xRes)
2013 continue;
2014 switch (sv[i])
2015 {
2016 case svSingleRef:
2017 {
2018 ScComplexRefData aRef;
2019 aRef.Ref1 = aRef.Ref2 = pt[i]->GetSingleRef();
2020 pRes->push_back( aRef);
2021 }
2022 break;
2023 case svDoubleRef:
2024 pRes->push_back( pt[i]->GetDoubleRef());
2025 break;
2026 case svRefList:
2027 {
2028 const ScRefList* p = pt[i]->GetRefList();
2029 ScRefList::const_iterator it( p->begin());
2030 ScRefList::const_iterator end( p->end());
2031 for ( ; it != end; ++it)
2032 {
2033 pRes->push_back( *it);
2034 }
2035 }
2036 break;
2037 default:
2038 ; // nothing, prevent compiler warning
2039 }
2040 }
2041 ValidateRef( *pRes); // set #REF! if needed
2042 PushTempToken( xRes);
2043 }
2044
2045
ScCurrent()2046 void ScInterpreter::ScCurrent()
2047 {
2048 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScCurrent" );
2049 FormulaTokenRef xTok( PopToken());
2050 if (xTok)
2051 {
2052 PushTempToken( xTok);
2053 PushTempToken( xTok);
2054 }
2055 else
2056 PushError( errUnknownStackVariable);
2057 }
2058
ScStyle()2059 void ScInterpreter::ScStyle()
2060 {
2061 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScStyle" );
2062 sal_uInt8 nParamCount = GetByte();
2063 if (nParamCount >= 1 && nParamCount <= 3)
2064 {
2065 String aStyle2; // Vorlage nach Timer
2066 if (nParamCount >= 3)
2067 aStyle2 = GetString();
2068 long nTimeOut = 0; // Timeout
2069 if (nParamCount >= 2)
2070 nTimeOut = (long)(GetDouble()*1000.0);
2071 String aStyle1 = GetString(); // Vorlage fuer sofort
2072
2073 if (nTimeOut < 0)
2074 nTimeOut = 0;
2075
2076 //
2077 // Request ausfuehren, um Vorlage anzuwenden
2078 //
2079
2080 if ( !pDok->IsClipOrUndo() )
2081 {
2082 SfxObjectShell* pShell = pDok->GetDocumentShell();
2083 if (pShell)
2084 {
2085 //! notify object shell directly
2086
2087 ScRange aRange(aPos);
2088 ScAutoStyleHint aHint( aRange, aStyle1, nTimeOut, aStyle2 );
2089 pShell->Broadcast( aHint );
2090 }
2091 }
2092
2093 PushDouble(0.0);
2094 }
2095 else
2096 PushIllegalParameter();
2097 }
2098
lcl_GetDdeLink(sfx2::LinkManager * pLinkMgr,const String & rA,const String & rT,const String & rI,sal_uInt8 nM)2099 ScDdeLink* lcl_GetDdeLink( sfx2::LinkManager* pLinkMgr,
2100 const String& rA, const String& rT, const String& rI, sal_uInt8 nM )
2101 {
2102 sal_uInt16 nCount = pLinkMgr->GetLinks().Count();
2103 for (sal_uInt16 i=0; i<nCount; i++ )
2104 {
2105 ::sfx2::SvBaseLink* pBase = *pLinkMgr->GetLinks()[i];
2106 if (pBase->ISA(ScDdeLink))
2107 {
2108 ScDdeLink* pLink = (ScDdeLink*)pBase;
2109 if ( pLink->GetAppl() == rA &&
2110 pLink->GetTopic() == rT &&
2111 pLink->GetItem() == rI &&
2112 pLink->GetMode() == nM )
2113 return pLink;
2114 }
2115 }
2116
2117 return NULL;
2118 }
2119
ScDde()2120 void ScInterpreter::ScDde()
2121 {
2122 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScDde" );
2123 // Applikation, Datei, Bereich
2124 // Application, Topic, Item
2125
2126 sal_uInt8 nParamCount = GetByte();
2127 if ( MustHaveParamCount( nParamCount, 3, 4 ) )
2128 {
2129 sal_uInt8 nMode = SC_DDE_DEFAULT;
2130 if (nParamCount == 4)
2131 nMode = (sal_uInt8) ::rtl::math::approxFloor(GetDouble());
2132 String aItem = GetString();
2133 String aTopic = GetString();
2134 String aAppl = GetString();
2135
2136 if (nMode > SC_DDE_TEXT)
2137 nMode = SC_DDE_DEFAULT;
2138
2139 // temporary documents (ScFunctionAccess) have no DocShell
2140 // and no LinkManager -> abort
2141
2142 sfx2::LinkManager* pLinkMgr = pDok->GetLinkManager();
2143 if (!pLinkMgr)
2144 {
2145 PushNoValue();
2146 return;
2147 }
2148
2149 // Nach dem Laden muss neu interpretiert werden (Verknuepfungen aufbauen)
2150
2151 if ( pMyFormulaCell->GetCode()->IsRecalcModeNormal() )
2152 pMyFormulaCell->GetCode()->SetRecalcModeOnLoad();
2153
2154 // solange der Link nicht ausgewertet ist, Idle abklemmen
2155 // (um zirkulaere Referenzen zu vermeiden)
2156
2157 sal_Bool bOldDis = pDok->IsIdleDisabled();
2158 pDok->DisableIdle( sal_True );
2159
2160 // Link-Objekt holen / anlegen
2161
2162 ScDdeLink* pLink = lcl_GetDdeLink( pLinkMgr, aAppl, aTopic, aItem, nMode );
2163
2164 //! Dde-Links (zusaetzlich) effizienter am Dokument speichern !!!!!
2165 // ScDdeLink* pLink = pDok->GetDdeLink( aAppl, aTopic, aItem );
2166
2167 sal_Bool bWasError = ( pMyFormulaCell->GetRawError() != 0 );
2168
2169 if (!pLink)
2170 {
2171 pLink = new ScDdeLink( pDok, aAppl, aTopic, aItem, nMode );
2172 pLinkMgr->InsertDDELink( pLink, aAppl, aTopic, aItem );
2173 if ( pLinkMgr->GetLinks().Count() == 1 ) // erster ?
2174 {
2175 SfxBindings* pBindings = pDok->GetViewBindings();
2176 if (pBindings)
2177 pBindings->Invalidate( SID_LINKS ); // Link-Manager enablen
2178 }
2179
2180 //! asynchron auswerten ???
2181 pLink->TryUpdate(); // TryUpdate ruft Update nicht mehrfach auf
2182
2183 // StartListening erst nach dem Update, sonst circular reference
2184 pMyFormulaCell->StartListening( *pLink );
2185 }
2186 else
2187 {
2188 pMyFormulaCell->StartListening( *pLink );
2189 }
2190
2191 // Wenn aus dem Reschedule beim Ausfuehren des Links ein Fehler
2192 // (z.B. zirkulaere Referenz) entstanden ist, der vorher nicht da war,
2193 // das Fehler-Flag zuruecksetzen:
2194
2195 if ( pMyFormulaCell->GetRawError() && !bWasError )
2196 pMyFormulaCell->SetErrCode(0);
2197
2198 // Wert abfragen
2199
2200 const ScMatrix* pLinkMat = pLink->GetResult();
2201 if (pLinkMat)
2202 {
2203 SCSIZE nC, nR;
2204 pLinkMat->GetDimensions(nC, nR);
2205 ScMatrixRef pNewMat = GetNewMat( nC, nR);
2206 if (pNewMat)
2207 {
2208 pLinkMat->MatCopy(*pNewMat); // kopieren
2209 PushMatrix( pNewMat );
2210 }
2211 else
2212 PushIllegalArgument();
2213 }
2214 else
2215 PushNA();
2216
2217 pDok->DisableIdle( bOldDis );
2218 }
2219 }
2220
ScBase()2221 void ScInterpreter::ScBase()
2222 { // Value, Base [, MinLen]
2223 sal_uInt8 nParamCount = GetByte();
2224 if ( MustHaveParamCount( nParamCount, 2, 3 ) )
2225 {
2226 static const sal_Unicode __FAR_DATA pDigits[] = {
2227 '0','1','2','3','4','5','6','7','8','9',
2228 'A','B','C','D','E','F','G','H','I','J','K','L','M',
2229 'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
2230 0
2231 };
2232 static const int nDigits = (sizeof(pDigits)/sizeof(sal_Unicode))-1;
2233 xub_StrLen nMinLen;
2234 if ( nParamCount == 3 )
2235 {
2236 double fLen = ::rtl::math::approxFloor( GetDouble() );
2237 if ( 1.0 <= fLen && fLen < STRING_MAXLEN )
2238 nMinLen = (xub_StrLen) fLen;
2239 else if ( fLen == 0.0 )
2240 nMinLen = 1;
2241 else
2242 nMinLen = 0; // Error
2243 }
2244 else
2245 nMinLen = 1;
2246 double fBase = ::rtl::math::approxFloor( GetDouble() );
2247 double fVal = ::rtl::math::approxFloor( GetDouble() );
2248 double fChars = ((fVal > 0.0 && fBase > 0.0) ?
2249 (ceil( log( fVal ) / log( fBase ) ) + 2.0) :
2250 2.0);
2251 if ( fChars >= STRING_MAXLEN )
2252 nMinLen = 0; // Error
2253
2254 if ( !nGlobalError && nMinLen && 2 <= fBase && fBase <= nDigits && 0 <= fVal )
2255 {
2256 const xub_StrLen nConstBuf = 128;
2257 sal_Unicode aBuf[nConstBuf];
2258 xub_StrLen nBuf = Max( (xub_StrLen) fChars, (xub_StrLen) (nMinLen+1) );
2259 sal_Unicode* pBuf = (nBuf <= nConstBuf ? aBuf : new sal_Unicode[nBuf]);
2260 for ( xub_StrLen j = 0; j < nBuf; ++j )
2261 {
2262 pBuf[j] = '0';
2263 }
2264 sal_Unicode* p = pBuf + nBuf - 1;
2265 *p = 0;
2266 if ( fVal <= (sal_uLong)(~0) )
2267 {
2268 sal_uLong nVal = (sal_uLong) fVal;
2269 sal_uLong nBase = (sal_uLong) fBase;
2270 while ( nVal && p > pBuf )
2271 {
2272 *--p = pDigits[ nVal % nBase ];
2273 nVal /= nBase;
2274 }
2275 fVal = (double) nVal;
2276 }
2277 else
2278 {
2279 sal_Bool bDirt = sal_False;
2280 while ( fVal && p > pBuf )
2281 {
2282 //! mit fmod Rundungsfehler ab 2**48
2283 // double fDig = ::rtl::math::approxFloor( fmod( fVal, fBase ) );
2284 // so ist es etwas besser
2285 double fInt = ::rtl::math::approxFloor( fVal / fBase );
2286 double fMult = fInt * fBase;
2287 #if OSL_DEBUG_LEVEL > 1
2288 // #53943# =BASIS(1e308;36) => GPF mit
2289 // nDig = (size_t) ::rtl::math::approxFloor( fVal - fMult );
2290 // trotz vorheriger Pruefung ob fVal >= fMult
2291 double fDebug1 = fVal - fMult;
2292 // fVal := 7,5975311883090e+290
2293 // fMult := 7,5975311883090e+290
2294 // fDebug1 := 1,3848924157003e+275 <- RoundOff-Error
2295 // fVal != fMult, aber: ::rtl::math::approxEqual( fVal, fMult ) == TRUE
2296 double fDebug2 = ::rtl::math::approxSub( fVal, fMult );
2297 // und ::rtl::math::approxSub( fVal, fMult ) == 0
2298 double fDebug3 = ( fInt ? fVal / fInt : 0.0 );
2299 // Nach dem strange fDebug1 und fVal < fMult ist eigentlich
2300 // fDebug2 == fBase, trotzdem wird das mit einem Vergleich
2301 // nicht erkannt, dann schlaegt bDirt zu und alles wird wieder gut..
2302
2303 // prevent compiler warnings
2304 (void)fDebug1; (void)fDebug2; (void)fDebug3;
2305 #endif
2306 size_t nDig;
2307 if ( fVal < fMult )
2308 { // da ist was gekippt
2309 bDirt = sal_True;
2310 nDig = 0;
2311 }
2312 else
2313 {
2314 double fDig = ::rtl::math::approxFloor( ::rtl::math::approxSub( fVal, fMult ) );
2315 if ( bDirt )
2316 {
2317 bDirt = sal_False;
2318 --fDig;
2319 }
2320 if ( fDig <= 0.0 )
2321 nDig = 0;
2322 else if ( fDig >= fBase )
2323 nDig = ((size_t) fBase) - 1;
2324 else
2325 nDig = (size_t) fDig;
2326 }
2327 *--p = pDigits[ nDig ];
2328 fVal = fInt;
2329 }
2330 }
2331 if ( fVal )
2332 PushError( errStringOverflow );
2333 else
2334 {
2335 if ( nBuf - (p - pBuf) <= nMinLen )
2336 p = pBuf + nBuf - 1 - nMinLen;
2337 PushStringBuffer( p );
2338 }
2339 if ( pBuf != aBuf )
2340 delete [] pBuf;
2341 }
2342 else
2343 PushIllegalArgument();
2344 }
2345 }
2346
2347
ScDecimal()2348 void ScInterpreter::ScDecimal()
2349 { // Text, Base
2350 if ( MustHaveParamCount( GetByte(), 2 ) )
2351 {
2352 double fBase = ::rtl::math::approxFloor( GetDouble() );
2353 String aStr( GetString() );
2354 if ( !nGlobalError && 2 <= fBase && fBase <= 36 )
2355 {
2356 double fVal = 0.0;
2357 int nBase = (int) fBase;
2358 register const sal_Unicode* p = aStr.GetBuffer();
2359 while ( *p == ' ' || *p == '\t' )
2360 p++; // strip leading white space
2361 if ( nBase == 16 )
2362 { // evtl. hex-prefix strippen
2363 if ( *p == 'x' || *p == 'X' )
2364 p++;
2365 else if ( *p == '0' && (*(p+1) == 'x' || *(p+1) == 'X') )
2366 p += 2;
2367 }
2368 while ( *p )
2369 {
2370 int n;
2371 if ( '0' <= *p && *p <= '9' )
2372 n = *p - '0';
2373 else if ( 'A' <= *p && *p <= 'Z' )
2374 n = 10 + (*p - 'A');
2375 else if ( 'a' <= *p && *p <= 'z' )
2376 n = 10 + (*p - 'a');
2377 else
2378 n = nBase;
2379 if ( nBase <= n )
2380 {
2381 if ( *(p+1) == 0 &&
2382 ( (nBase == 2 && (*p == 'b' || *p == 'B'))
2383 ||(nBase == 16 && (*p == 'h' || *p == 'H')) )
2384 )
2385 ; // 101b und F00Dh sind ok
2386 else
2387 {
2388 PushIllegalArgument();
2389 return ;
2390 }
2391 }
2392 else
2393 fVal = fVal * fBase + n;
2394 p++;
2395
2396 }
2397 PushDouble( fVal );
2398 }
2399 else
2400 PushIllegalArgument();
2401 }
2402 }
2403
2404
ScConvert()2405 void ScInterpreter::ScConvert()
2406 { // Value, FromUnit, ToUnit
2407 if ( MustHaveParamCount( GetByte(), 3 ) )
2408 {
2409 String aToUnit( GetString() );
2410 String aFromUnit( GetString() );
2411 double fVal = GetDouble();
2412 if ( nGlobalError )
2413 PushError( nGlobalError);
2414 else
2415 { // erst die angegebene Reihenfolge suchen, wenn nicht gefunden den Kehrwert
2416 double fConv;
2417 if ( ScGlobal::GetUnitConverter()->GetValue( fConv, aFromUnit, aToUnit ) )
2418 PushDouble( fVal * fConv );
2419 else if ( ScGlobal::GetUnitConverter()->GetValue( fConv, aToUnit, aFromUnit ) )
2420 PushDouble( fVal / fConv );
2421 else
2422 PushNA();
2423 }
2424 }
2425 }
2426
2427
ScRoman()2428 void ScInterpreter::ScRoman()
2429 { // Value [Mode]
2430 sal_uInt8 nParamCount = GetByte();
2431 if( MustHaveParamCount( nParamCount, 1, 2 ) )
2432 {
2433 double fMode = (nParamCount == 2) ? ::rtl::math::approxFloor( GetDouble() ) : 0.0;
2434 double fVal = ::rtl::math::approxFloor( GetDouble() );
2435 if( nGlobalError )
2436 PushError( nGlobalError);
2437 else if( (fMode >= 0.0) && (fMode < 5.0) && (fVal >= 0.0) && (fVal < 4000.0) )
2438 {
2439 static const sal_Unicode pChars[] = { 'M', 'D', 'C', 'L', 'X', 'V', 'I' };
2440 static const sal_uInt16 pValues[] = { 1000, 500, 100, 50, 10, 5, 1 };
2441 static const sal_uInt16 nMaxIndex = (sal_uInt16)(sizeof(pValues) / sizeof(pValues[0]) - 1);
2442
2443 String aRoman;
2444 sal_uInt16 nVal = (sal_uInt16) fVal;
2445 sal_uInt16 nMode = (sal_uInt16) fMode;
2446
2447 for( sal_uInt16 i = 0; i <= nMaxIndex / 2; i++ )
2448 {
2449 sal_uInt16 nIndex = 2 * i;
2450 sal_uInt16 nDigit = nVal / pValues[ nIndex ];
2451
2452 if( (nDigit % 5) == 4 )
2453 {
2454 sal_uInt16 nIndex2 = (nDigit == 4) ? nIndex - 1 : nIndex - 2;
2455 sal_uInt16 nSteps = 0;
2456 while( (nSteps < nMode) && (nIndex < nMaxIndex) )
2457 {
2458 nSteps++;
2459 if( pValues[ nIndex2 ] - pValues[ nIndex + 1 ] <= nVal )
2460 nIndex++;
2461 else
2462 nSteps = nMode;
2463 }
2464 aRoman += pChars[ nIndex ];
2465 aRoman += pChars[ nIndex2 ];
2466 nVal = sal::static_int_cast<sal_uInt16>( nVal + pValues[ nIndex ] );
2467 nVal = sal::static_int_cast<sal_uInt16>( nVal - pValues[ nIndex2 ] );
2468 }
2469 else
2470 {
2471 if( nDigit > 4 )
2472 aRoman += pChars[ nIndex - 1 ];
2473 aRoman.Expand( aRoman.Len() + (nDigit % 5), pChars[ nIndex ] );
2474 nVal %= pValues[ nIndex ];
2475 }
2476 }
2477
2478 PushString( aRoman );
2479 }
2480 else
2481 PushIllegalArgument();
2482 }
2483 }
2484
2485
lcl_GetArabicValue(sal_Unicode cChar,sal_uInt16 & rnValue,sal_Bool & rbIsDec)2486 sal_Bool lcl_GetArabicValue( sal_Unicode cChar, sal_uInt16& rnValue, sal_Bool& rbIsDec )
2487 {
2488 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScBase" );
2489 switch( cChar )
2490 {
2491 case 'M': rnValue = 1000; rbIsDec = sal_True; break;
2492 case 'D': rnValue = 500; rbIsDec = sal_False; break;
2493 case 'C': rnValue = 100; rbIsDec = sal_True; break;
2494 case 'L': rnValue = 50; rbIsDec = sal_False; break;
2495 case 'X': rnValue = 10; rbIsDec = sal_True; break;
2496 case 'V': rnValue = 5; rbIsDec = sal_False; break;
2497 case 'I': rnValue = 1; rbIsDec = sal_True; break;
2498 default: return sal_False;
2499 }
2500 return sal_True;
2501 }
2502
2503
ScArabic()2504 void ScInterpreter::ScArabic()
2505 {
2506 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScArabic" );
2507 String aRoman( GetString() );
2508 if( nGlobalError )
2509 PushError( nGlobalError);
2510 else
2511 {
2512 aRoman.ToUpperAscii();
2513
2514 sal_uInt16 nValue = 0;
2515 sal_uInt16 nValidRest = 3999;
2516 sal_uInt16 nCharIndex = 0;
2517 sal_uInt16 nCharCount = aRoman.Len();
2518 sal_Bool bValid = sal_True;
2519
2520 while( bValid && (nCharIndex < nCharCount) )
2521 {
2522 sal_uInt16 nDigit1 = 0;
2523 sal_uInt16 nDigit2 = 0;
2524 sal_Bool bIsDec1 = sal_False;
2525 sal_Bool bIsDec2 = sal_False;
2526 bValid = lcl_GetArabicValue( aRoman.GetChar( nCharIndex ), nDigit1, bIsDec1 );
2527 if( bValid && (nCharIndex + 1 < nCharCount) )
2528 bValid = lcl_GetArabicValue( aRoman.GetChar( nCharIndex + 1 ), nDigit2, bIsDec2 );
2529 if( bValid )
2530 {
2531 if( nDigit1 >= nDigit2 )
2532 {
2533 nValue = sal::static_int_cast<sal_uInt16>( nValue + nDigit1 );
2534 nValidRest %= (nDigit1 * (bIsDec1 ? 5 : 2));
2535 bValid = (nValidRest >= nDigit1);
2536 if( bValid )
2537 nValidRest = sal::static_int_cast<sal_uInt16>( nValidRest - nDigit1 );
2538 nCharIndex++;
2539 }
2540 else if( nDigit1 * 2 != nDigit2 )
2541 {
2542 sal_uInt16 nDiff = nDigit2 - nDigit1;
2543 nValue = sal::static_int_cast<sal_uInt16>( nValue + nDiff );
2544 bValid = (nValidRest >= nDiff);
2545 if( bValid )
2546 nValidRest = nDigit1 - 1;
2547 nCharIndex += 2;
2548 }
2549 else
2550 bValid = sal_False;
2551 }
2552 }
2553 if( bValid )
2554 PushInt( nValue );
2555 else
2556 PushIllegalArgument();
2557 }
2558 }
2559
2560
ScHyperLink()2561 void ScInterpreter::ScHyperLink()
2562 {
2563 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScHyperLink" );
2564 sal_uInt8 nParamCount = GetByte();
2565 if ( MustHaveParamCount( nParamCount, 1, 2 ) )
2566 {
2567 double fVal = 0.0;
2568 String aStr;
2569 ScMatValType nResultType = SC_MATVAL_STRING;
2570
2571 if ( nParamCount == 2 )
2572 {
2573 switch ( GetStackType() )
2574 {
2575 case svDouble:
2576 fVal = GetDouble();
2577 nResultType = SC_MATVAL_VALUE;
2578 break;
2579 case svString:
2580 aStr = GetString();
2581 break;
2582 case svSingleRef:
2583 case svDoubleRef:
2584 {
2585 ScAddress aAdr;
2586 if ( !PopDoubleRefOrSingleRef( aAdr ) )
2587 break;
2588 ScBaseCell* pCell = GetCell( aAdr );
2589 if (HasCellEmptyData( pCell))
2590 nResultType = SC_MATVAL_EMPTY;
2591 else
2592 {
2593 sal_uInt16 nErr = GetCellErrCode( pCell );
2594 if (nErr)
2595 SetError( nErr);
2596 else if (HasCellValueData( pCell))
2597 {
2598 fVal = GetCellValue( aAdr, pCell );
2599 nResultType = SC_MATVAL_VALUE;
2600 }
2601 else
2602 GetCellString( aStr, pCell );
2603 }
2604 }
2605 break;
2606 case svMatrix:
2607 nResultType = GetDoubleOrStringFromMatrix( fVal, aStr);
2608 break;
2609 case svMissing:
2610 case svEmptyCell:
2611 Pop();
2612 // mimic xcl
2613 fVal = 0.0;
2614 nResultType = SC_MATVAL_VALUE;
2615 break;
2616 default:
2617 PopError();
2618 SetError( errIllegalArgument);
2619 }
2620 }
2621 String aUrl = GetString();
2622 ScMatrixRef pResMat = GetNewMat( 1, 2);
2623 if (nGlobalError)
2624 {
2625 fVal = CreateDoubleError( nGlobalError);
2626 nResultType = SC_MATVAL_VALUE;
2627 }
2628 if (nParamCount == 2 || nGlobalError)
2629 {
2630 if (ScMatrix::IsValueType( nResultType))
2631 pResMat->PutDouble( fVal, 0);
2632 else if (ScMatrix::IsRealStringType( nResultType))
2633 pResMat->PutString( aStr, 0);
2634 else // EmptyType, EmptyPathType, mimic xcl
2635 pResMat->PutDouble( 0.0, 0 );
2636 }
2637 else
2638 pResMat->PutString( aUrl, 0 );
2639 pResMat->PutString( aUrl, 1 );
2640 bMatrixFormula = true;
2641 PushMatrix(pResMat);
2642 }
2643 }
2644
2645
lclConvertMoney(const String & aSearchUnit,double & rfRate,int & rnDec)2646 sal_Bool lclConvertMoney( const String& aSearchUnit, double& rfRate, int& rnDec )
2647 {
2648 struct ConvertInfo
2649 {
2650 const sal_Char* pCurrText;
2651 double fRate;
2652 int nDec;
2653 };
2654 ConvertInfo aConvertTable[] = {
2655 { "EUR", 1.0, 2 },
2656 { "ATS", 13.7603, 2 },
2657 { "BEF", 40.3399, 0 },
2658 { "DEM", 1.95583, 2 },
2659 { "ESP", 166.386, 0 },
2660 { "FIM", 5.94573, 2 },
2661 { "FRF", 6.55957, 2 },
2662 { "IEP", 0.787564, 2 },
2663 { "ITL", 1936.27, 0 },
2664 { "LUF", 40.3399, 0 },
2665 { "NLG", 2.20371, 2 },
2666 { "PTE", 200.482, 2 },
2667 { "GRD", 340.750, 2 },
2668 { "SIT", 239.640, 2 },
2669 { "MTL", 0.429300, 2 },
2670 { "CYP", 0.585274, 2 },
2671 { "SKK", 30.1260, 2 },
2672 { "EEK", 15.6466, 2 },
2673 { "LVL", 0.702804, 2 },
2674 { "LTL", 3.45280, 2 },
2675 { "HRK", 7.53450, 2 }
2676 };
2677
2678 const size_t nConversionCount = sizeof( aConvertTable ) / sizeof( aConvertTable[0] );
2679 for ( size_t i = 0; i < nConversionCount; i++ )
2680 if ( aSearchUnit.EqualsIgnoreCaseAscii( aConvertTable[i].pCurrText ) )
2681 {
2682 rfRate = aConvertTable[i].fRate;
2683 rnDec = aConvertTable[i].nDec;
2684 return sal_True;
2685 }
2686 return sal_False;
2687 }
2688
ScEuroConvert()2689 void ScInterpreter::ScEuroConvert()
2690 { //Value, FromUnit, ToUnit[, FullPrecision, [TriangulationPrecision]]
2691 sal_uInt8 nParamCount = GetByte();
2692 if ( MustHaveParamCount( nParamCount, 3, 5 ) )
2693 {
2694 double nPrecision = 0.0;
2695 if ( nParamCount == 5 )
2696 {
2697 nPrecision = ::rtl::math::approxFloor(GetDouble());
2698 if ( nPrecision < 3 )
2699 {
2700 PushIllegalArgument();
2701 return;
2702 }
2703 }
2704 sal_Bool bFullPrecision = sal_False;
2705 if ( nParamCount >= 4 )
2706 bFullPrecision = GetBool();
2707 String aToUnit( GetString() );
2708 String aFromUnit( GetString() );
2709 double fVal = GetDouble();
2710 if ( nGlobalError )
2711 PushError( nGlobalError);
2712 else
2713 {
2714 double fRes;
2715 double fFromRate;
2716 double fToRate;
2717 int nFromDec;
2718 int nToDec;
2719 String aEur( RTL_CONSTASCII_USTRINGPARAM("EUR"));
2720 if ( lclConvertMoney( aFromUnit, fFromRate, nFromDec )
2721 && lclConvertMoney( aToUnit, fToRate, nToDec ) )
2722 {
2723 if ( aFromUnit.EqualsIgnoreCaseAscii( aToUnit ) )
2724 fRes = fVal;
2725 else
2726 {
2727 if ( aFromUnit.EqualsIgnoreCaseAscii( aEur ) )
2728 fRes = fVal * fToRate;
2729 else
2730 {
2731 double fIntermediate = fVal / fFromRate;
2732 if ( nPrecision )
2733 fIntermediate = ::rtl::math::round( fIntermediate,
2734 (int) nPrecision );
2735 fRes = fIntermediate * fToRate;
2736 }
2737 if ( !bFullPrecision )
2738 fRes = ::rtl::math::round( fRes, nToDec );
2739 }
2740 PushDouble( fRes );
2741 }
2742 else
2743 PushIllegalArgument();
2744 }
2745 }
2746 }
2747
2748
2749 // BAHTTEXT ===================================================================
2750
2751 #define UTF8_TH_0 "\340\270\250\340\270\271\340\270\231\340\270\242\340\271\214"
2752 #define UTF8_TH_1 "\340\270\253\340\270\231\340\270\266\340\271\210\340\270\207"
2753 #define UTF8_TH_2 "\340\270\252\340\270\255\340\270\207"
2754 #define UTF8_TH_3 "\340\270\252\340\270\262\340\270\241"
2755 #define UTF8_TH_4 "\340\270\252\340\270\265\340\271\210"
2756 #define UTF8_TH_5 "\340\270\253\340\271\211\340\270\262"
2757 #define UTF8_TH_6 "\340\270\253\340\270\201"
2758 #define UTF8_TH_7 "\340\271\200\340\270\210\340\271\207\340\270\224"
2759 #define UTF8_TH_8 "\340\271\201\340\270\233\340\270\224"
2760 #define UTF8_TH_9 "\340\271\200\340\270\201\340\271\211\340\270\262"
2761 #define UTF8_TH_10 "\340\270\252\340\270\264\340\270\232"
2762 #define UTF8_TH_11 "\340\271\200\340\270\255\340\271\207\340\270\224"
2763 #define UTF8_TH_20 "\340\270\242\340\270\265\340\271\210"
2764 #define UTF8_TH_1E2 "\340\270\243\340\271\211\340\270\255\340\270\242"
2765 #define UTF8_TH_1E3 "\340\270\236\340\270\261\340\270\231"
2766 #define UTF8_TH_1E4 "\340\270\253\340\270\241\340\270\267\340\271\210\340\270\231"
2767 #define UTF8_TH_1E5 "\340\271\201\340\270\252\340\270\231"
2768 #define UTF8_TH_1E6 "\340\270\245\340\271\211\340\270\262\340\270\231"
2769 #define UTF8_TH_DOT0 "\340\270\226\340\271\211\340\270\247\340\270\231"
2770 #define UTF8_TH_BAHT "\340\270\232\340\270\262\340\270\227"
2771 #define UTF8_TH_SATANG "\340\270\252\340\270\225\340\270\262\340\270\207\340\270\204\340\271\214"
2772 #define UTF8_TH_MINUS "\340\270\245\340\270\232"
2773
2774 #define UTF8_STRINGPARAM( ascii ) ascii, static_cast< xub_StrLen >( sizeof( ascii ) - 1 )
2775 #define UTF8_CREATE( ascii ) ByteString( UTF8_STRINGPARAM( ascii ) )
2776 #define UTF8_APPEND( ascii ) Append( UTF8_STRINGPARAM( ascii ) )
2777 #define UTF8_PREPEND( ascii ) Insert( UTF8_CREATE( ascii ), 0 )
2778
2779 // local functions ------------------------------------------------------------
2780
2781 namespace {
2782
lclSplitBlock(double & rfInt,sal_Int32 & rnBlock,double fValue,double fSize)2783 inline void lclSplitBlock( double& rfInt, sal_Int32& rnBlock, double fValue, double fSize )
2784 {
2785 rnBlock = static_cast< sal_Int32 >( modf( (fValue + 0.1) / fSize, &rfInt ) * fSize + 0.1 );
2786 }
2787
2788 /** Appends a digit (0 to 9) to the passed string. */
lclAppendDigit(ByteString & rText,sal_Int32 nDigit)2789 void lclAppendDigit( ByteString& rText, sal_Int32 nDigit )
2790 {
2791 switch( nDigit )
2792 {
2793 case 0: rText.UTF8_APPEND( UTF8_TH_0 ); break;
2794 case 1: rText.UTF8_APPEND( UTF8_TH_1 ); break;
2795 case 2: rText.UTF8_APPEND( UTF8_TH_2 ); break;
2796 case 3: rText.UTF8_APPEND( UTF8_TH_3 ); break;
2797 case 4: rText.UTF8_APPEND( UTF8_TH_4 ); break;
2798 case 5: rText.UTF8_APPEND( UTF8_TH_5 ); break;
2799 case 6: rText.UTF8_APPEND( UTF8_TH_6 ); break;
2800 case 7: rText.UTF8_APPEND( UTF8_TH_7 ); break;
2801 case 8: rText.UTF8_APPEND( UTF8_TH_8 ); break;
2802 case 9: rText.UTF8_APPEND( UTF8_TH_9 ); break;
2803 default: DBG_ERRORFILE( "lclAppendDigit - illegal digit" );
2804 }
2805 }
2806
2807 /** Appends a value raised to a power of 10: nDigit*10^nPow10.
2808 @param nDigit A digit in the range from 1 to 9.
2809 @param nPow10 A value in the range from 2 to 5.
2810 */
lclAppendPow10(ByteString & rText,sal_Int32 nDigit,sal_Int32 nPow10)2811 void lclAppendPow10( ByteString& rText, sal_Int32 nDigit, sal_Int32 nPow10 )
2812 {
2813 DBG_ASSERT( (1 <= nDigit) && (nDigit <= 9), "lclAppendPow10 - illegal digit" );
2814 lclAppendDigit( rText, nDigit );
2815 switch( nPow10 )
2816 {
2817 case 2: rText.UTF8_APPEND( UTF8_TH_1E2 ); break;
2818 case 3: rText.UTF8_APPEND( UTF8_TH_1E3 ); break;
2819 case 4: rText.UTF8_APPEND( UTF8_TH_1E4 ); break;
2820 case 5: rText.UTF8_APPEND( UTF8_TH_1E5 ); break;
2821 default: DBG_ERRORFILE( "lclAppendPow10 - illegal power" );
2822 }
2823 }
2824
2825 /** Appends a block of 6 digits (value from 1 to 999,999) to the passed string. */
lclAppendBlock(ByteString & rText,sal_Int32 nValue)2826 void lclAppendBlock( ByteString& rText, sal_Int32 nValue )
2827 {
2828 DBG_ASSERT( (1 <= nValue) && (nValue <= 999999), "lclAppendBlock - illegal value" );
2829 if( nValue >= 100000 )
2830 {
2831 lclAppendPow10( rText, nValue / 100000, 5 );
2832 nValue %= 100000;
2833 }
2834 if( nValue >= 10000 )
2835 {
2836 lclAppendPow10( rText, nValue / 10000, 4 );
2837 nValue %= 10000;
2838 }
2839 if( nValue >= 1000 )
2840 {
2841 lclAppendPow10( rText, nValue / 1000, 3 );
2842 nValue %= 1000;
2843 }
2844 if( nValue >= 100 )
2845 {
2846 lclAppendPow10( rText, nValue / 100, 2 );
2847 nValue %= 100;
2848 }
2849 if( nValue > 0 )
2850 {
2851 sal_Int32 nTen = nValue / 10;
2852 sal_Int32 nOne = nValue % 10;
2853 if( nTen >= 1 )
2854 {
2855 if( nTen >= 3 )
2856 lclAppendDigit( rText, nTen );
2857 else if( nTen == 2 )
2858 rText.UTF8_APPEND( UTF8_TH_20 );
2859 rText.UTF8_APPEND( UTF8_TH_10 );
2860 }
2861 if( (nTen > 0) && (nOne == 1) )
2862 rText.UTF8_APPEND( UTF8_TH_11 );
2863 else if( nOne > 0 )
2864 lclAppendDigit( rText, nOne );
2865 }
2866 }
2867
2868 } // namespace
2869
2870 // ----------------------------------------------------------------------------
2871
ScBahtText()2872 void ScInterpreter::ScBahtText()
2873 {
2874 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScBahtText" );
2875 sal_uInt8 nParamCount = GetByte();
2876 if ( MustHaveParamCount( nParamCount, 1 ) )
2877 {
2878 double fValue = GetDouble();
2879 if( nGlobalError )
2880 {
2881 PushError( nGlobalError);
2882 return;
2883 }
2884
2885 // sign
2886 bool bMinus = fValue < 0.0;
2887 fValue = fabs( fValue );
2888
2889 // round to 2 digits after decimal point, fValue contains Satang as integer
2890 fValue = ::rtl::math::approxFloor( fValue * 100.0 + 0.5 );
2891
2892 // split Baht and Satang
2893 double fBaht = 0.0;
2894 sal_Int32 nSatang = 0;
2895 lclSplitBlock( fBaht, nSatang, fValue, 100.0 );
2896
2897 ByteString aText;
2898
2899 // generate text for Baht value
2900 if( fBaht == 0.0 )
2901 {
2902 if( nSatang == 0 )
2903 aText.UTF8_APPEND( UTF8_TH_0 );
2904 }
2905 else while( fBaht > 0.0 )
2906 {
2907 ByteString aBlock;
2908 sal_Int32 nBlock = 0;
2909 lclSplitBlock( fBaht, nBlock, fBaht, 1.0e6 );
2910 if( nBlock > 0 )
2911 lclAppendBlock( aBlock, nBlock );
2912 // add leading "million", if there will come more blocks
2913 if( fBaht > 0.0 )
2914 aBlock.UTF8_PREPEND( UTF8_TH_1E6 );
2915 aText.Insert( aBlock, 0 );
2916 }
2917 if( aText.Len() > 0 )
2918 aText.UTF8_APPEND( UTF8_TH_BAHT );
2919
2920 // generate text for Satang value
2921 if( nSatang == 0 )
2922 {
2923 aText.UTF8_APPEND( UTF8_TH_DOT0 );
2924 }
2925 else
2926 {
2927 lclAppendBlock( aText, nSatang );
2928 aText.UTF8_APPEND( UTF8_TH_SATANG );
2929 }
2930
2931 // add the minus sign
2932 if( bMinus )
2933 aText.UTF8_PREPEND( UTF8_TH_MINUS );
2934
2935 PushString( String( aText, RTL_TEXTENCODING_UTF8 ) );
2936 }
2937 }
2938
2939 // ============================================================================
2940
ScGetPivotData()2941 void ScInterpreter::ScGetPivotData()
2942 {
2943 RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScGetPivotData" );
2944 sal_uInt8 nParamCount = GetByte();
2945
2946 if ( MustHaveParamCount( nParamCount, 2, 30 ) )
2947 {
2948 // there must be an even number of args
2949 // target, ref, then field/item pairs
2950 if( (nParamCount % 2) == 1)
2951 goto failed;
2952
2953 bool bOldSyntax = false;
2954 if ( nParamCount == 2 )
2955 {
2956 // if the first parameter is a ref, assume old syntax
2957 StackVar eFirstType = GetStackType( 2 );
2958 if ( eFirstType == svSingleRef || eFirstType == svDoubleRef )
2959 bOldSyntax = true;
2960 }
2961
2962 ScDPGetPivotDataField aTarget; // target field, and returns result
2963 std::vector< ScDPGetPivotDataField > aFilters;
2964 String aFilterList;
2965 if ( bOldSyntax )
2966 aFilterList = GetString(); // old syntax: second parameter is list of constraints
2967 else
2968 {
2969 // new syntax: separate name/value pairs
2970
2971 sal_uInt16 nFilterCount = nParamCount / 2 - 1;
2972 aFilters.resize( nFilterCount );
2973
2974 sal_uInt16 i = nFilterCount;
2975 while( i-- > 0 )
2976 {
2977 //! should allow numeric constraint values
2978 aFilters[i].mbValIsStr = sal_True;
2979 aFilters[i].maValStr = GetString();
2980
2981 aFilters[i].maFieldName = GetString();
2982 }
2983 }
2984
2985 // common to both syntaxes: a reference to the data pilot table
2986
2987 ScRange aBlock;
2988 switch ( GetStackType() )
2989 {
2990 case svDoubleRef :
2991 PopDoubleRef( aBlock );
2992 break;
2993
2994 case svSingleRef :
2995 {
2996 ScAddress aAddr;
2997 PopSingleRef( aAddr );
2998 aBlock = aAddr;
2999 break;
3000 }
3001 default:
3002 goto failed;
3003 }
3004 // NOTE : MS Excel docs claim to use the 'most recent' which is not
3005 // exactly the same as what we do in ScDocument::GetDPAtBlock
3006 // However we do need to use GetDPABlock
3007 ScDPObject* pDPObj = pDok->GetDPAtBlock ( aBlock );
3008 if( NULL == pDPObj)
3009 goto failed;
3010
3011 if ( bOldSyntax )
3012 {
3013 // fill aFilters / aTarget from aFilterList string
3014 if ( !pDPObj->ParseFilters( aTarget, aFilters, aFilterList ) )
3015 goto failed;
3016 }
3017 else
3018 aTarget.maFieldName = GetString(); // new syntax: first parameter is data field name
3019
3020 if( pDPObj->GetPivotData( aTarget, aFilters ) )
3021 {
3022 if( aTarget.mbValIsStr )
3023 PushString( aTarget.maValStr );
3024 else
3025 PushDouble( aTarget.mnValNum );
3026 return;
3027 }
3028 }
3029
3030 failed :
3031 PushError( errNoRef );
3032 }
3033