basic/source/runtime/methods.cxx

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