?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bump product version to 5.0.4.1
[LibreOffice.git] / basic / source / runtime / methods.cxx
bloba2bb3467e015690836107a6f42db152681896f60
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 <tools/date.hxx>
23 #include <basic/sbxvar.hxx>
24 #include <basic/sbuno.hxx>
25 #include <osl/process.h>
26 #include <vcl/dibtools.hxx>
27 #include <vcl/svapp.hxx>
28 #include <vcl/settings.hxx>
29 #include <vcl/sound.hxx>
30 #include <tools/wintypes.hxx>
31 #include <vcl/msgbox.hxx>
32 #include <basic/sbx.hxx>
33 #include <svl/zforlist.hxx>
34 #include <rtl/math.hxx>
35 #include <tools/urlobj.hxx>
36 #include <osl/time.h>
37 #include <unotools/charclass.hxx>
38 #include <unotools/ucbstreamhelper.hxx>
39 #include <tools/wldcrd.hxx>
40 #include <i18nlangtag/lang.h>
41 #include <rtl/string.hxx>
42 #include <rtl/strbuf.hxx>
43
44 #include "runtime.hxx"
45 #include "sbunoobj.hxx"
46 #include <osl/file.hxx>
47 #include "errobject.hxx"
48
49 #include <comphelper/processfactory.hxx>
50 #include <comphelper/string.hxx>
51
52 #include <com/sun/star/uno/Sequence.hxx>
53 #include <com/sun/star/util/DateTime.hpp>
54 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
55 #include <com/sun/star/lang/Locale.hpp>
56 #include <com/sun/star/ucb/SimpleFileAccess.hpp>
57 #include <com/sun/star/script/XErrorQuery.hpp>
58 #include <ooo/vba/XHelperInterface.hpp>
59 #include <com/sun/star/bridge/oleautomation/XAutomationObject.hpp>
60 #include <boost/scoped_array.hpp>
61 #include <boost/scoped_ptr.hpp>
62
63 #include <random>
64
65 using namespace comphelper;
66 using namespace osl;
67 using namespace com::sun::star;
68 using namespace com::sun::star::lang;
69 using namespace com::sun::star::uno;
70
71 #include "date.hxx"
72 #include "stdobj.hxx"
73 #include "sbstdobj.hxx"
74 #include "rtlproto.hxx"
75 #include "basrid.hxx"
76 #include "image.hxx"
77 #include "sb.hrc"
78 #include "iosys.hxx"
79 #include "ddectrl.hxx"
80 #include <sbintern.hxx>
81 #include <basic/vbahelper.hxx>
82
83 #include <list>
84 #include <math.h>
85 #include <stdio.h>
86 #include <stdlib.h>
87 #include <ctype.h>
88 #include <errno.h>
89
90 #include "sbobjmod.hxx"
91 #include "sbxmod.hxx"
92
93 #ifdef WNT
94 #include <prewin.h>
95 #include <direct.h>
96 #include <io.h>
97 #include <postwin.h>
98 #endif
99
100 #if HAVE_FEATURE_SCRIPTING
101
102 static void FilterWhiteSpace( OUString& rStr )
103 {
104 if (rStr.isEmpty())
105 {
106 return;
107 }
108 OUStringBuffer aRet;
109
110 for (sal_Int32 i = 0; i < rStr.getLength(); ++i)
111 {
112 sal_Unicode cChar = rStr[i];
113 if ((cChar != ' ') && (cChar != '\t') &&
114 (cChar != '\n') && (cChar != '\r'))
115 {
116 aRet.append(cChar);
117 }
118 }
119
120 rStr = aRet.makeStringAndClear();
121 }
122
123 static long GetDayDiff( const Date& rDate );
124
125 static const CharClass& GetCharClass()
126 {
127 static bool bNeedsInit = true;
128 static LanguageTag aLanguageTag( LANGUAGE_SYSTEM);
129 if( bNeedsInit )
130 {
131 bNeedsInit = false;
132 aLanguageTag = Application::GetSettings().GetLanguageTag();
133 }
134 static CharClass aCharClass( aLanguageTag );
135 return aCharClass;
136 }
137
138 static inline bool isFolder( FileStatus::Type aType )
139 {
140 return ( aType == FileStatus::Directory || aType == FileStatus::Volume );
141 }
142
143
144 //*** UCB file access ***
145
146 // Converts possibly relative paths to absolute paths
147 // according to the setting done by ChDir/ChDrive
148 OUString getFullPath( const OUString& aRelPath )
149 {
150 OUString aFileURL;
151
152 // #80204 Try first if it already is a valid URL
153 INetURLObject aURLObj( aRelPath );
154 aFileURL = aURLObj.GetMainURL( INetURLObject::NO_DECODE );
155
156 if( aFileURL.isEmpty() )
157 {
158 File::getFileURLFromSystemPath( aRelPath, aFileURL );
159 }
160
161 return aFileURL;
162 }
163
164 // TODO: -> SbiGlobals
165 static uno::Reference< ucb::XSimpleFileAccess3 > getFileAccess()
166 {
167 static uno::Reference< ucb::XSimpleFileAccess3 > xSFI;
168 if( !xSFI.is() )
169 {
170 xSFI = ucb::SimpleFileAccess::create( comphelper::getProcessComponentContext() );
171 }
172 return xSFI;
173 }
174
175
176
177 // Properties and methods lie down the return value at the Get (bPut = sal_False) in the
178 // element 0 of the Argv; the value of element 0 is saved at Put (bPut = sal_True)
179
180 // CreateObject( class )
181
182 RTLFUNC(CreateObject)
183 {
184 (void)bWrite;
185
186 OUString aClass( rPar.Get( 1 )->GetOUString() );
187 SbxObjectRef p = SbxBase::CreateObject( aClass );
188 if( !p )
189 StarBASIC::Error( SbERR_CANNOT_LOAD );
190 else
191 {
192 // Convenience: enter BASIC as parent
193 p->SetParent( pBasic );
194 rPar.Get( 0 )->PutObject( p );
195 }
196 }
197
198 // Error( n )
199
200 RTLFUNC(Error)
201 {
202 (void)bWrite;
203
204 if( !pBasic )
205 StarBASIC::Error( SbERR_INTERNAL_ERROR );
206 else
207 {
208 OUString aErrorMsg;
209 SbError nErr = 0L;
210 sal_Int32 nCode = 0;
211 if( rPar.Count() == 1 )
212 {
213 nErr = StarBASIC::GetErrBasic();
214 aErrorMsg = StarBASIC::GetErrorMsg();
215 }
216 else
217 {
218 nCode = rPar.Get( 1 )->GetLong();
219 if( nCode > 65535L )
220 {
221 StarBASIC::Error( SbERR_CONVERSION );
222 }
223 else
224 {
225 nErr = StarBASIC::GetSfxFromVBError( (sal_uInt16)nCode );
226 }
227 }
228
229 bool bVBA = SbiRuntime::isVBAEnabled();
230 OUString tmpErrMsg;
231 if( bVBA && !aErrorMsg.isEmpty())
232 {
233 tmpErrMsg = aErrorMsg;
234 }
235 else
236 {
237 StarBASIC::MakeErrorText( nErr, aErrorMsg );
238 tmpErrMsg = StarBASIC::GetErrorText();
239 }
240 // If this rtlfunc 'Error' passed a errcode the same as the active Err Objects's
241 // current err then return the description for the error message if it is set
242 // ( complicated isn't it ? )
243 if ( bVBA && rPar.Count() > 1 )
244 {
245 uno::Reference< ooo::vba::XErrObject > xErrObj( SbxErrObject::getUnoErrObject() );
246 if ( xErrObj.is() && xErrObj->getNumber() == nCode && !xErrObj->getDescription().isEmpty() )
247 {
248 tmpErrMsg = xErrObj->getDescription();
249 }
250 }
251 rPar.Get( 0 )->PutString( tmpErrMsg );
252 }
253 }
254
255 // Sinus
256
257 RTLFUNC(Sin)
258 {
259 (void)pBasic;
260 (void)bWrite;
261
262 if ( rPar.Count() < 2 )
263 StarBASIC::Error( SbERR_BAD_ARGUMENT );
264 else
265 {
266 SbxVariableRef pArg = rPar.Get( 1 );
267 rPar.Get( 0 )->PutDouble( sin( pArg->GetDouble() ) );
268 }
269 }
270
271
272 RTLFUNC(Cos)
273 {
274 (void)pBasic;
275 (void)bWrite;
276
277 if ( rPar.Count() < 2 )
278 StarBASIC::Error( SbERR_BAD_ARGUMENT );
279 else
280 {
281 SbxVariableRef pArg = rPar.Get( 1 );
282 rPar.Get( 0 )->PutDouble( cos( pArg->GetDouble() ) );
283 }
284 }
285
286
287 RTLFUNC(Atn)
288 {
289 (void)pBasic;
290 (void)bWrite;
291
292 if ( rPar.Count() < 2 )
293 StarBASIC::Error( SbERR_BAD_ARGUMENT );
294 else
295 {
296 SbxVariableRef pArg = rPar.Get( 1 );
297 rPar.Get( 0 )->PutDouble( atan( pArg->GetDouble() ) );
298 }
299 }
300
301
302
303 RTLFUNC(Abs)
304 {
305 (void)pBasic;
306 (void)bWrite;
307
308 if ( rPar.Count() < 2 )
309 {
310 StarBASIC::Error( SbERR_BAD_ARGUMENT );
311 }
312 else
313 {
314 SbxVariableRef pArg = rPar.Get( 1 );
315 rPar.Get( 0 )->PutDouble( fabs( pArg->GetDouble() ) );
316 }
317 }
318
319
320 RTLFUNC(Asc)
321 {
322 (void)pBasic;
323 (void)bWrite;
324
325 if ( rPar.Count() < 2 )
326 {
327 StarBASIC::Error( SbERR_BAD_ARGUMENT );
328 }
329 else
330 {
331 SbxVariableRef pArg = rPar.Get( 1 );
332 OUString aStr( pArg->GetOUString() );
333 if ( aStr.isEmpty())
334 {
335 StarBASIC::Error( SbERR_BAD_ARGUMENT );
336 rPar.Get(0)->PutEmpty();
337 }
338 else
339 {
340 sal_Unicode aCh = aStr[0];
341 rPar.Get(0)->PutLong( aCh );
342 }
343 }
344 }
345
346 void implChr( SbxArray& rPar, bool bChrW )
347 {
348 if ( rPar.Count() < 2 )
349 {
350 StarBASIC::Error( SbERR_BAD_ARGUMENT );
351 }
352 else
353 {
354 SbxVariableRef pArg = rPar.Get( 1 );
355
356 OUString aStr;
357 if( !bChrW && SbiRuntime::isVBAEnabled() )
358 {
359 sal_Char c = static_cast<sal_Char>(pArg->GetByte());
360 aStr = OUString(&c, 1, osl_getThreadTextEncoding());
361 }
362 else
363 {
364 sal_Unicode aCh = static_cast<sal_Unicode>(pArg->GetUShort());
365 aStr = OUString(aCh);
366 }
367 rPar.Get(0)->PutString( aStr );
368 }
369 }
370
371 RTLFUNC(Chr)
372 {
373 (void)pBasic;
374 (void)bWrite;
375
376 bool bChrW = false;
377 implChr( rPar, bChrW );
378 }
379
380 RTLFUNC(ChrW)
381 {
382 (void)pBasic;
383 (void)bWrite;
384
385 bool bChrW = true;
386 implChr( rPar, bChrW );
387 }
388
389 RTLFUNC(CurDir)
390 {
391 (void)pBasic;
392 (void)bWrite;
393
394 // #57064 Although this function doesn't work with DirEntry, it isn't touched
395 // by the adjustment to virtual URLs, as, using the DirEntry-functionality,
396 // there's no possibility to detect the current one in a way that a virtual URL
397 // could be delivered.
398
399 #if defined (WNT)
400 int nCurDir = 0; // Current dir // JSM
401 if ( rPar.Count() == 2 )
402 {
403 OUString aDrive = rPar.Get(1)->GetOUString();
404 if ( aDrive.getLength() != 1 )
405 {
406 StarBASIC::Error( SbERR_BAD_ARGUMENT );
407 return;
408 }
409 else
410 {
411 nCurDir = (int)aDrive[0];
412 if ( !isalpha( nCurDir ) )
413 {
414 StarBASIC::Error( SbERR_BAD_ARGUMENT );
415 return;
416 }
417 else
418 {
419 nCurDir -= ( 'A' - 1 );
420 }
421 }
422 }
423 char* pBuffer = new char[ _MAX_PATH ];
424 if ( _getdcwd( nCurDir, pBuffer, _MAX_PATH ) != 0 )
425 {
426 rPar.Get(0)->PutString( OUString::createFromAscii( pBuffer ) );
427 }
428 else
429 {
430 StarBASIC::Error( SbERR_NO_DEVICE );
431 }
432 delete [] pBuffer;
433
434 #else
435
436 const int PATH_INCR = 250;
437
438 int nSize = PATH_INCR;
439 boost::scoped_array<char> pMem;
440 while( true )
441 {
442 pMem.reset(new char[nSize]);
443 if( !pMem )
444 {
445 StarBASIC::Error( SbERR_NO_MEMORY );
446 return;
447 }
448 if( getcwd( pMem.get(), nSize-1 ) != NULL )
449 {
450 rPar.Get(0)->PutString( OUString::createFromAscii(pMem.get()) );
451 return;
452 }
453 if( errno != ERANGE )
454 {
455 StarBASIC::Error( SbERR_INTERNAL_ERROR );
456 return;
457 }
458 nSize += PATH_INCR;
459 };
460
461 #endif
462 }
463
464 RTLFUNC(ChDir)
465 {
466 (void)bWrite;
467
468 rPar.Get(0)->PutEmpty();
469 if (rPar.Count() == 2)
470 {
471 // VBA: track current directory per document type (separately for Writer, Calc, Impress, etc.)
472 if( SbiRuntime::isVBAEnabled() )
473 {
474 ::basic::vba::registerCurrentDirectory( getDocumentModel( pBasic ), rPar.Get(1)->GetOUString() );
475 }
476 }
477 else
478 {
479 StarBASIC::Error( SbERR_BAD_ARGUMENT );
480 }
481 }
482
483 RTLFUNC(ChDrive)
484 {
485 (void)pBasic;
486 (void)bWrite;
487
488 rPar.Get(0)->PutEmpty();
489 if (rPar.Count() != 2)
490 {
491 StarBASIC::Error( SbERR_BAD_ARGUMENT );
492 }
493 }
494
495
496 // Implementation of StepRENAME with UCB
497 void implStepRenameUCB( const OUString& aSource, const OUString& aDest )
498 {
499 uno::Reference< ucb::XSimpleFileAccess3 > xSFI = getFileAccess();
500 if( xSFI.is() )
501 {
502 try
503 {
504 OUString aSourceFullPath = getFullPath( aSource );
505 if( !xSFI->exists( aSourceFullPath ) )
506 {
507 StarBASIC::Error( SbERR_FILE_NOT_FOUND );
508 return;
509 }
510
511 OUString aDestFullPath = getFullPath( aDest );
512 if( xSFI->exists( aDestFullPath ) )
513 {
514 StarBASIC::Error( SbERR_FILE_EXISTS );
515 }
516 else
517 {
518 xSFI->move( aSourceFullPath, aDestFullPath );
519 }
520 }
521 catch(const Exception & )
522 {
523 StarBASIC::Error( SbERR_FILE_NOT_FOUND );
524 }
525 }
526 }
527
528 // Implementation of StepRENAME with OSL
529 void implStepRenameOSL( const OUString& aSource, const OUString& aDest )
530 {
531 FileBase::RC nRet = File::move( getFullPath( aSource ), getFullPath( aDest ) );
532 if( nRet != FileBase::E_None )
533 {
534 StarBASIC::Error( SbERR_PATH_NOT_FOUND );
535 }
536 }
537
538 RTLFUNC(FileCopy)
539 {
540 (void)pBasic;
541 (void)bWrite;
542
543 rPar.Get(0)->PutEmpty();
544 if (rPar.Count() == 3)
545 {
546 OUString aSource = rPar.Get(1)->GetOUString();
547 OUString aDest = rPar.Get(2)->GetOUString();
548 if( hasUno() )
549 {
550 uno::Reference< ucb::XSimpleFileAccess3 > xSFI = getFileAccess();
551 if( xSFI.is() )
552 {
553 try
554 {
555 xSFI->copy( getFullPath( aSource ), getFullPath( aDest ) );
556 }
557 catch(const Exception & )
558 {
559 StarBASIC::Error( SbERR_PATH_NOT_FOUND );
560 }
561 }
562 }
563 else
564 {
565 FileBase::RC nRet = File::copy( getFullPath( aSource ), getFullPath( aDest ) );
566 if( nRet != FileBase::E_None )
567 {
568 StarBASIC::Error( SbERR_PATH_NOT_FOUND );
569 }
570 }
571 }
572 else
573 StarBASIC::Error( SbERR_BAD_ARGUMENT );
574 }
575
576 RTLFUNC(Kill)
577 {
578 (void)pBasic;
579 (void)bWrite;
580
581 rPar.Get(0)->PutEmpty();
582 if (rPar.Count() == 2)
583 {
584 OUString aFileSpec = rPar.Get(1)->GetOUString();
585
586 if( hasUno() )
587 {
588 uno::Reference< ucb::XSimpleFileAccess3 > xSFI = getFileAccess();
589 if( xSFI.is() )
590 {
591 OUString aFullPath = getFullPath( aFileSpec );
592 if( !xSFI->exists( aFullPath ) || xSFI->isFolder( aFullPath ) )
593 {
594 StarBASIC::Error( SbERR_FILE_NOT_FOUND );
595 return;
596 }
597 try
598 {
599 xSFI->kill( aFullPath );
600 }
601 catch(const Exception & )
602 {
603 StarBASIC::Error( ERRCODE_IO_GENERAL );
604 }
605 }
606 }
607 else
608 {
609 File::remove( getFullPath( aFileSpec ) );
610 }
611 }
612 else
613 {
614 StarBASIC::Error( SbERR_BAD_ARGUMENT );
615 }
616 }
617
618 RTLFUNC(MkDir)
619 {
620 (void)pBasic;
621 (void)bWrite;
622
623 rPar.Get(0)->PutEmpty();
624 if (rPar.Count() == 2)
625 {
626 OUString aPath = rPar.Get(1)->GetOUString();
627 if ( SbiRuntime::isVBAEnabled() )
628 {
629 // In vba if the full path is not specified then
630 // folder is created relative to the curdir
631 INetURLObject aURLObj( getFullPath( aPath ) );
632 if ( aURLObj.GetProtocol() != INetProtocol::File )
633 {
634 SbxArrayRef pPar = new SbxArray();
635 SbxVariableRef pResult = new SbxVariable();
636 SbxVariableRef pParam = new SbxVariable();
637 pPar->Insert( pResult, pPar->Count() );
638 pPar->Insert( pParam, pPar->Count() );
639 SbRtl_CurDir( pBasic, *pPar, bWrite );
640
641 rtl::OUString sCurPathURL;
642 File::getFileURLFromSystemPath( pPar->Get(0)->GetOUString(), sCurPathURL );
643
644 aURLObj.SetURL( sCurPathURL );
645 aURLObj.Append( aPath );
646 File::getSystemPathFromFileURL(aURLObj.GetMainURL( INetURLObject::DECODE_TO_IURI ),aPath ) ;
647 }
648 }
649
650 if( hasUno() )
651 {
652 uno::Reference< ucb::XSimpleFileAccess3 > xSFI = getFileAccess();
653 if( xSFI.is() )
654 {
655 try
656 {
657 xSFI->createFolder( getFullPath( aPath ) );
658 }
659 catch(const Exception & )
660 {
661 StarBASIC::Error( ERRCODE_IO_GENERAL );
662 }
663 }
664 }
665 else
666 {
667 Directory::create( getFullPath( aPath ) );
668 }
669 }
670 else
671 {
672 StarBASIC::Error( SbERR_BAD_ARGUMENT );
673 }
674 }
675
676
677 // In OSL only empty directories can be deleted
678 // so we have to delete all files recursively
679 void implRemoveDirRecursive( const OUString& aDirPath )
680 {
681 DirectoryItem aItem;
682 FileBase::RC nRet = DirectoryItem::get( aDirPath, aItem );
683 bool bExists = (nRet == FileBase::E_None);
684
685 FileStatus aFileStatus( osl_FileStatus_Mask_Type );
686 nRet = aItem.getFileStatus( aFileStatus );
687 FileStatus::Type aType = aFileStatus.getFileType();
688 bool bFolder = isFolder( aType );
689
690 if( !bExists || !bFolder )
691 {
692 StarBASIC::Error( SbERR_PATH_NOT_FOUND );
693 return;
694 }
695
696 Directory aDir( aDirPath );
697 nRet = aDir.open();
698 if( nRet != FileBase::E_None )
699 {
700 StarBASIC::Error( SbERR_PATH_NOT_FOUND );
701 return;
702 }
703
704 for( ;; )
705 {
706 DirectoryItem aItem2;
707 nRet = aDir.getNextItem( aItem2 );
708 if( nRet != FileBase::E_None )
709 {
710 break;
711 }
712 // Handle flags
713 FileStatus aFileStatus2( osl_FileStatus_Mask_Type | osl_FileStatus_Mask_FileURL );
714 nRet = aItem2.getFileStatus( aFileStatus2 );
715 OUString aPath = aFileStatus2.getFileURL();
716
717 // Directory?
718 FileStatus::Type aType2 = aFileStatus2.getFileType();
719 bool bFolder2 = isFolder( aType2 );
720 if( bFolder2 )
721 {
722 implRemoveDirRecursive( aPath );
723 }
724 else
725 {
726 File::remove( aPath );
727 }
728 }
729 nRet = aDir.close();
730
731 nRet = Directory::remove( aDirPath );
732 }
733
734
735 RTLFUNC(RmDir)
736 {
737 (void)pBasic;
738 (void)bWrite;
739
740 rPar.Get(0)->PutEmpty();
741 if (rPar.Count() == 2)
742 {
743 OUString aPath = rPar.Get(1)->GetOUString();
744 if( hasUno() )
745 {
746 uno::Reference< ucb::XSimpleFileAccess3 > xSFI = getFileAccess();
747 if( xSFI.is() )
748 {
749 try
750 {
751 if( !xSFI->isFolder( aPath ) )
752 {
753 StarBASIC::Error( SbERR_PATH_NOT_FOUND );
754 return;
755 }
756 SbiInstance* pInst = GetSbData()->pInst;
757 bool bCompatibility = ( pInst && pInst->IsCompatibility() );
758 if( bCompatibility )
759 {
760 Sequence< OUString > aContent = xSFI->getFolderContents( aPath, true );
761 sal_Int32 nCount = aContent.getLength();
762 if( nCount > 0 )
763 {
764 StarBASIC::Error( SbERR_ACCESS_ERROR );
765 return;
766 }
767 }
768
769 xSFI->kill( getFullPath( aPath ) );
770 }
771 catch(const Exception & )
772 {
773 StarBASIC::Error( ERRCODE_IO_GENERAL );
774 }
775 }
776 }
777 else
778 {
779 implRemoveDirRecursive( getFullPath( aPath ) );
780 }
781 }
782 else
783 {
784 StarBASIC::Error( SbERR_BAD_ARGUMENT );
785 }
786 }
787
788 RTLFUNC(SendKeys)
789 {
790 (void)pBasic;
791 (void)bWrite;
792
793 rPar.Get(0)->PutEmpty();
794 StarBASIC::Error(SbERR_NOT_IMPLEMENTED);
795 }
796
797 RTLFUNC(Exp)
798 {
799 (void)pBasic;
800 (void)bWrite;
801
802 if( rPar.Count() < 2 )
803 StarBASIC::Error( SbERR_BAD_ARGUMENT );
804 else
805 {
806 double aDouble = rPar.Get( 1 )->GetDouble();
807 aDouble = exp( aDouble );
808 checkArithmeticOverflow( aDouble );
809 rPar.Get( 0 )->PutDouble( aDouble );
810 }
811 }
812
813 RTLFUNC(FileLen)
814 {
815 (void)pBasic;
816 (void)bWrite;
817
818 if ( rPar.Count() < 2 )
819 {
820 StarBASIC::Error( SbERR_BAD_ARGUMENT );
821 }
822 else
823 {
824 SbxVariableRef pArg = rPar.Get( 1 );
825 OUString aStr( pArg->GetOUString() );
826 sal_Int32 nLen = 0;
827 if( hasUno() )
828 {
829 uno::Reference< ucb::XSimpleFileAccess3 > xSFI = getFileAccess();
830 if( xSFI.is() )
831 {
832 try
833 {
834 nLen = xSFI->getSize( getFullPath( aStr ) );
835 }
836 catch(const Exception & )
837 {
838 StarBASIC::Error( ERRCODE_IO_GENERAL );
839 }
840 }
841 }
842 else
843 {
844 DirectoryItem aItem;
845 DirectoryItem::get( getFullPath( aStr ), aItem );
846 FileStatus aFileStatus( osl_FileStatus_Mask_FileSize );
847 aItem.getFileStatus( aFileStatus );
848 nLen = (sal_Int32)aFileStatus.getFileSize();
849 }
850 rPar.Get(0)->PutLong( (long)nLen );
851 }
852 }
853
854
855 RTLFUNC(Hex)
856 {
857 (void)pBasic;
858 (void)bWrite;
859
860 if ( rPar.Count() < 2 )
861 {
862 StarBASIC::Error( SbERR_BAD_ARGUMENT );
863 }
864 else
865 {
866 SbxVariableRef pArg = rPar.Get( 1 );
867 // converting value to unsigned and limit to 2 or 4 byte representation
868 sal_uInt32 nVal = pArg->IsInteger() ?
869 static_cast<sal_uInt16>(pArg->GetInteger()) :
870 static_cast<sal_uInt32>(pArg->GetLong());
871 OUString aStr(OUString::number( nVal, 16 ));
872 aStr = aStr.toAsciiUpperCase();
873 rPar.Get(0)->PutString( aStr );
874 }
875 }
876
877 RTLFUNC(FuncCaller)
878 {
879 (void)pBasic;
880 (void)bWrite;
881 if ( SbiRuntime::isVBAEnabled() && GetSbData()->pInst && GetSbData()->pInst->pRun )
882 {
883 if ( GetSbData()->pInst->pRun->GetExternalCaller() )
884 *rPar.Get(0) = *GetSbData()->pInst->pRun->GetExternalCaller();
885 else
886 {
887 SbxVariableRef pVar = new SbxVariable(SbxVARIANT);
888 *rPar.Get(0) = *pVar;
889 }
890 }
891 else
892 {
893 StarBASIC::Error( SbERR_NOT_IMPLEMENTED );
894 }
895
896 }
897 // InStr( [start],string,string,[compare] )
898
899 RTLFUNC(InStr)
900 {
901 (void)pBasic;
902 (void)bWrite;
903
904 sal_Size nArgCount = rPar.Count()-1;
905 if ( nArgCount < 2 )
906 StarBASIC::Error( SbERR_BAD_ARGUMENT );
907 else
908 {
909 sal_Int32 nStartPos = 1;
910 sal_Int32 nFirstStringPos = 1;
911
912 if ( nArgCount >= 3 )
913 {
914 nStartPos = rPar.Get(1)->GetLong();
915 if( nStartPos <= 0 )
916 {
917 StarBASIC::Error( SbERR_BAD_ARGUMENT );
918 nStartPos = 1;
919 }
920 nFirstStringPos++;
921 }
922
923 SbiInstance* pInst = GetSbData()->pInst;
924 int bTextMode;
925 bool bCompatibility = ( pInst && pInst->IsCompatibility() );
926 if( bCompatibility )
927 {
928 SbiRuntime* pRT = pInst->pRun;
929 bTextMode = pRT ? pRT->IsImageFlag( SbiImageFlags::COMPARETEXT ) : sal_False;
930 }
931 else
932 {
933 bTextMode = 1;;
934 }
935 if ( nArgCount == 4 )
936 {
937 bTextMode = rPar.Get(4)->GetInteger();
938 }
939 sal_Int32 nPos;
940 const OUString& rToken = rPar.Get(nFirstStringPos+1)->GetOUString();
941
942 // #97545 Always find empty string
943 if( rToken.isEmpty() )
944 {
945 nPos = nStartPos;
946 }
947 else
948 {
949 if( !bTextMode )
950 {
951 const OUString& rStr1 = rPar.Get(nFirstStringPos)->GetOUString();
952 nPos = rStr1.indexOf( rToken, nStartPos - 1 ) + 1;
953 }
954 else
955 {
956 OUString aStr1 = rPar.Get(nFirstStringPos)->GetOUString();
957 OUString aToken = rToken;
958
959 aStr1 = aStr1.toAsciiUpperCase();
960 aToken = aToken.toAsciiUpperCase();
961
962 nPos = aStr1.indexOf( aToken, nStartPos-1 ) + 1;
963 }
964 }
965 rPar.Get(0)->PutLong( nPos );
966 }
967 }
968
969
970 // InstrRev(string1, string2[, start[, compare]])
971
972 RTLFUNC(InStrRev)
973 {
974 (void)pBasic;
975 (void)bWrite;
976
977 sal_Size nArgCount = rPar.Count()-1;
978 if ( nArgCount < 2 )
979 {
980 StarBASIC::Error( SbERR_BAD_ARGUMENT );
981 }
982 else
983 {
984 OUString aStr1 = rPar.Get(1)->GetOUString();
985 OUString aToken = rPar.Get(2)->GetOUString();
986
987 sal_Int32 nStartPos = -1;
988 if ( nArgCount >= 3 )
989 {
990 nStartPos = rPar.Get(3)->GetLong();
991 if( (nStartPos <= 0 && nStartPos != -1))
992 {
993 StarBASIC::Error( SbERR_BAD_ARGUMENT );
994 nStartPos = -1;
995 }
996 }
997
998 SbiInstance* pInst = GetSbData()->pInst;
999 int bTextMode;
1000 bool bCompatibility = ( pInst && pInst->IsCompatibility() );
1001 if( bCompatibility )
1002 {
1003 SbiRuntime* pRT = pInst->pRun;
1004 bTextMode = pRT ? pRT->IsImageFlag( SbiImageFlags::COMPARETEXT ) : sal_False;
1005 }
1006 else
1007 {
1008 bTextMode = 1;;
1009 }
1010 if ( nArgCount == 4 )
1011 {
1012 bTextMode = rPar.Get(4)->GetInteger();
1013 }
1014 sal_Int32 nStrLen = aStr1.getLength();
1015 if( nStartPos == -1 )
1016 {
1017 nStartPos = nStrLen;
1018 }
1019
1020 sal_Int32 nPos = 0;
1021 if( nStartPos <= nStrLen )
1022 {
1023 sal_Int32 nTokenLen = aToken.getLength();
1024 if( !nTokenLen )
1025 {
1026 // Always find empty string
1027 nPos = nStartPos;
1028 }
1029 else if( nStrLen > 0 )
1030 {
1031 if( !bTextMode )
1032 {
1033 nPos = aStr1.lastIndexOf( aToken, nStartPos ) + 1;
1034 }
1035 else
1036 {
1037 aStr1 = aStr1.toAsciiUpperCase();
1038 aToken = aToken.toAsciiUpperCase();
1039
1040 nPos = aStr1.lastIndexOf( aToken, nStartPos ) + 1;
1041 }
1042 }
1043 }
1044 rPar.Get(0)->PutLong( nPos );
1045 }
1046 }
1047
1048
1049 /*
1050 Int( 2.8 ) = 2.0
1051 Int( -2.8 ) = -3.0
1052 Fix( 2.8 ) = 2.0
1053 Fix( -2.8 ) = -2.0 <- !!
1054 */
1055
1056 RTLFUNC(Int)
1057 {
1058 (void)pBasic;
1059 (void)bWrite;
1060
1061 if ( rPar.Count() < 2 )
1062 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1063 else
1064 {
1065 SbxVariableRef pArg = rPar.Get( 1 );
1066 double aDouble= pArg->GetDouble();
1067 /*
1068 floor( 2.8 ) = 2.0
1069 floor( -2.8 ) = -3.0
1070 */
1071 aDouble = floor( aDouble );
1072 rPar.Get(0)->PutDouble( aDouble );
1073 }
1074 }
1075
1076
1077
1078 RTLFUNC(Fix)
1079 {
1080 (void)pBasic;
1081 (void)bWrite;
1082
1083 if ( rPar.Count() < 2 )
1084 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1085 else
1086 {
1087 SbxVariableRef pArg = rPar.Get( 1 );
1088 double aDouble = pArg->GetDouble();
1089 if ( aDouble >= 0.0 )
1090 aDouble = floor( aDouble );
1091 else
1092 aDouble = ceil( aDouble );
1093 rPar.Get(0)->PutDouble( aDouble );
1094 }
1095 }
1096
1097
1098 RTLFUNC(LCase)
1099 {
1100 (void)pBasic;
1101 (void)bWrite;
1102
1103 if ( rPar.Count() < 2 )
1104 {
1105 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1106 }
1107 else
1108 {
1109 const CharClass& rCharClass = GetCharClass();
1110 OUString aStr( rPar.Get(1)->GetOUString() );
1111 aStr = rCharClass.lowercase(aStr);
1112 rPar.Get(0)->PutString( aStr );
1113 }
1114 }
1115
1116 RTLFUNC(Left)
1117 {
1118 (void)pBasic;
1119 (void)bWrite;
1120
1121 if ( rPar.Count() < 3 )
1122 {
1123 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1124 }
1125 else
1126 {
1127 OUString aStr( rPar.Get(1)->GetOUString() );
1128 sal_Int32 nResultLen = rPar.Get(2)->GetLong();
1129 if( nResultLen < 0 )
1130 {
1131 nResultLen = 0;
1132 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1133 }
1134 else if(nResultLen > aStr.getLength())
1135 {
1136 nResultLen = aStr.getLength();
1137 }
1138 aStr = aStr.copy(0, nResultLen );
1139 rPar.Get(0)->PutString( aStr );
1140 }
1141 }
1142
1143 RTLFUNC(Log)
1144 {
1145 (void)pBasic;
1146 (void)bWrite;
1147
1148 if ( rPar.Count() < 2 )
1149 {
1150 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1151 }
1152 else
1153 {
1154 double aArg = rPar.Get(1)->GetDouble();
1155 if ( aArg > 0 )
1156 {
1157 double d = log( aArg );
1158 checkArithmeticOverflow( d );
1159 rPar.Get( 0 )->PutDouble( d );
1160 }
1161 else
1162 {
1163 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1164 }
1165 }
1166 }
1167
1168 RTLFUNC(LTrim)
1169 {
1170 (void)pBasic;
1171 (void)bWrite;
1172
1173 if ( rPar.Count() < 2 )
1174 {
1175 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1176 }
1177 else
1178 {
1179 OUString aStr(comphelper::string::stripStart(rPar.Get(1)->GetOUString(), ' '));
1180 rPar.Get(0)->PutString(aStr);
1181 }
1182 }
1183
1184
1185 // Mid( String, nStart, nLength )
1186
1187 RTLFUNC(Mid)
1188 {
1189 (void)pBasic;
1190 (void)bWrite;
1191
1192 int nArgCount = rPar.Count()-1;
1193 if ( nArgCount < 2 )
1194 {
1195 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1196 }
1197 else
1198 {
1199 // #23178: replicate the functionality of Mid$ as a command
1200 // by adding a replacement-string as a fourth parameter.
1201 // In contrast to the original the third parameter (nLength)
1202 // can't be left out here. That's considered in bWrite already.
1203 if( nArgCount == 4 )
1204 {
1205 bWrite = true;
1206 }
1207 OUString aArgStr = rPar.Get(1)->GetOUString();
1208 sal_Int32 nStartPos = rPar.Get(2)->GetLong();
1209 if ( nStartPos < 1 )
1210 {
1211 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1212 }
1213 else
1214 {
1215 nStartPos--;
1216 sal_Int32 nLen = -1;
1217 bool bWriteNoLenParam = false;
1218 if ( nArgCount == 3 || bWrite )
1219 {
1220 sal_Int32 n = rPar.Get(3)->GetLong();
1221 if( bWrite && n == -1 )
1222 {
1223 bWriteNoLenParam = true;
1224 }
1225 nLen = n;
1226 }
1227 if ( bWrite )
1228 {
1229 OUStringBuffer aResultStr;
1230 SbiInstance* pInst = GetSbData()->pInst;
1231 bool bCompatibility = ( pInst && pInst->IsCompatibility() );
1232 if( bCompatibility )
1233 {
1234 sal_Int32 nArgLen = aArgStr.getLength();
1235 if( nStartPos + 1 > nArgLen )
1236 {
1237 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1238 return;
1239 }
1240
1241 OUString aReplaceStr = rPar.Get(4)->GetOUString();
1242 sal_Int32 nReplaceStrLen = aReplaceStr.getLength();
1243 sal_Int32 nReplaceLen;
1244 if( bWriteNoLenParam )
1245 {
1246 nReplaceLen = nReplaceStrLen;
1247 }
1248 else
1249 {
1250 nReplaceLen = nLen;
1251 if( nReplaceLen < 0 || nReplaceLen > nReplaceStrLen )
1252 {
1253 nReplaceLen = nReplaceStrLen;
1254 }
1255 }
1256
1257 sal_Int32 nReplaceEndPos = nStartPos + nReplaceLen;
1258 if( nReplaceEndPos > nArgLen )
1259 {
1260 nReplaceLen -= (nReplaceEndPos - nArgLen);
1261 }
1262 aResultStr = aArgStr;
1263 sal_Int32 nErase = nReplaceLen;
1264 aResultStr.remove( nStartPos, nErase );
1265 aResultStr.insert( nStartPos, aReplaceStr.getStr(), nReplaceLen);
1266 }
1267 else
1268 {
1269 aResultStr = aArgStr;
1270 sal_Int32 nTmpStartPos = nStartPos;
1271 if ( nTmpStartPos > aArgStr.getLength() )
1272 nTmpStartPos = aArgStr.getLength();
1273 else
1274 aResultStr.remove( nTmpStartPos, nLen );
1275 aResultStr.insert( nTmpStartPos, rPar.Get(4)->GetOUString().getStr(), std::min(nLen, rPar.Get(4)->GetOUString().getLength()));
1276 }
1277
1278 rPar.Get(1)->PutString( aResultStr.makeStringAndClear() );
1279 }
1280 else
1281 {
1282 OUString aResultStr;
1283 if (nStartPos > aArgStr.getLength())
1284 {
1285 // do nothing
1286 }
1287 else if(nArgCount == 2)
1288 {
1289 aResultStr = aArgStr.copy( nStartPos);
1290 }
1291 else
1292 {
1293 if (nLen < 0)
1294 nLen = 0;
1295 if(nStartPos + nLen > aArgStr.getLength())
1296 {
1297 nLen = aArgStr.getLength() - nStartPos;
1298 }
1299 if (nLen > 0)
1300 aResultStr = aArgStr.copy( nStartPos, nLen );
1301 }
1302 rPar.Get(0)->PutString( aResultStr );
1303 }
1304 }
1305 }
1306 }
1307
1308 RTLFUNC(Oct)
1309 {
1310 (void)pBasic;
1311 (void)bWrite;
1312
1313 if ( rPar.Count() < 2 )
1314 {
1315 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1316 }
1317 else
1318 {
1319 char aBuffer[16];
1320 SbxVariableRef pArg = rPar.Get( 1 );
1321 if ( pArg->IsInteger() )
1322 {
1323 snprintf( aBuffer, sizeof(aBuffer), "%o", pArg->GetInteger() );
1324 }
1325 else
1326 {
1327 snprintf( aBuffer, sizeof(aBuffer), "%lo", static_cast<long unsigned int>(pArg->GetLong()) );
1328 }
1329 rPar.Get(0)->PutString( OUString::createFromAscii( aBuffer ) );
1330 }
1331 }
1332
1333 // Replace(expression, find, replace[, start[, count[, compare]]])
1334
1335 RTLFUNC(Replace)
1336 {
1337 (void)pBasic;
1338 (void)bWrite;
1339
1340 sal_Size nArgCount = rPar.Count()-1;
1341 if ( nArgCount < 3 || nArgCount > 6 )
1342 {
1343 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1344 }
1345 else
1346 {
1347 OUString aExpStr = rPar.Get(1)->GetOUString();
1348 OUString aFindStr = rPar.Get(2)->GetOUString();
1349 OUString aReplaceStr = rPar.Get(3)->GetOUString();
1350
1351 sal_Int32 lStartPos = 1;
1352 if ( nArgCount >= 4 )
1353 {
1354 if( rPar.Get(4)->GetType() != SbxEMPTY )
1355 {
1356 lStartPos = rPar.Get(4)->GetLong();
1357 }
1358 if( lStartPos < 1)
1359 {
1360 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1361 lStartPos = 1;
1362 }
1363 }
1364
1365 sal_Int32 lCount = -1;
1366 if( nArgCount >=5 )
1367 {
1368 if( rPar.Get(5)->GetType() != SbxEMPTY )
1369 {
1370 lCount = rPar.Get(5)->GetLong();
1371 }
1372 if( lCount < -1)
1373 {
1374 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1375 lCount = -1;
1376 }
1377 }
1378
1379 SbiInstance* pInst = GetSbData()->pInst;
1380 int bTextMode;
1381 bool bCompatibility = ( pInst && pInst->IsCompatibility() );
1382 if( bCompatibility )
1383 {
1384 SbiRuntime* pRT = pInst->pRun;
1385 bTextMode = pRT ? pRT->IsImageFlag( SbiImageFlags::COMPARETEXT ) : sal_False;
1386 }
1387 else
1388 {
1389 bTextMode = 1;
1390 }
1391 if ( nArgCount == 6 )
1392 {
1393 bTextMode = rPar.Get(6)->GetInteger();
1394 }
1395 sal_Int32 nExpStrLen = aExpStr.getLength();
1396 sal_Int32 nFindStrLen = aFindStr.getLength();
1397 sal_Int32 nReplaceStrLen = aReplaceStr.getLength();
1398
1399 if( lStartPos <= nExpStrLen )
1400 {
1401 sal_Int32 nPos = lStartPos - 1;
1402 sal_Int32 nCounts = 0;
1403 while( lCount == -1 || lCount > nCounts )
1404 {
1405 OUString aSrcStr( aExpStr );
1406 if( bTextMode )
1407 {
1408 aSrcStr = aSrcStr.toAsciiUpperCase();
1409 aFindStr = aFindStr.toAsciiUpperCase();
1410 }
1411 nPos = aSrcStr.indexOf( aFindStr, nPos );
1412 if( nPos >= 0 )
1413 {
1414 aExpStr = aExpStr.replaceAt( nPos, nFindStrLen, aReplaceStr );
1415 nPos = nPos + nReplaceStrLen;
1416 nCounts++;
1417 }
1418 else
1419 {
1420 break;
1421 }
1422 }
1423 }
1424 rPar.Get(0)->PutString( aExpStr.copy( lStartPos - 1 ) );
1425 }
1426 }
1427
1428 RTLFUNC(Right)
1429 {
1430 (void)pBasic;
1431 (void)bWrite;
1432
1433 if ( rPar.Count() < 3 )
1434 {
1435 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1436 }
1437 else
1438 {
1439 const OUString& rStr = rPar.Get(1)->GetOUString();
1440 int nResultLen = rPar.Get(2)->GetLong();
1441 if( nResultLen < 0 )
1442 {
1443 nResultLen = 0;
1444 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1445 }
1446 int nStrLen = rStr.getLength();
1447 if ( nResultLen > nStrLen )
1448 {
1449 nResultLen = nStrLen;
1450 }
1451 OUString aResultStr = rStr.copy( nStrLen - nResultLen );
1452 rPar.Get(0)->PutString( aResultStr );
1453 }
1454 }
1455
1456 RTLFUNC(RTL)
1457 {
1458 (void)pBasic;
1459 (void)bWrite;
1460
1461 rPar.Get( 0 )->PutObject( pBasic->getRTL() );
1462 }
1463
1464 RTLFUNC(RTrim)
1465 {
1466 (void)pBasic;
1467 (void)bWrite;
1468
1469 if ( rPar.Count() < 2 )
1470 {
1471 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1472 }
1473 else
1474 {
1475 OUString aStr(comphelper::string::stripEnd(rPar.Get(1)->GetOUString(), ' '));
1476 rPar.Get(0)->PutString(aStr);
1477 }
1478 }
1479
1480 RTLFUNC(Sgn)
1481 {
1482 (void)pBasic;
1483 (void)bWrite;
1484
1485 if ( rPar.Count() < 2 )
1486 {
1487 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1488 }
1489 else
1490 {
1491 double aDouble = rPar.Get(1)->GetDouble();
1492 sal_Int16 nResult = 0;
1493 if ( aDouble > 0 )
1494 {
1495 nResult = 1;
1496 }
1497 else if ( aDouble < 0 )
1498 {
1499 nResult = -1;
1500 }
1501 rPar.Get(0)->PutInteger( nResult );
1502 }
1503 }
1504
1505 RTLFUNC(Space)
1506 {
1507 (void)pBasic;
1508 (void)bWrite;
1509
1510 if ( rPar.Count() < 2 )
1511 {
1512 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1513 }
1514 else
1515 {
1516 OUStringBuffer aBuf;
1517 string::padToLength(aBuf, rPar.Get(1)->GetLong(), ' ');
1518 rPar.Get(0)->PutString(aBuf.makeStringAndClear());
1519 }
1520 }
1521
1522 RTLFUNC(Spc)
1523 {
1524 (void)pBasic;
1525 (void)bWrite;
1526
1527 if ( rPar.Count() < 2 )
1528 {
1529 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1530 }
1531 else
1532 {
1533 OUStringBuffer aBuf;
1534 string::padToLength(aBuf, rPar.Get(1)->GetLong(), ' ');
1535 rPar.Get(0)->PutString(aBuf.makeStringAndClear());
1536 }
1537 }
1538
1539 RTLFUNC(Sqr)
1540 {
1541 (void)pBasic;
1542 (void)bWrite;
1543
1544 if ( rPar.Count() < 2 )
1545 {
1546 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1547 }
1548 else
1549 {
1550 double aDouble = rPar.Get(1)->GetDouble();
1551 if ( aDouble >= 0 )
1552 {
1553 rPar.Get(0)->PutDouble( sqrt( aDouble ));
1554 }
1555 else
1556 {
1557 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1558 }
1559 }
1560 }
1561
1562 RTLFUNC(Str)
1563 {
1564 (void)pBasic;
1565 (void)bWrite;
1566
1567 if ( rPar.Count() < 2 )
1568 {
1569 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1570 }
1571 else
1572 {
1573 OUString aStr;
1574 OUString aStrNew("");
1575 SbxVariableRef pArg = rPar.Get( 1 );
1576 pArg->Format( aStr );
1577
1578 // Numbers start with a space
1579 if( pArg->IsNumericRTL() )
1580 {
1581 // replace commas by points so that it's symmetric to Val!
1582 aStr = aStr.replaceFirst( ",", "." );
1583
1584 SbiInstance* pInst = GetSbData()->pInst;
1585 bool bCompatibility = ( pInst && pInst->IsCompatibility() );
1586 if( bCompatibility )
1587 {
1588 sal_Int32 nLen = aStr.getLength();
1589
1590 const sal_Unicode* pBuf = aStr.getStr();
1591
1592 bool bNeg = ( pBuf[0] == '-' );
1593 sal_Int32 iZeroSearch = 0;
1594 if( bNeg )
1595 {
1596 aStrNew += "-";
1597 iZeroSearch++;
1598 }
1599 else
1600 {
1601 if( pBuf[0] != ' ' )
1602 {
1603 aStrNew += " ";
1604 }
1605 }
1606 sal_Int32 iNext = iZeroSearch + 1;
1607 if( pBuf[iZeroSearch] == '0' && nLen > iNext && pBuf[iNext] == '.' )
1608 {
1609 iZeroSearch += 1;
1610 }
1611 aStrNew += aStr.copy(iZeroSearch);
1612 }
1613 else
1614 {
1615 aStrNew = " " + aStr;
1616 }
1617 }
1618 else
1619 {
1620 aStrNew = aStr;
1621 }
1622 rPar.Get(0)->PutString( aStrNew );
1623 }
1624 }
1625
1626 RTLFUNC(StrComp)
1627 {
1628 (void)pBasic;
1629 (void)bWrite;
1630
1631 if ( rPar.Count() < 3 )
1632 {
1633 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1634 rPar.Get(0)->PutEmpty();
1635 return;
1636 }
1637 const OUString& rStr1 = rPar.Get(1)->GetOUString();
1638 const OUString& rStr2 = rPar.Get(2)->GetOUString();
1639
1640 SbiInstance* pInst = GetSbData()->pInst;
1641 bool nTextCompare;
1642 bool bCompatibility = ( pInst && pInst->IsCompatibility() );
1643 if( bCompatibility )
1644 {
1645 SbiRuntime* pRT = pInst->pRun;
1646 nTextCompare = pRT && pRT->IsImageFlag( SbiImageFlags::COMPARETEXT );
1647 }
1648 else
1649 {
1650 nTextCompare = true;
1651 }
1652 if ( rPar.Count() == 4 )
1653 nTextCompare = rPar.Get(3)->GetInteger();
1654
1655 if( !bCompatibility )
1656 {
1657 nTextCompare = !nTextCompare;
1658 }
1659 sal_Int32 nRetValue = 0;
1660 if( nTextCompare )
1661 {
1662 ::utl::TransliterationWrapper* pTransliterationWrapper = GetSbData()->pTransliterationWrapper;
1663 if( !pTransliterationWrapper )
1664 {
1665 uno::Reference< uno::XComponentContext > xContext = getProcessComponentContext();
1666 pTransliterationWrapper = GetSbData()->pTransliterationWrapper =
1667 new ::utl::TransliterationWrapper( xContext,
1668 i18n::TransliterationModules_IGNORE_CASE |
1669 i18n::TransliterationModules_IGNORE_KANA |
1670 i18n::TransliterationModules_IGNORE_WIDTH );
1671 }
1672
1673 LanguageType eLangType = Application::GetSettings().GetLanguageTag().getLanguageType();
1674 pTransliterationWrapper->loadModuleIfNeeded( eLangType );
1675 nRetValue = pTransliterationWrapper->compareString( rStr1, rStr2 );
1676 }
1677 else
1678 {
1679 sal_Int32 aResult;
1680 aResult = rStr1.compareTo( rStr2 );
1681 if ( aResult < 0 )
1682 {
1683 nRetValue = -1;
1684 }
1685 else if ( aResult > 0)
1686 {
1687 nRetValue = 1;
1688 }
1689 }
1690 rPar.Get(0)->PutInteger( sal::static_int_cast< sal_Int16 >( nRetValue ) );
1691 }
1692
1693 RTLFUNC(String)
1694 {
1695 (void)pBasic;
1696 (void)bWrite;
1697
1698 if ( rPar.Count() < 2 )
1699 {
1700 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1701 }
1702 else
1703 {
1704 sal_Unicode aFiller;
1705 sal_Int32 lCount = rPar.Get(1)->GetLong();
1706 if( lCount < 0 || lCount > 0xffff )
1707 {
1708 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1709 }
1710 if( rPar.Get(2)->GetType() == SbxINTEGER )
1711 {
1712 aFiller = (sal_Unicode)rPar.Get(2)->GetInteger();
1713 }
1714 else
1715 {
1716 const OUString& rStr = rPar.Get(2)->GetOUString();
1717 aFiller = rStr[0];
1718 }
1719 OUStringBuffer aBuf(lCount);
1720 string::padToLength(aBuf, lCount, aFiller);
1721 rPar.Get(0)->PutString(aBuf.makeStringAndClear());
1722 }
1723 }
1724
1725 RTLFUNC(Tan)
1726 {
1727 (void)pBasic;
1728 (void)bWrite;
1729
1730 if ( rPar.Count() < 2 )
1731 {
1732 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1733 }
1734 else
1735 {
1736 SbxVariableRef pArg = rPar.Get( 1 );
1737 rPar.Get( 0 )->PutDouble( tan( pArg->GetDouble() ) );
1738 }
1739 }
1740
1741 RTLFUNC(UCase)
1742 {
1743 (void)pBasic;
1744 (void)bWrite;
1745
1746 if ( rPar.Count() < 2 )
1747 {
1748 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1749 }
1750 else
1751 {
1752 const CharClass& rCharClass = GetCharClass();
1753 OUString aStr( rPar.Get(1)->GetOUString() );
1754 aStr = rCharClass.uppercase( aStr );
1755 rPar.Get(0)->PutString( aStr );
1756 }
1757 }
1758
1759
1760 RTLFUNC(Val)
1761 {
1762 (void)pBasic;
1763 (void)bWrite;
1764
1765 if ( rPar.Count() < 2 )
1766 {
1767 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1768 }
1769 else
1770 {
1771 double nResult = 0.0;
1772 char* pEndPtr;
1773
1774 OUString aStr( rPar.Get(1)->GetOUString() );
1775
1776 FilterWhiteSpace( aStr );
1777 if ( aStr[0] == '&' && aStr.getLength() > 1 )
1778 {
1779 int nRadix = 10;
1780 char aChar = (char)aStr[1];
1781 if ( aChar == 'h' || aChar == 'H' )
1782 {
1783 nRadix = 16;
1784 }
1785 else if ( aChar == 'o' || aChar == 'O' )
1786 {
1787 nRadix = 8;
1788 }
1789 if ( nRadix != 10 )
1790 {
1791 OString aByteStr(OUStringToOString(aStr, osl_getThreadTextEncoding()));
1792 sal_Int16 nlResult = (sal_Int16)strtol( aByteStr.getStr()+2, &pEndPtr, nRadix);
1793 nResult = (double)nlResult;
1794 }
1795 }
1796 else
1797 {
1798 rtl_math_ConversionStatus eStatus = rtl_math_ConversionStatus_Ok;
1799 sal_Int32 nParseEnd = 0;
1800 nResult = ::rtl::math::stringToDouble( aStr, '.', ',', &eStatus, &nParseEnd );
1801 if ( eStatus != rtl_math_ConversionStatus_Ok )
1802 StarBASIC::Error( SbERR_MATH_OVERFLOW );
1803 /* TODO: we should check whether all characters were parsed here,
1804 * but earlier code silently ignored trailing nonsense such as "1x"
1805 * resulting in 1 with the side effect that any alpha-only-string
1806 * like "x" resulted in 0. Not changing that now (2013-03-22) as
1807 * user macros may rely on it. */
1808 #if 0
1809 else if ( nParseEnd != aStr.getLength() )
1810 StarBASIC::Error( SbERR_CONVERSION );
1811 #endif
1812 }
1813
1814 rPar.Get(0)->PutDouble( nResult );
1815 }
1816 }
1817
1818
1819 // Helper functions for date conversion
1820 sal_Int16 implGetDateDay( double aDate )
1821 {
1822 aDate -= 2.0; // standardize: 1.1.1900 => 0.0
1823 Date aRefDate( 1, 1, 1900 );
1824 if ( aDate >= 0.0 )
1825 {
1826 aDate = floor( aDate );
1827 aRefDate += static_cast<long>(aDate);
1828 }
1829 else
1830 {
1831 aDate = ceil( aDate );
1832 aRefDate -= static_cast<long>(-1.0 * aDate);
1833 }
1834
1835 sal_Int16 nRet = (sal_Int16)( aRefDate.GetDay() );
1836 return nRet;
1837 }
1838
1839 sal_Int16 implGetDateMonth( double aDate )
1840 {
1841 Date aRefDate( 1,1,1900 );
1842 long nDays = (long)aDate;
1843 nDays -= 2; // standardize: 1.1.1900 => 0.0
1844 aRefDate += nDays;
1845 sal_Int16 nRet = (sal_Int16)( aRefDate.GetMonth() );
1846 return nRet;
1847 }
1848
1849 ::com::sun::star::util::Date SbxDateToUNODate( const SbxValue* const pVal )
1850 {
1851 double aDate = pVal->GetDate();
1852
1853 com::sun::star::util::Date aUnoDate;
1854 aUnoDate.Day = implGetDateDay ( aDate );
1855 aUnoDate.Month = implGetDateMonth( aDate );
1856 aUnoDate.Year = implGetDateYear ( aDate );
1857
1858 return aUnoDate;
1859 }
1860
1861 void SbxDateFromUNODate( SbxValue *pVal, const ::com::sun::star::util::Date& aUnoDate)
1862 {
1863 double dDate;
1864 if( implDateSerial( aUnoDate.Year, aUnoDate.Month, aUnoDate.Day, dDate ) )
1865 {
1866 pVal->PutDate( dDate );
1867 }
1868 }
1869
1870 // Function to convert date to UNO date (com.sun.star.util.Date)
1871 RTLFUNC(CDateToUnoDate)
1872 {
1873 (void)pBasic;
1874 (void)bWrite;
1875
1876 if ( rPar.Count() != 2 )
1877 {
1878 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1879 return;
1880 }
1881
1882 unoToSbxValue(rPar.Get(0), Any(SbxDateToUNODate(rPar.Get(1))));
1883 }
1884
1885 // Function to convert date from UNO date (com.sun.star.util.Date)
1886 RTLFUNC(CDateFromUnoDate)
1887 {
1888 (void)pBasic;
1889 (void)bWrite;
1890
1891 if ( rPar.Count() != 2 || rPar.Get(1)->GetType() != SbxOBJECT )
1892 {
1893 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1894 return;
1895 }
1896
1897 Any aAny (sbxToUnoValue(rPar.Get(1), cppu::UnoType<com::sun::star::util::Date>::get()));
1898 com::sun::star::util::Date aUnoDate;
1899 if(aAny >>= aUnoDate)
1900 SbxDateFromUNODate(rPar.Get(0), aUnoDate);
1901 else
1902 SbxBase::SetError( SbxERR_CONVERSION );
1903 }
1904
1905 ::com::sun::star::util::Time SbxDateToUNOTime( const SbxValue* const pVal )
1906 {
1907 double aDate = pVal->GetDate();
1908
1909 com::sun::star::util::Time aUnoTime;
1910 aUnoTime.Hours = implGetHour ( aDate );
1911 aUnoTime.Minutes = implGetMinute ( aDate );
1912 aUnoTime.Seconds = implGetSecond ( aDate );
1913 aUnoTime.NanoSeconds = 0;
1914
1915 return aUnoTime;
1916 }
1917
1918 void SbxDateFromUNOTime( SbxValue *pVal, const ::com::sun::star::util::Time& aUnoTime)
1919 {
1920 pVal->PutDate( implTimeSerial(aUnoTime.Hours, aUnoTime.Minutes, aUnoTime.Seconds) );
1921 }
1922
1923 // Function to convert date to UNO time (com.sun.star.util.Time)
1924 RTLFUNC(CDateToUnoTime)
1925 {
1926 (void)pBasic;
1927 (void)bWrite;
1928
1929 if ( rPar.Count() != 2 )
1930 {
1931 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1932 return;
1933 }
1934
1935 unoToSbxValue(rPar.Get(0), Any(SbxDateToUNOTime(rPar.Get(1))));
1936 }
1937
1938 // Function to convert date from UNO time (com.sun.star.util.Time)
1939 RTLFUNC(CDateFromUnoTime)
1940 {
1941 (void)pBasic;
1942 (void)bWrite;
1943
1944 if ( rPar.Count() != 2 || rPar.Get(1)->GetType() != SbxOBJECT )
1945 {
1946 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1947 return;
1948 }
1949
1950 Any aAny (sbxToUnoValue(rPar.Get(1), cppu::UnoType<com::sun::star::util::Time>::get()));
1951 com::sun::star::util::Time aUnoTime;
1952 if(aAny >>= aUnoTime)
1953 SbxDateFromUNOTime(rPar.Get(0), aUnoTime);
1954 else
1955 SbxBase::SetError( SbxERR_CONVERSION );
1956 }
1957
1958 ::com::sun::star::util::DateTime SbxDateToUNODateTime( const SbxValue* const pVal )
1959 {
1960 double aDate = pVal->GetDate();
1961
1962 com::sun::star::util::DateTime aUnoDT;
1963 aUnoDT.Day = implGetDateDay ( aDate );
1964 aUnoDT.Month = implGetDateMonth( aDate );
1965 aUnoDT.Year = implGetDateYear ( aDate );
1966 aUnoDT.Hours = implGetHour ( aDate );
1967 aUnoDT.Minutes = implGetMinute ( aDate );
1968 aUnoDT.Seconds = implGetSecond ( aDate );
1969 aUnoDT.NanoSeconds = 0;
1970
1971 return aUnoDT;
1972 }
1973
1974 void SbxDateFromUNODateTime( SbxValue *pVal, const ::com::sun::star::util::DateTime& aUnoDT)
1975 {
1976 double dDate(0.0);
1977 if( implDateTimeSerial( aUnoDT.Year, aUnoDT.Month, aUnoDT.Day,
1978 aUnoDT.Hours, aUnoDT.Minutes, aUnoDT.Seconds,
1979 dDate ) )
1980 {
1981 pVal->PutDate( dDate );
1982 }
1983 }
1984
1985 // Function to convert date to UNO date (com.sun.star.util.Date)
1986 RTLFUNC(CDateToUnoDateTime)
1987 {
1988 (void)pBasic;
1989 (void)bWrite;
1990
1991 if ( rPar.Count() != 2 )
1992 {
1993 StarBASIC::Error( SbERR_BAD_ARGUMENT );
1994 return;
1995 }
1996
1997 unoToSbxValue(rPar.Get(0), Any(SbxDateToUNODateTime(rPar.Get(1))));
1998 }
1999
2000 // Function to convert date from UNO date (com.sun.star.util.Date)
2001 RTLFUNC(CDateFromUnoDateTime)
2002 {
2003 (void)pBasic;
2004 (void)bWrite;
2005
2006 if ( rPar.Count() != 2 || rPar.Get(1)->GetType() != SbxOBJECT )
2007 {
2008 StarBASIC::Error( SbERR_BAD_ARGUMENT );
2009 return;
2010 }
2011
2012 Any aAny (sbxToUnoValue(rPar.Get(1), cppu::UnoType<com::sun::star::util::DateTime>::get()));
2013 com::sun::star::util::DateTime aUnoDT;
2014 if(aAny >>= aUnoDT)
2015 SbxDateFromUNODateTime(rPar.Get(0), aUnoDT);
2016 else
2017 SbxBase::SetError( SbxERR_CONVERSION );
2018 }
2019
2020 // Function to convert date to ISO 8601 date format
2021 RTLFUNC(CDateToIso)
2022 {
2023 (void)pBasic;
2024 (void)bWrite;
2025
2026 if ( rPar.Count() == 2 )
2027 {
2028 double aDate = rPar.Get(1)->GetDate();
2029
2030 char Buffer[9];
2031 snprintf( Buffer, sizeof( Buffer ), "%04d%02d%02d",
2032 implGetDateYear( aDate ),
2033 implGetDateMonth( aDate ),
2034 implGetDateDay( aDate ) );
2035 OUString aRetStr = OUString::createFromAscii( Buffer );
2036 rPar.Get(0)->PutString( aRetStr );
2037 }
2038 else
2039 {
2040 StarBASIC::Error( SbERR_BAD_ARGUMENT );
2041 }
2042 }
2043
2044 // Function to convert date from ISO 8601 date format
2045 RTLFUNC(CDateFromIso)
2046 {
2047 (void)pBasic;
2048 (void)bWrite;
2049
2050 if ( rPar.Count() == 2 )
2051 {
2052 OUString aStr = rPar.Get(1)->GetOUString();
2053 sal_Int16 iMonthStart = aStr.getLength() - 4;
2054 OUString aYearStr = aStr.copy( 0, iMonthStart );
2055 OUString aMonthStr = aStr.copy( iMonthStart, 2 );
2056 OUString aDayStr = aStr.copy( iMonthStart+2, 2 );
2057
2058 double dDate;
2059 if( implDateSerial( (sal_Int16)aYearStr.toInt32(),
2060 (sal_Int16)aMonthStr.toInt32(), (sal_Int16)aDayStr.toInt32(), dDate ) )
2061 {
2062 rPar.Get(0)->PutDate( dDate );
2063 }
2064 }
2065 else
2066 {
2067 StarBASIC::Error( SbERR_BAD_ARGUMENT );
2068 }
2069 }
2070
2071 RTLFUNC(DateSerial)
2072 {
2073 (void)pBasic;
2074 (void)bWrite;
2075
2076 if ( rPar.Count() < 4 )
2077 {
2078 StarBASIC::Error( SbERR_BAD_ARGUMENT );
2079 return;
2080 }
2081 sal_Int16 nYear = rPar.Get(1)->GetInteger();
2082 sal_Int16 nMonth = rPar.Get(2)->GetInteger();
2083 sal_Int16 nDay = rPar.Get(3)->GetInteger();
2084
2085 double dDate;
2086 if( implDateSerial( nYear, nMonth, nDay, dDate ) )
2087 {
2088 rPar.Get(0)->PutDate( dDate );
2089 }
2090 }
2091
2092 RTLFUNC(TimeSerial)
2093 {
2094 (void)pBasic;
2095 (void)bWrite;
2096
2097 if ( rPar.Count() < 4 )
2098 {
2099 StarBASIC::Error( SbERR_BAD_ARGUMENT );
2100 return;
2101 }
2102 sal_Int16 nHour = rPar.Get(1)->GetInteger();
2103 if ( nHour == 24 )
2104 {
2105 nHour = 0; // because of UNO DateTimes, which go till 24 o'clock
2106 }
2107 sal_Int16 nMinute = rPar.Get(2)->GetInteger();
2108 sal_Int16 nSecond = rPar.Get(3)->GetInteger();
2109 if ((nHour < 0 || nHour > 23) ||
2110 (nMinute < 0 || nMinute > 59 ) ||
2111 (nSecond < 0 || nSecond > 59 ))
2112 {
2113 StarBASIC::Error( SbERR_BAD_ARGUMENT );
2114 return;
2115 }
2116
2117 rPar.Get(0)->PutDate( implTimeSerial(nHour, nMinute, nSecond) ); // JSM
2118 }
2119
2120 RTLFUNC(DateValue)
2121 {
2122 (void)pBasic;
2123 (void)bWrite;
2124
2125 if ( rPar.Count() < 2 )
2126 {
2127 StarBASIC::Error( SbERR_BAD_ARGUMENT );
2128 }
2129 else
2130 {
2131 // #39629 check GetSbData()->pInst, can be called from the URL line
2132 SvNumberFormatter* pFormatter = NULL;
2133 if( GetSbData()->pInst )
2134 {
2135 pFormatter = GetSbData()->pInst->GetNumberFormatter();
2136 }
2137 else
2138 {
2139 sal_uInt32 n; // Dummy
2140 SbiInstance::PrepareNumberFormatter( pFormatter, n, n, n );
2141 }
2142
2143 sal_uInt32 nIndex = 0;
2144 double fResult;
2145 OUString aStr( rPar.Get(1)->GetOUString() );
2146 bool bSuccess = pFormatter->IsNumberFormat( aStr, nIndex, fResult );
2147 short nType = pFormatter->GetType( nIndex );
2148
2149 // DateValue("February 12, 1969") raises error if the system locale is not en_US
2150 // by using SbiInstance::GetNumberFormatter.
2151 // It seems that both locale number formatter and English number formatter
2152 // are supported in Visual Basic.
2153 LanguageType eLangType = Application::GetSettings().GetLanguageTag().getLanguageType();
2154 if( !bSuccess && ( eLangType != LANGUAGE_ENGLISH_US ) )
2155 {
2156 // Create a new SvNumberFormatter by using LANGUAGE_ENGLISH to get the date value;
2157 SvNumberFormatter aFormatter( comphelper::getProcessComponentContext(), LANGUAGE_ENGLISH_US );
2158 nIndex = 0;
2159 bSuccess = aFormatter.IsNumberFormat( aStr, nIndex, fResult );
2160 nType = aFormatter.GetType( nIndex );
2161 }
2162
2163 if(bSuccess && (nType==css::util::NumberFormat::DATE || nType==css::util::NumberFormat::DATETIME))
2164 {
2165 if ( nType == css::util::NumberFormat::DATETIME )
2166 {
2167 // cut time
2168 if ( fResult > 0.0 )
2169 {
2170 fResult = floor( fResult );
2171 }
2172 else
2173 {
2174 fResult = ceil( fResult );
2175 }
2176 }
2177 rPar.Get(0)->PutDate( fResult );
2178 }
2179 else
2180 {
2181 StarBASIC::Error( SbERR_CONVERSION );
2182 }
2183 // #39629 pFormatter can be requested itself
2184 if( !GetSbData()->pInst )
2185 {
2186 delete pFormatter;
2187 }
2188 }
2189 }
2190
2191 RTLFUNC(TimeValue)
2192 {
2193 (void)pBasic;
2194 (void)bWrite;
2195
2196 if ( rPar.Count() < 2 )
2197 {
2198 StarBASIC::Error( SbERR_BAD_ARGUMENT );
2199 }
2200 else
2201 {
2202 SvNumberFormatter* pFormatter = NULL;
2203 if( GetSbData()->pInst )
2204 pFormatter = GetSbData()->pInst->GetNumberFormatter();
2205 else
2206 {
2207 sal_uInt32 n;
2208 SbiInstance::PrepareNumberFormatter( pFormatter, n, n, n );
2209 }
2210
2211 sal_uInt32 nIndex = 0;
2212 double fResult;
2213 bool bSuccess = pFormatter->IsNumberFormat( rPar.Get(1)->GetOUString(),
2214 nIndex, fResult );
2215 short nType = pFormatter->GetType(nIndex);
2216 if(bSuccess && (nType==css::util::NumberFormat::TIME||nType==css::util::NumberFormat::DATETIME))
2217 {
2218 if ( nType == css::util::NumberFormat::DATETIME )
2219 {
2220 // cut days
2221 fResult = fmod( fResult, 1 );
2222 }
2223 rPar.Get(0)->PutDate( fResult );
2224 }
2225 else
2226 {
2227 StarBASIC::Error( SbERR_CONVERSION );
2228 }
2229 if( !GetSbData()->pInst )
2230 {
2231 delete pFormatter;
2232 }
2233 }
2234 }
2235
2236 RTLFUNC(Day)
2237 {
2238 (void)pBasic;
2239 (void)bWrite;
2240
2241 if ( rPar.Count() < 2 )
2242 {
2243 StarBASIC::Error( SbERR_BAD_ARGUMENT );
2244 }
2245 else
2246 {
2247 SbxVariableRef pArg = rPar.Get( 1 );
2248 double aDate = pArg->GetDate();
2249
2250 sal_Int16 nDay = implGetDateDay( aDate );
2251 rPar.Get(0)->PutInteger( nDay );
2252 }
2253 }
2254
2255 RTLFUNC(Year)
2256 {
2257 (void)pBasic;
2258 (void)bWrite;
2259
2260 if ( rPar.Count() < 2 )
2261 {
2262 StarBASIC::Error( SbERR_BAD_ARGUMENT );
2263 }
2264 else
2265 {
2266 sal_Int16 nYear = implGetDateYear( rPar.Get(1)->GetDate() );
2267 rPar.Get(0)->PutInteger( nYear );
2268 }
2269 }
2270
2271 sal_Int16 implGetHour( double dDate )
2272 {
2273 if( dDate < 0.0 )
2274 {
2275 dDate *= -1.0;
2276 }
2277 double nFrac = dDate - floor( dDate );
2278 nFrac *= 86400.0;
2279 sal_Int32 nSeconds = (sal_Int32)(nFrac + 0.5);
2280 sal_Int16 nHour = (sal_Int16)(nSeconds / 3600);
2281 return nHour;
2282 }
2283
2284 RTLFUNC(Hour)
2285 {
2286 (void)pBasic;
2287 (void)bWrite;
2288
2289 if ( rPar.Count() < 2 )
2290 {
2291 StarBASIC::Error( SbERR_BAD_ARGUMENT );
2292 }
2293 else
2294 {
2295 double nArg = rPar.Get(1)->GetDate();
2296 sal_Int16 nHour = implGetHour( nArg );
2297 rPar.Get(0)->PutInteger( nHour );
2298 }
2299 }
2300
2301 RTLFUNC(Minute)
2302 {
2303 (void)pBasic;
2304 (void)bWrite;
2305
2306 if ( rPar.Count() < 2 )
2307 {
2308 StarBASIC::Error( SbERR_BAD_ARGUMENT );
2309 }
2310 else
2311 {
2312 double nArg = rPar.Get(1)->GetDate();
2313 sal_Int16 nMin = implGetMinute( nArg );
2314 rPar.Get(0)->PutInteger( nMin );
2315 }
2316 }
2317
2318 RTLFUNC(Month)
2319 {
2320 (void)pBasic;
2321 (void)bWrite;
2322
2323 if ( rPar.Count() < 2 )
2324 {
2325 StarBASIC::Error( SbERR_BAD_ARGUMENT );
2326 }
2327 else
2328 {
2329 sal_Int16 nMonth = implGetDateMonth( rPar.Get(1)->GetDate() );
2330 rPar.Get(0)->PutInteger( nMonth );
2331 }
2332 }
2333
2334 sal_Int16 implGetSecond( double dDate )
2335 {
2336 if( dDate < 0.0 )
2337 {
2338 dDate *= -1.0;
2339 }
2340 double nFrac = dDate - floor( dDate );
2341 nFrac *= 86400.0;
2342 sal_Int32 nSeconds = (sal_Int32)(nFrac + 0.5);
2343 sal_Int16 nTemp = (sal_Int16)(nSeconds / 3600);
2344 nSeconds -= nTemp * 3600;
2345 nTemp = (sal_Int16)(nSeconds / 60);
2346 nSeconds -= nTemp * 60;
2347
2348 sal_Int16 nRet = (sal_Int16)nSeconds;
2349 return nRet;
2350 }
2351
2352 RTLFUNC(Second)
2353 {
2354 (void)pBasic;
2355 (void)bWrite;
2356
2357 if ( rPar.Count() < 2 )
2358 {
2359 StarBASIC::Error( SbERR_BAD_ARGUMENT );
2360 }
2361 else
2362 {
2363 double nArg = rPar.Get(1)->GetDate();
2364 sal_Int16 nSecond = implGetSecond( nArg );
2365 rPar.Get(0)->PutInteger( nSecond );
2366 }
2367 }
2368
2369 double Now_Impl()
2370 {
2371 Date aDate( Date::SYSTEM );
2372 tools::Time aTime( tools::Time::SYSTEM );
2373 double aSerial = (double)GetDayDiff( aDate );
2374 long nSeconds = aTime.GetHour();
2375 nSeconds *= 3600;
2376 nSeconds += aTime.GetMin() * 60;
2377 nSeconds += aTime.GetSec();
2378 double nDays = ((double)nSeconds) / (double)(24.0*3600.0);
2379 aSerial += nDays;
2380 return aSerial;
2381 }
2382
2383 // Date Now()
2384
2385 RTLFUNC(Now)
2386 {
2387 (void)pBasic;
2388 (void)bWrite;
2389 rPar.Get(0)->PutDate( Now_Impl() );
2390 }
2391
2392 // Date Time()
2393
2394 RTLFUNC(Time)
2395 {
2396 (void)pBasic;
2397
2398 if ( !bWrite )
2399 {
2400 tools::Time aTime( tools::Time::SYSTEM );
2401 SbxVariable* pMeth = rPar.Get( 0 );
2402 OUString aRes;
2403 if( pMeth->IsFixed() )
2404 {
2405 // Time$: hh:mm:ss
2406 char buf[ 20 ];
2407 snprintf( buf, sizeof(buf), "%02d:%02d:%02d",
2408 aTime.GetHour(), aTime.GetMin(), aTime.GetSec() );
2409 aRes = OUString::createFromAscii( buf );
2410 }
2411 else
2412 {
2413 // Time: system dependent
2414 long nSeconds=aTime.GetHour();
2415 nSeconds *= 3600;
2416 nSeconds += aTime.GetMin() * 60;
2417 nSeconds += aTime.GetSec();
2418 double nDays = (double)nSeconds * ( 1.0 / (24.0*3600.0) );
2419 Color* pCol;
2420
2421 SvNumberFormatter* pFormatter = NULL;
2422 sal_uInt32 nIndex;
2423 if( GetSbData()->pInst )
2424 {
2425 pFormatter = GetSbData()->pInst->GetNumberFormatter();
2426 nIndex = GetSbData()->pInst->GetStdTimeIdx();
2427 }
2428 else
2429 {
2430 sal_uInt32 n; // Dummy
2431 SbiInstance::PrepareNumberFormatter( pFormatter, n, nIndex, n );
2432 }
2433
2434 pFormatter->GetOutputString( nDays, nIndex, aRes, &pCol );
2435
2436 if( !GetSbData()->pInst )
2437 {
2438 delete pFormatter;
2439 }
2440 }
2441 pMeth->PutString( aRes );
2442 }
2443 else
2444 {
2445 StarBASIC::Error( SbERR_NOT_IMPLEMENTED );
2446 }
2447 }
2448
2449 RTLFUNC(Timer)
2450 {
2451 (void)pBasic;
2452 (void)bWrite;
2453
2454 tools::Time aTime( tools::Time::SYSTEM );
2455 long nSeconds = aTime.GetHour();
2456 nSeconds *= 3600;
2457 nSeconds += aTime.GetMin() * 60;
2458 nSeconds += aTime.GetSec();
2459 rPar.Get(0)->PutDate( (double)nSeconds );
2460 }
2461
2462
2463 RTLFUNC(Date)
2464 {
2465 (void)pBasic;
2466 (void)bWrite;
2467
2468 if ( !bWrite )
2469 {
2470 Date aToday( Date::SYSTEM );
2471 double nDays = (double)GetDayDiff( aToday );
2472 SbxVariable* pMeth = rPar.Get( 0 );
2473 if( pMeth->IsString() )
2474 {
2475 OUString aRes;
2476 Color* pCol;
2477
2478 SvNumberFormatter* pFormatter = NULL;
2479 sal_uInt32 nIndex;
2480 if( GetSbData()->pInst )
2481 {
2482 pFormatter = GetSbData()->pInst->GetNumberFormatter();
2483 nIndex = GetSbData()->pInst->GetStdDateIdx();
2484 }
2485 else
2486 {
2487 sal_uInt32 n;
2488 SbiInstance::PrepareNumberFormatter( pFormatter, nIndex, n, n );
2489 }
2490
2491 pFormatter->GetOutputString( nDays, nIndex, aRes, &pCol );
2492 pMeth->PutString( aRes );
2493
2494 if( !GetSbData()->pInst )
2495 {
2496 delete pFormatter;
2497 }
2498 }
2499 else
2500 {
2501 pMeth->PutDate( nDays );
2502 }
2503 }
2504 else
2505 {
2506 StarBASIC::Error( SbERR_NOT_IMPLEMENTED );
2507 }
2508 }
2509
2510 RTLFUNC(IsArray)
2511 {
2512 (void)pBasic;
2513 (void)bWrite;
2514
2515 if ( rPar.Count() < 2 )
2516 {
2517 StarBASIC::Error( SbERR_BAD_ARGUMENT );
2518 }
2519 else
2520 {
2521 rPar.Get(0)->PutBool((rPar.Get(1)->GetType() & SbxARRAY) != 0);
2522 }
2523 }
2524
2525 RTLFUNC(IsObject)
2526 {
2527 (void)pBasic;
2528 (void)bWrite;
2529
2530 if ( rPar.Count() < 2 )
2531 {
2532 StarBASIC::Error( SbERR_BAD_ARGUMENT );
2533 }
2534 else
2535 {
2536 SbxVariable* pVar = rPar.Get(1);
2537 SbxBase* pObj = pVar->GetObject();
2538
2539 // #100385: GetObject can result in an error, so reset it
2540 SbxBase::ResetError();
2541
2542 SbUnoClass* pUnoClass;
2543 bool bObject;
2544 if( pObj && NULL != ( pUnoClass=PTR_CAST(SbUnoClass,pObj) ) )
2545 {
2546 bObject = pUnoClass->getUnoClass().is();
2547 }
2548 else
2549 {
2550 bObject = pVar->IsObject();
2551 }
2552 rPar.Get( 0 )->PutBool( bObject );
2553 }
2554 }
2555
2556 RTLFUNC(IsDate)
2557 {
2558 (void)pBasic;
2559 (void)bWrite;
2560
2561 if ( rPar.Count() < 2 )
2562 {
2563 StarBASIC::Error( SbERR_BAD_ARGUMENT );
2564 }
2565 else
2566 {
2567 // #46134 only string is converted, all other types result in sal_False
2568 SbxVariableRef xArg = rPar.Get( 1 );
2569 SbxDataType eType = xArg->GetType();
2570 bool bDate = false;
2571
2572 if( eType == SbxDATE )
2573 {
2574 bDate = true;
2575 }
2576 else if( eType == SbxSTRING )
2577 {
2578 SbxError nPrevError = SbxBase::GetError();
2579 SbxBase::ResetError();
2580
2581 // force conversion of the parameter to SbxDATE
2582 xArg->SbxValue::GetDate();
2583
2584 bDate = !SbxBase::IsError();
2585
2586 SbxBase::ResetError();
2587 SbxBase::SetError( nPrevError );
2588 }
2589 rPar.Get( 0 )->PutBool( bDate );
2590 }
2591 }
2592
2593 RTLFUNC(IsEmpty)
2594 {
2595 (void)pBasic;
2596 (void)bWrite;
2597
2598 if ( rPar.Count() < 2 )
2599 {
2600 StarBASIC::Error( SbERR_BAD_ARGUMENT );
2601 }
2602 else
2603 {
2604 SbxVariable* pVar = NULL;
2605 if( SbiRuntime::isVBAEnabled() )
2606 {
2607 pVar = getDefaultProp( rPar.Get(1) );
2608 }
2609 if ( pVar )
2610 {
2611 pVar->Broadcast( SBX_HINT_DATAWANTED );
2612 rPar.Get( 0 )->PutBool( pVar->IsEmpty() );
2613 }
2614 else
2615 {
2616 rPar.Get( 0 )->PutBool( rPar.Get(1)->IsEmpty() );
2617 }
2618 }
2619 }
2620
2621 RTLFUNC(IsError)
2622 {
2623 (void)pBasic;
2624 (void)bWrite;
2625
2626 if ( rPar.Count() < 2 )
2627 {
2628 StarBASIC::Error( SbERR_BAD_ARGUMENT );
2629 }
2630 else
2631 {
2632 SbxVariable* pVar =rPar.Get( 1 );
2633 SbUnoObject* pObj = PTR_CAST(SbUnoObject,pVar );
2634 if ( !pObj )
2635 {
2636 if ( SbxBase* pBaseObj = pVar->GetObject() )
2637 {
2638 pObj = PTR_CAST(SbUnoObject, pBaseObj );
2639 }
2640 }
2641 uno::Reference< script::XErrorQuery > xError;
2642 if ( pObj )
2643 {
2644 xError.set( pObj->getUnoAny(), uno::UNO_QUERY );
2645 }
2646 if ( xError.is() )
2647 {
2648 rPar.Get( 0 )->PutBool( xError->hasError() );
2649 }
2650 else
2651 {
2652 rPar.Get( 0 )->PutBool( rPar.Get(1)->IsErr() );
2653 }
2654 }
2655 }
2656
2657 RTLFUNC(IsNull)
2658 {
2659 (void)pBasic;
2660 (void)bWrite;
2661
2662 if ( rPar.Count() < 2 )
2663 {
2664 StarBASIC::Error( SbERR_BAD_ARGUMENT );
2665 }
2666 else
2667 {
2668 // #51475 because of Uno-objects return true
2669 // even if the pObj value is NULL
2670 SbxVariableRef pArg = rPar.Get( 1 );
2671 bool bNull = rPar.Get(1)->IsNull();
2672 if( !bNull && pArg->GetType() == SbxOBJECT )
2673 {
2674 SbxBase* pObj = pArg->GetObject();
2675 if( !pObj )
2676 {
2677 bNull = true;
2678 }
2679 }
2680 rPar.Get( 0 )->PutBool( bNull );
2681 }
2682 }
2683
2684 RTLFUNC(IsNumeric)
2685 {
2686 (void)pBasic;
2687 (void)bWrite;
2688
2689 if ( rPar.Count() < 2 )
2690 {
2691 StarBASIC::Error( SbERR_BAD_ARGUMENT );
2692 }
2693 else
2694 {
2695 rPar.Get( 0 )->PutBool( rPar.Get( 1 )->IsNumericRTL() );
2696 }
2697 }
2698
2699
2700
2701 RTLFUNC(IsMissing)
2702 {
2703 (void)pBasic;
2704 (void)bWrite;
2705
2706 if ( rPar.Count() < 2 )
2707 {
2708 StarBASIC::Error( SbERR_BAD_ARGUMENT );
2709 }
2710 else
2711 {
2712 // #57915 Missing is reported by an error
2713 rPar.Get( 0 )->PutBool( rPar.Get(1)->IsErr() );
2714 }
2715 }
2716
2717 // Function looks for wildcards, removes them and always returns the pure path
2718 OUString implSetupWildcard( const OUString& rFileParam, SbiRTLData* pRTLData )
2719 {
2720 static sal_Char cDelim1 = (sal_Char)'/';
2721 static sal_Char cDelim2 = (sal_Char)'\\';
2722 static sal_Char cWild1 = '*';
2723 static sal_Char cWild2 = '?';
2724
2725 delete pRTLData->pWildCard;
2726 pRTLData->pWildCard = NULL;
2727 pRTLData->sFullNameToBeChecked.clear();
2728
2729 OUString aFileParam = rFileParam;
2730 sal_Int32 nLastWild = aFileParam.lastIndexOf( cWild1 );
2731 if( nLastWild < 0 )
2732 {
2733 nLastWild = aFileParam.lastIndexOf( cWild2 );
2734 }
2735 bool bHasWildcards = ( nLastWild >= 0 );
2736
2737
2738 sal_Int32 nLastDelim = aFileParam.lastIndexOf( cDelim1 );
2739 if( nLastDelim < 0 )
2740 {
2741 nLastDelim = aFileParam.lastIndexOf( cDelim2 );
2742 }
2743 if( bHasWildcards )
2744 {
2745 // Wildcards in path?
2746 if( nLastDelim >= 0 && nLastDelim > nLastWild )
2747 {
2748 return aFileParam;
2749 }
2750 }
2751 else
2752 {
2753 OUString aPathStr = getFullPath( aFileParam );
2754 if( nLastDelim != aFileParam.getLength() - 1 )
2755 {
2756 pRTLData->sFullNameToBeChecked = aPathStr;
2757 }
2758 return aPathStr;
2759 }
2760
2761 OUString aPureFileName;
2762 if( nLastDelim < 0 )
2763 {
2764 aPureFileName = aFileParam;
2765 aFileParam.clear();
2766 }
2767 else
2768 {
2769 aPureFileName = aFileParam.copy( nLastDelim + 1 );
2770 aFileParam = aFileParam.copy( 0, nLastDelim );
2771 }
2772
2773 // Try again to get a valid URL/UNC-path with only the path
2774 OUString aPathStr = getFullPath( aFileParam );
2775
2776 // Is there a pure file name left? Otherwise the path is
2777 // invalid anyway because it was not accepted by OSL before
2778 if (!string::equals(aPureFileName, '*'))
2779 {
2780 pRTLData->pWildCard = new WildCard( aPureFileName );
2781 }
2782 return aPathStr;
2783 }
2784
2785 inline bool implCheckWildcard( const OUString& rName, SbiRTLData* pRTLData )
2786 {
2787 bool bMatch = true;
2788
2789 if( pRTLData->pWildCard )
2790 {
2791 bMatch = pRTLData->pWildCard->Matches( rName );
2792 }
2793 return bMatch;
2794 }
2795
2796
2797 bool isRootDir( const OUString& aDirURLStr )
2798 {
2799 INetURLObject aDirURLObj( aDirURLStr );
2800 bool bRoot = false;
2801
2802 // Check if it's a root directory
2803 sal_Int32 nCount = aDirURLObj.getSegmentCount();
2804
2805 // No segment means Unix root directory "file:///"
2806 if( nCount == 0 )
2807 {
2808 bRoot = true;
2809 }
2810 // Exactly one segment needs further checking, because it
2811 // can be Unix "file:///foo/" -> no root
2812 // or Windows "file:///c:/" -> root
2813 else if( nCount == 1 )
2814 {
2815 OUString aSeg1 = aDirURLObj.getName( 0, true,
2816 INetURLObject::DECODE_WITH_CHARSET );
2817 if( aSeg1[1] == (sal_Unicode)':' )
2818 {
2819 bRoot = true;
2820 }
2821 }
2822 // More than one segments can never be root
2823 // so bRoot remains false
2824
2825 return bRoot;
2826 }
2827
2828 RTLFUNC(Dir)
2829 {
2830 (void)pBasic;
2831 (void)bWrite;
2832
2833 OUString aPath;
2834
2835 sal_uInt16 nParCount = rPar.Count();
2836 if( nParCount > 3 )
2837 {
2838 StarBASIC::Error( SbERR_BAD_ARGUMENT );
2839 }
2840 else
2841 {
2842 SbiRTLData* pRTLData = GetSbData()->pInst->GetRTLData();
2843
2844 // #34645: can also be called from the URL line via 'macro: Dir'
2845 // there's no pRTLDate existing in that case and the method must be left
2846 if( !pRTLData )
2847 {
2848 return;
2849 }
2850 if( hasUno() )
2851 {
2852 uno::Reference< ucb::XSimpleFileAccess3 > xSFI = getFileAccess();
2853 if( xSFI.is() )
2854 {
2855 if ( nParCount >= 2 )
2856 {
2857 OUString aFileParam = rPar.Get(1)->GetOUString();
2858
2859 OUString aFileURLStr = implSetupWildcard( aFileParam, pRTLData );
2860 if( !pRTLData->sFullNameToBeChecked.isEmpty())
2861 {
2862 bool bExists = false;
2863 try { bExists = xSFI->exists( aFileURLStr ); }
2864 catch(const Exception & ) {}
2865
2866 OUString aNameOnlyStr;
2867 if( bExists )
2868 {
2869 INetURLObject aFileURL( aFileURLStr );
2870 aNameOnlyStr = aFileURL.getName( INetURLObject::LAST_SEGMENT,
2871 true, INetURLObject::DECODE_WITH_CHARSET );
2872 }
2873 rPar.Get(0)->PutString( aNameOnlyStr );
2874 return;
2875 }
2876
2877 try
2878 {
2879 OUString aDirURLStr;
2880 bool bFolder = xSFI->isFolder( aFileURLStr );
2881
2882 if( bFolder )
2883 {
2884 aDirURLStr = aFileURLStr;
2885 }
2886 else
2887 {
2888 OUString aEmptyStr;
2889 rPar.Get(0)->PutString( aEmptyStr );
2890 }
2891
2892 sal_uInt16 nFlags = 0;
2893 if ( nParCount > 2 )
2894 {
2895 pRTLData->nDirFlags = nFlags = rPar.Get(2)->GetInteger();
2896 }
2897 else
2898 {
2899 pRTLData->nDirFlags = 0;
2900 }
2901 // Read directory
2902 bool bIncludeFolders = ((nFlags & Sb_ATTR_DIRECTORY) != 0);
2903 pRTLData->aDirSeq = xSFI->getFolderContents( aDirURLStr, bIncludeFolders );
2904 pRTLData->nCurDirPos = 0;
2905
2906 // #78651 Add "." and ".." directories for VB compatibility
2907 if( bIncludeFolders )
2908 {
2909 bool bRoot = isRootDir( aDirURLStr );
2910
2911 // If it's no root directory we flag the need for
2912 // the "." and ".." directories by the value -2
2913 // for the actual position. Later for -2 will be
2914 // returned "." and for -1 ".."
2915 if( !bRoot )
2916 {
2917 pRTLData->nCurDirPos = -2;
2918 }
2919 }
2920 }
2921 catch(const Exception & )
2922 {
2923 }
2924 }
2925
2926
2927 if( pRTLData->aDirSeq.getLength() > 0 )
2928 {
2929 bool bFolderFlag = ((pRTLData->nDirFlags & Sb_ATTR_DIRECTORY) != 0);
2930
2931 SbiInstance* pInst = GetSbData()->pInst;
2932 bool bCompatibility = ( pInst && pInst->IsCompatibility() );
2933 for( ;; )
2934 {
2935 if( pRTLData->nCurDirPos < 0 )
2936 {
2937 if( pRTLData->nCurDirPos == -2 )
2938 {
2939 aPath = ".";
2940 }
2941 else if( pRTLData->nCurDirPos == -1 )
2942 {
2943 aPath = "..";
2944 }
2945 pRTLData->nCurDirPos++;
2946 }
2947 else if( pRTLData->nCurDirPos >= pRTLData->aDirSeq.getLength() )
2948 {
2949 pRTLData->aDirSeq.realloc( 0 );
2950 aPath.clear();
2951 break;
2952 }
2953 else
2954 {
2955 OUString aFile = pRTLData->aDirSeq.getConstArray()[pRTLData->nCurDirPos++];
2956
2957 if( bCompatibility )
2958 {
2959 if( !bFolderFlag )
2960 {
2961 bool bFolder = xSFI->isFolder( aFile );
2962 if( bFolder )
2963 {
2964 continue;
2965 }
2966 }
2967 }
2968 else
2969 {
2970 // Only directories
2971 if( bFolderFlag )
2972 {
2973 bool bFolder = xSFI->isFolder( aFile );
2974 if( !bFolder )
2975 {
2976 continue;
2977 }
2978 }
2979 }
2980
2981 INetURLObject aURL( aFile );
2982 aPath = aURL.getName( INetURLObject::LAST_SEGMENT, true,
2983 INetURLObject::DECODE_WITH_CHARSET );
2984 }
2985
2986 bool bMatch = implCheckWildcard( aPath, pRTLData );
2987 if( !bMatch )
2988 {
2989 continue;
2990 }
2991 break;
2992 }
2993 }
2994 rPar.Get(0)->PutString( aPath );
2995 }
2996 }
2997 else
2998 {
2999 // TODO: OSL
3000 if ( nParCount >= 2 )
3001 {
3002 OUString aFileParam = rPar.Get(1)->GetOUString();
3003
3004 OUString aDirURL = implSetupWildcard( aFileParam, pRTLData );
3005
3006 sal_uInt16 nFlags = 0;
3007 if ( nParCount > 2 )
3008 {
3009 pRTLData->nDirFlags = nFlags = rPar.Get(2)->GetInteger();
3010 }
3011 else
3012 {
3013 pRTLData->nDirFlags = 0;
3014 }
3015
3016 // Read directory
3017 bool bIncludeFolders = ((nFlags & Sb_ATTR_DIRECTORY) != 0);
3018 pRTLData->pDir = new Directory( aDirURL );
3019 FileBase::RC nRet = pRTLData->pDir->open();
3020 if( nRet != FileBase::E_None )
3021 {
3022 delete pRTLData->pDir;
3023 pRTLData->pDir = NULL;
3024 rPar.Get(0)->PutString( OUString() );
3025 return;
3026 }
3027
3028 // #86950 Add "." and ".." directories for VB compatibility
3029 pRTLData->nCurDirPos = 0;
3030 if( bIncludeFolders )
3031 {
3032 bool bRoot = isRootDir( aDirURL );
3033
3034 // If it's no root directory we flag the need for
3035 // the "." and ".." directories by the value -2
3036 // for the actual position. Later for -2 will be
3037 // returned "." and for -1 ".."
3038 if( !bRoot )
3039 {
3040 pRTLData->nCurDirPos = -2;
3041 }
3042 }
3043
3044 }
3045
3046 if( pRTLData->pDir )
3047 {
3048 bool bFolderFlag = ((pRTLData->nDirFlags & Sb_ATTR_DIRECTORY) != 0);
3049 for( ;; )
3050 {
3051 if( pRTLData->nCurDirPos < 0 )
3052 {
3053 if( pRTLData->nCurDirPos == -2 )
3054 {
3055 aPath = ".";
3056 }
3057 else if( pRTLData->nCurDirPos == -1 )
3058 {
3059 aPath = "..";
3060 }
3061 pRTLData->nCurDirPos++;
3062 }
3063 else
3064 {
3065 DirectoryItem aItem;
3066 FileBase::RC nRet = pRTLData->pDir->getNextItem( aItem );
3067 if( nRet != FileBase::E_None )
3068 {
3069 delete pRTLData->pDir;
3070 pRTLData->pDir = NULL;
3071 aPath.clear();
3072 break;
3073 }
3074
3075 // Handle flags
3076 FileStatus aFileStatus( osl_FileStatus_Mask_Type | osl_FileStatus_Mask_FileName );
3077 nRet = aItem.getFileStatus( aFileStatus );
3078
3079 // Only directories?
3080 if( bFolderFlag )
3081 {
3082 FileStatus::Type aType = aFileStatus.getFileType();
3083 bool bFolder = isFolder( aType );
3084 if( !bFolder )
3085 {
3086 continue;
3087 }
3088 }
3089
3090 aPath = aFileStatus.getFileName();
3091 }
3092
3093 bool bMatch = implCheckWildcard( aPath, pRTLData );
3094 if( !bMatch )
3095 {
3096 continue;
3097 }
3098 break;
3099 }
3100 }
3101 rPar.Get(0)->PutString( aPath );
3102 }
3103 }
3104 }
3105
3106
3107 RTLFUNC(GetAttr)
3108 {
3109 (void)pBasic;
3110 (void)bWrite;
3111
3112 if ( rPar.Count() == 2 )
3113 {
3114 sal_Int16 nFlags = 0;
3115
3116 // In Windows, we want to use Windows API to get the file attributes
3117 // for VBA interoperability.
3118 #if defined( WNT )
3119 if( SbiRuntime::isVBAEnabled() )
3120 {
3121 OUString aPathURL = getFullPath( rPar.Get(1)->GetOUString() );
3122 OUString aPath;
3123 FileBase::getSystemPathFromFileURL( aPathURL, aPath );
3124 OString aSystemPath(OUStringToOString(aPath, osl_getThreadTextEncoding()));
3125 DWORD nRealFlags = GetFileAttributes (aSystemPath.getStr());
3126 if (nRealFlags != 0xffffffff)
3127 {
3128 if (nRealFlags == FILE_ATTRIBUTE_NORMAL)
3129 {
3130 nRealFlags = 0;
3131 }
3132 nFlags = (sal_Int16) (nRealFlags);
3133 }
3134 else
3135 {
3136 StarBASIC::Error( SbERR_FILE_NOT_FOUND );
3137 }
3138 rPar.Get(0)->PutInteger( nFlags );
3139
3140 return;
3141 }
3142 #endif
3143
3144 if( hasUno() )
3145 {
3146 uno::Reference< ucb::XSimpleFileAccess3 > xSFI = getFileAccess();
3147 if( xSFI.is() )
3148 {
3149 try
3150 {
3151 OUString aPath = getFullPath( rPar.Get(1)->GetOUString() );
3152 bool bExists = false;
3153 try { bExists = xSFI->exists( aPath ); }
3154 catch(const Exception & ) {}
3155 if( !bExists )
3156 {
3157 StarBASIC::Error( SbERR_FILE_NOT_FOUND );
3158 return;
3159 }
3160
3161 bool bReadOnly = xSFI->isReadOnly( aPath );
3162 bool bHidden = xSFI->isHidden( aPath );
3163 bool bDirectory = xSFI->isFolder( aPath );
3164 if( bReadOnly )
3165 {
3166 nFlags |= Sb_ATTR_READONLY;
3167 }
3168 if( bHidden )
3169 {
3170 nFlags |= Sb_ATTR_HIDDEN;
3171 }
3172 if( bDirectory )
3173 {
3174 nFlags |= Sb_ATTR_DIRECTORY;
3175 }
3176 }
3177 catch(const Exception & )
3178 {
3179 StarBASIC::Error( ERRCODE_IO_GENERAL );
3180 }
3181 }
3182 }
3183 else
3184 {
3185 DirectoryItem aItem;
3186 DirectoryItem::get( getFullPath( rPar.Get(1)->GetOUString() ), aItem );
3187 FileStatus aFileStatus( osl_FileStatus_Mask_Attributes | osl_FileStatus_Mask_Type );
3188 aItem.getFileStatus( aFileStatus );
3189 sal_uInt64 nAttributes = aFileStatus.getAttributes();
3190 bool bReadOnly = (nAttributes & osl_File_Attribute_ReadOnly) != 0;
3191
3192 FileStatus::Type aType = aFileStatus.getFileType();
3193 bool bDirectory = isFolder( aType );
3194 if( bReadOnly )
3195 {
3196 nFlags |= Sb_ATTR_READONLY;
3197 }
3198 if( bDirectory )
3199 {
3200 nFlags |= Sb_ATTR_DIRECTORY;
3201 }
3202 }
3203 rPar.Get(0)->PutInteger( nFlags );
3204 }
3205 else
3206 {
3207 StarBASIC::Error( SbERR_BAD_ARGUMENT );
3208 }
3209 }
3210
3211
3212 RTLFUNC(FileDateTime)
3213 {
3214 (void)pBasic;
3215 (void)bWrite;
3216
3217 if ( rPar.Count() != 2 )
3218 {
3219 StarBASIC::Error( SbERR_BAD_ARGUMENT );
3220 }
3221 else
3222 {
3223 OUString aPath = rPar.Get(1)->GetOUString();
3224 tools::Time aTime( tools::Time::EMPTY );
3225 Date aDate( Date::EMPTY );
3226 if( hasUno() )
3227 {
3228 uno::Reference< ucb::XSimpleFileAccess3 > xSFI = getFileAccess();
3229 if( xSFI.is() )
3230 {
3231 try
3232 {
3233 util::DateTime aUnoDT = xSFI->getDateTimeModified( aPath );
3234 aTime = tools::Time( aUnoDT );
3235 aDate = Date( aUnoDT );
3236 }
3237 catch(const Exception & )
3238 {
3239 StarBASIC::Error( ERRCODE_IO_GENERAL );
3240 }
3241 }
3242 }
3243 else
3244 {
3245 DirectoryItem aItem;
3246 DirectoryItem::get( getFullPath( aPath ), aItem );
3247 FileStatus aFileStatus( osl_FileStatus_Mask_ModifyTime );
3248 aItem.getFileStatus( aFileStatus );
3249 TimeValue aTimeVal = aFileStatus.getModifyTime();
3250 oslDateTime aDT;
3251 osl_getDateTimeFromTimeValue( &aTimeVal, &aDT );
3252
3253 aTime = tools::Time( aDT.Hours, aDT.Minutes, aDT.Seconds, aDT.NanoSeconds );
3254 aDate = Date( aDT.Day, aDT.Month, aDT.Year );
3255 }
3256
3257 double fSerial = (double)GetDayDiff( aDate );
3258 long nSeconds = aTime.GetHour();
3259 nSeconds *= 3600;
3260 nSeconds += aTime.GetMin() * 60;
3261 nSeconds += aTime.GetSec();
3262 double nDays = ((double)nSeconds) / (double)(24.0*3600.0);
3263 fSerial += nDays;
3264
3265 Color* pCol;
3266
3267 SvNumberFormatter* pFormatter = NULL;
3268 sal_uInt32 nIndex;
3269 if( GetSbData()->pInst )
3270 {
3271 pFormatter = GetSbData()->pInst->GetNumberFormatter();
3272 nIndex = GetSbData()->pInst->GetStdDateTimeIdx();
3273 }
3274 else
3275 {
3276 sal_uInt32 n;
3277 SbiInstance::PrepareNumberFormatter( pFormatter, n, n, nIndex );
3278 }
3279
3280 OUString aRes;
3281 pFormatter->GetOutputString( fSerial, nIndex, aRes, &pCol );
3282 rPar.Get(0)->PutString( aRes );
3283
3284 if( !GetSbData()->pInst )
3285 {
3286 delete pFormatter;
3287 }
3288 }
3289 }
3290
3291
3292 RTLFUNC(EOF)
3293 {
3294 (void)pBasic;
3295 (void)bWrite;
3296
3297 // No changes for UCB
3298 if ( rPar.Count() != 2 )
3299 {
3300 StarBASIC::Error( SbERR_BAD_ARGUMENT );
3301 }
3302 else
3303 {
3304 sal_Int16 nChannel = rPar.Get(1)->GetInteger();
3305 SbiIoSystem* pIO = GetSbData()->pInst->GetIoSystem();
3306 SbiStream* pSbStrm = pIO->GetStream( nChannel );
3307 if ( !pSbStrm )
3308 {
3309 StarBASIC::Error( SbERR_BAD_CHANNEL );
3310 return;
3311 }
3312 bool bIsEof;
3313 SvStream* pSvStrm = pSbStrm->GetStrm();
3314 if ( pSbStrm->IsText() )
3315 {
3316 char cBla;
3317 (*pSvStrm).ReadChar( cBla ); // can we read another character?
3318 bIsEof = pSvStrm->IsEof();
3319 if ( !bIsEof )
3320 {
3321 pSvStrm->SeekRel( -1 );
3322 }
3323 }
3324 else
3325 {
3326 bIsEof = pSvStrm->IsEof(); // for binary data!
3327 }
3328 rPar.Get(0)->PutBool( bIsEof );
3329 }
3330 }
3331
3332 RTLFUNC(FileAttr)
3333 {
3334 (void)pBasic;
3335 (void)bWrite;
3336
3337 // No changes for UCB
3338 // #57064 Although this function doesn't operate with DirEntry, it is
3339 // not touched by the adjustment to virtual URLs, as it only works on
3340 // already opened files and the name doesn't matter there.
3341
3342 if ( rPar.Count() != 3 )
3343 {
3344 StarBASIC::Error( SbERR_BAD_ARGUMENT );
3345 }
3346 else
3347 {
3348 sal_Int16 nChannel = rPar.Get(1)->GetInteger();
3349 SbiIoSystem* pIO = GetSbData()->pInst->GetIoSystem();
3350 SbiStream* pSbStrm = pIO->GetStream( nChannel );
3351 if ( !pSbStrm )
3352 {
3353 StarBASIC::Error( SbERR_BAD_CHANNEL );
3354 return;
3355 }
3356 sal_Int16 nRet;
3357 if ( rPar.Get(2)->GetInteger() == 1 )
3358 {
3359 nRet = (sal_Int16)(pSbStrm->GetMode());
3360 }
3361 else
3362 {
3363 nRet = 0; // System file handle not supported
3364 }
3365 rPar.Get(0)->PutInteger( nRet );
3366 }
3367 }
3368 RTLFUNC(Loc)
3369 {
3370 (void)pBasic;
3371 (void)bWrite;
3372
3373 // No changes for UCB
3374 if ( rPar.Count() != 2 )
3375 {
3376 StarBASIC::Error( SbERR_BAD_ARGUMENT );
3377 }
3378 else
3379 {
3380 sal_Int16 nChannel = rPar.Get(1)->GetInteger();
3381 SbiIoSystem* pIO = GetSbData()->pInst->GetIoSystem();
3382 SbiStream* pSbStrm = pIO->GetStream( nChannel );
3383 if ( !pSbStrm )
3384 {
3385 StarBASIC::Error( SbERR_BAD_CHANNEL );
3386 return;
3387 }
3388 SvStream* pSvStrm = pSbStrm->GetStrm();
3389 sal_Size nPos;
3390 if( pSbStrm->IsRandom())
3391 {
3392 short nBlockLen = pSbStrm->GetBlockLen();
3393 nPos = nBlockLen ? (pSvStrm->Tell() / nBlockLen) : 0;
3394 nPos++; // block positions starting at 1
3395 }
3396 else if ( pSbStrm->IsText() )
3397 {
3398 nPos = pSbStrm->GetLine();
3399 }
3400 else if( pSbStrm->IsBinary() )
3401 {
3402 nPos = pSvStrm->Tell();
3403 }
3404 else if ( pSbStrm->IsSeq() )
3405 {
3406 nPos = ( pSvStrm->Tell()+1 ) / 128;
3407 }
3408 else
3409 {
3410 nPos = pSvStrm->Tell();
3411 }
3412 rPar.Get(0)->PutLong( (sal_Int32)nPos );
3413 }
3414 }
3415
3416 RTLFUNC(Lof)
3417 {
3418 (void)pBasic;
3419 (void)bWrite;
3420
3421 // No changes for UCB
3422 if ( rPar.Count() != 2 )
3423 {
3424 StarBASIC::Error( SbERR_BAD_ARGUMENT );
3425 }
3426 else
3427 {
3428 sal_Int16 nChannel = rPar.Get(1)->GetInteger();
3429 SbiIoSystem* pIO = GetSbData()->pInst->GetIoSystem();
3430 SbiStream* pSbStrm = pIO->GetStream( nChannel );
3431 if ( !pSbStrm )
3432 {
3433 StarBASIC::Error( SbERR_BAD_CHANNEL );
3434 return;
3435 }
3436 SvStream* pSvStrm = pSbStrm->GetStrm();
3437 sal_Size nOldPos = pSvStrm->Tell();
3438 sal_Size nLen = pSvStrm->Seek( STREAM_SEEK_TO_END );
3439 pSvStrm->Seek( nOldPos );
3440 rPar.Get(0)->PutLong( (sal_Int32)nLen );
3441 }
3442 }
3443
3444
3445 RTLFUNC(Seek)
3446 {
3447 (void)pBasic;
3448 (void)bWrite;
3449
3450 // No changes for UCB
3451 int nArgs = (int)rPar.Count();
3452 if ( nArgs < 2 || nArgs > 3 )
3453 {
3454 StarBASIC::Error( SbERR_BAD_ARGUMENT );
3455 return;
3456 }
3457 sal_Int16 nChannel = rPar.Get(1)->GetInteger();
3458 SbiIoSystem* pIO = GetSbData()->pInst->GetIoSystem();
3459 SbiStream* pSbStrm = pIO->GetStream( nChannel );
3460 if ( !pSbStrm )
3461 {
3462 StarBASIC::Error( SbERR_BAD_CHANNEL );
3463 return;
3464 }
3465 SvStream* pStrm = pSbStrm->GetStrm();
3466
3467 if ( nArgs == 2 ) // Seek-Function
3468 {
3469 sal_Size nPos = pStrm->Tell();
3470 if( pSbStrm->IsRandom() )
3471 {
3472 nPos = nPos / pSbStrm->GetBlockLen();
3473 }
3474 nPos++; // Basic counts from 1
3475 rPar.Get(0)->PutLong( (sal_Int32)nPos );
3476 }
3477 else // Seek-Statement
3478 {
3479 sal_Int32 nPos = rPar.Get(2)->GetLong();
3480 if ( nPos < 1 )
3481 {
3482 StarBASIC::Error( SbERR_BAD_ARGUMENT );
3483 return;
3484 }
3485 nPos--; // Basic counts from 1, SvStreams count from 0
3486 pSbStrm->SetExpandOnWriteTo( 0 );
3487 if ( pSbStrm->IsRandom() )
3488 {
3489 nPos *= pSbStrm->GetBlockLen();
3490 }
3491 pStrm->Seek( (sal_Size)nPos );
3492 pSbStrm->SetExpandOnWriteTo( nPos );
3493 }
3494 }
3495
3496 RTLFUNC(Format)
3497 {
3498 (void)pBasic;
3499 (void)bWrite;
3500
3501 sal_uInt16 nArgCount = (sal_uInt16)rPar.Count();
3502 if ( nArgCount < 2 || nArgCount > 3 )
3503 {
3504 StarBASIC::Error( SbERR_BAD_ARGUMENT );
3505 }
3506 else
3507 {
3508 OUString aResult;
3509 if( nArgCount == 2 )
3510 {
3511 rPar.Get(1)->Format( aResult );
3512 }
3513 else
3514 {
3515 OUString aFmt( rPar.Get(2)->GetOUString() );
3516 rPar.Get(1)->Format( aResult, &aFmt );
3517 }
3518 rPar.Get(0)->PutString( aResult );
3519 }
3520 }
3521
3522 namespace {
3523
3524 // note: BASIC does not use comphelper::random, because
3525 // Randomize(int) must be supported and should not affect non-BASIC random use
3526 struct RandomNumberGenerator
3527 {
3528 std::mt19937 global_rng;
3529
3530 RandomNumberGenerator()
3531 {
3532 try
3533 {
3534 std::random_device rd;
3535 // initialises the state of the global random number generator
3536 // should only be called once.
3537 // (note, a few std::variate_generator<> (like normal) have their
3538 // own state which would need a reset as well to guarantee identical
3539 // sequence of numbers, e.g. via myrand.distribution().reset())
3540 global_rng.seed(rd() ^ time(nullptr));
3541 }
3542 catch (std::runtime_error& e)
3543 {
3544 SAL_WARN("basic", "Using std::random_device failed: " << e.what());
3545 global_rng.seed(time(nullptr));
3546 }
3547 }
3548 };
3549
3550 class theRandomNumberGenerator : public rtl::Static<RandomNumberGenerator, theRandomNumberGenerator> {};
3551
3552 }
3553
3554 RTLFUNC(Randomize)
3555 {
3556 (void)pBasic;
3557 (void)bWrite;
3558
3559 if ( rPar.Count() > 2 )
3560 {
3561 StarBASIC::Error( SbERR_BAD_ARGUMENT );
3562 }
3563 int nSeed;
3564 if( rPar.Count() == 2 )
3565 {
3566 nSeed = (int)rPar.Get(1)->GetInteger();
3567 theRandomNumberGenerator::get().global_rng.seed(nSeed);
3568 }
3569 // without parameter, no need to do anything - RNG is seeded at first use
3570 }
3571
3572 RTLFUNC(Rnd)
3573 {
3574 (void)pBasic;
3575 (void)bWrite;
3576
3577 if ( rPar.Count() > 2 )
3578 {
3579 StarBASIC::Error( SbERR_BAD_ARGUMENT );
3580 }
3581 else
3582 {
3583 std::uniform_real_distribution<double> dist(0.0, 1.0);
3584 double const tmp(dist(theRandomNumberGenerator::get().global_rng));
3585 rPar.Get(0)->PutDouble(tmp);
3586 }
3587 }
3588
3589
3590 // Syntax: Shell("Path",[ Window-Style,[ "Params", [ bSync = sal_False ]]])
3591 // WindowStyles (VBA-kompatibel):
3592 // 2 == Minimized
3593 // 3 == Maximized
3594 // 10 == Full-Screen (text mode applications OS/2, WIN95, WNT)
3595 // HACK: The WindowStyle will be passed to
3596 // Application::StartApp in Creator. Format: "xxxx2"
3597
3598
3599 RTLFUNC(Shell)
3600 {
3601 (void)pBasic;
3602 (void)bWrite;
3603
3604 // No shell command for "virtual" portal users
3605 if( needSecurityRestrictions() )
3606 {
3607 StarBASIC::Error(SbERR_NOT_IMPLEMENTED);
3608 return;
3609 }
3610
3611 sal_Size nArgCount = rPar.Count();
3612 if ( nArgCount < 2 || nArgCount > 5 )
3613 {
3614 rPar.Get(0)->PutLong(0);
3615 StarBASIC::Error( SbERR_BAD_ARGUMENT );
3616 }
3617 else
3618 {
3619 oslProcessOption nOptions = osl_Process_SEARCHPATH | osl_Process_DETACHED;
3620
3621 OUString aCmdLine = rPar.Get(1)->GetOUString();
3622 // attach additional parameters - everything must be parsed anyway
3623 if( nArgCount >= 4 )
3624 {
3625 OUString tmp = rPar.Get(3)->GetOUString().trim();
3626 if (!tmp.isEmpty())
3627 {
3628 aCmdLine += " ";
3629 aCmdLine += tmp;
3630 }
3631 }
3632 else if( aCmdLine.isEmpty() )
3633 {
3634 // avaoid special treatment (empty list)
3635 aCmdLine += " ";
3636 }
3637 sal_Int32 nLen = aCmdLine.getLength();
3638
3639 // #55735 if there are parameters, they have to be separated
3640 // #72471 also separate the single parameters
3641 std::list<OUString> aTokenList;
3642 OUString aToken;
3643 sal_Int32 i = 0;
3644 sal_Unicode c;
3645 while( i < nLen )
3646 {
3647 for ( ;; ++i )
3648 {
3649 c = aCmdLine[ i ];
3650 if ( c != ' ' && c != '\t' )
3651 {
3652 break;
3653 }
3654 }
3655
3656 if( c == '\"' || c == '\'' )
3657 {
3658 sal_Int32 iFoundPos = aCmdLine.indexOf( c, i + 1 );
3659
3660 if( iFoundPos < 0 )
3661 {
3662 aToken = aCmdLine.copy( i);
3663 i = nLen;
3664 }
3665 else
3666 {
3667 aToken = aCmdLine.copy( i + 1, (iFoundPos - i - 1) );
3668 i = iFoundPos + 1;
3669 }
3670 }
3671 else
3672 {
3673 sal_Int32 iFoundSpacePos = aCmdLine.indexOf( ' ', i );
3674 sal_Int32 iFoundTabPos = aCmdLine.indexOf( '\t', i );
3675 sal_Int32 iFoundPos = iFoundSpacePos >= 0 ? iFoundTabPos >= 0 ? std::min( iFoundSpacePos, iFoundTabPos ) : iFoundSpacePos : -1;
3676
3677 if( iFoundPos < 0 )
3678 {
3679 aToken = aCmdLine.copy( i );
3680 i = nLen;
3681 }
3682 else
3683 {
3684 aToken = aCmdLine.copy( i, (iFoundPos - i) );
3685 i = iFoundPos;
3686 }
3687 }
3688
3689 // insert into the list
3690 aTokenList.push_back( aToken );
3691 }
3692 // #55735 / #72471 end
3693
3694 sal_Int16 nWinStyle = 0;
3695 if( nArgCount >= 3 )
3696 {
3697 nWinStyle = rPar.Get(2)->GetInteger();
3698 switch( nWinStyle )
3699 {
3700 case 2:
3701 nOptions |= osl_Process_MINIMIZED;
3702 break;
3703 case 3:
3704 nOptions |= osl_Process_MAXIMIZED;
3705 break;
3706 case 10:
3707 nOptions |= osl_Process_FULLSCREEN;
3708 break;
3709 }
3710
3711 bool bSync = false;
3712 if( nArgCount >= 5 )
3713 {
3714 bSync = rPar.Get(4)->GetBool();
3715 }
3716 if( bSync )
3717 {
3718 nOptions |= osl_Process_WAIT;
3719 }
3720 }
3721
3722 // #72471 work parameter(s) up
3723 std::list<OUString>::const_iterator iter = aTokenList.begin();
3724 const OUString& rStr = *iter;
3725 OUString aOUStrProg( rStr.getStr(), rStr.getLength() );
3726 OUString aOUStrProgURL = getFullPath( aOUStrProg );
3727
3728 ++iter;
3729
3730 sal_uInt16 nParamCount = sal::static_int_cast< sal_uInt16 >(aTokenList.size() - 1 );
3731 rtl_uString** pParamList = NULL;
3732 if( nParamCount )
3733 {
3734 pParamList = new rtl_uString*[nParamCount];
3735 for(int iList = 0; iter != aTokenList.end(); ++iList, ++iter)
3736 {
3737 const OUString& rParamStr = (*iter);
3738 const OUString aTempStr( rParamStr.getStr(), rParamStr.getLength());
3739 pParamList[iList] = NULL;
3740 rtl_uString_assign(&(pParamList[iList]), aTempStr.pData);
3741 }
3742 }
3743
3744 oslProcess pApp;
3745 bool bSucc = osl_executeProcess(
3746 aOUStrProgURL.pData,
3747 pParamList,
3748 nParamCount,
3749 nOptions,
3750 NULL,
3751 NULL,
3752 NULL, 0,
3753 &pApp ) == osl_Process_E_None;
3754
3755 // 53521 only free process handle on success
3756 if (bSucc)
3757 {
3758 osl_freeProcessHandle( pApp );
3759 }
3760
3761 for(int j = 0; j < nParamCount; ++j)
3762 {
3763 rtl_uString_release(pParamList[j]);
3764 }
3765
3766 delete [] pParamList;
3767
3768 if( !bSucc )
3769 {
3770 StarBASIC::Error( SbERR_FILE_NOT_FOUND );
3771 }
3772 else
3773 {
3774 rPar.Get(0)->PutLong( 0 );
3775 }
3776 }
3777 }
3778
3779 RTLFUNC(VarType)
3780 {
3781 (void)pBasic;
3782 (void)bWrite;
3783
3784 if ( rPar.Count() != 2 )
3785 {
3786 StarBASIC::Error( SbERR_BAD_ARGUMENT );
3787 }
3788 else
3789 {
3790 SbxDataType eType = rPar.Get(1)->GetType();
3791 rPar.Get(0)->PutInteger( (sal_Int16)eType );
3792 }
3793 }
3794
3795 // Exported function
3796 OUString getBasicTypeName( SbxDataType eType )
3797 {
3798 static const char* pTypeNames[] =
3799 {
3800 "Empty", // SbxEMPTY
3801 "Null", // SbxNULL
3802 "Integer", // SbxINTEGER
3803 "Long", // SbxLONG
3804 "Single", // SbxSINGLE
3805 "Double", // SbxDOUBLE
3806 "Currency", // SbxCURRENCY
3807 "Date", // SbxDATE
3808 "String", // SbxSTRING
3809 "Object", // SbxOBJECT
3810 "Error", // SbxERROR
3811 "Boolean", // SbxBOOL
3812 "Variant", // SbxVARIANT
3813 "DataObject", // SbxDATAOBJECT
3814 "Unknown Type",
3815 "Unknown Type",
3816 "Char", // SbxCHAR
3817 "Byte", // SbxBYTE
3818 "UShort", // SbxUSHORT
3819 "ULong", // SbxULONG
3820 "Long64", // SbxLONG64
3821 "ULong64", // SbxULONG64
3822 "Int", // SbxINT
3823 "UInt", // SbxUINT
3824 "Void", // SbxVOID
3825 "HResult", // SbxHRESULT
3826 "Pointer", // SbxPOINTER
3827 "DimArray", // SbxDIMARRAY
3828 "CArray", // SbxCARRAY
3829 "Userdef", // SbxUSERDEF
3830 "Lpstr", // SbxLPSTR
3831 "Lpwstr", // SbxLPWSTR
3832 "Unknown Type", // SbxCoreSTRING
3833 "WString", // SbxWSTRING
3834 "WChar", // SbxWCHAR
3835 "Int64", // SbxSALINT64
3836 "UInt64", // SbxSALUINT64
3837 "Decimal", // SbxDECIMAL
3838 };
3839
3840 int nPos = ((int)eType) & 0x0FFF;
3841 sal_uInt16 nTypeNameCount = sizeof( pTypeNames ) / sizeof( char* );
3842 if ( nPos < 0 || nPos >= nTypeNameCount )
3843 {
3844 nPos = nTypeNameCount - 1;
3845 }
3846 return OUString::createFromAscii(pTypeNames[nPos]);
3847 }
3848
3849 OUString getObjectTypeName( SbxVariable* pVar )
3850 {
3851 OUString sRet( "Object" );
3852 if ( pVar )
3853 {
3854 SbxBase* pObj = pVar->GetObject();
3855 if( !pObj )
3856 {
3857 sRet = "Nothing";
3858 }
3859 else
3860 {
3861 SbUnoObject* pUnoObj = PTR_CAST(SbUnoObject,pVar );
3862 if ( !pUnoObj )
3863 {
3864 if ( SbxBase* pBaseObj = pVar->GetObject() )
3865 {
3866 pUnoObj = PTR_CAST(SbUnoObject, pBaseObj );
3867 }
3868 }
3869 if ( pUnoObj )
3870 {
3871 Any aObj = pUnoObj->getUnoAny();
3872 // For upstreaming unless we start to build oovbaapi by default
3873 // we need to get detect the vba-ness of the object in some
3874 // other way
3875 // note: Automation objects do not support XServiceInfo
3876 uno::Reference< XServiceInfo > xServInfo( aObj, uno::UNO_QUERY );
3877 if ( xServInfo.is() )
3878 {
3879 // is this a VBA object ?
3880 uno::Reference< ooo::vba::XHelperInterface > xVBA( aObj, uno::UNO_QUERY );
3881 Sequence< OUString > sServices = xServInfo->getSupportedServiceNames();
3882 if ( sServices.getLength() )
3883 {
3884 sRet = sServices[ 0 ];
3885 }
3886 }
3887 else
3888 {
3889 uno::Reference< bridge::oleautomation::XAutomationObject > xAutoMation( aObj, uno::UNO_QUERY );
3890 if ( xAutoMation.is() )
3891 {
3892 uno::Reference< script::XInvocation > xInv( aObj, uno::UNO_QUERY );
3893 if ( xInv.is() )
3894 {
3895 try
3896 {
3897 xInv->getValue( OUString( "$GetTypeName" ) ) >>= sRet;
3898 }
3899 catch(const Exception& )
3900 {
3901 }
3902 }
3903 }
3904 }
3905 sal_Int32 nDot = sRet.lastIndexOf( '.' );
3906 if ( nDot != -1 && nDot < sRet.getLength() )
3907 {
3908 sRet = sRet.copy( nDot + 1 );
3909 }
3910 }
3911 }
3912 }
3913 return sRet;
3914 }
3915
3916 RTLFUNC(TypeName)
3917 {
3918 (void)pBasic;
3919 (void)bWrite;
3920
3921 if ( rPar.Count() != 2 )
3922 {
3923 StarBASIC::Error( SbERR_BAD_ARGUMENT );
3924 }
3925 else
3926 {
3927 SbxDataType eType = rPar.Get(1)->GetType();
3928 bool bIsArray = ( ( eType & SbxARRAY ) != 0 );
3929
3930 OUString aRetStr;
3931 if ( SbiRuntime::isVBAEnabled() && eType == SbxOBJECT )
3932 {
3933 aRetStr = getObjectTypeName( rPar.Get(1) );
3934 }
3935 else
3936 {
3937 aRetStr = getBasicTypeName( eType );
3938 }
3939 if( bIsArray )
3940 {
3941 aRetStr += "()";
3942 }
3943 rPar.Get(0)->PutString( aRetStr );
3944 }
3945 }
3946
3947 RTLFUNC(Len)
3948 {
3949 (void)pBasic;
3950 (void)bWrite;
3951
3952 if ( rPar.Count() != 2 )
3953 {
3954 StarBASIC::Error( SbERR_BAD_ARGUMENT );
3955 }
3956 else
3957 {
3958 const OUString& rStr = rPar.Get(1)->GetOUString();
3959 rPar.Get(0)->PutLong( rStr.getLength() );
3960 }
3961 }
3962
3963 RTLFUNC(DDEInitiate)
3964 {
3965 (void)pBasic;
3966 (void)bWrite;
3967
3968 // No DDE for "virtual" portal users
3969 if( needSecurityRestrictions() )
3970 {
3971 StarBASIC::Error(SbERR_NOT_IMPLEMENTED);
3972 return;
3973 }
3974
3975 int nArgs = (int)rPar.Count();
3976 if ( nArgs != 3 )
3977 {
3978 StarBASIC::Error( SbERR_BAD_ARGUMENT );
3979 return;
3980 }
3981 const OUString& rApp = rPar.Get(1)->GetOUString();
3982 const OUString& rTopic = rPar.Get(2)->GetOUString();
3983
3984 SbiDdeControl* pDDE = GetSbData()->pInst->GetDdeControl();
3985 size_t nChannel;
3986 SbError nDdeErr = pDDE->Initiate( rApp, rTopic, nChannel );
3987 if( nDdeErr )
3988 {
3989 StarBASIC::Error( nDdeErr );
3990 }
3991 else
3992 {
3993 rPar.Get(0)->PutInteger( (int)nChannel );
3994 }
3995 }
3996
3997 RTLFUNC(DDETerminate)
3998 {
3999 (void)pBasic;
4000 (void)bWrite;
4001
4002 // No DDE for "virtual" portal users
4003 if( needSecurityRestrictions() )
4004 {
4005 StarBASIC::Error(SbERR_NOT_IMPLEMENTED);
4006 return;
4007 }
4008
4009 rPar.Get(0)->PutEmpty();
4010 int nArgs = (int)rPar.Count();
4011 if ( nArgs != 2 )
4012 {
4013 StarBASIC::Error( SbERR_BAD_ARGUMENT );
4014 return;
4015 }
4016 size_t nChannel = rPar.Get(1)->GetInteger();
4017 SbiDdeControl* pDDE = GetSbData()->pInst->GetDdeControl();
4018 SbError nDdeErr = pDDE->Terminate( nChannel );
4019 if( nDdeErr )
4020 {
4021 StarBASIC::Error( nDdeErr );
4022 }
4023 }
4024
4025 RTLFUNC(DDETerminateAll)
4026 {
4027 (void)pBasic;
4028 (void)bWrite;
4029
4030 // No DDE for "virtual" portal users
4031 if( needSecurityRestrictions() )
4032 {
4033 StarBASIC::Error(SbERR_NOT_IMPLEMENTED);
4034 return;
4035 }
4036
4037 rPar.Get(0)->PutEmpty();
4038 int nArgs = (int)rPar.Count();
4039 if ( nArgs != 1 )
4040 {
4041 StarBASIC::Error( SbERR_BAD_ARGUMENT );
4042 return;
4043 }
4044
4045 SbiDdeControl* pDDE = GetSbData()->pInst->GetDdeControl();
4046 SbError nDdeErr = pDDE->TerminateAll();
4047 if( nDdeErr )
4048 {
4049 StarBASIC::Error( nDdeErr );
4050 }
4051 }
4052
4053 RTLFUNC(DDERequest)
4054 {
4055 (void)pBasic;
4056 (void)bWrite;
4057
4058 // No DDE for "virtual" portal users
4059 if( needSecurityRestrictions() )
4060 {
4061 StarBASIC::Error(SbERR_NOT_IMPLEMENTED);
4062 return;
4063 }
4064
4065 int nArgs = (int)rPar.Count();
4066 if ( nArgs != 3 )
4067 {
4068 StarBASIC::Error( SbERR_BAD_ARGUMENT );
4069 return;
4070 }
4071 size_t nChannel = rPar.Get(1)->GetInteger();
4072 const OUString& rItem = rPar.Get(2)->GetOUString();
4073 SbiDdeControl* pDDE = GetSbData()->pInst->GetDdeControl();
4074 OUString aResult;
4075 SbError nDdeErr = pDDE->Request( nChannel, rItem, aResult );
4076 if( nDdeErr )
4077 {
4078 StarBASIC::Error( nDdeErr );
4079 }
4080 else
4081 {
4082 rPar.Get(0)->PutString( aResult );
4083 }
4084 }
4085
4086 RTLFUNC(DDEExecute)
4087 {
4088 (void)pBasic;
4089 (void)bWrite;
4090
4091 // No DDE for "virtual" portal users
4092 if( needSecurityRestrictions() )
4093 {
4094 StarBASIC::Error(SbERR_NOT_IMPLEMENTED);
4095 return;
4096 }
4097
4098 rPar.Get(0)->PutEmpty();
4099 int nArgs = (int)rPar.Count();
4100 if ( nArgs != 3 )
4101 {
4102 StarBASIC::Error( SbERR_BAD_ARGUMENT );
4103 return;
4104 }
4105 size_t nChannel = rPar.Get(1)->GetInteger();
4106 const OUString& rCommand = rPar.Get(2)->GetOUString();
4107 SbiDdeControl* pDDE = GetSbData()->pInst->GetDdeControl();
4108 SbError nDdeErr = pDDE->Execute( nChannel, rCommand );
4109 if( nDdeErr )
4110 {
4111 StarBASIC::Error( nDdeErr );
4112 }
4113 }
4114
4115 RTLFUNC(DDEPoke)
4116 {
4117 (void)pBasic;
4118 (void)bWrite;
4119
4120 // No DDE for "virtual" portal users
4121 if( needSecurityRestrictions() )
4122 {
4123 StarBASIC::Error(SbERR_NOT_IMPLEMENTED);
4124 return;
4125 }
4126
4127 rPar.Get(0)->PutEmpty();
4128 int nArgs = (int)rPar.Count();
4129 if ( nArgs != 4 )
4130 {
4131 StarBASIC::Error( SbERR_BAD_ARGUMENT );
4132 return;
4133 }
4134 size_t nChannel = rPar.Get(1)->GetInteger();
4135 const OUString& rItem = rPar.Get(2)->GetOUString();
4136 const OUString& rData = rPar.Get(3)->GetOUString();
4137 SbiDdeControl* pDDE = GetSbData()->pInst->GetDdeControl();
4138 SbError nDdeErr = pDDE->Poke( nChannel, rItem, rData );
4139 if( nDdeErr )
4140 {
4141 StarBASIC::Error( nDdeErr );
4142 }
4143 }
4144
4145
4146 RTLFUNC(FreeFile)
4147 {
4148 (void)pBasic;
4149 (void)bWrite;
4150
4151 if ( rPar.Count() != 1 )
4152 {
4153 StarBASIC::Error( SbERR_BAD_ARGUMENT );
4154 return;
4155 }
4156 SbiIoSystem* pIO = GetSbData()->pInst->GetIoSystem();
4157 short nChannel = 1;
4158 while( nChannel < CHANNELS )
4159 {
4160 SbiStream* pStrm = pIO->GetStream( nChannel );
4161 if( !pStrm )
4162 {
4163 rPar.Get(0)->PutInteger( nChannel );
4164 return;
4165 }
4166 nChannel++;
4167 }
4168 StarBASIC::Error( SbERR_TOO_MANY_FILES );
4169 }
4170
4171 RTLFUNC(LBound)
4172 {
4173 (void)pBasic;
4174 (void)bWrite;
4175
4176 sal_uInt16 nParCount = rPar.Count();
4177 if ( nParCount != 3 && nParCount != 2 )
4178 {
4179 StarBASIC::Error( SbERR_BAD_ARGUMENT );
4180 return;
4181 }
4182 SbxBase* pParObj = rPar.Get(1)->GetObject();
4183 SbxDimArray* pArr = PTR_CAST(SbxDimArray,pParObj);
4184 if( pArr )
4185 {
4186 sal_Int32 nLower, nUpper;
4187 short nDim = (nParCount == 3) ? (short)rPar.Get(2)->GetInteger() : 1;
4188 if( !pArr->GetDim32( nDim, nLower, nUpper ) )
4189 StarBASIC::Error( SbERR_OUT_OF_RANGE );
4190 else
4191 rPar.Get(0)->PutLong( nLower );
4192 }
4193 else
4194 StarBASIC::Error( SbERR_MUST_HAVE_DIMS );
4195 }
4196
4197 RTLFUNC(UBound)
4198 {
4199 (void)pBasic;
4200 (void)bWrite;
4201
4202 sal_uInt16 nParCount = rPar.Count();
4203 if ( nParCount != 3 && nParCount != 2 )
4204 {
4205 StarBASIC::Error( SbERR_BAD_ARGUMENT );
4206 return;
4207 }
4208
4209 SbxBase* pParObj = rPar.Get(1)->GetObject();
4210 SbxDimArray* pArr = PTR_CAST(SbxDimArray,pParObj);
4211 if( pArr )
4212 {
4213 sal_Int32 nLower, nUpper;
4214 short nDim = (nParCount == 3) ? (short)rPar.Get(2)->GetInteger() : 1;
4215 if( !pArr->GetDim32( nDim, nLower, nUpper ) )
4216 StarBASIC::Error( SbERR_OUT_OF_RANGE );
4217 else
4218 rPar.Get(0)->PutLong( nUpper );
4219 }
4220 else
4221 StarBASIC::Error( SbERR_MUST_HAVE_DIMS );
4222 }
4223
4224 RTLFUNC(RGB)
4225 {
4226 (void)pBasic;
4227 (void)bWrite;
4228
4229 if ( rPar.Count() != 4 )
4230 {
4231 StarBASIC::Error( SbERR_BAD_ARGUMENT );
4232 return;
4233 }
4234
4235 sal_Int32 nRed = rPar.Get(1)->GetInteger() & 0xFF;
4236 sal_Int32 nGreen = rPar.Get(2)->GetInteger() & 0xFF;
4237 sal_Int32 nBlue = rPar.Get(3)->GetInteger() & 0xFF;
4238 sal_Int32 nRGB;
4239
4240 SbiInstance* pInst = GetSbData()->pInst;
4241 bool bCompatibility = ( pInst && pInst->IsCompatibility() );
4242 if( bCompatibility )
4243 {
4244 nRGB = (nBlue << 16) | (nGreen << 8) | nRed;
4245 }
4246 else
4247 {
4248 nRGB = (nRed << 16) | (nGreen << 8) | nBlue;
4249 }
4250 rPar.Get(0)->PutLong( nRGB );
4251 }
4252
4253 RTLFUNC(QBColor)
4254 {
4255 (void)pBasic;
4256 (void)bWrite;
4257
4258 static const sal_Int32 pRGB[] =
4259 {
4260 0x000000,
4261 0x800000,
4262 0x008000,
4263 0x808000,
4264 0x000080,
4265 0x800080,
4266 0x008080,
4267 0xC0C0C0,
4268 0x808080,
4269 0xFF0000,
4270 0x00FF00,
4271 0xFFFF00,
4272 0x0000FF,
4273 0xFF00FF,
4274 0x00FFFF,
4275 0xFFFFFF,
4276 };
4277
4278 if ( rPar.Count() != 2 )
4279 {
4280 StarBASIC::Error( SbERR_BAD_ARGUMENT );
4281 return;
4282 }
4283
4284 sal_Int16 nCol = rPar.Get(1)->GetInteger();
4285 if( nCol < 0 || nCol > 15 )
4286 {
4287 StarBASIC::Error( SbERR_BAD_ARGUMENT );
4288 return;
4289 }
4290 sal_Int32 nRGB = pRGB[ nCol ];
4291 rPar.Get(0)->PutLong( nRGB );
4292 }
4293
4294 // StrConv(string, conversion, LCID)
4295 RTLFUNC(StrConv)
4296 {
4297 (void)pBasic;
4298 (void)bWrite;
4299
4300 sal_Size nArgCount = rPar.Count()-1;
4301 if( nArgCount < 2 || nArgCount > 3 )
4302 {
4303 StarBASIC::Error( SbERR_BAD_ARGUMENT );
4304 return;
4305 }
4306
4307 OUString aOldStr = rPar.Get(1)->GetOUString();
4308 sal_Int32 nConversion = rPar.Get(2)->GetLong();
4309
4310 sal_uInt16 nLanguage = LANGUAGE_SYSTEM;
4311
4312 sal_Int32 nOldLen = aOldStr.getLength();
4313 if( nOldLen == 0 )
4314 {
4315 // null string,return
4316 rPar.Get(0)->PutString(aOldStr);
4317 return;
4318 }
4319
4320 sal_Int32 nType = 0;
4321 if ( (nConversion & 0x03) == 3 ) // vbProperCase
4322 {
4323 const CharClass& rCharClass = GetCharClass();
4324 aOldStr = rCharClass.titlecase( aOldStr.toAsciiLowerCase(), 0, nOldLen );
4325 }
4326 else if ( (nConversion & 0x01) == 1 ) // vbUpperCase
4327 {
4328 nType |= i18n::TransliterationModules_LOWERCASE_UPPERCASE;
4329 }
4330 else if ( (nConversion & 0x02) == 2 ) // vbLowerCase
4331 {
4332 nType |= i18n::TransliterationModules_UPPERCASE_LOWERCASE;
4333 }
4334 if ( (nConversion & 0x04) == 4 ) // vbWide
4335 {
4336 nType |= i18n::TransliterationModules_HALFWIDTH_FULLWIDTH;
4337 }
4338 else if ( (nConversion & 0x08) == 8 ) // vbNarrow
4339 {
4340 nType |= i18n::TransliterationModules_FULLWIDTH_HALFWIDTH;
4341 }
4342 if ( (nConversion & 0x10) == 16) // vbKatakana
4343 {
4344 nType |= i18n::TransliterationModules_HIRAGANA_KATAKANA;
4345 }
4346 else if ( (nConversion & 0x20) == 32 ) // vbHiragana
4347 {
4348 nType |= i18n::TransliterationModules_KATAKANA_HIRAGANA;
4349 }
4350 OUString aNewStr( aOldStr );
4351 if( nType != 0 )
4352 {
4353 uno::Reference< uno::XComponentContext > xContext = getProcessComponentContext();
4354 ::utl::TransliterationWrapper aTransliterationWrapper( xContext, nType );
4355 uno::Sequence<sal_Int32> aOffsets;
4356 aTransliterationWrapper.loadModuleIfNeeded( nLanguage );
4357 aNewStr = aTransliterationWrapper.transliterate( aOldStr, nLanguage, 0, nOldLen, &aOffsets );
4358 }
4359
4360 if ( (nConversion & 0x40) == 64 ) // vbUnicode
4361 {
4362 // convert the string to byte string, preserving unicode (2 bytes per character)
4363 sal_Int32 nSize = aNewStr.getLength()*2;
4364 const sal_Unicode* pSrc = aNewStr.getStr();
4365 sal_Char* pChar = new sal_Char[nSize+1];
4366 for( sal_Int32 i=0; i < nSize; i++ )
4367 {
4368 pChar[i] = static_cast< sal_Char >( (i%2) ? ((*pSrc) >> 8) & 0xff : (*pSrc) & 0xff );
4369 if( i%2 )
4370 {
4371 pSrc++;
4372 }
4373 }
4374 pChar[nSize] = '\0';
4375 OString aOStr(pChar);
4376 delete[] pChar;
4377
4378 // there is no concept about default codepage in unix. so it is incorrectly in unix
4379 OUString aOUStr = OStringToOUString(aOStr, osl_getThreadTextEncoding());
4380 rPar.Get(0)->PutString( aOUStr );
4381 return;
4382 }
4383 else if ( (nConversion & 0x80) == 128 ) // vbFromUnicode
4384 {
4385 // there is no concept about default codepage in unix. so it is incorrectly in unix
4386 OString aOStr = OUStringToOString(aNewStr,osl_getThreadTextEncoding());
4387 const sal_Char* pChar = aOStr.getStr();
4388 sal_Int32 nArraySize = aOStr.getLength();
4389 SbxDimArray* pArray = new SbxDimArray(SbxBYTE);
4390 bool bIncIndex = (IsBaseIndexOne() && SbiRuntime::isVBAEnabled() );
4391 if(nArraySize)
4392 {
4393 if( bIncIndex )
4394 {
4395 pArray->AddDim( 1, nArraySize );
4396 }
4397 else
4398 {
4399 pArray->AddDim( 0, nArraySize-1 );
4400 }
4401 }
4402 else
4403 {
4404 pArray->unoAddDim( 0, -1 );
4405 }
4406
4407 for( sal_Int32 i=0; i< nArraySize; i++)
4408 {
4409 SbxVariable* pNew = new SbxVariable( SbxBYTE );
4410 pNew->PutByte(*pChar);
4411 pChar++;
4412 pNew->SetFlag( SBX_WRITE );
4413 short index = i;
4414 if( bIncIndex )
4415 {
4416 ++index;
4417 }
4418 // coverity[callee_ptr_arith]
4419 pArray->Put( pNew, &index );
4420 }
4421
4422 SbxVariableRef refVar = rPar.Get(0);
4423 SbxFlagBits nFlags = refVar->GetFlags();
4424 refVar->ResetFlag( SBX_FIXED );
4425 refVar->PutObject( pArray );
4426 refVar->SetFlags( nFlags );
4427 refVar->SetParameters( NULL );
4428 return;
4429 }
4430 rPar.Get(0)->PutString(aNewStr);
4431 }
4432
4433
4434 RTLFUNC(Beep)
4435 {
4436 (void)pBasic;
4437 (void)bWrite;
4438
4439 if ( rPar.Count() != 1 )
4440 {
4441 StarBASIC::Error( SbERR_BAD_ARGUMENT );
4442 return;
4443 }
4444 Sound::Beep();
4445 }
4446
4447 RTLFUNC(Load)
4448 {
4449 (void)pBasic;
4450 (void)bWrite;
4451
4452 if( rPar.Count() != 2 )
4453 {
4454 StarBASIC::Error( SbERR_BAD_ARGUMENT );
4455 return;
4456 }
4457
4458
4459 SbxBase* pObj = static_cast<SbxObject*>(rPar.Get(1)->GetObject());
4460 if ( pObj )
4461 {
4462 if( pObj->IsA( TYPE( SbUserFormModule ) ) )
4463 {
4464 static_cast<SbUserFormModule*>(pObj)->Load();
4465 }
4466 else if( pObj->IsA( TYPE( SbxObject ) ) )
4467 {
4468 SbxVariable* pVar = static_cast<SbxObject*>(pObj)->Find( OUString("Load"), SbxCLASS_METHOD );
4469 if( pVar )
4470 {
4471 pVar->GetInteger();
4472 }
4473 }
4474 }
4475 }
4476
4477 RTLFUNC(Unload)
4478 {
4479 (void)pBasic;
4480 (void)bWrite;
4481
4482 rPar.Get(0)->PutEmpty();
4483 if( rPar.Count() != 2 )
4484 {
4485 StarBASIC::Error( SbERR_BAD_ARGUMENT );
4486 return;
4487 }
4488
4489
4490 SbxBase* pObj = static_cast<SbxObject*>(rPar.Get(1)->GetObject());
4491 if ( pObj )
4492 {
4493 if( pObj->IsA( TYPE( SbUserFormModule ) ) )
4494 {
4495 SbUserFormModule* pFormModule = static_cast<SbUserFormModule*>(pObj);
4496 pFormModule->Unload();
4497 }
4498 else if( pObj->IsA( TYPE( SbxObject ) ) )
4499 {
4500 SbxVariable* pVar = static_cast<SbxObject*>(pObj)->Find( OUString("Unload"), SbxCLASS_METHOD );
4501 if( pVar )
4502 {
4503 pVar->GetInteger();
4504 }
4505 }
4506 }
4507 }
4508
4509 RTLFUNC(LoadPicture)
4510 {
4511 (void)pBasic;
4512 (void)bWrite;
4513
4514 if( rPar.Count() != 2 )
4515 {
4516 StarBASIC::Error( SbERR_BAD_ARGUMENT );
4517 return;
4518 }
4519
4520 OUString aFileURL = getFullPath( rPar.Get(1)->GetOUString() );
4521 boost::scoped_ptr<SvStream> pStream(utl::UcbStreamHelper::CreateStream( aFileURL, StreamMode::READ ));
4522 if( pStream )
4523 {
4524 Bitmap aBmp;
4525 ReadDIB(aBmp, *pStream, true);
4526 Graphic aGraphic(aBmp);
4527
4528 SbxObjectRef xRef = new SbStdPicture;
4529 static_cast<SbStdPicture*>((SbxObject*)xRef)->SetGraphic( aGraphic );
4530 rPar.Get(0)->PutObject( xRef );
4531 }
4532 }
4533
4534 RTLFUNC(SavePicture)
4535 {
4536 (void)pBasic;
4537 (void)bWrite;
4538
4539 rPar.Get(0)->PutEmpty();
4540 if( rPar.Count() != 3 )
4541 {
4542 StarBASIC::Error( SbERR_BAD_ARGUMENT );
4543 return;
4544 }
4545
4546 SbxBase* pObj = static_cast<SbxObject*>(rPar.Get(1)->GetObject());
4547 if( pObj->IsA( TYPE( SbStdPicture ) ) )
4548 {
4549 SvFileStream aOStream( rPar.Get(2)->GetOUString(), StreamMode::WRITE | StreamMode::TRUNC );
4550 Graphic aGraphic = static_cast<SbStdPicture*>(pObj)->GetGraphic();
4551 WriteGraphic( aOStream, aGraphic );
4552 }
4553 }
4554
4555
4556
4557
4558 RTLFUNC(MsgBox)
4559 {
4560 (void)pBasic;
4561 (void)bWrite;
4562
4563 static const WinBits nStyleMap[] =
4564 {
4565 WB_OK, // MB_OK
4566 WB_OK_CANCEL, // MB_OKCANCEL
4567 WB_ABORT_RETRY_IGNORE, // MB_ABORTRETRYIGNORE
4568 WB_YES_NO_CANCEL, // MB_YESNOCANCEL
4569 WB_YES_NO, // MB_YESNO
4570 WB_RETRY_CANCEL // MB_RETRYCANCEL
4571 };
4572 static const sal_Int16 nButtonMap[] =
4573 {
4574 2, // RET_CANCEL is 0
4575 1, // RET_OK is 1
4576 6, // RET_YES is 2
4577 7, // RET_NO is 3
4578 4 // RET_RETRY is 4
4579 };
4580
4581
4582 sal_uInt16 nArgCount = (sal_uInt16)rPar.Count();
4583 if( nArgCount < 2 || nArgCount > 6 )
4584 {
4585 StarBASIC::Error( SbERR_BAD_ARGUMENT );
4586 return;
4587 }
4588 WinBits nWinBits;
4589 WinBits nType = 0; // MB_OK
4590 if( nArgCount >= 3 )
4591 nType = (WinBits)rPar.Get(2)->GetInteger();
4592 WinBits nStyle = nType;
4593 nStyle &= 15; // delete bits 4-16
4594 if( nStyle > 5 )
4595 {
4596 nStyle = 0;
4597 }
4598 nWinBits = nStyleMap[ nStyle ];
4599
4600 WinBits nWinDefBits;
4601 nWinDefBits = (WB_DEF_OK | WB_DEF_RETRY | WB_DEF_YES);
4602 if( nType & 256 )
4603 {
4604 if( nStyle == 5 )
4605 {
4606 nWinDefBits = WB_DEF_CANCEL;
4607 }
4608 else if( nStyle == 2 )
4609 {
4610 nWinDefBits = WB_DEF_RETRY;
4611 }
4612 else
4613 {
4614 nWinDefBits = (WB_DEF_CANCEL | WB_DEF_RETRY | WB_DEF_NO);
4615 }
4616 }
4617 else if( nType & 512 )
4618 {
4619 if( nStyle == 2)
4620 {
4621 nWinDefBits = WB_DEF_IGNORE;
4622 }
4623 else
4624 {
4625 nWinDefBits = WB_DEF_CANCEL;
4626 }
4627 }
4628 else if( nStyle == 2)
4629 {
4630 nWinDefBits = WB_DEF_CANCEL;
4631 }
4632 nWinBits |= nWinDefBits;
4633
4634 OUString aMsg = rPar.Get(1)->GetOUString();
4635 OUString aTitle;
4636 if( nArgCount >= 4 )
4637 {
4638 aTitle = rPar.Get(3)->GetOUString();
4639 }
4640 else
4641 {
4642 aTitle = Application::GetAppName();
4643 }
4644
4645 nType &= (16+32+64);
4646 VclPtr<MessBox> pBox;
4647
4648 SolarMutexGuard aSolarGuard;
4649
4650 vcl::Window* pParent = Application::GetDefDialogParent();
4651 switch( nType )
4652 {
4653 case 16:
4654 pBox.reset(VclPtr<ErrorBox>::Create( pParent, nWinBits, aMsg ));
4655 break;
4656 case 32:
4657 pBox.reset(VclPtr<QueryBox>::Create( pParent, nWinBits, aMsg ));
4658 break;
4659 case 48:
4660 pBox.reset(VclPtr<WarningBox>::Create( pParent, nWinBits, aMsg ));
4661 break;
4662 case 64:
4663 pBox.reset(VclPtr<InfoBox>::Create( pParent, nWinBits, aMsg ));
4664 break;
4665 default:
4666 pBox.reset(VclPtr<MessBox>::Create( pParent, nWinBits, aTitle, aMsg ));
4667 }
4668 pBox->SetText( aTitle );
4669 short nRet = pBox->Execute();
4670 sal_Int16 nMappedRet;
4671 if( nStyle == 2 )
4672 {
4673 nMappedRet = nRet;
4674 if( nMappedRet == 0 )
4675 {
4676 nMappedRet = 3; // Abort
4677 }
4678 }
4679 else
4680 {
4681 nMappedRet = nButtonMap[ nRet ];
4682 }
4683 rPar.Get(0)->PutInteger( nMappedRet );
4684 pBox.disposeAndClear();
4685 }
4686
4687 RTLFUNC(SetAttr)
4688 {
4689 (void)pBasic;
4690 (void)bWrite;
4691
4692 rPar.Get(0)->PutEmpty();
4693 if ( rPar.Count() == 3 )
4694 {
4695 OUString aStr = rPar.Get(1)->GetOUString();
4696 sal_Int16 nFlags = rPar.Get(2)->GetInteger();
4697
4698 if( hasUno() )
4699 {
4700 uno::Reference< ucb::XSimpleFileAccess3 > xSFI = getFileAccess();
4701 if( xSFI.is() )
4702 {
4703 try
4704 {
4705 bool bReadOnly = (nFlags & Sb_ATTR_READONLY) != 0;
4706 xSFI->setReadOnly( aStr, bReadOnly );
4707 bool bHidden = (nFlags & Sb_ATTR_HIDDEN) != 0;
4708 xSFI->setHidden( aStr, bHidden );
4709 }
4710 catch(const Exception & )
4711 {
4712 StarBASIC::Error( ERRCODE_IO_GENERAL );
4713 }
4714 }
4715 }
4716 }
4717 else
4718 {
4719 StarBASIC::Error( SbERR_BAD_ARGUMENT );
4720 }
4721 }
4722
4723 RTLFUNC(Reset)
4724 {
4725 (void)pBasic;
4726 (void)bWrite;
4727 (void)rPar;
4728
4729 SbiIoSystem* pIO = GetSbData()->pInst->GetIoSystem();
4730 if (pIO)
4731 {
4732 pIO->CloseAll();
4733 }
4734 }
4735
4736 RTLFUNC(DumpAllObjects)
4737 {
4738 (void)pBasic;
4739 (void)bWrite;
4740
4741 sal_uInt16 nArgCount = (sal_uInt16)rPar.Count();
4742 if( nArgCount < 2 || nArgCount > 3 )
4743 {
4744 StarBASIC::Error( SbERR_BAD_ARGUMENT );
4745 }
4746 else if( !pBasic )
4747 {
4748 StarBASIC::Error( SbERR_INTERNAL_ERROR );
4749 }
4750 else
4751 {
4752 SbxObject* p = pBasic;
4753 while( p->GetParent() )
4754 {
4755 p = p->GetParent();
4756 }
4757 SvFileStream aStrm( rPar.Get( 1 )->GetOUString(),
4758 StreamMode::WRITE | StreamMode::TRUNC );
4759 p->Dump( aStrm, rPar.Get( 2 )->GetBool() );
4760 aStrm.Close();
4761 if( aStrm.GetError() != SVSTREAM_OK )
4762 {
4763 StarBASIC::Error( SbERR_IO_ERROR );
4764 }
4765 }
4766 }
4767
4768
4769 RTLFUNC(FileExists)
4770 {
4771 (void)pBasic;
4772 (void)bWrite;
4773
4774 if ( rPar.Count() == 2 )
4775 {
4776 OUString aStr = rPar.Get(1)->GetOUString();
4777 bool bExists = false;
4778
4779 if( hasUno() )
4780 {
4781 uno::Reference< ucb::XSimpleFileAccess3 > xSFI = getFileAccess();
4782 if( xSFI.is() )
4783 {
4784 try
4785 {
4786 bExists = xSFI->exists( aStr );
4787 }
4788 catch(const Exception & )
4789 {
4790 StarBASIC::Error( ERRCODE_IO_GENERAL );
4791 }
4792 }
4793 }
4794 else
4795 {
4796 DirectoryItem aItem;
4797 FileBase::RC nRet = DirectoryItem::get( getFullPath( aStr ), aItem );
4798 bExists = (nRet == FileBase::E_None);
4799 }
4800 rPar.Get(0)->PutBool( bExists );
4801 }
4802 else
4803 {
4804 StarBASIC::Error( SbERR_BAD_ARGUMENT );
4805 }
4806 }
4807
4808 RTLFUNC(Partition)
4809 {
4810 (void)pBasic;
4811 (void)bWrite;
4812
4813 if ( rPar.Count() != 5 )
4814 {
4815 StarBASIC::Error( SbERR_BAD_ARGUMENT );
4816 return;
4817 }
4818
4819 sal_Int32 nNumber = rPar.Get(1)->GetLong();
4820 sal_Int32 nStart = rPar.Get(2)->GetLong();
4821 sal_Int32 nStop = rPar.Get(3)->GetLong();
4822 sal_Int32 nInterval = rPar.Get(4)->GetLong();
4823
4824 if( nStart < 0 || nStop <= nStart || nInterval < 1 )
4825 {
4826 StarBASIC::Error( SbERR_BAD_ARGUMENT );
4827 return;
4828 }
4829
4830 // the Partition function inserts leading spaces before lowervalue and uppervalue
4831 // so that they both have the same number of characters as the string
4832 // representation of the value (Stop + 1). This ensures that if you use the output
4833 // of the Partition function with several values of Number, the resulting text
4834 // will be handled properly during any subsequent sort operation.
4835
4836 // calculate the maximun number of characters before lowervalue and uppervalue
4837 OUString aBeforeStart = OUString::number( nStart - 1 );
4838 OUString aAfterStop = OUString::number( nStop + 1 );
4839 sal_Int32 nLen1 = aBeforeStart.getLength();
4840 sal_Int32 nLen2 = aAfterStop.getLength();
4841 sal_Int32 nLen = nLen1 >= nLen2 ? nLen1:nLen2;
4842
4843 OUStringBuffer aRetStr( nLen * 2 + 1);
4844 OUString aLowerValue;
4845 OUString aUpperValue;
4846 if( nNumber < nStart )
4847 {
4848 aUpperValue = aBeforeStart;
4849 }
4850 else if( nNumber > nStop )
4851 {
4852 aLowerValue = aAfterStop;
4853 }
4854 else
4855 {
4856 sal_Int32 nLowerValue = nNumber;
4857 sal_Int32 nUpperValue = nLowerValue;
4858 if( nInterval > 1 )
4859 {
4860 nLowerValue = ((( nNumber - nStart ) / nInterval ) * nInterval ) + nStart;
4861 nUpperValue = nLowerValue + nInterval - 1;
4862 }
4863 aLowerValue = OUString::number( nLowerValue );
4864 aUpperValue = OUString::number( nUpperValue );
4865 }
4866
4867 nLen1 = aLowerValue.getLength();
4868 nLen2 = aUpperValue.getLength();
4869
4870 if( nLen > nLen1 )
4871 {
4872 // appending the leading spaces for the lowervalue
4873 for ( sal_Int32 i= (nLen - nLen1) ; i > 0; --i )
4874 {
4875 aRetStr.appendAscii(" ");
4876 }
4877 }
4878 aRetStr.append( aLowerValue ).appendAscii(":");
4879 if( nLen > nLen2 )
4880 {
4881 // appending the leading spaces for the uppervalue
4882 for ( sal_Int32 i= (nLen - nLen2) ; i > 0; --i )
4883 {
4884 aRetStr.appendAscii(" ");
4885 }
4886 }
4887 aRetStr.append( aUpperValue );
4888 rPar.Get(0)->PutString( aRetStr.makeStringAndClear());
4889 }
4890
4891 #endif
4892
4893 static long GetDayDiff( const Date& rDate )
4894 {
4895 Date aRefDate( 1,1,1900 );
4896 long nDiffDays;
4897 if ( aRefDate > rDate )
4898 {
4899 nDiffDays = (long)(aRefDate - rDate);
4900 nDiffDays *= -1;
4901 }
4902 else
4903 {
4904 nDiffDays = (long)(rDate - aRefDate);
4905 }
4906 nDiffDays += 2; // adjustment VisualBasic: 1.Jan.1900 == 2
4907 return nDiffDays;
4908 }
4909
4910 sal_Int16 implGetDateYear( double aDate )
4911 {
4912 Date aRefDate( 1,1,1900 );
4913 long nDays = (long) aDate;
4914 nDays -= 2; // standardize: 1.1.1900 => 0.0
4915 aRefDate += nDays;
4916 sal_Int16 nRet = (sal_Int16)( aRefDate.GetYear() );
4917 return nRet;
4918 }
4919
4920 bool implDateSerial( sal_Int16 nYear, sal_Int16 nMonth, sal_Int16 nDay, double& rdRet )
4921 {
4922 #if HAVE_FEATURE_SCRIPTING
4923 if ( nYear < 30 && SbiRuntime::isVBAEnabled() )
4924 {
4925 nYear += 2000;
4926 }
4927 else
4928 #endif
4929 {
4930 if ( nYear < 100 )
4931 {
4932 nYear += 1900;
4933 }
4934 }
4935 Date aCurDate( nDay, nMonth, nYear );
4936 if ((nYear < 100 || nYear > 9999) )
4937 {
4938 #if HAVE_FEATURE_SCRIPTING
4939 StarBASIC::Error( SbERR_BAD_ARGUMENT );
4940 #endif
4941 return false;
4942 }
4943
4944 #if HAVE_FEATURE_SCRIPTING
4945 if ( !SbiRuntime::isVBAEnabled() )
4946 #endif
4947 {
4948 if ( (nMonth < 1 || nMonth > 12 )||
4949 (nDay < 1 || nDay > 31 ) )
4950 {
4951 #if HAVE_FEATURE_SCRIPTING
4952 StarBASIC::Error( SbERR_BAD_ARGUMENT );
4953 #endif
4954 return false;
4955 }
4956 }
4957 #if HAVE_FEATURE_SCRIPTING
4958 else
4959 {
4960 // grab the year & month
4961 aCurDate = Date( 1, (( nMonth % 12 ) > 0 ) ? ( nMonth % 12 ) : 12 + ( nMonth % 12 ), nYear );
4962
4963 // adjust year based on month value
4964 // e.g. 2000, 0, xx = 1999, 12, xx ( or December of the previous year )
4965 // 2000, 13, xx = 2001, 1, xx ( or January of the following year )
4966 if( ( nMonth < 1 ) || ( nMonth > 12 ) )
4967 {
4968 // inacurrate around leap year, don't use days to calculate,
4969 // just modify the months directory
4970 sal_Int16 nYearAdj = ( nMonth /12 ); // default to positive months inputed
4971 if ( nMonth <=0 )
4972 {
4973 nYearAdj = ( ( nMonth -12 ) / 12 );
4974 }
4975 aCurDate.SetYear( aCurDate.GetYear() + nYearAdj );
4976 }
4977
4978 // adjust day value,
4979 // e.g. 2000, 2, 0 = 2000, 1, 31 or the last day of the previous month
4980 // 2000, 1, 32 = 2000, 2, 1 or the first day of the following month
4981 if( ( nDay < 1 ) || ( nDay > aCurDate.GetDaysInMonth() ) )
4982 {
4983 aCurDate += nDay - 1;
4984 }
4985 else
4986 {
4987 aCurDate.SetDay( nDay );
4988 }
4989 }
4990 #endif
4991
4992 long nDiffDays = GetDayDiff( aCurDate );
4993 rdRet = (double)nDiffDays;
4994 return true;
4995 }
4996
4997 double implTimeSerial( sal_Int16 nHours, sal_Int16 nMinutes, sal_Int16 nSeconds )
4998 {
4999 return
5000 static_cast<double>( nHours * ::tools::Time::secondPerHour +
5001 nMinutes * ::tools::Time::secondPerMinute +
5002 nSeconds)
5003 /
5004 static_cast<double>( ::tools::Time::secondPerDay );
5005 }
5006
5007 bool implDateTimeSerial( sal_Int16 nYear, sal_Int16 nMonth, sal_Int16 nDay,
5008 sal_Int16 nHour, sal_Int16 nMinute, sal_Int16 nSecond,
5009 double& rdRet )
5010 {
5011 double dDate;
5012 if(!implDateSerial(nYear, nMonth, nDay, dDate))
5013 return false;
5014 rdRet += dDate + implTimeSerial(nHour, nMinute, nSecond);
5015 return true;
5016 }
5017
5018 sal_Int16 implGetMinute( double dDate )
5019 {
5020 if( dDate < 0.0 )
5021 {
5022 dDate *= -1.0;
5023 }
5024 double nFrac = dDate - floor( dDate );
5025 nFrac *= 86400.0;
5026 sal_Int32 nSeconds = (sal_Int32)(nFrac + 0.5);
5027 sal_Int16 nTemp = (sal_Int16)(nSeconds % 3600);
5028 sal_Int16 nMin = nTemp / 60;
5029 return nMin;
5030 }
5031
5032 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE