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