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