LCOV - code coverage report
Current view: top level - basic/source/runtime - methods1.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 1522 0.0 %
Date: 2014-04-14 Functions: 0 101 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10