Debian Codegraph @

basic/source/runtime/methods1.cxx

raw
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 <config_features.h>
21
22 #include <sal/config.h>
23 #include <config_version.h>
24
25 #include <rtl/math.hxx>
26 #include <vcl/svapp.hxx>
27 #include <vcl/mapmod.hxx>
28 #include <vcl/outdev.hxx>
29 #include <vcl/timer.hxx>
30 #include <vcl/settings.hxx>
31 #include <basic/sbxvar.hxx>
32 #include <basic/sbx.hxx>
33 #include <svl/zforlist.hxx>
34 #include <tools/urlobj.hxx>
35 #include <tools/fract.hxx>
36 #include <o3tl/environment.hxx>
37 #include <o3tl/temporary.hxx>
38 #include <osl/file.hxx>
39 #include <sbobjmod.hxx>
40 #include <basic/sbuno.hxx>
41
42 #include <date.hxx>
43 #include <sbintern.hxx>
44 #include <runtime.hxx>
45 #include <rtlproto.hxx>
46 #include "dllmgr.hxx"
47 #include <iosys.hxx>
48 #include <sbunoobj.hxx>
49 #include <propacc.hxx>
50 #include <sal/log.hxx>
51 #include <eventatt.hxx>
52 #include <rtl/math.h>
53 #include <svl/numformat.hxx>
54
55 #include <comphelper/processfactory.hxx>
56 #include <comphelper/string.hxx>
57
58 #include <com/sun/star/uno/Sequence.hxx>
59 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
60 #include <com/sun/star/i18n/LocaleCalendar2.hpp>
61 #include <com/sun/star/sheet/XFunctionAccess.hpp>
62
63 #include <memory>
64
65 using namespace comphelper;
66 using namespace com::sun::star::i18n;
67 using namespace com::sun::star::lang;
68 using namespace com::sun::star::sheet;
69 using namespace com::sun::star::uno;
70
71 static Reference< XCalendar4 > const & getLocaleCalendar()
72 {
73 static Reference< XCalendar4 > xCalendar = LocaleCalendar2::create(getProcessComponentContext());
74 static css::lang::Locale aLastLocale;
75 static bool bNeedsReload = true;
76
77 css::lang::Locale aLocale = Application::GetSettings().GetLanguageTag().getLocale();
78 bNeedsReload = bNeedsReload ||
79 ( aLocale.Language != aLastLocale.Language ||
80 aLocale.Country != aLastLocale.Country ||
81 aLocale.Variant != aLastLocale.Variant );
82 if( bNeedsReload )
83 {
84 bNeedsReload = false;
85 aLastLocale = aLocale;
86 xCalendar->loadDefaultCalendar( aLocale );
87 }
88 return xCalendar;
89 }
90
91 #if HAVE_FEATURE_SCRIPTING
92
93 void SbRtl_CallByName(StarBASIC *, SbxArray & rPar, bool)
94 {
95 const sal_Int16 vbGet = 2;
96 const sal_Int16 vbLet = 4;
97 const sal_Int16 vbMethod = 1;
98 const sal_Int16 vbSet = 8;
99
100 // At least 3 parameter needed plus function itself -> 4
101 sal_uInt32 nParCount = rPar.Count();
102 if ( nParCount < 4 )
103 {
104 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
105 return;
106 }
107
108 // 1. parameter is object
109 SbxBase* pObjVar = rPar.Get(1)->GetObject();
110 SbxObject* pObj = nullptr;
111 if( pObjVar )
112 pObj = dynamic_cast<SbxObject*>( pObjVar );
113 if( !pObj )
114 if (auto pSbxVar = dynamic_cast<const SbxVariable*>( pObjVar))
115 pObj = dynamic_cast<SbxObject*>( pSbxVar->GetObject() );
116 if( !pObj )
117 {
118 StarBASIC::Error( ERRCODE_BASIC_BAD_PARAMETER );
119 return;
120 }
121
122 // 2. parameter is ProcName
123 OUString aNameStr = rPar.Get(2)->GetOUString();
124
125 // 3. parameter is CallType
126 sal_Int16 nCallType = rPar.Get(3)->GetInteger();
127
128 //SbxObject* pFindObj = NULL;
129 SbxVariable* pFindVar = pObj->Find( aNameStr, SbxClassType::DontCare );
130 if( pFindVar == nullptr )
131 {
132 StarBASIC::Error( ERRCODE_BASIC_PROC_UNDEFINED );
133 return;
134 }
135
136 switch( nCallType )
137 {
138 case vbGet:
139 {
140 SbxValues aVals;
141 aVals.eType = SbxVARIANT;
142 pFindVar->Get( aVals );
143
144 SbxVariableRef refVar = rPar.Get(0);
145 refVar->Put( aVals );
146 }
147 break;
148 case vbLet:
149 case vbSet:
150 {
151 if ( nParCount != 5 )
152 {
153 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
154 return;
155 }
156 SbxVariableRef pValVar = rPar.Get(4);
157 if( nCallType == vbLet )
158 {
159 SbxValues aVals;
160 aVals.eType = SbxVARIANT;
161 pValVar->Get( aVals );
162 pFindVar->Put( aVals );
163 }
164 else
165 {
166 SbxVariableRef rFindVar = pFindVar;
167 SbiInstance* pInst = GetSbData()->pInst;
168 SbiRuntime* pRT = pInst ? pInst->pRun : nullptr;
169 if( pRT != nullptr )
170 {
171 pRT->StepSET_Impl( pValVar, rFindVar );
172 }
173 }
174 }
175 break;
176 case vbMethod:
177 {
178 SbMethod* pMeth = dynamic_cast<SbMethod*>( pFindVar );
179 if( pMeth == nullptr )
180 {
181 StarBASIC::Error( ERRCODE_BASIC_PROC_UNDEFINED );
182 return;
183 }
184
185 // Setup parameters
186 SbxArrayRef xArray;
187 sal_uInt32 nMethParamCount = nParCount - 4;
188 if( nMethParamCount > 0 )
189 {
190 xArray = new SbxArray;
191 for( sal_uInt32 i = 0 ; i < nMethParamCount ; i++ )
192 {
193 SbxVariable* pPar = rPar.Get(i + 4);
194 xArray->Put(pPar, i + 1);
195 }
196 }
197
198 // Call method
199 SbxVariableRef refVar = rPar.Get(0);
200 if( xArray.is() )
201 pMeth->SetParameters( xArray.get() );
202 pMeth->Call( refVar.get() );
203 pMeth->SetParameters( nullptr );
204 }
205 break;
206 default:
207 StarBASIC::Error( ERRCODE_BASIC_PROC_UNDEFINED );
208 }
209 }
210
211 void SbRtl_CBool(StarBASIC *, SbxArray & rPar, bool) // JSM
212 {
213 bool bVal = false;
214 if (rPar.Count() == 2)
215 {
216 SbxVariable* pSbxVariable = rPar.Get(1);
217 bVal = pSbxVariable->GetBool();
218 }
219 else
220 {
221 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
222 }
223 rPar.Get(0)->PutBool(bVal);
224 }
225
226 void SbRtl_CByte(StarBASIC *, SbxArray & rPar, bool) // JSM
227 {
228 sal_uInt8 nByte = 0;
229 if (rPar.Count() == 2)
230 {
231 SbxVariable* pSbxVariable = rPar.Get(1);
232 nByte = pSbxVariable->GetByte();
233 }
234 else
235 {
236 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
237 }
238 rPar.Get(0)->PutByte(nByte);
239 }
240
241 void SbRtl_CCur(StarBASIC *, SbxArray & rPar, bool)
242 {
243 sal_Int64 nCur = 0;
244 if (rPar.Count() == 2)
245 {
246 SbxVariable* pSbxVariable = rPar.Get(1);
247 nCur = pSbxVariable->GetCurrency();
248 }
249 else
250 {
251 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
252 }
253 rPar.Get(0)->PutCurrency(nCur);
254 }
255
256 void SbRtl_CDec(StarBASIC *, SbxArray & rPar, bool)
257 {
258 #ifdef _WIN32
259 SbxDecimal* pDec = nullptr;
260 if (rPar.Count() == 2)
261 {
262 SbxVariable* pSbxVariable = rPar.Get(1);
263 pDec = pSbxVariable->GetDecimal();
264 }
265 else
266 {
267 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
268 }
269 rPar.Get(0)->PutDecimal(pDec);
270 #else
271 rPar.Get(0)->PutEmpty();
272 StarBASIC::Error(ERRCODE_BASIC_NOT_IMPLEMENTED);
273 #endif
274 }
275
276 void SbRtl_CDate(StarBASIC *, SbxArray & rPar, bool) // JSM
277 {
278 double nVal = 0.0;
279 if (rPar.Count() != 2)
280 return StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
281
282 SbxVariable* pSbxVariable = rPar.Get(1);
283 nVal = pSbxVariable->GetDate();
284 rPar.Get(0)->PutDate(nVal);
285 }
286
287 void SbRtl_CDbl(StarBASIC *, SbxArray & rPar, bool) // JSM
288 {
289 double nVal = 0.0;
290 if (rPar.Count() == 2)
291 {
292 SbxVariable* pSbxVariable = rPar.Get(1);
293 if( pSbxVariable->GetType() == SbxSTRING )
294 {
295 // #41690
296 OUString aScanStr = pSbxVariable->GetOUString();
297 ErrCode Error = SbxValue::ScanNumIntnl( aScanStr, nVal );
298 if( Error != ERRCODE_NONE )
299 {
300 StarBASIC::Error( Error );
301 }
302 }
303 else
304 {
305 nVal = pSbxVariable->GetDouble();
306 }
307 }
308 else
309 {
310 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
311 }
312
313 rPar.Get(0)->PutDouble(nVal);
314 }
315
316 void SbRtl_CInt(StarBASIC *, SbxArray & rPar, bool) // JSM
317 {
318 sal_Int16 nVal = 0;
319 if (rPar.Count() != 2)
320 return StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
321
322 SbxVariable* pSbxVariable = rPar.Get(1);
323 nVal = pSbxVariable->GetInteger();
324 rPar.Get(0)->PutInteger(nVal);
325 }
326
327 void SbRtl_CLng(StarBASIC *, SbxArray & rPar, bool) // JSM
328 {
329 sal_Int32 nVal = 0;
330 if (rPar.Count() != 2)
331 return StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
332
333 SbxVariable* pSbxVariable = rPar.Get(1);
334 nVal = pSbxVariable->GetLong();
335 rPar.Get(0)->PutLong(nVal);
336 }
337
338 void SbRtl_CSng(StarBASIC *, SbxArray & rPar, bool) // JSM
339 {
340 float nVal = float(0.0);
341 if (rPar.Count() == 2)
342 {
343 SbxVariable* pSbxVariable = rPar.Get(1);
344 if( pSbxVariable->GetType() == SbxSTRING )
345 {
346 // #41690
347 double dVal = 0.0;
348 OUString aScanStr = pSbxVariable->GetOUString();
349 ErrCode Error = SbxValue::ScanNumIntnl( aScanStr, dVal, /*bSingle=*/true );
350 if( SbxBase::GetError() == ERRCODE_NONE && Error != ERRCODE_NONE )
351 {
352 StarBASIC::Error( Error );
353 }
354 nVal = static_cast<float>(dVal);
355 }
356 else
357 {
358 nVal = pSbxVariable->GetSingle();
359 }
360 }
361 else
362 {
363 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
364 }
365 rPar.Get(0)->PutSingle(nVal);
366 }
367
368 void SbRtl_CStr(StarBASIC *, SbxArray & rPar, bool) // JSM
369 {
370 if (rPar.Count() != 2)
371 return StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
372
373 SbxVariable* pSbxVariable = rPar.Get(1);
374 OUString aString = pSbxVariable->GetOUString();
375 rPar.Get(0)->PutString(aString);
376 }
377
378 void SbRtl_CVar(StarBASIC *, SbxArray & rPar, bool) // JSM
379 {
380 SbxValues aVals( SbxVARIANT );
381 if (rPar.Count() == 2)
382 {
383 SbxVariable* pSbxVariable = rPar.Get(1);
384 pSbxVariable->Get( aVals );
385 }
386 else
387 {
388 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
389 }
390 rPar.Get(0)->Put(aVals);
391 }
392
393 void SbRtl_CVErr(StarBASIC *, SbxArray & rPar, bool)
394 {
395 if (rPar.Count() != 2)
396 return StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
397
398 SbxVariable* pSbxVariable = rPar.Get(1);
399 sal_Int16 nErrCode = pSbxVariable->GetInteger();
400 rPar.Get(0)->PutErr(nErrCode);
401 }
402
403 void SbRtl_Iif(StarBASIC *, SbxArray & rPar, bool) // JSM
404 {
405 if (rPar.Count() != 4)
406 return StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
407
408 if (rPar.Get(1)->GetBool())
409 {
410 *rPar.Get(0) = *rPar.Get(2);
411 }
412 else
413 {
414 *rPar.Get(0) = *rPar.Get(3);
415 }
416
417 }
418
419 void SbRtl_GetSystemType(StarBASIC *, SbxArray & rPar, bool)
420 {
421 if (rPar.Count() != 1)
422 return StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
423
424 // Removed for SRC595
425 rPar.Get(0)->PutInteger(-1);
426 }
427
428 void SbRtl_GetGUIType(StarBASIC *, SbxArray & rPar, bool)
429 {
430 if (rPar.Count() != 1)
431 return StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
432
433 // 17.7.2000 Make simple solution for testtool / fat office
434 #if defined(_WIN32)
435 rPar.Get(0)->PutInteger(1);
436 #elif defined(UNX)
437 rPar.Get(0)->PutInteger(4);
438 #else
439 rPar.Get(0)->PutInteger(-1);
440 #endif
441 }
442
443 void SbRtl_Red(StarBASIC *, SbxArray & rPar, bool)
444 {
445 if (rPar.Count() != 2)
446 return StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
447
448 sal_Int32 nRGB = rPar.Get(1)->GetLong();
449 nRGB &= 0x00FF0000;
450 nRGB >>= 16;
451 rPar.Get(0)->PutInteger(static_cast<sal_Int16>(nRGB));
452
453 }
454
455 void SbRtl_Green(StarBASIC *, SbxArray & rPar, bool)
456 {
457 if (rPar.Count() != 2)
458
459 return StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
460
461 sal_Int32 nRGB = rPar.Get(1)->GetLong();
462 nRGB &= 0x0000FF00;
463 nRGB >>= 8;
464 rPar.Get(0)->PutInteger(static_cast<sal_Int16>(nRGB));
465 }
466
467 void SbRtl_Blue(StarBASIC *, SbxArray & rPar, bool)
468 {
469 if (rPar.Count() != 2)
470 return StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
471
472 sal_Int32 nRGB = rPar.Get(1)->GetLong();
473 nRGB &= 0x000000FF;
474 rPar.Get(0)->PutInteger(static_cast<sal_Int16>(nRGB));
475 }
476
477
478 void SbRtl_Switch(StarBASIC *, SbxArray & rPar, bool)
479 {
480 sal_uInt32 nCount = rPar.Count();
481 if( !(nCount & 0x0001 ))
482 {
483 // number of arguments must be odd
484 return StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
485 }
486 sal_uInt32 nCurExpr = 1;
487 while( nCurExpr < (nCount-1) )
488 {
489 if (rPar.Get(nCurExpr)->GetBool())
490 {
491 (*rPar.Get(0)) = *(rPar.Get(nCurExpr + 1));
492 return;
493 }
494 nCurExpr += 2;
495 }
496 rPar.Get(0)->PutNull();
497 }
498
499 //i#64882# Common wait impl for existing Wait and new WaitUntil
500 // rtl functions
501 void Wait_Impl( bool bDurationBased, SbxArray& rPar )
502 {
503 if (rPar.Count() != 2)
504 return StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
505
506 tools::Long nWait = 0;
507 if ( bDurationBased )
508 {
509 double dWait = rPar.Get(1)->GetDouble();
510 double dNow = Now_Impl();
511 double dSecs = ( dWait - dNow ) * 24.0 * 3600.0;
512 nWait = static_cast<tools::Long>( dSecs * 1000 ); // wait in thousands of sec
513 }
514 else
515 {
516 nWait = rPar.Get(1)->GetLong();
517 }
518
519 if( nWait < 0 )
520 return StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
521
522 Timer aTimer("basic Wait_Impl");
523 aTimer.SetTimeout( nWait );
524 aTimer.Start();
525 while ( aTimer.IsActive() && !Application::IsQuit())
526 {
527 Application::Yield();
528 }
529 }
530
531 //i#64882#
532 void SbRtl_Wait(StarBASIC *, SbxArray & rPar, bool)
533 {
534 Wait_Impl( false, rPar );
535 }
536
537 //i#64882# add new WaitUntil ( for application.wait )
538 // share wait_impl with 'normal' oobasic wait
539 void SbRtl_WaitUntil(StarBASIC *, SbxArray & rPar, bool)
540 {
541 Wait_Impl( true, rPar );
542 }
543
544 void SbRtl_DoEvents(StarBASIC *, SbxArray & rPar, bool)
545 {
546 // don't understand what upstream are up to
547 // we already process application events etc. in between
548 // basic runtime pcode ( on a timed basis )
549 // always return 0
550 rPar.Get(0)->PutInteger(0);
551 Application::Reschedule( true );
552 }
553
554 void SbRtl_GetGUIVersion(StarBASIC *, SbxArray & rPar, bool)
555 {
556 if (rPar.Count() != 1)
557 return StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
558
559 // Removed for SRC595
560 rPar.Get(0)->PutLong(-1);
561 }
562
563 void SbRtl_Choose(StarBASIC *, SbxArray & rPar, bool)
564 {
565 if (rPar.Count() < 2)
566 {
567 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
568 }
569 sal_Int16 nIndex = rPar.Get(1)->GetInteger();
570 sal_uInt32 nCount = rPar.Count();
571 nCount--;
572 if( nCount == 1 || nIndex > sal::static_int_cast<sal_Int16>(nCount-1) || nIndex < 1 )
573 {
574 rPar.Get(0)->PutNull();
575 return;
576 }
577 (*rPar.Get(0)) = *(rPar.Get(nIndex + 1));
578 }
579
580
581 void SbRtl_Trim(StarBASIC *, SbxArray & rPar, bool)
582 {
583 if (rPar.Count() < 2)
584 {
585 return StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
586 }
587 OUString aStr(comphelper::string::strip(rPar.Get(1)->GetOUString(), ' '));
588 rPar.Get(0)->PutString(aStr);
589 }
590
591 void SbRtl_GetSolarVersion(StarBASIC *, SbxArray & rPar, bool)
592 {
593 rPar.Get(0)->PutLong(LIBO_VERSION_MAJOR * 10000 + LIBO_VERSION_MINOR * 100
594 + LIBO_VERSION_MICRO * 1);
595 }
596
597 void SbRtl_TwipsPerPixelX(StarBASIC *, SbxArray & rPar, bool)
598 {
599 sal_Int32 nResult = 0;
600 Size aSize( 100,0 );
601 MapMode aMap( MapUnit::MapTwip );
602 OutputDevice* pDevice = Application::GetDefaultDevice();
603 if( pDevice )
604 {
605 aSize = pDevice->PixelToLogic( aSize, aMap );
606 nResult = aSize.Width() / 100;
607 }
608 rPar.Get(0)->PutLong(nResult);
609 }
610
611 void SbRtl_TwipsPerPixelY(StarBASIC *, SbxArray & rPar, bool)
612 {
613 sal_Int32 nResult = 0;
614 Size aSize( 0,100 );
615 MapMode aMap( MapUnit::MapTwip );
616 OutputDevice* pDevice = Application::GetDefaultDevice();
617 if( pDevice )
618 {
619 aSize = pDevice->PixelToLogic( aSize, aMap );
620 nResult = aSize.Height() / 100;
621 }
622 rPar.Get(0)->PutLong(nResult);
623 }
624
625
626 void SbRtl_FreeLibrary(StarBASIC *, SbxArray & rPar, bool)
627 {
628 if (rPar.Count() != 2)
629 {
630 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
631 }
632 GetSbData()->pInst->GetDllMgr()->FreeDll(rPar.Get(1)->GetOUString());
633 }
634 bool IsBaseIndexOne()
635 {
636 bool bResult = false;
637 if ( GetSbData()->pInst && GetSbData()->pInst->pRun )
638 {
639 sal_uInt16 res = GetSbData()->pInst->pRun->GetBase();
640 if ( res )
641 {
642 bResult = true;
643 }
644 }
645 return bResult;
646 }
647
648 void SbRtl_Array(StarBASIC *, SbxArray & rPar, bool)
649 {
650 SbxDimArray* pArray = new SbxDimArray( SbxVARIANT );
651 sal_uInt32 nArraySize = rPar.Count() - 1;
652 bool bIncIndex = IsBaseIndexOne();
653 if( nArraySize )
654 {
655 if ( bIncIndex )
656 {
657 pArray->AddDim(1, sal::static_int_cast<sal_Int32>(nArraySize));
658 }
659 else
660 {
661 pArray->AddDim(0, sal::static_int_cast<sal_Int32>(nArraySize) - 1);
662 }
663 }
664 else
665 {
666 pArray->unoAddDim(0, -1);
667 }
668
669 // insert parameters into the array
670 for( sal_uInt32 i = 0 ; i < nArraySize ; i++ )
671 {
672 SbxVariable* pVar = rPar.Get(i + 1);
673 SbxVariable* pNew = new SbxEnsureParentVariable(*pVar);
674 pNew->SetFlag( SbxFlagBits::Write );
675 sal_Int32 aIdx[1];
676 aIdx[0] = static_cast<sal_Int32>(i);
677 if ( bIncIndex )
678 {
679 ++aIdx[0];
680 }
681 pArray->Put(pNew, aIdx);
682 }
683
684 // return array
685 SbxVariableRef refVar = rPar.Get(0);
686 SbxFlagBits nFlags = refVar->GetFlags();
687 refVar->ResetFlag( SbxFlagBits::Fixed );
688 refVar->PutObject( pArray );
689 refVar->SetFlags( nFlags );
690 refVar->SetParameters( nullptr );
691 }
692
693
694 // Featurewish #57868
695 // The function returns a variant-array; if there are no parameters passed,
696 // an empty array is created (according to dim a(); equal to a sequence of
697 // the length 0 in Uno).
698 // If there are parameters passed, there's a dimension created for each of
699 // them; DimArray( 2, 2, 4 ) is equal to DIM a( 2, 2, 4 )
700 // the array is always of the type variant
701 void SbRtl_DimArray(StarBASIC *, SbxArray & rPar, bool)
702 {
703 SbxDimArray * pArray = new SbxDimArray( SbxVARIANT );
704 sal_uInt32 nArrayDims = rPar.Count() - 1;
705 if( nArrayDims > 0 )
706 {
707 for( sal_uInt32 i = 0; i < nArrayDims ; i++ )
708 {
709 sal_Int32 ub = rPar.Get(i + 1)->GetLong();
710 if( ub < 0 )
711 {
712 StarBASIC::Error( ERRCODE_BASIC_OUT_OF_RANGE );
713 ub = 0;
714 }
715 pArray->AddDim(0, ub);
716 }
717 }
718 else
719 {
720 pArray->unoAddDim(0, -1);
721 }
722 SbxVariableRef refVar = rPar.Get(0);
723 SbxFlagBits nFlags = refVar->GetFlags();
724 refVar->ResetFlag( SbxFlagBits::Fixed );
725 refVar->PutObject( pArray );
726 refVar->SetFlags( nFlags );
727 refVar->SetParameters( nullptr );
728 }
729
730 /*
731 * FindObject and FindPropertyObject make it possible to
732 * address objects and properties of the type Object with
733 * their name as string-parameters at the runtime.
734 *
735 * Example:
736 * MyObj.Prop1.Bla = 5
737 *
738 * is equal to:
739 * dim ObjVar as Object
740 * dim ObjProp as Object
741 * ObjName$ = "MyObj"
742 * ObjVar = FindObject( ObjName$ )
743 * PropName$ = "Prop1"
744 * ObjProp = FindPropertyObject( ObjVar, PropName$ )
745 * ObjProp.Bla = 5
746 *
747 * The names can be created dynamically at the runtime
748 * so that e. g. via controls "TextEdit1" to "TextEdit5"
749 * can be iterated in a dialog in a loop.
750 */
751
752
753 // 1st parameter = the object's name as string
754 void SbRtl_FindObject(StarBASIC *, SbxArray & rPar, bool)
755 {
756 if (rPar.Count() != 2)
757 return StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
758
759
760 OUString aNameStr = rPar.Get(1)->GetOUString();
761
762 SbxBase* pFind = StarBASIC::FindSBXInCurrentScope( aNameStr );
763 SbxObject* pFindObj = nullptr;
764 if( pFind )
765 {
766 pFindObj = dynamic_cast<SbxObject*>( pFind );
767 }
768 SbxVariableRef refVar = rPar.Get(0);
769 refVar->PutObject( pFindObj );
770 }
771
772 // address object-property in an object
773 // 1st parameter = object
774 // 2nd parameter = the property's name as string
775 void SbRtl_FindPropertyObject(StarBASIC *, SbxArray & rPar, bool)
776 {
777 if (rPar.Count() != 3)
778 return StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
779
780
781 SbxBase* pObjVar = rPar.Get(1)->GetObject();
782 SbxObject* pObj = nullptr;
783 if( pObjVar )
784 {
785 pObj = dynamic_cast<SbxObject*>( pObjVar );
786 }
787 if( !pObj )
788 if (auto pSbxVar = dynamic_cast<const SbxVariable*>( pObjVar))
789 pObj = dynamic_cast<SbxObject*>( pSbxVar->GetObject() );
790
791 OUString aNameStr = rPar.Get(2)->GetOUString();
792
793 SbxObject* pFindObj = nullptr;
794 if( pObj )
795 {
796 SbxVariable* pFindVar = pObj->Find( aNameStr, SbxClassType::Object );
797 pFindObj = dynamic_cast<SbxObject*>( pFindVar );
798 }
799 else
800 {
801 StarBASIC::Error( ERRCODE_BASIC_BAD_PARAMETER );
802 }
803
804 SbxVariableRef refVar = rPar.Get(0);
805 refVar->PutObject( pFindObj );
806 }
807
808
809 static bool lcl_WriteSbxVariable( const SbxVariable& rVar, SvStream* pStrm,
810 bool bBinary, short nBlockLen, bool bIsArray )
811 {
812 sal_uInt64 const nFPos = pStrm->Tell();
813
814 bool bIsVariant = !rVar.IsFixed();
815 SbxDataType eType = rVar.GetType();
816
817 switch( eType )
818 {
819 case SbxBOOL:
820 case SbxCHAR:
821 case SbxBYTE:
822 if( bIsVariant )
823 {
824 pStrm->WriteUInt16( SbxBYTE ); // VarType Id
825 }
826 pStrm->WriteUChar( rVar.GetByte() );
827 break;
828
829 case SbxEMPTY:
830 case SbxNULL:
831 case SbxVOID:
832 case SbxINTEGER:
833 case SbxUSHORT:
834 case SbxINT:
835 case SbxUINT:
836 if( bIsVariant )
837 {
838 pStrm->WriteUInt16( SbxINTEGER ); // VarType Id
839 }
840 pStrm->WriteInt16( rVar.GetInteger() );
841 break;
842
843 case SbxLONG:
844 case SbxULONG:
845 if( bIsVariant )
846 {
847 pStrm->WriteUInt16( SbxLONG ); // VarType Id
848 }
849 pStrm->WriteInt32( rVar.GetLong() );
850 break;
851 case SbxSALINT64:
852 case SbxSALUINT64:
853 if( bIsVariant )
854 {
855 pStrm->WriteUInt16( SbxSALINT64 ); // VarType Id
856 }
857 pStrm->WriteUInt64( rVar.GetInt64() );
858 break;
859 case SbxSINGLE:
860 if( bIsVariant )
861 {
862 pStrm->WriteUInt16( eType ); // VarType Id
863 }
864 pStrm->WriteFloat( rVar.GetSingle() );
865 break;
866
867 case SbxDOUBLE:
868 case SbxCURRENCY:
869 case SbxDATE:
870 if( bIsVariant )
871 {
872 pStrm->WriteUInt16( eType ); // VarType Id
873 }
874 pStrm->WriteDouble( rVar.GetDouble() );
875 break;
876
877 case SbxSTRING:
878 case SbxLPSTR:
879 {
880 const OUString aStr = rVar.GetOUString();
881 if( !bBinary || bIsArray )
882 {
883 if( bIsVariant )
884 {
885 pStrm->WriteUInt16( SbxSTRING );
886 }
887 pStrm->WriteUniOrByteString( aStr, osl_getThreadTextEncoding() );
888 }
889 else
890 {
891 // without any length information! without end-identifier!
892 // What does that mean for Unicode?! Choosing conversion to ByteString...
893 OString aByteStr(OUStringToOString(aStr, osl_getThreadTextEncoding()));
894 pStrm->WriteOString( aByteStr );
895 }
896 }
897 break;
898
899 default:
900 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
901 return false;
902 }
903
904 if( nBlockLen )
905 {
906 pStrm->Seek( nFPos + nBlockLen );
907 }
908 return pStrm->GetErrorCode() == ERRCODE_NONE;
909 }
910
911 static bool lcl_ReadSbxVariable( SbxVariable& rVar, SvStream* pStrm,
912 bool bBinary, short nBlockLen )
913 {
914 double aDouble;
915
916 sal_uInt64 const nFPos = pStrm->Tell();
917
918 bool bIsVariant = !rVar.IsFixed();
919 SbxDataType eVarType = rVar.GetType();
920
921 SbxDataType eSrcType = eVarType;
922 if( bIsVariant )
923 {
924 sal_uInt16 nTemp;
925 pStrm->ReadUInt16( nTemp );
926 eSrcType = static_cast<SbxDataType>(nTemp);
927 }
928
929 switch( eSrcType )
930 {
931 case SbxBOOL:
932 case SbxCHAR:
933 case SbxBYTE:
934 {
935 sal_uInt8 aByte;
936 pStrm->ReadUChar( aByte );
937
938 if( bBinary && SbiRuntime::isVBAEnabled() && aByte == 1 && pStrm->eof() )
939 {
940 aByte = 0;
941 }
942 rVar.PutByte( aByte );
943 }
944 break;
945
946 case SbxEMPTY:
947 case SbxNULL:
948 case SbxVOID:
949 case SbxINTEGER:
950 case SbxUSHORT:
951 case SbxINT:
952 case SbxUINT:
953 {
954 sal_Int16 aInt;
955 pStrm->ReadInt16( aInt );
956 rVar.PutInteger( aInt );
957 }
958 break;
959
960 case SbxLONG:
961 case SbxULONG:
962 {
963 sal_Int32 aInt;
964 pStrm->ReadInt32( aInt );
965 rVar.PutLong( aInt );
966 }
967 break;
968 case SbxSALINT64:
969 case SbxSALUINT64:
970 {
971 sal_uInt32 aInt;
972 pStrm->ReadUInt32( aInt );
973 rVar.PutInt64( static_cast<sal_Int64>(aInt) );
974 }
975 break;
976 case SbxSINGLE:
977 {
978 float nS;
979 pStrm->ReadFloat( nS );
980 rVar.PutSingle( nS );
981 }
982 break;
983
984 case SbxDOUBLE:
985 case SbxCURRENCY:
986 {
987 pStrm->ReadDouble( aDouble );
988 rVar.PutDouble( aDouble );
989 }
990 break;
991
992 case SbxDATE:
993 {
994 pStrm->ReadDouble( aDouble );
995 rVar.PutDate( aDouble );
996 }
997 break;
998
999 case SbxSTRING:
1000 case SbxLPSTR:
1001 {
1002 OUString aStr = pStrm->ReadUniOrByteString(osl_getThreadTextEncoding());
1003 rVar.PutString( aStr );
1004 }
1005 break;
1006
1007 default:
1008 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
1009 return false;
1010 }
1011
1012 if( nBlockLen )
1013 {
1014 pStrm->Seek( nFPos + nBlockLen );
1015 }
1016 return pStrm->GetErrorCode() == ERRCODE_NONE;
1017 }
1018
1019
1020 // nCurDim = 1...n
1021 static bool lcl_WriteReadSbxArray( SbxDimArray& rArr, SvStream* pStrm,
1022 bool bBinary, sal_Int32 nCurDim, sal_Int32* pOtherDims, bool bWrite )
1023 {
1024 SAL_WARN_IF( nCurDim <= 0,"basic", "Bad Dim");
1025 sal_Int32 nLower, nUpper;
1026 if (!rArr.GetDim(nCurDim, nLower, nUpper))
1027 return false;
1028 for(sal_Int32 nCur = nLower; nCur <= nUpper; nCur++ )
1029 {
1030 pOtherDims[ nCurDim-1 ] = nCur;
1031 if( nCurDim != 1 )
1032 lcl_WriteReadSbxArray(rArr, pStrm, bBinary, nCurDim-1, pOtherDims, bWrite);
1033 else
1034 {
1035 SbxVariable* pVar = rArr.Get(pOtherDims);
1036 bool bRet;
1037 if( bWrite )
1038 bRet = lcl_WriteSbxVariable(*pVar, pStrm, bBinary, 0, true );
1039 else
1040 bRet = lcl_ReadSbxVariable(*pVar, pStrm, bBinary, 0 );
1041 if( !bRet )
1042 return false;
1043 }
1044 }
1045 return true;
1046 }
1047
1048 static void PutGet( SbxArray& rPar, bool bPut )
1049 {
1050 if (rPar.Count() != 4)
1051 return StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
1052
1053 sal_Int16 nFileNo = rPar.Get(1)->GetInteger();
1054 SbxVariable* pVar2 = rPar.Get(2);
1055 SbxDataType eType2 = pVar2->GetType();
1056 bool bHasRecordNo = (eType2 != SbxEMPTY && eType2 != SbxERROR);
1057 tools::Long nRecordNo = pVar2->GetLong();
1058 if ( nFileNo < 1 || ( bHasRecordNo && nRecordNo < 1 ) )
1059 {
1060 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
1061 return;
1062 }
1063 nRecordNo--;
1064 SbiIoSystem* pIO = GetSbData()->pInst->GetIoSystem();
1065 SbiStream* pSbStrm = pIO->GetStream( nFileNo );
1066
1067 if ( !pSbStrm || !(pSbStrm->GetMode() & (SbiStreamFlags::Binary | SbiStreamFlags::Random)) )
1068 return StarBASIC::Error( ERRCODE_BASIC_BAD_CHANNEL );
1069
1070 SvStream* pStrm = pSbStrm->GetStrm();
1071 bool bRandom = pSbStrm->IsRandom();
1072 short nBlockLen = bRandom ? pSbStrm->GetBlockLen() : 0;
1073
1074 if( bPut )
1075 {
1076 pSbStrm->ExpandFile();
1077 }
1078
1079 if( bHasRecordNo )
1080 {
1081 sal_uInt64 const nFilePos = bRandom
1082 ? static_cast<sal_uInt64>(nBlockLen * nRecordNo)
1083 : static_cast<sal_uInt64>(nRecordNo);
1084 pStrm->Seek( nFilePos );
1085 }
1086
1087 SbxDimArray* pArr = nullptr;
1088 SbxVariable* pVar = rPar.Get(3);
1089 if( pVar->GetType() & SbxARRAY )
1090 {
1091 SbxBase* pParObj = pVar->GetObject();
1092 pArr = dynamic_cast<SbxDimArray*>( pParObj );
1093 }
1094
1095 bool bRet;
1096
1097 if( pArr )
1098 {
1099 sal_uInt64 const nFPos = pStrm->Tell();
1100 sal_Int32 nDims = pArr->GetDims();
1101 std::unique_ptr<sal_Int32[]> pDims(new sal_Int32[ nDims ]);
1102 bRet = lcl_WriteReadSbxArray(*pArr,pStrm,!bRandom,nDims,pDims.get(),bPut);
1103 pDims.reset();
1104 if( nBlockLen )
1105 pStrm->Seek( nFPos + nBlockLen );
1106 }
1107 else
1108 {
1109 if( bPut )
1110 bRet = lcl_WriteSbxVariable(*pVar, pStrm, !bRandom, nBlockLen, false);
1111 else
1112 bRet = lcl_ReadSbxVariable(*pVar, pStrm, !bRandom, nBlockLen);
1113 }
1114 if( !bRet || pStrm->GetErrorCode() )
1115 StarBASIC::Error( ERRCODE_BASIC_IO_ERROR );
1116 }
1117
1118 void SbRtl_Put(StarBASIC *, SbxArray & rPar, bool)
1119 {
1120 PutGet( rPar, true );
1121 }
1122
1123 void SbRtl_Get(StarBASIC *, SbxArray & rPar, bool)
1124 {
1125 PutGet( rPar, false );
1126 }
1127
1128 void SbRtl_Environ(StarBASIC *, SbxArray & rPar, bool)
1129 {
1130 if (rPar.Count() != 2)
1131 return StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
1132
1133 rPar.Get(0)->PutString(o3tl::getEnvironment(rPar.Get(1)->GetOUString()));
1134 }
1135
1136 static double GetDialogZoomFactor( bool bX, tools::Long nValue )
1137 {
1138 OutputDevice* pDevice = Application::GetDefaultDevice();
1139 double nResult = 0;
1140 if( pDevice )
1141 {
1142 Size aRefSize( nValue, nValue );
1143 Fraction aFracX( 1, 26 );
1144 Fraction aFracY( 1, 24 );
1145 MapMode aMap( MapUnit::MapAppFont, Point(), aFracX, aFracY );
1146 Size aScaledSize = pDevice->LogicToPixel( aRefSize, aMap );
1147 aRefSize = pDevice->LogicToPixel( aRefSize, MapMode(MapUnit::MapTwip) );
1148
1149 double nRef, nScaled;
1150 if( bX )
1151 {
1152 nRef = aRefSize.Width();
1153 nScaled = aScaledSize.Width();
1154 }
1155 else
1156 {
1157 nRef = aRefSize.Height();
1158 nScaled = aScaledSize.Height();
1159 }
1160 nResult = nScaled / nRef;
1161 }
1162 return nResult;
1163 }
1164
1165
1166 void SbRtl_GetDialogZoomFactorX(StarBASIC *, SbxArray & rPar, bool)
1167 {
1168 if (rPar.Count() != 2)
1169 return StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
1170 rPar.Get(0)->PutDouble(GetDialogZoomFactor(true, rPar.Get(1)->GetLong()));
1171 }
1172
1173 void SbRtl_GetDialogZoomFactorY(StarBASIC *, SbxArray & rPar, bool)
1174 {
1175 if (rPar.Count() != 2)
1176 return StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
1177
1178 rPar.Get(0)->PutDouble(GetDialogZoomFactor(false, rPar.Get(1)->GetLong()));
1179 }
1180
1181
1182 void SbRtl_EnableReschedule(StarBASIC *, SbxArray & rPar, bool)
1183 {
1184 rPar.Get(0)->PutEmpty();
1185 if (rPar.Count() != 2)
1186 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
1187 if( GetSbData()->pInst )
1188 GetSbData()->pInst->EnableReschedule(rPar.Get(1)->GetBool());
1189 }
1190
1191 void SbRtl_GetSystemTicks(StarBASIC *, SbxArray & rPar, bool)
1192 {
1193 if (rPar.Count() != 1)
1194 return StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
1195
1196 rPar.Get(0)->PutLong(tools::Time::GetSystemTicks());
1197 }
1198
1199 void SbRtl_GetPathSeparator(StarBASIC *, SbxArray & rPar, bool)
1200 {
1201 if (rPar.Count() != 1)
1202 return StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
1203
1204 rPar.Get(0)->PutString(OUString(SAL_PATHDELIMITER));
1205 }
1206
1207 void SbRtl_ResolvePath(StarBASIC *, SbxArray & rPar, bool)
1208 {
1209 if (rPar.Count() != 2)
1210 return StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
1211
1212 OUString aStr = rPar.Get(1)->GetOUString();
1213 rPar.Get(0)->PutString(aStr);
1214 }
1215
1216 void SbRtl_TypeLen(StarBASIC *, SbxArray & rPar, bool)
1217 {
1218 if (rPar.Count() != 2)
1219 return StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
1220
1221 SbxDataType eType = rPar.Get(1)->GetType();
1222 sal_Int16 nLen = 0;
1223 switch( eType )
1224 {
1225 case SbxEMPTY:
1226 case SbxNULL:
1227 case SbxVECTOR:
1228 case SbxARRAY:
1229 case SbxBYREF:
1230 case SbxVOID:
1231 case SbxHRESULT:
1232 case SbxPOINTER:
1233 case SbxDIMARRAY:
1234 case SbxCARRAY:
1235 case SbxUSERDEF:
1236 case SbxOBJECT:
1237 case SbxVARIANT:
1238 case SbxDATAOBJECT:
1239 nLen = 0;
1240 break;
1241
1242 case SbxINTEGER:
1243 case SbxERROR:
1244 case SbxUSHORT:
1245 case SbxINT:
1246 case SbxUINT:
1247 nLen = 2;
1248 break;
1249
1250 case SbxLONG:
1251 case SbxSINGLE:
1252 case SbxULONG:
1253 nLen = 4;
1254 break;
1255
1256 case SbxDOUBLE:
1257 case SbxCURRENCY:
1258 case SbxDATE:
1259 case SbxSALINT64:
1260 case SbxSALUINT64:
1261 nLen = 8;
1262 break;
1263
1264 case SbxCHAR:
1265 case SbxBYTE:
1266 case SbxBOOL:
1267 nLen = 1;
1268 break;
1269
1270 case SbxLPSTR:
1271 case SbxLPWSTR:
1272 case SbxCoreSTRING:
1273 case SbxSTRING:
1274 nLen = static_cast<sal_Int16>(rPar.Get(1)->GetOUString().getLength());
1275 break;
1276
1277 default:
1278 nLen = 0;
1279 break;
1280 }
1281 rPar.Get(0)->PutInteger(nLen);
1282 }
1283
1284
1285 // 1st parameter == class name, other parameters for initialisation
1286 void SbRtl_CreateUnoStruct(StarBASIC *, SbxArray & rPar, bool)
1287 {
1288 RTL_Impl_CreateUnoStruct( rPar );
1289 }
1290
1291
1292 // 1st parameter == service-name
1293 void SbRtl_CreateUnoService(StarBASIC *, SbxArray & rPar, bool)
1294 {
1295 RTL_Impl_CreateUnoService( rPar );
1296 }
1297
1298 void SbRtl_CreateUnoServiceWithArguments(StarBASIC *, SbxArray & rPar, bool)
1299 {
1300 RTL_Impl_CreateUnoServiceWithArguments( rPar );
1301 }
1302
1303
1304 void SbRtl_CreateUnoValue(StarBASIC *, SbxArray & rPar, bool)
1305 {
1306 RTL_Impl_CreateUnoValue( rPar );
1307 }
1308
1309
1310 // no parameters
1311 void SbRtl_GetProcessServiceManager(StarBASIC *, SbxArray & rPar, bool)
1312 {
1313 RTL_Impl_GetProcessServiceManager( rPar );
1314 }
1315
1316
1317 // 1st parameter == Sequence<PropertyValue>
1318 void SbRtl_CreatePropertySet(StarBASIC *, SbxArray & rPar, bool)
1319 {
1320 RTL_Impl_CreatePropertySet( rPar );
1321 }
1322
1323
1324 // multiple interface-names as parameters
1325 void SbRtl_HasUnoInterfaces(StarBASIC *, SbxArray & rPar, bool)
1326 {
1327 RTL_Impl_HasInterfaces( rPar );
1328 }
1329
1330
1331 void SbRtl_IsUnoStruct(StarBASIC *, SbxArray & rPar, bool)
1332 {
1333 RTL_Impl_IsUnoStruct( rPar );
1334 }
1335
1336
1337 void SbRtl_EqualUnoObjects(StarBASIC *, SbxArray & rPar, bool)
1338 {
1339 RTL_Impl_EqualUnoObjects( rPar );
1340 }
1341
1342 void SbRtl_CreateUnoDialog(StarBASIC *, SbxArray & rPar, bool)
1343 {
1344 RTL_Impl_CreateUnoDialog( rPar );
1345 }
1346
1347 // Return the application standard lib as root scope
1348 void SbRtl_GlobalScope(StarBASIC * pBasic, SbxArray & rPar, bool)
1349 {
1350 SbxObject* p = pBasic;
1351 while( p->GetParent() )
1352 {
1353 p = p->GetParent();
1354 }
1355 SbxVariableRef refVar = rPar.Get(0);
1356 refVar->PutObject( p );
1357 }
1358
1359 // Helper functions to convert Url from/to system paths
1360 void SbRtl_ConvertToUrl(StarBASIC *, SbxArray & rPar, bool)
1361 {
1362 if (rPar.Count() != 2)
1363 return StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
1364
1365 OUString aStr = rPar.Get(1)->GetOUString();
1366 INetURLObject aURLObj( aStr, INetProtocol::File );
1367 OUString aFileURL = aURLObj.GetMainURL( INetURLObject::DecodeMechanism::NONE );
1368 if( aFileURL.isEmpty() )
1369 {
1370 osl::File::getFileURLFromSystemPath(aStr, aFileURL);
1371 }
1372 if( aFileURL.isEmpty() )
1373 {
1374 aFileURL = aStr;
1375 }
1376 rPar.Get(0)->PutString(aFileURL);
1377
1378 }
1379
1380 void SbRtl_ConvertFromUrl(StarBASIC *, SbxArray & rPar, bool)
1381 {
1382 if (rPar.Count() != 2)
1383 return StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
1384
1385 OUString aStr = rPar.Get(1)->GetOUString();
1386 OUString aSysPath;
1387 ::osl::File::getSystemPathFromFileURL( aStr, aSysPath );
1388 if( aSysPath.isEmpty() )
1389 {
1390 aSysPath = aStr;
1391 }
1392 rPar.Get(0)->PutString(aSysPath);
1393 }
1394
1395
1396 // Provide DefaultContext
1397 void SbRtl_GetDefaultContext(StarBASIC *, SbxArray & rPar, bool)
1398 {
1399 RTL_Impl_GetDefaultContext( rPar );
1400 }
1401
1402 void SbRtl_Join(StarBASIC *, SbxArray & rPar, bool)
1403 {
1404 sal_uInt32 nParCount = rPar.Count();
1405 if ( nParCount != 3 && nParCount != 2 )
1406 return StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
1407
1408 SbxBase* pParObj = rPar.Get(1)->GetObject();
1409 SbxDimArray* pArr = dynamic_cast<SbxDimArray*>( pParObj );
1410 if( !pArr )
1411 return StarBASIC::Error( ERRCODE_BASIC_MUST_HAVE_DIMS );
1412
1413 if (pArr->GetDims() != 1)
1414 return StarBASIC::Error( ERRCODE_BASIC_WRONG_DIMS ); // Syntax Error?!
1415
1416 OUString aDelim;
1417 if( nParCount == 3 )
1418 {
1419 aDelim = rPar.Get(2)->GetOUString();
1420 }
1421 else
1422 {
1423 aDelim = " ";
1424 }
1425 OUStringBuffer aRetStr(32);
1426 sal_Int32 nLower, nUpper;
1427 pArr->GetDim(1, nLower, nUpper);
1428 sal_Int32 aIdx[1];
1429 for (aIdx[0] = nLower; aIdx[0] <= nUpper; ++aIdx[0])
1430 {
1431 OUString aStr = pArr->Get(aIdx)->GetOUString();
1432 aRetStr.append(aStr);
1433 if (aIdx[0] != nUpper)
1434 {
1435 aRetStr.append(aDelim);
1436 }
1437 }
1438 rPar.Get(0)->PutString(aRetStr.makeStringAndClear());
1439
1440 }
1441
1442
1443 void SbRtl_Split(StarBASIC *, SbxArray & rPar, bool)
1444 {
1445 sal_uInt32 nParCount = rPar.Count();
1446 if ( nParCount < 2 )
1447 {
1448 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
1449 return;
1450 }
1451
1452 OUString aExpression = rPar.Get(1)->GetOUString();
1453 sal_Int32 nArraySize = 0;
1454 std::vector< OUString > vRet;
1455 if( !aExpression.isEmpty() )
1456 {
1457 OUString aDelim;
1458 if( nParCount >= 3 )
1459 {
1460 aDelim = rPar.Get(2)->GetOUString();
1461 }
1462 else
1463 {
1464 aDelim = " ";
1465 }
1466
1467 sal_Int32 nCount = -1;
1468 if( nParCount == 4 )
1469 {
1470 nCount = rPar.Get(3)->GetLong();
1471 }
1472 sal_Int32 nDelimLen = aDelim.getLength();
1473 if( nDelimLen )
1474 {
1475 sal_Int32 iSearch = -1;
1476 sal_Int32 iStart = 0;
1477 do
1478 {
1479 bool bBreak = false;
1480 if( nCount >= 0 && nArraySize == nCount - 1 )
1481 {
1482 bBreak = true;
1483 }
1484 iSearch = aExpression.indexOf( aDelim, iStart );
1485 OUString aSubStr;
1486 if( iSearch >= 0 && !bBreak )
1487 {
1488 aSubStr = aExpression.copy( iStart, iSearch - iStart );
1489 iStart = iSearch + nDelimLen;
1490 }
1491 else
1492 {
1493 aSubStr = aExpression.copy( iStart );
1494 }
1495 vRet.push_back( aSubStr );
1496 nArraySize++;
1497
1498 if( bBreak )
1499 {
1500 break;
1501 }
1502 }
1503 while( iSearch >= 0 );
1504 }
1505 else
1506 {
1507 vRet.push_back( aExpression );
1508 nArraySize = 1;
1509 }
1510 }
1511
1512 // tdf#123025 - split returns an array of substrings
1513 SbxDimArray* pArray = new SbxDimArray( SbxSTRING );
1514 pArray->unoAddDim(0, nArraySize - 1);
1515
1516 // insert parameter(s) into the array
1517 const bool bIsVBAInterOp = SbiRuntime::isVBAEnabled();
1518 for(sal_Int32 i = 0 ; i < nArraySize ; i++ )
1519 {
1520 // tdf#123025 - split returns an array of substrings
1521 SbxVariableRef xVar = new SbxVariable( SbxSTRING );
1522 xVar->PutString( vRet[i] );
1523 // tdf#144924 - allow the assignment of different data types to the individual elements
1524 if (!bIsVBAInterOp)
1525 {
1526 xVar->ResetFlag(SbxFlagBits::Fixed);
1527 }
1528 pArray->Put(xVar.get(), &i);
1529 }
1530
1531 // return array
1532 SbxVariableRef refVar = rPar.Get(0);
1533 SbxFlagBits nFlags = refVar->GetFlags();
1534 refVar->ResetFlag( SbxFlagBits::Fixed );
1535 refVar->PutObject( pArray );
1536 refVar->SetFlags( nFlags );
1537 refVar->SetParameters( nullptr );
1538 }
1539
1540 // MonthName(month[, abbreviate])
1541 void SbRtl_MonthName(StarBASIC *, SbxArray & rPar, bool)
1542 {
1543 sal_uInt32 nParCount = rPar.Count();
1544 if( nParCount != 2 && nParCount != 3 )
1545 {
1546 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
1547 return;
1548 }
1549
1550 const Reference< XCalendar4 >& xCalendar = getLocaleCalendar();
1551 if( !xCalendar.is() )
1552 {
1553 StarBASIC::Error( ERRCODE_BASIC_INTERNAL_ERROR );
1554 return;
1555 }
1556 Sequence< CalendarItem2 > aMonthSeq = xCalendar->getMonths2();
1557 sal_Int32 nMonthCount = aMonthSeq.getLength();
1558
1559 sal_Int16 nVal = rPar.Get(1)->GetInteger();
1560 if( nVal < 1 || nVal > nMonthCount )
1561 {
1562 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
1563 return;
1564 }
1565
1566 bool bAbbreviate = false;
1567 if( nParCount == 3 )
1568 bAbbreviate = rPar.Get(2)->GetBool();
1569
1570 const CalendarItem2* pCalendarItems = aMonthSeq.getConstArray();
1571 const CalendarItem2& rItem = pCalendarItems[nVal - 1];
1572
1573 OUString aRetStr = ( bAbbreviate ? rItem.AbbrevName : rItem.FullName );
1574 rPar.Get(0)->PutString(aRetStr);
1575 }
1576
1577 // WeekdayName(weekday, abbreviate, firstdayofweek)
1578 void SbRtl_WeekdayName(StarBASIC *, SbxArray & rPar, bool)
1579 {
1580 sal_uInt32 nParCount = rPar.Count();
1581 if( nParCount < 2 || nParCount > 4 )
1582 {
1583 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
1584 return;
1585 }
1586
1587 const Reference< XCalendar4 >& xCalendar = getLocaleCalendar();
1588 if( !xCalendar.is() )
1589 {
1590 StarBASIC::Error( ERRCODE_BASIC_INTERNAL_ERROR );
1591 return;
1592 }
1593
1594 Sequence< CalendarItem2 > aDaySeq = xCalendar->getDays2();
1595 sal_Int16 nDayCount = static_cast<sal_Int16>(aDaySeq.getLength());
1596 sal_Int16 nDay = rPar.Get(1)->GetInteger();
1597 sal_Int16 nFirstDay = 0;
1598 if( nParCount == 4 )
1599 {
1600 nFirstDay = rPar.Get(3)->GetInteger();
1601 if( nFirstDay < 0 || nFirstDay > 7 )
1602 {
1603 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
1604 return;
1605 }
1606 }
1607 if( nFirstDay == 0 )
1608 {
1609 nFirstDay = sal_Int16( xCalendar->getFirstDayOfWeek() + 1 );
1610 }
1611 nDay = 1 + (nDay + nDayCount + nFirstDay - 2) % nDayCount;
1612 if( nDay < 1 || nDay > nDayCount )
1613 {
1614 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
1615 return;
1616 }
1617
1618 bool bAbbreviate = false;
1619 if( nParCount >= 3 )
1620 {
1621 SbxVariable* pPar2 = rPar.Get(2);
1622 if( !pPar2->IsErr() )
1623 {
1624 bAbbreviate = pPar2->GetBool();
1625 }
1626 }
1627
1628 const CalendarItem2* pCalendarItems = aDaySeq.getConstArray();
1629 const CalendarItem2& rItem = pCalendarItems[nDay - 1];
1630
1631 OUString aRetStr = ( bAbbreviate ? rItem.AbbrevName : rItem.FullName );
1632 rPar.Get(0)->PutString(aRetStr);
1633 }
1634
1635 void SbRtl_Weekday(StarBASIC *, SbxArray & rPar, bool)
1636 {
1637 sal_uInt32 nParCount = rPar.Count();
1638 if ( nParCount < 2 || nParCount > 3 )
1639 {
1640 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
1641 }
1642 else
1643 {
1644 double aDate = rPar.Get(1)->GetDate();
1645
1646 bool bFirstDay = false;
1647 sal_Int16 nFirstDay = 0;
1648 if ( nParCount > 2 )
1649 {
1650 nFirstDay = rPar.Get(2)->GetInteger();
1651 bFirstDay = true;
1652 }
1653 sal_Int16 nDay = implGetWeekDay( aDate, bFirstDay, nFirstDay );
1654 rPar.Get(0)->PutInteger(nDay);
1655 }
1656 }
1657
1658 namespace {
1659
1660 enum Interval
1661 {
1662 INTERVAL_YYYY,
1663 INTERVAL_Q,
1664 INTERVAL_M,
1665 INTERVAL_Y,
1666 INTERVAL_D,
1667 INTERVAL_W,
1668 INTERVAL_WW,
1669 INTERVAL_H,
1670 INTERVAL_N,
1671 INTERVAL_S
1672 };
1673
1674 struct IntervalInfo
1675 {
1676 Interval meInterval;
1677 char const * mStringCode;
1678 double mdValue;
1679 bool mbSimple;
1680 };
1681
1682 }
1683
1684 static IntervalInfo const * getIntervalInfo( const OUString& rStringCode )
1685 {
1686 static IntervalInfo const aIntervalTable[] =
1687 {
1688 { INTERVAL_YYYY, "yyyy", 0.0, false }, // Year
1689 { INTERVAL_Q, "q", 0.0, false }, // Quarter
1690 { INTERVAL_M, "m", 0.0, false }, // Month
1691 { INTERVAL_Y, "y", 1.0, true }, // Day of year
1692 { INTERVAL_D, "d", 1.0, true }, // Day
1693 { INTERVAL_W, "w", 1.0, true }, // Weekday
1694 { INTERVAL_WW, "ww", 7.0, true }, // Week
1695 { INTERVAL_H, "h", 1.0 / 24.0, true }, // Hour
1696 { INTERVAL_N, "n", 1.0 / 1440.0, true }, // Minute
1697 { INTERVAL_S, "s", 1.0 / 86400.0, true } // Second
1698 };
1699 auto const pred = [&rStringCode](const IntervalInfo &aInterval) {
1700 return rStringCode.equalsIgnoreAsciiCaseAscii(aInterval.mStringCode);
1701 };
1702
1703 auto intervalIter = std::find_if(std::begin(aIntervalTable), std::end(aIntervalTable), pred);
1704 if(intervalIter != std::end(aIntervalTable)) {
1705 return intervalIter;
1706 }
1707 return nullptr;
1708 }
1709
1710 static void implGetDayMonthYear( sal_Int16& rnYear, sal_Int16& rnMonth, sal_Int16& rnDay, double dDate )
1711 {
1712 rnDay = implGetDateDay( dDate );
1713 rnMonth = implGetDateMonth( dDate );
1714 rnYear = implGetDateYear( dDate );
1715 }
1716
1717 /** Limits a date to valid dates within tools' class Date capabilities.
1718
1719 @return the year number, truncated if necessary and in that case also
1720 rMonth and rDay adjusted.
1721 */
1722 static sal_Int16 limitDate( sal_Int32 n32Year, sal_Int16& rMonth, sal_Int16& rDay )
1723 {
1724 if( n32Year > SAL_MAX_INT16 )
1725 {
1726 n32Year = SAL_MAX_INT16;
1727 rMonth = 12;
1728 rDay = 31;
1729 }
1730 else if( n32Year < SAL_MIN_INT16 )
1731 {
1732 n32Year = SAL_MIN_INT16;
1733 rMonth = 1;
1734 rDay = 1;
1735 }
1736 return static_cast<sal_Int16>(n32Year);
1737 }
1738
1739 void SbRtl_DateAdd(StarBASIC *, SbxArray & rPar, bool)
1740 {
1741 sal_uInt32 nParCount = rPar.Count();
1742 if( nParCount != 4 )
1743 {
1744 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
1745 return;
1746 }
1747
1748 OUString aStringCode = rPar.Get(1)->GetOUString();
1749 IntervalInfo const * pInfo = getIntervalInfo( aStringCode );
1750 if( !pInfo )
1751 {
1752 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
1753 return;
1754 }
1755
1756 sal_Int32 lNumber = rPar.Get(2)->GetLong();
1757 double dDate = rPar.Get(3)->GetDate();
1758 double dNewDate = 0;
1759 if( pInfo->mbSimple )
1760 {
1761 double dAdd = pInfo->mdValue * lNumber;
1762 dNewDate = dDate + dAdd;
1763 }
1764 else
1765 {
1766 // Keep hours, minutes, seconds
1767 double dHoursMinutesSeconds = dDate - floor( dDate );
1768
1769 bool bOk = true;
1770 sal_Int16 nYear, nMonth, nDay;
1771 sal_Int16 nTargetYear16 = 0, nTargetMonth = 0;
1772 implGetDayMonthYear( nYear, nMonth, nDay, dDate );
1773 switch( pInfo->meInterval )
1774 {
1775 case INTERVAL_YYYY:
1776 {
1777 sal_Int32 nTargetYear = lNumber + nYear;
1778 nTargetYear16 = limitDate( nTargetYear, nMonth, nDay );
1779 /* TODO: should the result be error if the date was limited? It never was. */
1780 nTargetMonth = nMonth;
1781 bOk = implDateSerial( nTargetYear16, nTargetMonth, nDay, false, SbDateCorrection::TruncateToMonth, dNewDate );
1782 break;
1783 }
1784 case INTERVAL_Q:
1785 case INTERVAL_M:
1786 {
1787 bool bNeg = (lNumber < 0);
1788 if( bNeg )
1789 lNumber = -lNumber;
1790 sal_Int32 nYearsAdd;
1791 sal_Int16 nMonthAdd;
1792 if( pInfo->meInterval == INTERVAL_Q )
1793 {
1794 nYearsAdd = lNumber / 4;
1795 nMonthAdd = static_cast<sal_Int16>( 3 * (lNumber % 4) );
1796 }
1797 else
1798 {
1799 nYearsAdd = lNumber / 12;
1800 nMonthAdd = static_cast<sal_Int16>( lNumber % 12 );
1801 }
1802
1803 sal_Int32 nTargetYear;
1804 if( bNeg )
1805 {
1806 nTargetMonth = nMonth - nMonthAdd;
1807 if( nTargetMonth <= 0 )
1808 {
1809 nTargetMonth += 12;
1810 nYearsAdd++;
1811 }
1812 nTargetYear = static_cast<sal_Int32>(nYear) - nYearsAdd;
1813 }
1814 else
1815 {
1816 nTargetMonth = nMonth + nMonthAdd;
1817 if( nTargetMonth > 12 )
1818 {
1819 nTargetMonth -= 12;
1820 nYearsAdd++;
1821 }
1822 nTargetYear = static_cast<sal_Int32>(nYear) + nYearsAdd;
1823 }
1824 nTargetYear16 = limitDate( nTargetYear, nTargetMonth, nDay );
1825 /* TODO: should the result be error if the date was limited? It never was. */
1826 bOk = implDateSerial( nTargetYear16, nTargetMonth, nDay, false, SbDateCorrection::TruncateToMonth, dNewDate );
1827 break;
1828 }
1829 default: break;
1830 }
1831
1832 if( bOk )
1833 dNewDate += dHoursMinutesSeconds;
1834 }
1835
1836 rPar.Get(0)->PutDate(dNewDate);
1837 }
1838
1839 static double RoundImpl( double d )
1840 {
1841 return ( d >= 0 ) ? floor( d + 0.5 ) : -floor( -d + 0.5 );
1842 }
1843
1844 void SbRtl_DateDiff(StarBASIC *, SbxArray & rPar, bool)
1845 {
1846 // DateDiff(interval, date1, date2[, firstdayofweek[, firstweekofyear]])
1847
1848 sal_uInt32 nParCount = rPar.Count();
1849 if( nParCount < 4 || nParCount > 6 )
1850 {
1851 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
1852 return;
1853 }
1854
1855 OUString aStringCode = rPar.Get(1)->GetOUString();
1856 IntervalInfo const * pInfo = getIntervalInfo( aStringCode );
1857 if( !pInfo )
1858 {
1859 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
1860 return;
1861 }
1862
1863 double dDate1 = rPar.Get(2)->GetDate();
1864 double dDate2 = rPar.Get(3)->GetDate();
1865
1866 double dRet = 0.0;
1867 switch( pInfo->meInterval )
1868 {
1869 case INTERVAL_YYYY:
1870 {
1871 sal_Int16 nYear1 = implGetDateYear( dDate1 );
1872 sal_Int16 nYear2 = implGetDateYear( dDate2 );
1873 dRet = nYear2 - nYear1;
1874 break;
1875 }
1876 case INTERVAL_Q:
1877 {
1878 sal_Int16 nYear1 = implGetDateYear( dDate1 );
1879 sal_Int16 nYear2 = implGetDateYear( dDate2 );
1880 sal_Int16 nQ1 = 1 + (implGetDateMonth( dDate1 ) - 1) / 3;
1881 sal_Int16 nQ2 = 1 + (implGetDateMonth( dDate2 ) - 1) / 3;
1882 sal_Int16 nQGes1 = 4 * nYear1 + nQ1;
1883 sal_Int16 nQGes2 = 4 * nYear2 + nQ2;
1884 dRet = nQGes2 - nQGes1;
1885 break;
1886 }
1887 case INTERVAL_M:
1888 {
1889 sal_Int16 nYear1 = implGetDateYear( dDate1 );
1890 sal_Int16 nYear2 = implGetDateYear( dDate2 );
1891 sal_Int16 nMonth1 = implGetDateMonth( dDate1 );
1892 sal_Int16 nMonth2 = implGetDateMonth( dDate2 );
1893 sal_Int16 nMonthGes1 = 12 * nYear1 + nMonth1;
1894 sal_Int16 nMonthGes2 = 12 * nYear2 + nMonth2;
1895 dRet = nMonthGes2 - nMonthGes1;
1896 break;
1897 }
1898 case INTERVAL_Y:
1899 case INTERVAL_D:
1900 {
1901 double dDays1 = floor( dDate1 );
1902 double dDays2 = floor( dDate2 );
1903 dRet = dDays2 - dDays1;
1904 break;
1905 }
1906 case INTERVAL_W:
1907 case INTERVAL_WW:
1908 {
1909 double dDays1 = floor( dDate1 );
1910 double dDays2 = floor( dDate2 );
1911 if( pInfo->meInterval == INTERVAL_WW )
1912 {
1913 sal_Int16 nFirstDay = 1; // Default
1914 if( nParCount >= 5 )
1915 {
1916 nFirstDay = rPar.Get(4)->GetInteger();
1917 if( nFirstDay < 0 || nFirstDay > 7 )
1918 {
1919 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
1920 return;
1921 }
1922 if( nFirstDay == 0 )
1923 {
1924 const Reference< XCalendar4 >& xCalendar = getLocaleCalendar();
1925 if( !xCalendar.is() )
1926 {
1927 StarBASIC::Error( ERRCODE_BASIC_INTERNAL_ERROR );
1928 return;
1929 }
1930 nFirstDay = sal_Int16( xCalendar->getFirstDayOfWeek() + 1 );
1931 }
1932 }
1933 sal_Int16 nDay1 = implGetWeekDay( dDate1 );
1934 sal_Int16 nDay1_Diff = nDay1 - nFirstDay;
1935 if( nDay1_Diff < 0 )
1936 nDay1_Diff += 7;
1937 dDays1 -= nDay1_Diff;
1938
1939 sal_Int16 nDay2 = implGetWeekDay( dDate2 );
1940 sal_Int16 nDay2_Diff = nDay2 - nFirstDay;
1941 if( nDay2_Diff < 0 )
1942 nDay2_Diff += 7;
1943 dDays2 -= nDay2_Diff;
1944 }
1945
1946 double dDiff = dDays2 - dDays1;
1947 dRet = ( dDiff >= 0 ) ? floor( dDiff / 7.0 ) : -floor( -dDiff / 7.0 );
1948 break;
1949 }
1950 case INTERVAL_H:
1951 {
1952 dRet = RoundImpl( 24.0 * (dDate2 - dDate1) );
1953 break;
1954 }
1955 case INTERVAL_N:
1956 {
1957 dRet = RoundImpl( 1440.0 * (dDate2 - dDate1) );
1958 break;
1959 }
1960 case INTERVAL_S:
1961 {
1962 dRet = RoundImpl( 86400.0 * (dDate2 - dDate1) );
1963 break;
1964 }
1965 }
1966 rPar.Get(0)->PutDouble(dRet);
1967 }
1968
1969 static double implGetDateOfFirstDayInFirstWeek
1970 ( sal_Int16 nYear, sal_Int16& nFirstDay, sal_Int16& nFirstWeek, bool* pbError = nullptr )
1971 {
1972 ErrCode nError = ERRCODE_NONE;
1973 if( nFirstDay < 0 || nFirstDay > 7 )
1974 nError = ERRCODE_BASIC_BAD_ARGUMENT;
1975
1976 if( nFirstWeek < 0 || nFirstWeek > 3 )
1977 nError = ERRCODE_BASIC_BAD_ARGUMENT;
1978
1979 Reference< XCalendar4 > xCalendar;
1980 if( nFirstDay == 0 || nFirstWeek == 0 )
1981 {
1982 xCalendar = getLocaleCalendar();
1983 if( !xCalendar.is() )
1984 nError = ERRCODE_BASIC_BAD_ARGUMENT;
1985 }
1986
1987 if( nError != ERRCODE_NONE )
1988 {
1989 StarBASIC::Error( nError );
1990 if( pbError )
1991 *pbError = true;
1992 return 0.0;
1993 }
1994
1995 if( nFirstDay == 0 )
1996 nFirstDay = sal_Int16( xCalendar->getFirstDayOfWeek() + 1 );
1997
1998 sal_Int16 nFirstWeekMinDays = 0; // Not used for vbFirstJan1 = default
1999 if( nFirstWeek == 0 )
2000 {
2001 nFirstWeekMinDays = xCalendar->getMinimumNumberOfDaysForFirstWeek();
2002 if( nFirstWeekMinDays == 1 )
2003 {
2004 nFirstWeekMinDays = 0;
2005 nFirstWeek = 1;
2006 }
2007 else if( nFirstWeekMinDays == 4 )
2008 nFirstWeek = 2;
2009 else if( nFirstWeekMinDays == 7 )
2010 nFirstWeek = 3;
2011 }
2012 else if( nFirstWeek == 2 )
2013 nFirstWeekMinDays = 4; // vbFirstFourDays
2014 else if( nFirstWeek == 3 )
2015 nFirstWeekMinDays = 7; // vbFirstFourDays
2016
2017 double dBaseDate;
2018 implDateSerial( nYear, 1, 1, false, SbDateCorrection::None, dBaseDate );
2019
2020 sal_Int16 nWeekDay0101 = implGetWeekDay( dBaseDate );
2021 sal_Int16 nDayDiff = nWeekDay0101 - nFirstDay;
2022 if( nDayDiff < 0 )
2023 nDayDiff += 7;
2024
2025 if( nFirstWeekMinDays )
2026 {
2027 sal_Int16 nThisWeeksDaysInYearCount = 7 - nDayDiff;
2028 if( nThisWeeksDaysInYearCount < nFirstWeekMinDays )
2029 nDayDiff -= 7;
2030 }
2031 double dRetDate = dBaseDate - nDayDiff;
2032 return dRetDate;
2033 }
2034
2035 void SbRtl_DatePart(StarBASIC *, SbxArray & rPar, bool)
2036 {
2037 // DatePart(interval, date[,firstdayofweek[, firstweekofyear]])
2038
2039 sal_uInt32 nParCount = rPar.Count();
2040 if( nParCount < 3 || nParCount > 5 )
2041 {
2042 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
2043 return;
2044 }
2045
2046 OUString aStringCode = rPar.Get(1)->GetOUString();
2047 IntervalInfo const * pInfo = getIntervalInfo( aStringCode );
2048 if( !pInfo )
2049 {
2050 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
2051 return;
2052 }
2053
2054 double dDate = rPar.Get(2)->GetDate();
2055
2056 sal_Int32 nRet = 0;
2057 switch( pInfo->meInterval )
2058 {
2059 case INTERVAL_YYYY:
2060 {
2061 nRet = implGetDateYear( dDate );
2062 break;
2063 }
2064 case INTERVAL_Q:
2065 {
2066 nRet = 1 + (implGetDateMonth( dDate ) - 1) / 3;
2067 break;
2068 }
2069 case INTERVAL_M:
2070 {
2071 nRet = implGetDateMonth( dDate );
2072 break;
2073 }
2074 case INTERVAL_Y:
2075 {
2076 sal_Int16 nYear = implGetDateYear( dDate );
2077 double dBaseDate;
2078 implDateSerial( nYear, 1, 1, false, SbDateCorrection::None, dBaseDate );
2079 nRet = 1 + sal_Int32( dDate - dBaseDate );
2080 break;
2081 }
2082 case INTERVAL_D:
2083 {
2084 nRet = implGetDateDay( dDate );
2085 break;
2086 }
2087 case INTERVAL_W:
2088 {
2089 bool bFirstDay = false;
2090 sal_Int16 nFirstDay = 1; // Default
2091 if( nParCount >= 4 )
2092 {
2093 nFirstDay = rPar.Get(3)->GetInteger();
2094 bFirstDay = true;
2095 }
2096 nRet = implGetWeekDay( dDate, bFirstDay, nFirstDay );
2097 break;
2098 }
2099 case INTERVAL_WW:
2100 {
2101 sal_Int16 nFirstDay = 1; // Default
2102 if( nParCount >= 4 )
2103 nFirstDay = rPar.Get(3)->GetInteger();
2104
2105 sal_Int16 nFirstWeek = 1; // Default
2106 if( nParCount == 5 )
2107 nFirstWeek = rPar.Get(4)->GetInteger();
2108
2109 sal_Int16 nYear = implGetDateYear( dDate );
2110 bool bError = false;
2111 double dYearFirstDay = implGetDateOfFirstDayInFirstWeek( nYear, nFirstDay, nFirstWeek, &bError );
2112 if( !bError )
2113 {
2114 if( dYearFirstDay > dDate )
2115 {
2116 // Date belongs to last year's week
2117 dYearFirstDay = implGetDateOfFirstDayInFirstWeek( nYear - 1, nFirstDay, nFirstWeek );
2118 }
2119 else if( nFirstWeek != 1 )
2120 {
2121 // Check if date belongs to next year
2122 double dNextYearFirstDay = implGetDateOfFirstDayInFirstWeek( nYear + 1, nFirstDay, nFirstWeek );
2123 if( dDate >= dNextYearFirstDay )
2124 dYearFirstDay = dNextYearFirstDay;
2125 }
2126
2127 // Calculate week
2128 double dDiff = dDate - dYearFirstDay;
2129 nRet = 1 + sal_Int32( dDiff / 7 );
2130 }
2131 break;
2132 }
2133 case INTERVAL_H:
2134 {
2135 nRet = implGetHour( dDate );
2136 break;
2137 }
2138 case INTERVAL_N:
2139 {
2140 nRet = implGetMinute( dDate );
2141 break;
2142 }
2143 case INTERVAL_S:
2144 {
2145 nRet = implGetSecond( dDate );
2146 break;
2147 }
2148 }
2149 rPar.Get(0)->PutLong(nRet);
2150 }
2151
2152 // FormatDateTime(Date[,NamedFormat])
2153 void SbRtl_FormatDateTime(StarBASIC *, SbxArray & rPar, bool)
2154 {
2155 sal_uInt32 nParCount = rPar.Count();
2156 if( nParCount < 2 || nParCount > 3 )
2157 {
2158 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
2159 return;
2160 }
2161
2162 double dDate = rPar.Get(1)->GetDate();
2163 sal_Int16 nNamedFormat = 0;
2164 if( nParCount > 2 )
2165 {
2166 nNamedFormat = rPar.Get(2)->GetInteger();
2167 if( nNamedFormat < 0 || nNamedFormat > 4 )
2168 {
2169 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
2170 return;
2171 }
2172 }
2173
2174 const Reference< XCalendar4 >& xCalendar = getLocaleCalendar();
2175 if( !xCalendar.is() )
2176 {
2177 StarBASIC::Error( ERRCODE_BASIC_INTERNAL_ERROR );
2178 return;
2179 }
2180
2181 OUString aRetStr;
2182 SbxVariableRef pSbxVar = new SbxVariable( SbxSTRING );
2183 switch( nNamedFormat )
2184 {
2185 // GeneralDate:
2186 // Display a date and/or time. If there is a date part,
2187 // display it as a short date. If there is a time part,
2188 // display it as a long time. If present, both parts are displayed.
2189
2190 // 12/21/2004 11:24:50 AM
2191 // 21.12.2004 12:13:51
2192 case 0:
2193 pSbxVar->PutDate( dDate );
2194 aRetStr = pSbxVar->GetOUString();
2195 break;
2196
2197 // LongDate: Display a date using the long date format specified
2198 // in your computer's regional settings.
2199 // Tuesday, December 21, 2004
2200 // Dienstag, 21. December 2004
2201 case 1:
2202 {
2203 std::shared_ptr<SvNumberFormatter> pFormatter;
2204 if( GetSbData()->pInst )
2205 {
2206 pFormatter = GetSbData()->pInst->GetNumberFormatter();
2207 }
2208 else
2209 {
2210 sal_uInt32 n; // Dummy
2211 pFormatter = SbiInstance::PrepareNumberFormatter( n, n, n );
2212 }
2213
2214 LanguageType eLangType = Application::GetSettings().GetLanguageTag().getLanguageType();
2215 const sal_uInt32 nIndex = pFormatter->GetFormatIndex( NF_DATE_SYSTEM_LONG, eLangType );
2216 const Color* pCol;
2217 pFormatter->GetOutputString( dDate, nIndex, aRetStr, &pCol );
2218 break;
2219 }
2220
2221 // ShortDate: Display a date using the short date format specified
2222 // in your computer's regional settings.
2223 // 21.12.2004
2224 case 2:
2225 pSbxVar->PutDate( floor(dDate) );
2226 aRetStr = pSbxVar->GetOUString();
2227 break;
2228
2229 // LongTime: Display a time using the time format specified
2230 // in your computer's regional settings.
2231 // 11:24:50 AM
2232 // 12:13:51
2233 case 3:
2234 // ShortTime: Display a time using the 24-hour format (hh:mm).
2235 // 11:24
2236 case 4:
2237 double dTime = modf( dDate, &o3tl::temporary(double()) );
2238 pSbxVar->PutDate( dTime );
2239 if( nNamedFormat == 3 )
2240 {
2241 aRetStr = pSbxVar->GetOUString();
2242 }
2243 else
2244 {
2245 aRetStr = pSbxVar->GetOUString().copy( 0, 5 );
2246 }
2247 break;
2248 }
2249
2250 rPar.Get(0)->PutString(aRetStr);
2251 }
2252
2253 void SbRtl_Frac(StarBASIC *, SbxArray & rPar, bool)
2254 {
2255 sal_uInt32 nParCount = rPar.Count();
2256 if( nParCount != 2)
2257 {
2258 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
2259 return;
2260 }
2261
2262 SbxVariable* pSbxVariable = rPar.Get(1);
2263 double dVal = pSbxVariable->GetDouble();
2264 if(dVal >= 0)
2265 rPar.Get(0)->PutDouble(dVal - ::rtl::math::approxFloor(dVal));
2266 else
2267 rPar.Get(0)->PutDouble(dVal - ::rtl::math::approxCeil(dVal));
2268 }
2269
2270 void SbRtl_Round(StarBASIC *, SbxArray & rPar, bool)
2271 {
2272 sal_uInt32 nParCount = rPar.Count();
2273 if( nParCount != 2 && nParCount != 3 )
2274 {
2275 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
2276 return;
2277 }
2278
2279 SbxVariable* pSbxVariable = rPar.Get(1);
2280 double dVal = pSbxVariable->GetDouble();
2281 double dRes = 0.0;
2282 if( dVal != 0.0 )
2283 {
2284 sal_Int16 numdecimalplaces = 0;
2285 if( nParCount == 3 )
2286 {
2287 numdecimalplaces = rPar.Get(2)->GetInteger();
2288 if( numdecimalplaces < 0 || numdecimalplaces > 22 )
2289 {
2290 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
2291 return;
2292 }
2293 }
2294
2295 dRes = rtl_math_round(dVal, numdecimalplaces, rtl_math_RoundingMode_HalfEven);
2296 }
2297 rPar.Get(0)->PutDouble(dRes);
2298 }
2299
2300 static void CallFunctionAccessFunction( const Sequence< Any >& aArgs, const OUString& sFuncName, SbxVariable* pRet )
2301 {
2302 static Reference< XFunctionAccess > xFunc;
2303 try
2304 {
2305 if ( !xFunc.is() )
2306 {
2307 Reference< XMultiServiceFactory > xFactory( getProcessServiceFactory() );
2308 if( xFactory.is() )
2309 {
2310 xFunc.set( xFactory->createInstance(u"com.sun.star.sheet.FunctionAccess"_ustr), UNO_QUERY_THROW);
2311 }
2312 }
2313 Any aRet = xFunc->callFunction( sFuncName, aArgs );
2314
2315 unoToSbxValue( pRet, aRet );
2316
2317 }
2318 catch(const Exception& )
2319 {
2320 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
2321 }
2322 }
2323
2324 void SbRtl_SYD(StarBASIC *, SbxArray & rPar, bool)
2325 {
2326 sal_uInt32 nArgCount = rPar.Count() - 1;
2327
2328 if ( nArgCount < 4 )
2329 {
2330 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
2331 return;
2332 }
2333
2334 // retrieve non-optional params
2335
2336 Sequence< Any > aParams
2337 {
2338 Any(rPar.Get(1)->GetDouble()),
2339 Any(rPar.Get(2)->GetDouble()),
2340 Any(rPar.Get(3)->GetDouble()),
2341 Any(rPar.Get(4)->GetDouble())
2342 };
2343
2344 CallFunctionAccessFunction(aParams, u"SYD"_ustr, rPar.Get(0));
2345 }
2346
2347 void SbRtl_SLN(StarBASIC *, SbxArray & rPar, bool)
2348 {
2349 sal_uInt32 nArgCount = rPar.Count() - 1;
2350
2351 if ( nArgCount < 3 )
2352 {
2353 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
2354 return;
2355 }
2356
2357 // retrieve non-optional params
2358
2359 Sequence< Any > aParams
2360 {
2361 Any(rPar.Get(1)->GetDouble()),
2362 Any(rPar.Get(2)->GetDouble()),
2363 Any(rPar.Get(3)->GetDouble())
2364 };
2365
2366 CallFunctionAccessFunction(aParams, u"SLN"_ustr, rPar.Get(0));
2367 }
2368
2369 void SbRtl_Pmt(StarBASIC *, SbxArray & rPar, bool)
2370 {
2371 sal_uInt32 nArgCount = rPar.Count() - 1;
2372
2373 if ( nArgCount < 3 || nArgCount > 5 )
2374 {
2375 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
2376 return;
2377 }
2378 // retrieve non-optional params
2379
2380 double rate = rPar.Get(1)->GetDouble();
2381 double nper = rPar.Get(2)->GetDouble();
2382 double pmt = rPar.Get(3)->GetDouble();
2383
2384 // set default values for Optional args
2385 double fv = 0;
2386 double type = 0;
2387
2388 // fv
2389 if ( nArgCount >= 4 )
2390 {
2391 if (rPar.Get(4)->GetType() != SbxEMPTY)
2392 fv = rPar.Get(4)->GetDouble();
2393 }
2394 // type
2395 if ( nArgCount >= 5 )
2396 {
2397 if (rPar.Get(5)->GetType() != SbxEMPTY)
2398 type = rPar.Get(5)->GetDouble();
2399 }
2400
2401 Sequence< Any > aParams
2402 {
2403 Any(rate),
2404 Any(nper),
2405 Any(pmt),
2406 Any(fv),
2407 Any(type)
2408 };
2409
2410 CallFunctionAccessFunction(aParams, u"Pmt"_ustr, rPar.Get(0));
2411 }
2412
2413 void SbRtl_PPmt(StarBASIC *, SbxArray & rPar, bool)
2414 {
2415 sal_uInt32 nArgCount = rPar.Count() - 1;
2416
2417 if ( nArgCount < 4 || nArgCount > 6 )
2418 {
2419 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
2420 return;
2421 }
2422 // retrieve non-optional params
2423
2424 double rate = rPar.Get(1)->GetDouble();
2425 double per = rPar.Get(2)->GetDouble();
2426 double nper = rPar.Get(3)->GetDouble();
2427 double pv = rPar.Get(4)->GetDouble();
2428
2429 // set default values for Optional args
2430 double fv = 0;
2431 double type = 0;
2432
2433 // fv
2434 if ( nArgCount >= 5 )
2435 {
2436 if (rPar.Get(5)->GetType() != SbxEMPTY)
2437 fv = rPar.Get(5)->GetDouble();
2438 }
2439 // type
2440 if ( nArgCount >= 6 )
2441 {
2442 if (rPar.Get(6)->GetType() != SbxEMPTY)
2443 type = rPar.Get(6)->GetDouble();
2444 }
2445
2446 Sequence< Any > aParams
2447 {
2448 Any(rate),
2449 Any(per),
2450 Any(nper),
2451 Any(pv),
2452 Any(fv),
2453 Any(type)
2454 };
2455
2456 CallFunctionAccessFunction(aParams, u"PPmt"_ustr, rPar.Get(0));
2457 }
2458
2459 void SbRtl_PV(StarBASIC *, SbxArray & rPar, bool)
2460 {
2461 sal_uInt32 nArgCount = rPar.Count() - 1;
2462
2463 if ( nArgCount < 3 || nArgCount > 5 )
2464 {
2465 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
2466 return;
2467 }
2468 // retrieve non-optional params
2469
2470 double rate = rPar.Get(1)->GetDouble();
2471 double nper = rPar.Get(2)->GetDouble();
2472 double pmt = rPar.Get(3)->GetDouble();
2473
2474 // set default values for Optional args
2475 double fv = 0;
2476 double type = 0;
2477
2478 // fv
2479 if ( nArgCount >= 4 )
2480 {
2481 if (rPar.Get(4)->GetType() != SbxEMPTY)
2482 fv = rPar.Get(4)->GetDouble();
2483 }
2484 // type
2485 if ( nArgCount >= 5 )
2486 {
2487 if (rPar.Get(5)->GetType() != SbxEMPTY)
2488 type = rPar.Get(5)->GetDouble();
2489 }
2490
2491 Sequence< Any > aParams
2492 {
2493 Any(rate),
2494 Any(nper),
2495 Any(pmt),
2496 Any(fv),
2497 Any(type)
2498 };
2499
2500 CallFunctionAccessFunction(aParams, u"PV"_ustr, rPar.Get(0));
2501 }
2502
2503 void SbRtl_NPV(StarBASIC *, SbxArray & rPar, bool)
2504 {
2505 sal_uInt32 nArgCount = rPar.Count() - 1;
2506
2507 if ( nArgCount < 1 || nArgCount > 2 )
2508 {
2509 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
2510 return;
2511 }
2512
2513 Any aValues = sbxToUnoValue(rPar.Get(2),
2514 cppu::UnoType<Sequence<double>>::get() );
2515
2516 // convert for calc functions
2517 Sequence< Sequence< double > > sValues(1);
2518 aValues >>= sValues.getArray()[ 0 ];
2519 aValues <<= sValues;
2520
2521 Sequence< Any > aParams
2522 {
2523 Any(rPar.Get(1)->GetDouble()),
2524 aValues
2525 };
2526
2527 CallFunctionAccessFunction(aParams, u"NPV"_ustr, rPar.Get(0));
2528 }
2529
2530 void SbRtl_NPer(StarBASIC *, SbxArray & rPar, bool)
2531 {
2532 sal_uInt32 nArgCount = rPar.Count() - 1;
2533
2534 if ( nArgCount < 3 || nArgCount > 5 )
2535 {
2536 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
2537 return;
2538 }
2539 // retrieve non-optional params
2540
2541 double rate = rPar.Get(1)->GetDouble();
2542 double pmt = rPar.Get(2)->GetDouble();
2543 double pv = rPar.Get(3)->GetDouble();
2544
2545 // set default values for Optional args
2546 double fv = 0;
2547 double type = 0;
2548
2549 // fv
2550 if ( nArgCount >= 4 )
2551 {
2552 if (rPar.Get(4)->GetType() != SbxEMPTY)
2553 fv = rPar.Get(4)->GetDouble();
2554 }
2555 // type
2556 if ( nArgCount >= 5 )
2557 {
2558 if (rPar.Get(5)->GetType() != SbxEMPTY)
2559 type = rPar.Get(5)->GetDouble();
2560 }
2561
2562 Sequence< Any > aParams
2563 {
2564 Any(rate),
2565 Any(pmt),
2566 Any(pv),
2567 Any(fv),
2568 Any(type)
2569 };
2570
2571 CallFunctionAccessFunction(aParams, u"NPer"_ustr, rPar.Get(0));
2572 }
2573
2574 void SbRtl_MIRR(StarBASIC *, SbxArray & rPar, bool)
2575 {
2576 sal_uInt32 nArgCount = rPar.Count() - 1;
2577
2578 if ( nArgCount < 3 )
2579 {
2580 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
2581 return;
2582 }
2583
2584 // retrieve non-optional params
2585
2586 Any aValues = sbxToUnoValue(rPar.Get(1),
2587 cppu::UnoType<Sequence<double>>::get() );
2588
2589 // convert for calc functions
2590 Sequence< Sequence< double > > sValues(1);
2591 aValues >>= sValues.getArray()[ 0 ];
2592 aValues <<= sValues;
2593
2594 Sequence< Any > aParams
2595 {
2596 aValues,
2597 Any(rPar.Get(2)->GetDouble()),
2598 Any(rPar.Get(3)->GetDouble())
2599 };
2600
2601 CallFunctionAccessFunction(aParams, u"MIRR"_ustr, rPar.Get(0));
2602 }
2603
2604 void SbRtl_IRR(StarBASIC *, SbxArray & rPar, bool)
2605 {
2606 sal_uInt32 nArgCount = rPar.Count() - 1;
2607
2608 if ( nArgCount < 1 || nArgCount > 2 )
2609 {
2610 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
2611 return;
2612 }
2613 // retrieve non-optional params
2614 Any aValues = sbxToUnoValue(rPar.Get(1),
2615 cppu::UnoType<Sequence<double>>::get() );
2616
2617 // convert for calc functions
2618 Sequence< Sequence< double > > sValues(1);
2619 aValues >>= sValues.getArray()[ 0 ];
2620 aValues <<= sValues;
2621
2622 // set default values for Optional args
2623 double guess = 0.1;
2624 // guess
2625 if ( nArgCount >= 2 )
2626 {
2627 if (rPar.Get(2)->GetType() != SbxEMPTY)
2628 guess = rPar.Get(2)->GetDouble();
2629 }
2630
2631 Sequence< Any > aParams
2632 {
2633 aValues,
2634 Any(guess)
2635 };
2636
2637 CallFunctionAccessFunction(aParams, u"IRR"_ustr, rPar.Get(0));
2638 }
2639
2640 void SbRtl_IPmt(StarBASIC *, SbxArray & rPar, bool)
2641 {
2642 sal_uInt32 nArgCount = rPar.Count() - 1;
2643
2644 if ( nArgCount < 4 || nArgCount > 6 )
2645 {
2646 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
2647 return;
2648 }
2649 // retrieve non-optional params
2650
2651 double rate = rPar.Get(1)->GetDouble();
2652 double per = rPar.Get(2)->GetInteger();
2653 double nper = rPar.Get(3)->GetDouble();
2654 double pv = rPar.Get(4)->GetDouble();
2655
2656 // set default values for Optional args
2657 double fv = 0;
2658 double type = 0;
2659
2660 // fv
2661 if ( nArgCount >= 5 )
2662 {
2663 if (rPar.Get(5)->GetType() != SbxEMPTY)
2664 fv = rPar.Get(5)->GetDouble();
2665 }
2666 // type
2667 if ( nArgCount >= 6 )
2668 {
2669 if (rPar.Get(6)->GetType() != SbxEMPTY)
2670 type = rPar.Get(6)->GetDouble();
2671 }
2672
2673 Sequence< Any > aParams
2674 {
2675 Any(rate),
2676 Any(per),
2677 Any(nper),
2678 Any(pv),
2679 Any(fv),
2680 Any(type)
2681 };
2682
2683 CallFunctionAccessFunction(aParams, u"IPmt"_ustr, rPar.Get(0));
2684 }
2685
2686 void SbRtl_FV(StarBASIC *, SbxArray & rPar, bool)
2687 {
2688 sal_uInt32 nArgCount = rPar.Count() - 1;
2689
2690 if ( nArgCount < 3 || nArgCount > 5 )
2691 {
2692 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
2693 return;
2694 }
2695 // retrieve non-optional params
2696
2697 double rate = rPar.Get(1)->GetDouble();
2698 double nper = rPar.Get(2)->GetDouble();
2699 double pmt = rPar.Get(3)->GetDouble();
2700
2701 // set default values for Optional args
2702 double pv = 0;
2703 double type = 0;
2704
2705 // pv
2706 if ( nArgCount >= 4 )
2707 {
2708 if (rPar.Get(4)->GetType() != SbxEMPTY)
2709 pv = rPar.Get(4)->GetDouble();
2710 }
2711 // type
2712 if ( nArgCount >= 5 )
2713 {
2714 if (rPar.Get(5)->GetType() != SbxEMPTY)
2715 type = rPar.Get(5)->GetDouble();
2716 }
2717
2718 Sequence< Any > aParams
2719 {
2720 Any(rate),
2721 Any(nper),
2722 Any(pmt),
2723 Any(pv),
2724 Any(type)
2725 };
2726
2727 CallFunctionAccessFunction(aParams, u"FV"_ustr, rPar.Get(0));
2728 }
2729
2730 void SbRtl_DDB(StarBASIC *, SbxArray & rPar, bool)
2731 {
2732 sal_uInt32 nArgCount = rPar.Count() - 1;
2733
2734 if ( nArgCount < 4 || nArgCount > 5 )
2735 {
2736 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
2737 return;
2738 }
2739 // retrieve non-optional params
2740
2741 double cost = rPar.Get(1)->GetDouble();
2742 double salvage = rPar.Get(2)->GetDouble();
2743 double life = rPar.Get(3)->GetDouble();
2744 double period = rPar.Get(4)->GetDouble();
2745
2746 // set default values for Optional args
2747 double factor = 2;
2748
2749 // factor
2750 if ( nArgCount >= 5 )
2751 {
2752 if (rPar.Get(5)->GetType() != SbxEMPTY)
2753 factor = rPar.Get(5)->GetDouble();
2754 }
2755
2756 Sequence< Any > aParams
2757 {
2758 Any(cost),
2759 Any(salvage),
2760 Any(life),
2761 Any(period),
2762 Any(factor)
2763 };
2764
2765 CallFunctionAccessFunction(aParams, u"DDB"_ustr, rPar.Get(0));
2766 }
2767
2768 void SbRtl_Rate(StarBASIC *, SbxArray & rPar, bool)
2769 {
2770 sal_uInt32 nArgCount = rPar.Count() - 1;
2771
2772 if ( nArgCount < 3 || nArgCount > 6 )
2773 {
2774 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
2775 return;
2776 }
2777 // retrieve non-optional params
2778
2779 double nper = 0;
2780 double pmt = 0;
2781 double pv = 0;
2782
2783 nper = rPar.Get(1)->GetDouble();
2784 pmt = rPar.Get(2)->GetDouble();
2785 pv = rPar.Get(3)->GetDouble();
2786
2787 // set default values for Optional args
2788 double fv = 0;
2789 double type = 0;
2790 double guess = 0.1;
2791
2792 // fv
2793 if ( nArgCount >= 4 )
2794 {
2795 if (rPar.Get(4)->GetType() != SbxEMPTY)
2796 fv = rPar.Get(4)->GetDouble();
2797 }
2798
2799 // type
2800 if ( nArgCount >= 5 )
2801 {
2802 if (rPar.Get(5)->GetType() != SbxEMPTY)
2803 type = rPar.Get(5)->GetDouble();
2804 }
2805
2806 // guess
2807 if ( nArgCount >= 6 )
2808 {
2809 if (rPar.Get(6)->GetType() != SbxEMPTY)
2810 guess = rPar.Get(6)->GetDouble();
2811 }
2812
2813 Sequence< Any > aParams
2814 {
2815 Any(nper),
2816 Any(pmt),
2817 Any(pv),
2818 Any(fv),
2819 Any(type),
2820 Any(guess)
2821 };
2822
2823 CallFunctionAccessFunction(aParams, u"Rate"_ustr, rPar.Get(0));
2824 }
2825
2826 void SbRtl_StrReverse(StarBASIC *, SbxArray & rPar, bool)
2827 {
2828 if (rPar.Count() != 2)
2829 {
2830 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
2831 return;
2832 }
2833
2834 SbxVariable* pSbxVariable = rPar.Get(1);
2835 if( pSbxVariable->IsNull() )
2836 {
2837 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
2838 return;
2839 }
2840
2841 OUString aStr = comphelper::string::reverseString(pSbxVariable->GetOUString());
2842 rPar.Get(0)->PutString(aStr);
2843 }
2844
2845 void SbRtl_CompatibilityMode(StarBASIC *, SbxArray & rPar, bool)
2846 {
2847 bool bEnabled = false;
2848 sal_uInt32 nCount = rPar.Count();
2849 if ( nCount != 1 && nCount != 2 )
2850 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
2851
2852 SbiInstance* pInst = GetSbData()->pInst;
2853 if( pInst )
2854 {
2855 if ( nCount == 2 )
2856 {
2857 pInst->EnableCompatibility(rPar.Get(1)->GetBool());
2858 }
2859 bEnabled = pInst->IsCompatibility();
2860 }
2861 rPar.Get(0)->PutBool(bEnabled);
2862 }
2863
2864 void SbRtl_Input(StarBASIC *, SbxArray & rPar, bool)
2865 {
2866 // 2 parameters needed
2867 if (rPar.Count() < 3)
2868 {
2869 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
2870 return;
2871 }
2872
2873 sal_uInt16 nByteCount = rPar.Get(1)->GetUShort();
2874 sal_Int16 nFileNumber = rPar.Get(2)->GetInteger();
2875
2876 SbiIoSystem* pIosys = GetSbData()->pInst->GetIoSystem();
2877 SbiStream* pSbStrm = pIosys->GetStream( nFileNumber );
2878 if ( !pSbStrm || !(pSbStrm->GetMode() & (SbiStreamFlags::Binary | SbiStreamFlags::Input)) )
2879 {
2880 StarBASIC::Error( ERRCODE_BASIC_BAD_CHANNEL );
2881 return;
2882 }
2883
2884 OString aByteBuffer;
2885 ErrCode err = pSbStrm->Read( aByteBuffer, nByteCount, true );
2886 if( !err )
2887 err = pIosys->GetError();
2888
2889 if( err )
2890 {
2891 StarBASIC::Error( err );
2892 return;
2893 }
2894 rPar.Get(0)->PutString(OStringToOUString(aByteBuffer, osl_getThreadTextEncoding()));
2895 }
2896
2897 void SbRtl_Me(StarBASIC *, SbxArray & rPar, bool)
2898 {
2899 SbModule* pActiveModule = GetSbData()->pInst->GetActiveModule();
2900 SbClassModuleObject* pClassModuleObject = dynamic_cast<SbClassModuleObject*>( pActiveModule );
2901 SbxVariableRef refVar = rPar.Get(0);
2902 if( pClassModuleObject == nullptr )
2903 {
2904 SbObjModule* pMod = dynamic_cast<SbObjModule*>( pActiveModule );
2905 if ( pMod )
2906 refVar->PutObject( pMod );
2907 else
2908 StarBASIC::Error( ERRCODE_BASIC_INVALID_USAGE_OBJECT );
2909 }
2910 else
2911 refVar->PutObject( pClassModuleObject );
2912 }
2913
2914 #endif
2915
2916 sal_Int16 implGetWeekDay( double aDate, bool bFirstDayParam, sal_Int16 nFirstDay )
2917 {
2918 Date aRefDate(1899'12'30);
2919 sal_Int32 nDays = static_cast<sal_Int32>(aDate);
2920 aRefDate.AddDays( nDays);
2921 DayOfWeek aDay = aRefDate.GetDayOfWeek();
2922 sal_Int16 nDay;
2923 if ( aDay != SUNDAY )
2924 nDay = static_cast<sal_Int16>(aDay) + 2;
2925 else
2926 nDay = 1; // 1 == Sunday
2927
2928 // #117253 optional 2nd parameter "firstdayofweek"
2929 if( bFirstDayParam )
2930 {
2931 if( nFirstDay < 0 || nFirstDay > 7 )
2932 {
2933 #if HAVE_FEATURE_SCRIPTING
2934 StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
2935 #endif
2936 return 0;
2937 }
2938 if( nFirstDay == 0 )
2939 {
2940 const Reference< XCalendar4 >& xCalendar = getLocaleCalendar();
2941 if( !xCalendar.is() )
2942 {
2943 #if HAVE_FEATURE_SCRIPTING
2944 StarBASIC::Error( ERRCODE_BASIC_INTERNAL_ERROR );
2945 #endif
2946 return 0;
2947 }
2948 nFirstDay = sal_Int16( xCalendar->getFirstDayOfWeek() + 1 );
2949 }
2950 nDay = 1 + (nDay + 7 - nFirstDay) % 7;
2951 }
2952 return nDay;
2953 }
2954
2955 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */