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