| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| // MARKER(update_precomp.py): autogen include statement, do not remove | |
| #include "precompiled_basic.hxx" | |
| #include "runtime.hxx" | |
| #ifndef GCC | |
| #endif | |
| #include "iosys.hxx" | |
| #include "image.hxx" | |
| #include "sbintern.hxx" | |
| #include "sbunoobj.hxx" | |
| #include "opcodes.hxx" | |
| #include <com/sun/star/container/XIndexAccess.hpp> | |
| #include <com/sun/star/script/XDefaultMethod.hpp> | |
| #include <com/sun/star/beans/XPropertySet.hpp> | |
| #include <com/sun/star/uno/Any.hxx> | |
| #include <comphelper/processfactory.hxx> | |
| using namespace com::sun::star::uno; | |
| using namespace com::sun::star::container; | |
| using namespace com::sun::star::lang; | |
| using namespace com::sun::star::beans; | |
| using namespace com::sun::star::script; | |
| using com::sun::star::uno::Reference; | |
| SbxVariable* getVBAConstant( const String& rName ); | |
| // Suchen eines Elements | |
| // Die Bits im String-ID: | |
| // 0x8000 - Argv ist belegt | |
| SbxVariable* SbiRuntime::FindElement | |
| ( SbxObject* pObj, sal_uInt32 nOp1, sal_uInt32 nOp2, SbError nNotFound, sal_Bool bLocal, sal_Bool bStatic ) | |
| { | |
| bool bIsVBAInterOp = SbiRuntime::isVBAEnabled(); | |
| if( bIsVBAInterOp ) | |
| { | |
| StarBASIC* pMSOMacroRuntimeLib = GetSbData()->pMSOMacroRuntimLib; | |
| if( pMSOMacroRuntimeLib != NULL ) | |
| pMSOMacroRuntimeLib->ResetFlag( SBX_EXTSEARCH ); | |
| } | |
| SbxVariable* pElem = NULL; | |
| if( !pObj ) | |
| { | |
| Error( SbERR_NO_OBJECT ); | |
| pElem = new SbxVariable; | |
| } | |
| else | |
| { | |
| sal_Bool bFatalError = sal_False; | |
| SbxDataType t = (SbxDataType) nOp2; | |
| String aName( pImg->GetString( static_cast<short>( nOp1 & 0x7FFF ) ) ); | |
| // Hacky capture of Evaluate [] syntax | |
| // this should be tackled I feel at the pcode level | |
| if ( bIsVBAInterOp && aName.Search('[') == 0 ) | |
| { | |
| // emulate pcode here | |
| StepARGC(); | |
| // pseudo StepLOADSC | |
| String sArg = aName.Copy( 1, aName.Len() - 2 ); | |
| SbxVariable* p = new SbxVariable; | |
| p->PutString( sArg ); | |
| PushVar( p ); | |
| // | |
| StepARGV(); | |
| nOp1 = nOp1 | 0x8000; // indicate params are present | |
| aName = String::CreateFromAscii("Evaluate"); | |
| } | |
| if( bLocal ) | |
| { | |
| if ( bStatic ) | |
| { | |
| if ( pMeth ) | |
| pElem = pMeth->GetStatics()->Find( aName, SbxCLASS_DONTCARE ); | |
| } | |
| if ( !pElem ) | |
| pElem = refLocals->Find( aName, SbxCLASS_DONTCARE ); | |
| } | |
| if( !pElem ) | |
| { | |
| // Die RTL brauchen wir nicht mehr zu durchsuchen! | |
| sal_Bool bSave = rBasic.bNoRtl; | |
| rBasic.bNoRtl = sal_True; | |
| pElem = pObj->Find( aName, SbxCLASS_DONTCARE ); | |
| // #110004, #112015: Make private really private | |
| if( bLocal && pElem ) // Local as flag for global search | |
| { | |
| if( pElem->IsSet( SBX_PRIVATE ) ) | |
| { | |
| SbiInstance* pInst_ = pINST; | |
| if( pInst_ && pInst_->IsCompatibility() && pObj != pElem->GetParent() ) | |
| pElem = NULL; // Found but in wrong module! | |
| // Interfaces: Use SBX_EXTFOUND | |
| } | |
| } | |
| rBasic.bNoRtl = bSave; | |
| // Ist es ein globaler Uno-Bezeichner? | |
| if( bLocal && !pElem ) | |
| { | |
| bool bSetName = true; // preserve normal behaviour | |
| // i#i68894# if VBAInterOp favour searching vba globals | |
| // over searching for uno classess | |
| if ( bVBAEnabled ) | |
| { | |
| // Try Find in VBA symbols space | |
| pElem = rBasic.VBAFind( aName, SbxCLASS_DONTCARE ); | |
| if ( pElem ) | |
| bSetName = false; // don't overwrite uno name | |
| else | |
| pElem = getVBAConstant( aName ); | |
| } | |
| if( !pElem ) | |
| { | |
| // #72382 VORSICHT! Liefert jetzt wegen unbekannten | |
| // Modulen IMMER ein Ergebnis! | |
| SbUnoClass* pUnoClass = findUnoClass( aName ); | |
| if( pUnoClass ) | |
| { | |
| pElem = new SbxVariable( t ); | |
| SbxValues aRes( SbxOBJECT ); | |
| aRes.pObj = pUnoClass; | |
| pElem->SbxVariable::Put( aRes ); | |
| } | |
| } | |
| // #62939 Wenn eine Uno-Klasse gefunden wurde, muss | |
| // das Wrapper-Objekt gehalten werden, da sonst auch | |
| // die Uno-Klasse, z.B. "stardiv" immer wieder neu | |
| // aus der Registry gelesen werden muss | |
| if( pElem ) | |
| { | |
| // #63774 Darf nicht mit gespeichert werden!!! | |
| pElem->SetFlag( SBX_DONTSTORE ); | |
| pElem->SetFlag( SBX_NO_MODIFY); | |
| // #72382 Lokal speichern, sonst werden alle implizit | |
| // deklarierten Vars automatisch global ! | |
| if ( bSetName ) | |
| pElem->SetName( aName ); | |
| refLocals->Put( pElem, refLocals->Count() ); | |
| } | |
| } | |
| if( !pElem ) | |
| { | |
| // Nicht da und nicht im Objekt? | |
| // Hat das Ding Parameter, nicht einrichten! | |
| if( nOp1 & 0x8000 ) | |
| bFatalError = sal_True; | |
| // ALT: StarBASIC::FatalError( nNotFound ); | |
| // Sonst, falls keine Parameter sind, anderen Error Code verwenden | |
| if( !bLocal || pImg->GetFlag( SBIMG_EXPLICIT ) ) | |
| { | |
| // #39108 Bei explizit und als ELEM immer ein Fatal Error | |
| bFatalError = sal_True; | |
| // Falls keine Parameter sind, anderen Error Code verwenden | |
| if( !( nOp1 & 0x8000 ) && nNotFound == SbERR_PROC_UNDEFINED ) | |
| nNotFound = SbERR_VAR_UNDEFINED; | |
| } | |
| if( bFatalError ) | |
| { | |
| // #39108 Statt FatalError zu setzen, Dummy-Variable liefern | |
| if( !xDummyVar.Is() ) | |
| xDummyVar = new SbxVariable( SbxVARIANT ); | |
| pElem = xDummyVar; | |
| // Parameter von Hand loeschen | |
| ClearArgvStack(); | |
| // Normalen Error setzen | |
| Error( nNotFound, aName ); | |
| } | |
| else | |
| { | |
| if ( bStatic ) | |
| pElem = StepSTATIC_Impl( aName, t ); | |
| if ( !pElem ) | |
| { | |
| // Sonst Variable neu anlegen | |
| pElem = new SbxVariable( t ); | |
| if( t != SbxVARIANT ) | |
| pElem->SetFlag( SBX_FIXED ); | |
| pElem->SetName( aName ); | |
| refLocals->Put( pElem, refLocals->Count() ); | |
| } | |
| } | |
| } | |
| } | |
| // #39108 Args koennen schon geloescht sein! | |
| if( !bFatalError ) | |
| SetupArgs( pElem, nOp1 ); | |
| // Ein bestimmter Call-Type wurde gewuenscht, daher muessen | |
| // wir hier den Typ setzen und das Ding anfassen, um den | |
| // korrekten Returnwert zu erhalten! | |
| if( pElem->IsA( TYPE(SbxMethod) ) ) | |
| { | |
| // Soll der Typ konvertiert werden? | |
| SbxDataType t2 = pElem->GetType(); | |
| sal_Bool bSet = sal_False; | |
| if( !( pElem->GetFlags() & SBX_FIXED ) ) | |
| { | |
| if( t != SbxVARIANT && t != t2 && | |
| t >= SbxINTEGER && t <= SbxSTRING ) | |
| pElem->SetType( t ), bSet = sal_True; | |
| } | |
| // pElem auf eine Ref zuweisen, um ggf. eine Temp-Var zu loeschen | |
| SbxVariableRef refTemp = pElem; | |
| // Moegliche Reste vom letzten Aufruf der SbxMethod beseitigen | |
| // Vorher Schreiben freigeben, damit kein Error gesetzt wird. | |
| sal_uInt16 nSavFlags = pElem->GetFlags(); | |
| pElem->SetFlag( SBX_READWRITE | SBX_NO_BROADCAST ); | |
| pElem->SbxValue::Clear(); | |
| pElem->SetFlags( nSavFlags ); | |
| // Erst nach dem Setzen anfassen, da z.B. LEFT() | |
| // den Unterschied zwischen Left$() und Left() kennen muss | |
| // AB 12.8.96: Da in PopVar() die Parameter von Methoden weggehauen | |
| // werden, muessen wir hier explizit eine neue SbxMethod anlegen | |
| SbxVariable* pNew = new SbxMethod( *((SbxMethod*)pElem) ); // das ist der Call! | |
| //ALT: SbxVariable* pNew = new SbxVariable( *pElem ); // das ist der Call! | |
| pElem->SetParameters(0); // sonst bleibt Ref auf sich selbst | |
| pNew->SetFlag( SBX_READWRITE ); | |
| // den Datentypen zuruecksetzen? | |
| if( bSet ) | |
| pElem->SetType( t2 ); | |
| pElem = pNew; | |
| } | |
| // Index-Access bei UnoObjekten beruecksichtigen | |
| // definitely we want this for VBA where properties are often | |
| // collections ( which need index access ), but lets only do | |
| // this if we actually have params following | |
| else if( bVBAEnabled && pElem->ISA(SbUnoProperty) && pElem->GetParameters() ) | |
| { | |
| // pElem auf eine Ref zuweisen, um ggf. eine Temp-Var zu loeschen | |
| SbxVariableRef refTemp = pElem; | |
| // Variable kopieren und dabei den Notify aufloesen | |
| SbxVariable* pNew = new SbxVariable( *((SbxVariable*)pElem) ); // das ist der Call! | |
| pElem->SetParameters( NULL ); // sonst bleibt Ref auf sich selbst | |
| pElem = pNew; | |
| } | |
| } | |
| return CheckArray( pElem ); | |
| } | |
| // Find-Funktion ueber Name fuer aktuellen Scope (z.B. Abfrage aus BASIC-IDE) | |
| SbxBase* SbiRuntime::FindElementExtern( const String& rName ) | |
| { | |
| // Hinweis zu #35281#: Es darf nicht davon ausgegangen werden, dass | |
| // pMeth != null, da im RunInit noch keine gesetzt ist. | |
| SbxVariable* pElem = NULL; | |
| if( !pMod || !rName.Len() ) | |
| return NULL; | |
| // Lokal suchen | |
| if( refLocals ) | |
| pElem = refLocals->Find( rName, SbxCLASS_DONTCARE ); | |
| // In Statics suchen | |
| if ( !pElem && pMeth ) | |
| { | |
| // Bei Statics, Name der Methode davor setzen | |
| String aMethName = pMeth->GetName(); | |
| aMethName += ':'; | |
| aMethName += rName; | |
| pElem = pMod->Find(aMethName, SbxCLASS_DONTCARE); | |
| } | |
| // In Parameter-Liste suchen | |
| if( !pElem && pMeth ) | |
| { | |
| SbxInfo* pInfo = pMeth->GetInfo(); | |
| if( pInfo && refParams ) | |
| { | |
| sal_uInt16 nParamCount = refParams->Count(); | |
| sal_uInt16 j = 1; | |
| const SbxParamInfo* pParam = pInfo->GetParam( j ); | |
| while( pParam ) | |
| { | |
| if( pParam->aName.EqualsIgnoreCaseAscii( rName ) ) | |
| { | |
| if( j >= nParamCount ) | |
| { | |
| // Parameter is missing | |
| pElem = new SbxVariable( SbxSTRING ); | |
| pElem->PutString( String( RTL_CONSTASCII_USTRINGPARAM("<missing parameter>" ) ) ); | |
| } | |
| else | |
| { | |
| pElem = refParams->Get( j ); | |
| } | |
| break; | |
| } | |
| pParam = pInfo->GetParam( ++j ); | |
| } | |
| } | |
| } | |
| // Im Modul suchen | |
| if( !pElem ) | |
| { | |
| // RTL nicht durchsuchen! | |
| sal_Bool bSave = rBasic.bNoRtl; | |
| rBasic.bNoRtl = sal_True; | |
| pElem = pMod->Find( rName, SbxCLASS_DONTCARE ); | |
| rBasic.bNoRtl = bSave; | |
| } | |
| return pElem; | |
| } | |
| // Argumente eines Elements setzen | |
| // Dabei auch die Argumente umsetzen, falls benannte Parameter | |
| // verwendet wurden | |
| void SbiRuntime::SetupArgs( SbxVariable* p, sal_uInt32 nOp1 ) | |
| { | |
| if( nOp1 & 0x8000 ) | |
| { | |
| if( !refArgv ) | |
| StarBASIC::FatalError( SbERR_INTERNAL_ERROR ); | |
| sal_Bool bHasNamed = sal_False; | |
| sal_uInt16 i; | |
| sal_uInt16 nArgCount = refArgv->Count(); | |
| for( i = 1 ; i < nArgCount ; i++ ) | |
| { | |
| if( refArgv->GetAlias( i ).Len() ) | |
| { | |
| bHasNamed = sal_True; break; | |
| } | |
| } | |
| if( bHasNamed ) | |
| { | |
| // Wir haben mindestens einen benannten Parameter! | |
| // Wir muessen also umsortieren | |
| // Gibt es Parameter-Infos? | |
| SbxInfo* pInfo = p->GetInfo(); | |
| if( !pInfo ) | |
| { | |
| bool bError_ = true; | |
| SbUnoMethod* pUnoMethod = PTR_CAST(SbUnoMethod,p); | |
| SbUnoProperty* pUnoProperty = PTR_CAST(SbUnoProperty,p); | |
| if( pUnoMethod || pUnoProperty ) | |
| { | |
| SbUnoObject* pParentUnoObj = PTR_CAST( SbUnoObject,p->GetParent() ); | |
| if( pParentUnoObj ) | |
| { | |
| Any aUnoAny = pParentUnoObj->getUnoAny(); | |
| Reference< XInvocation > xInvocation; | |
| aUnoAny >>= xInvocation; | |
| if( xInvocation.is() ) // TODO: if( xOLEAutomation.is() ) | |
| { | |
| bError_ = false; | |
| sal_uInt16 nCurPar = 1; | |
| AutomationNamedArgsSbxArray* pArg = | |
| new AutomationNamedArgsSbxArray( nArgCount ); | |
| ::rtl::OUString* pNames = pArg->getNames().getArray(); | |
| for( i = 1 ; i < nArgCount ; i++ ) | |
| { | |
| SbxVariable* pVar = refArgv->Get( i ); | |
| const String& rName = refArgv->GetAlias( i ); | |
| if( rName.Len() ) | |
| pNames[i] = rName; | |
| pArg->Put( pVar, nCurPar++ ); | |
| } | |
| refArgv = pArg; | |
| } | |
| } | |
| } | |
| else if( bVBAEnabled && p->GetType() == SbxOBJECT && (!p->ISA(SbxMethod) || !p->IsBroadcaster()) ) | |
| { | |
| // Check for default method with named parameters | |
| SbxBaseRef pObj = (SbxBase*)p->GetObject(); | |
| if( pObj && pObj->ISA(SbUnoObject) ) | |
| { | |
| SbUnoObject* pUnoObj = (SbUnoObject*)(SbxBase*)pObj; | |
| Any aAny = pUnoObj->getUnoAny(); | |
| if( aAny.getValueType().getTypeClass() == TypeClass_INTERFACE ) | |
| { | |
| Reference< XInterface > x = *(Reference< XInterface >*)aAny.getValue(); | |
| Reference< XDefaultMethod > xDfltMethod( x, UNO_QUERY ); | |
| rtl::OUString sDefaultMethod; | |
| if ( xDfltMethod.is() ) | |
| sDefaultMethod = xDfltMethod->getDefaultMethodName(); | |
| if ( !sDefaultMethod.isEmpty() ) | |
| { | |
| SbxVariable* meth = pUnoObj->Find( sDefaultMethod, SbxCLASS_METHOD ); | |
| if( meth != NULL ) | |
| pInfo = meth->GetInfo(); | |
| if( pInfo ) | |
| bError_ = false; | |
| } | |
| } | |
| } | |
| } | |
| if( bError_ ) | |
| Error( SbERR_NO_NAMED_ARGS ); | |
| } | |
| else | |
| { | |
| sal_uInt16 nCurPar = 1; | |
| SbxArray* pArg = new SbxArray; | |
| for( i = 1 ; i < nArgCount ; i++ ) | |
| { | |
| SbxVariable* pVar = refArgv->Get( i ); | |
| const String& rName = refArgv->GetAlias( i ); | |
| if( rName.Len() ) | |
| { | |
| // nCurPar wird auf den gefundenen Parameter gesetzt | |
| sal_uInt16 j = 1; | |
| const SbxParamInfo* pParam = pInfo->GetParam( j ); | |
| while( pParam ) | |
| { | |
| if( pParam->aName.EqualsIgnoreCaseAscii( rName ) ) | |
| { | |
| nCurPar = j; | |
| break; | |
| } | |
| pParam = pInfo->GetParam( ++j ); | |
| } | |
| if( !pParam ) | |
| { | |
| Error( SbERR_NAMED_NOT_FOUND ); break; | |
| } | |
| } | |
| pArg->Put( pVar, nCurPar++ ); | |
| } | |
| refArgv = pArg; | |
| } | |
| } | |
| // Eigene Var als Parameter 0 | |
| refArgv->Put( p, 0 ); | |
| p->SetParameters( refArgv ); | |
| PopArgv(); | |
| } | |
| else | |
| p->SetParameters( NULL ); | |
| } | |
| // Holen eines Array-Elements | |
| SbxVariable* SbiRuntime::CheckArray( SbxVariable* pElem ) | |
| { | |
| // Falls wir ein Array haben, wollen wir bitte das Array-Element! | |
| SbxArray* pPar; | |
| if( pElem->GetType() & SbxARRAY ) | |
| { | |
| SbxBase* pElemObj = pElem->GetObject(); | |
| SbxDimArray* pDimArray = PTR_CAST(SbxDimArray,pElemObj); | |
| pPar = pElem->GetParameters(); | |
| if( pDimArray ) | |
| { | |
| // Die Parameter koennen fehlen, wenn ein Array als | |
| // Argument uebergeben wird. | |
| if( pPar ) | |
| pElem = pDimArray->Get( pPar ); | |
| } | |
| else | |
| { | |
| SbxArray* pArray = PTR_CAST(SbxArray,pElemObj); | |
| if( pArray ) | |
| { | |
| if( !pPar ) | |
| { | |
| Error( SbERR_OUT_OF_RANGE ); | |
| pElem = new SbxVariable; | |
| } | |
| else | |
| pElem = pArray->Get( pPar->Get( 1 )->GetInteger() ); | |
| } | |
| } | |
| // #42940, 0.Parameter zu NULL setzen, damit sich Var nicht selbst haelt | |
| if( pPar ) | |
| pPar->Put( NULL, 0 ); | |
| } | |
| // Index-Access bei UnoObjekten beruecksichtigen | |
| else if( pElem->GetType() == SbxOBJECT && (!pElem->ISA(SbxMethod) || (bVBAEnabled && !pElem->IsBroadcaster()) ) ) | |
| { | |
| pPar = pElem->GetParameters(); | |
| if ( pPar ) | |
| { | |
| // Ist es ein Uno-Objekt? | |
| SbxBaseRef pObj = (SbxBase*)pElem->GetObject(); | |
| if( pObj ) | |
| { | |
| if( pObj->ISA(SbUnoObject) ) | |
| { | |
| SbUnoObject* pUnoObj = (SbUnoObject*)(SbxBase*)pObj; | |
| Any aAny = pUnoObj->getUnoAny(); | |
| if( aAny.getValueType().getTypeClass() == TypeClass_INTERFACE ) | |
| { | |
| Reference< XInterface > x = *(Reference< XInterface >*)aAny.getValue(); | |
| Reference< XIndexAccess > xIndexAccess( x, UNO_QUERY ); | |
| if ( !bVBAEnabled ) | |
| { | |
| // Haben wir Index-Access? | |
| if( xIndexAccess.is() ) | |
| { | |
| sal_uInt32 nParamCount = (sal_uInt32)pPar->Count() - 1; | |
| if( nParamCount != 1 ) | |
| { | |
| StarBASIC::Error( SbERR_BAD_ARGUMENT ); | |
| return pElem; | |
| } | |
| // Index holen | |
| sal_Int32 nIndex = pPar->Get( 1 )->GetLong(); | |
| Reference< XInterface > xRet; | |
| try | |
| { | |
| Any aAny2 = xIndexAccess->getByIndex( nIndex ); | |
| TypeClass eType = aAny2.getValueType().getTypeClass(); | |
| if( eType == TypeClass_INTERFACE ) | |
| xRet = *(Reference< XInterface >*)aAny2.getValue(); | |
| } | |
| catch (IndexOutOfBoundsException&) | |
| { | |
| // Bei Exception erstmal immer von Konvertierungs-Problem ausgehen | |
| StarBASIC::Error( SbERR_OUT_OF_RANGE ); | |
| } | |
| // #57847 Immer neue Variable anlegen, sonst Fehler | |
| // durch PutObject(NULL) bei ReadOnly-Properties. | |
| pElem = new SbxVariable( SbxVARIANT ); | |
| if( xRet.is() ) | |
| { | |
| aAny <<= xRet; | |
| // #67173 Kein Namen angeben, damit echter Klassen-Namen eintragen wird | |
| String aName; | |
| SbxObjectRef xWrapper = (SbxObject*)new SbUnoObject( aName, aAny ); | |
| pElem->PutObject( xWrapper ); | |
| } | |
| else | |
| { | |
| pElem->PutObject( NULL ); | |
| } | |
| } | |
| } | |
| else | |
| { | |
| rtl::OUString sDefaultMethod; | |
| Reference< XDefaultMethod > xDfltMethod( x, UNO_QUERY ); | |
| if ( xDfltMethod.is() ) | |
| sDefaultMethod = xDfltMethod->getDefaultMethodName(); | |
| else if( xIndexAccess.is() ) | |
| sDefaultMethod = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "getByIndex" ) ); | |
| if ( !sDefaultMethod.isEmpty() ) | |
| { | |
| SbxVariable* meth = pUnoObj->Find( sDefaultMethod, SbxCLASS_METHOD ); | |
| SbxVariableRef refTemp = meth; | |
| if ( refTemp ) | |
| { | |
| meth->SetParameters( pPar ); | |
| SbxVariable* pNew = new SbxMethod( *(SbxMethod*)meth ); | |
| pElem = pNew; | |
| } | |
| } | |
| } | |
| } | |
| // #42940, 0.Parameter zu NULL setzen, damit sich Var nicht selbst haelt | |
| pPar->Put( NULL, 0 ); | |
| } | |
| else if( pObj->ISA(BasicCollection) ) | |
| { | |
| BasicCollection* pCol = (BasicCollection*)(SbxBase*)pObj; | |
| pElem = new SbxVariable( SbxVARIANT ); | |
| pPar->Put( pElem, 0 ); | |
| pCol->CollItem( pPar ); | |
| } | |
| } | |
| else if( bVBAEnabled ) // !pObj | |
| { | |
| SbxArray* pParam = pElem->GetParameters(); | |
| if( pParam != NULL && !pElem->IsSet( SBX_VAR_TO_DIM ) ) | |
| Error( SbERR_NO_OBJECT ); | |
| } | |
| } | |
| } | |
| return pElem; | |
| } | |
| // Laden eines Elements aus der Runtime-Library (+StringID+Typ) | |
| void SbiRuntime::StepRTL( sal_uInt32 nOp1, sal_uInt32 nOp2 ) | |
| { | |
| PushVar( FindElement( rBasic.pRtl, nOp1, nOp2, SbERR_PROC_UNDEFINED, sal_False ) ); | |
| } | |
| void | |
| SbiRuntime::StepFIND_Impl( SbxObject* pObj, sal_uInt32 nOp1, sal_uInt32 nOp2, SbError nNotFound, sal_Bool bLocal, sal_Bool bStatic ) | |
| { | |
| if( !refLocals ) | |
| refLocals = new SbxArray; | |
| PushVar( FindElement( pObj, nOp1, nOp2, nNotFound, bLocal, bStatic ) ); | |
| } | |
| // Laden einer lokalen/globalen Variablen (+StringID+Typ) | |
| void SbiRuntime::StepFIND( sal_uInt32 nOp1, sal_uInt32 nOp2 ) | |
| { | |
| StepFIND_Impl( pMod, nOp1, nOp2, SbERR_PROC_UNDEFINED, sal_True ); | |
| } | |
| // Search inside a class module (CM) to enable global search in time | |
| void SbiRuntime::StepFIND_CM( sal_uInt32 nOp1, sal_uInt32 nOp2 ) | |
| { | |
| SbClassModuleObject* pClassModuleObject = PTR_CAST(SbClassModuleObject,pMod); | |
| if( pClassModuleObject ) | |
| pMod->SetFlag( SBX_GBLSEARCH ); | |
| StepFIND_Impl( pMod, nOp1, nOp2, SbERR_PROC_UNDEFINED, sal_True ); | |
| if( pClassModuleObject ) | |
| pMod->ResetFlag( SBX_GBLSEARCH ); | |
| } | |
| void SbiRuntime::StepFIND_STATIC( sal_uInt32 nOp1, sal_uInt32 nOp2 ) | |
| { | |
| StepFIND_Impl( pMod, nOp1, nOp2, SbERR_PROC_UNDEFINED, sal_True, sal_True ); | |
| } | |
| // Laden eines Objekt-Elements (+StringID+Typ) | |
| // Das Objekt liegt auf TOS | |
| void SbiRuntime::StepELEM( sal_uInt32 nOp1, sal_uInt32 nOp2 ) | |
| { | |
| // Liegt auf dem TOS ein Objekt? | |
| SbxVariableRef pObjVar = PopVar(); | |
| SbxObject* pObj = PTR_CAST(SbxObject,(SbxVariable*) pObjVar); | |
| if( !pObj ) | |
| { | |
| SbxBase* pObjVarObj = pObjVar->GetObject(); | |
| pObj = PTR_CAST(SbxObject,pObjVarObj); | |
| } | |
| // #56368 Bei StepElem Referenz sichern, sonst koennen Objekte | |
| // in Qualifizierungsketten wie ActiveComponent.Selection(0).Text | |
| // zu fueh die Referenz verlieren | |
| // #74254 Jetzt per Liste | |
| if( pObj ) | |
| SaveRef( (SbxVariable*)pObj ); | |
| PushVar( FindElement( pObj, nOp1, nOp2, SbERR_NO_METHOD, sal_False ) ); | |
| } | |
| // Laden eines Parameters (+Offset+Typ) | |
| // Wenn der Datentyp nicht stimmen sollte, eine Kopie anlegen | |
| // Der Datentyp SbxEMPTY zeigt an, daa kein Parameter angegeben ist. | |
| // Get( 0 ) darf EMPTY sein | |
| void SbiRuntime::StepPARAM( sal_uInt32 nOp1, sal_uInt32 nOp2 ) | |
| { | |
| sal_uInt16 i = static_cast<sal_uInt16>( nOp1 & 0x7FFF ); | |
| SbxDataType t = (SbxDataType) nOp2; | |
| SbxVariable* p; | |
| // #57915 Missing sauberer loesen | |
| sal_uInt16 nParamCount = refParams->Count(); | |
| if( i >= nParamCount ) | |
| { | |
| sal_Int16 iLoop = i; | |
| while( iLoop >= nParamCount ) | |
| { | |
| p = new SbxVariable(); | |
| if( SbiRuntime::isVBAEnabled() && | |
| (t == SbxOBJECT || t == SbxSTRING) ) | |
| { | |
| if( t == SbxOBJECT ) | |
| p->PutObject( NULL ); | |
| else | |
| p->PutString( String() ); | |
| } | |
| else | |
| p->PutErr( 448 ); // Wie in VB: Error-Code 448 (SbERR_NAMED_NOT_FOUND) | |
| refParams->Put( p, iLoop ); | |
| iLoop--; | |
| } | |
| } | |
| p = refParams->Get( i ); | |
| if( p->GetType() == SbxERROR && ( i ) ) | |
| //if( p->GetType() == SbxEMPTY && ( i ) ) | |
| { | |
| // Wenn ein Parameter fehlt, kann er OPTIONAL sein | |
| sal_Bool bOpt = sal_False; | |
| if( pMeth ) | |
| { | |
| SbxInfo* pInfo = pMeth->GetInfo(); | |
| if ( pInfo ) | |
| { | |
| const SbxParamInfo* pParam = pInfo->GetParam( i ); | |
| if( pParam && ( (pParam->nFlags & SBX_OPTIONAL) != 0 ) ) | |
| { | |
| // Default value? | |
| sal_uInt16 nDefaultId = sal::static_int_cast< sal_uInt16 >( | |
| pParam->nUserData & 0xffff ); | |
| if( nDefaultId > 0 ) | |
| { | |
| String aDefaultStr = pImg->GetString( nDefaultId ); | |
| p = new SbxVariable(); | |
| p->PutString( aDefaultStr ); | |
| refParams->Put( p, i ); | |
| } | |
| bOpt = sal_True; | |
| } | |
| } | |
| } | |
| if( bOpt == sal_False ) | |
| Error( SbERR_NOT_OPTIONAL ); | |
| } | |
| else if( t != SbxVARIANT && (SbxDataType)(p->GetType() & 0x0FFF ) != t ) | |
| { | |
| SbxVariable* q = new SbxVariable( t ); | |
| SaveRef( q ); | |
| *q = *p; | |
| p = q; | |
| } | |
| SetupArgs( p, nOp1 ); | |
| PushVar( CheckArray( p ) ); | |
| } | |
| // Case-Test (+True-Target+Test-Opcode) | |
| void SbiRuntime::StepCASEIS( sal_uInt32 nOp1, sal_uInt32 nOp2 ) | |
| { | |
| if( !refCaseStk || !refCaseStk->Count() ) | |
| StarBASIC::FatalError( SbERR_INTERNAL_ERROR ); | |
| else | |
| { | |
| SbxVariableRef xComp = PopVar(); | |
| SbxVariableRef xCase = refCaseStk->Get( refCaseStk->Count() - 1 ); | |
| if( xCase->Compare( (SbxOperator) nOp2, *xComp ) ) | |
| StepJUMP( nOp1 ); | |
| } | |
| } | |
| // Aufruf einer DLL-Prozedur (+StringID+Typ) | |
| // Auch hier zeigt das MSB des StringIDs an, dass Argv belegt ist | |
| void SbiRuntime::StepCALL( sal_uInt32 nOp1, sal_uInt32 nOp2 ) | |
| { | |
| String aName = pImg->GetString( static_cast<short>( nOp1 & 0x7FFF ) ); | |
| SbxArray* pArgs = NULL; | |
| if( nOp1 & 0x8000 ) | |
| pArgs = refArgv; | |
| DllCall( aName, aLibName, pArgs, (SbxDataType) nOp2, sal_False ); | |
| aLibName = String(); | |
| if( nOp1 & 0x8000 ) | |
| PopArgv(); | |
| } | |
| // Aufruf einer DLL-Prozedur nach CDecl (+StringID+Typ) | |
| // Auch hier zeigt das MSB des StringIDs an, dass Argv belegt ist | |
| void SbiRuntime::StepCALLC( sal_uInt32 nOp1, sal_uInt32 nOp2 ) | |
| { | |
| String aName = pImg->GetString( static_cast<short>( nOp1 & 0x7FFF ) ); | |
| SbxArray* pArgs = NULL; | |
| if( nOp1 & 0x8000 ) | |
| pArgs = refArgv; | |
| DllCall( aName, aLibName, pArgs, (SbxDataType) nOp2, sal_True ); | |
| aLibName = String(); | |
| if( nOp1 & 0x8000 ) | |
| PopArgv(); | |
| } | |
| // Beginn eines Statements (+Line+Col) | |
| void SbiRuntime::StepSTMNT( sal_uInt32 nOp1, sal_uInt32 nOp2 ) | |
| { | |
| // Wenn der Expr-Stack am Anfang einen Statements eine Variable enthaelt, | |
| // hat ein Trottel X als Funktion aufgerufen, obwohl es eine Variable ist! | |
| sal_Bool bFatalExpr = sal_False; | |
| String sUnknownMethodName; | |
| if( nExprLvl > 1 ) | |
| bFatalExpr = sal_True; | |
| else if( nExprLvl ) | |
| { | |
| SbxVariable* p = refExprStk->Get( 0 ); | |
| if( p->GetRefCount() > 1 | |
| && refLocals.Is() && refLocals->Find( p->GetName(), p->GetClass() ) ) | |
| { | |
| sUnknownMethodName = p->GetName(); | |
| bFatalExpr = sal_True; | |
| } | |
| } | |
| // Der Expr-Stack ist nun nicht mehr notwendig | |
| ClearExprStack(); | |
| // #56368 Kuenstliche Referenz fuer StepElem wieder freigeben, | |
| // damit sie nicht ueber ein Statement hinaus erhalten bleibt | |
| //refSaveObj = NULL; | |
| // #74254 Jetzt per Liste | |
| ClearRefs(); | |
| // Wir muessen hier hart abbrechen, da sonst Zeile und Spalte nicht mehr | |
| // stimmen! | |
| if( bFatalExpr) | |
| { | |
| StarBASIC::FatalError( SbERR_NO_METHOD, sUnknownMethodName ); | |
| return; | |
| } | |
| pStmnt = pCode - 9; | |
| sal_uInt16 nOld = nLine; | |
| nLine = static_cast<short>( nOp1 ); | |
| // #29955 & 0xFF, um for-Schleifen-Ebene wegzufiltern | |
| nCol1 = static_cast<short>( nOp2 & 0xFF ); | |
| // Suchen des naechsten STMNT-Befehls, | |
| // um die End-Spalte dieses Statements zu setzen | |
| // Searches of the next STMNT instruction, | |
| // around the final column of this statement to set | |
| nCol2 = 0xffff; | |
| sal_uInt16 n1, n2; | |
| const sal_uInt8* p = pMod->FindNextStmnt( pCode, n1, n2 ); | |
| if( p ) | |
| { | |
| if( n1 == nOp1 ) | |
| { | |
| // #29955 & 0xFF, um for-Schleifen-Ebene wegzufiltern | |
| nCol2 = (n2 & 0xFF) - 1; | |
| } | |
| } | |
| // #29955 for-Schleifen-Ebene korrigieren, #67452 NICHT im Error-Handler sonst Chaos | |
| if( !bInError ) | |
| { | |
| // (Bei Sprüngen aus Schleifen tritt hier eine Differenz auf) | |
| sal_uInt16 nExspectedForLevel = static_cast<sal_uInt16>( nOp2 / 0x100 ); | |
| if( pGosubStk ) | |
| nExspectedForLevel = nExspectedForLevel + pGosubStk->nStartForLvl; | |
| // Wenn der tatsaechliche For-Level zu klein ist, wurde aus | |
| // einer Schleife heraus gesprungen -> korrigieren | |
| while( nForLvl > nExspectedForLevel ) | |
| PopFor(); | |
| } | |
| // 16.10.96: #31460 Neues Konzept fuer StepInto/Over/Out | |
| // Erklärung siehe bei _ImplGetBreakCallLevel. | |
| if( pInst->nCallLvl <= pInst->nBreakCallLvl ) | |
| //if( nFlags & SbDEBUG_STEPINTO ) | |
| { | |
| StarBASIC* pStepBasic = GetCurrentBasic( &rBasic ); | |
| sal_uInt16 nNewFlags = pStepBasic->StepPoint( nLine, nCol1, nCol2 ); | |
| // Neuen BreakCallLevel ermitteln | |
| pInst->CalcBreakCallLevel( nNewFlags ); | |
| } | |
| // Breakpoints nur bei STMNT-Befehlen in neuer Zeile! | |
| else if( ( nOp1 != nOld ) | |
| && ( nFlags & SbDEBUG_BREAK ) | |
| && pMod->IsBP( static_cast<sal_uInt16>( nOp1 ) ) ) | |
| { | |
| StarBASIC* pBreakBasic = GetCurrentBasic( &rBasic ); | |
| sal_uInt16 nNewFlags = pBreakBasic->BreakPoint( nLine, nCol1, nCol2 ); | |
| // Neuen BreakCallLevel ermitteln | |
| pInst->CalcBreakCallLevel( nNewFlags ); | |
| //16.10.96, ALT: | |
| //if( nNewFlags != SbDEBUG_CONTINUE ) | |
| // nFlags = nNewFlags; | |
| } | |
| } | |
| // (+SvStreamFlags+Flags) | |
| // Stack: Blocklaenge | |
| // Kanalnummer | |
| // Dateiname | |
| void SbiRuntime::StepOPEN( sal_uInt32 nOp1, sal_uInt32 nOp2 ) | |
| { | |
| SbxVariableRef pName = PopVar(); | |
| SbxVariableRef pChan = PopVar(); | |
| SbxVariableRef pLen = PopVar(); | |
| short nBlkLen = pLen->GetInteger(); | |
| short nChan = pChan->GetInteger(); | |
| ByteString aName( pName->GetString(), gsl_getSystemTextEncoding() ); | |
| pIosys->Open( nChan, aName, static_cast<short>( nOp1 ), | |
| static_cast<short>( nOp2 ), nBlkLen ); | |
| Error( pIosys->GetError() ); | |
| } | |
| // Objekt kreieren (+StringID+StringID) | |
| void SbiRuntime::StepCREATE( sal_uInt32 nOp1, sal_uInt32 nOp2 ) | |
| { | |
| String aClass( pImg->GetString( static_cast<short>( nOp2 ) ) ); | |
| SbxObject *pObj = SbxBase::CreateObject( aClass ); | |
| if( !pObj ) | |
| Error( SbERR_INVALID_OBJECT ); | |
| else | |
| { | |
| String aName( pImg->GetString( static_cast<short>( nOp1 ) ) ); | |
| pObj->SetName( aName ); | |
| // Das Objekt muss BASIC rufen koennen | |
| pObj->SetParent( &rBasic ); | |
| SbxVariable* pNew = new SbxVariable; | |
| pNew->PutObject( pObj ); | |
| PushVar( pNew ); | |
| } | |
| } | |
| void SbiRuntime::StepDCREATE( sal_uInt32 nOp1, sal_uInt32 nOp2 ) | |
| { | |
| StepDCREATE_IMPL( nOp1, nOp2 ); | |
| } | |
| void SbiRuntime::StepDCREATE_REDIMP( sal_uInt32 nOp1, sal_uInt32 nOp2 ) | |
| { | |
| StepDCREATE_IMPL( nOp1, nOp2 ); | |
| } | |
| // Helper function for StepDCREATE_IMPL / bRedimp = true | |
| void implCopyDimArray_DCREATE( SbxDimArray* pNewArray, SbxDimArray* pOldArray, short nMaxDimIndex, | |
| short nActualDim, sal_Int32* pActualIndices, sal_Int32* pLowerBounds, sal_Int32* pUpperBounds ) | |
| { | |
| sal_Int32& ri = pActualIndices[nActualDim]; | |
| for( ri = pLowerBounds[nActualDim] ; ri <= pUpperBounds[nActualDim] ; ri++ ) | |
| { | |
| if( nActualDim < nMaxDimIndex ) | |
| { | |
| implCopyDimArray_DCREATE( pNewArray, pOldArray, nMaxDimIndex, nActualDim + 1, | |
| pActualIndices, pLowerBounds, pUpperBounds ); | |
| } | |
| else | |
| { | |
| SbxVariable* pSource = pOldArray->Get32( pActualIndices ); | |
| pNewArray->Put32( pSource, pActualIndices ); | |
| } | |
| } | |
| } | |
| // #56204 Objekt-Array kreieren (+StringID+StringID), DCREATE == Dim-Create | |
| void SbiRuntime::StepDCREATE_IMPL( sal_uInt32 nOp1, sal_uInt32 nOp2 ) | |
| { | |
| SbxVariableRef refVar = PopVar(); | |
| DimImpl( refVar ); | |
| // Das Array mit Instanzen der geforderten Klasse fuellen | |
| SbxBaseRef xObj = (SbxBase*)refVar->GetObject(); | |
| if( !xObj ) | |
| { | |
| StarBASIC::Error( SbERR_INVALID_OBJECT ); | |
| return; | |
| } | |
| SbxDimArray* pArray = 0; | |
| if( xObj->ISA(SbxDimArray) ) | |
| { | |
| SbxBase* pObj = (SbxBase*)xObj; | |
| pArray = (SbxDimArray*)pObj; | |
| // Dimensionen auswerten | |
| short nDims = pArray->GetDims(); | |
| sal_Int32 nTotalSize = 0; | |
| // es muss ein eindimensionales Array sein | |
| sal_Int32 nLower, nUpper, nSize; | |
| sal_Int32 i; | |
| for( i = 0 ; i < nDims ; i++ ) | |
| { | |
| pArray->GetDim32( i+1, nLower, nUpper ); | |
| nSize = nUpper - nLower + 1; | |
| if( i == 0 ) | |
| nTotalSize = nSize; | |
| else | |
| nTotalSize *= nSize; | |
| } | |
| // Objekte anlegen und ins Array eintragen | |
| String aClass( pImg->GetString( static_cast<short>( nOp2 ) ) ); | |
| for( i = 0 ; i < nTotalSize ; i++ ) | |
| { | |
| SbxObject *pClassObj = SbxBase::CreateObject( aClass ); | |
| if( !pClassObj ) | |
| { | |
| Error( SbERR_INVALID_OBJECT ); | |
| break; | |
| } | |
| else | |
| { | |
| String aName( pImg->GetString( static_cast<short>( nOp1 ) ) ); | |
| pClassObj->SetName( aName ); | |
| // Das Objekt muss BASIC rufen koennen | |
| pClassObj->SetParent( &rBasic ); | |
| pArray->SbxArray::Put32( pClassObj, i ); | |
| } | |
| } | |
| } | |
| SbxDimArray* pOldArray = (SbxDimArray*)(SbxArray*)refRedimpArray; | |
| if( pArray && pOldArray ) | |
| { | |
| short nDimsNew = pArray->GetDims(); | |
| short nDimsOld = pOldArray->GetDims(); | |
| short nDims = nDimsNew; | |
| sal_Bool bRangeError = sal_False; | |
| // Store dims to use them for copying later | |
| sal_Int32* pLowerBounds = new sal_Int32[nDims]; | |
| sal_Int32* pUpperBounds = new sal_Int32[nDims]; | |
| sal_Int32* pActualIndices = new sal_Int32[nDims]; | |
| if( nDimsOld != nDimsNew ) | |
| { | |
| bRangeError = sal_True; | |
| } | |
| else | |
| { | |
| // Compare bounds | |
| for( short i = 1 ; i <= nDims ; i++ ) | |
| { | |
| sal_Int32 lBoundNew, uBoundNew; | |
| sal_Int32 lBoundOld, uBoundOld; | |
| pArray->GetDim32( i, lBoundNew, uBoundNew ); | |
| pOldArray->GetDim32( i, lBoundOld, uBoundOld ); | |
| lBoundNew = std::max( lBoundNew, lBoundOld ); | |
| uBoundNew = std::min( uBoundNew, uBoundOld ); | |
| short j = i - 1; | |
| pActualIndices[j] = pLowerBounds[j] = lBoundNew; | |
| pUpperBounds[j] = uBoundNew; | |
| } | |
| } | |
| if( bRangeError ) | |
| { | |
| StarBASIC::Error( SbERR_OUT_OF_RANGE ); | |
| } | |
| else | |
| { | |
| // Copy data from old array by going recursively through all dimensions | |
| // (It would be faster to work on the flat internal data array of an | |
| // SbyArray but this solution is clearer and easier) | |
| implCopyDimArray_DCREATE( pArray, pOldArray, nDims - 1, | |
| 0, pActualIndices, pLowerBounds, pUpperBounds ); | |
| } | |
| delete [] pUpperBounds; | |
| delete [] pLowerBounds; | |
| delete [] pActualIndices; | |
| refRedimpArray = NULL; | |
| } | |
| } | |
| // Objekt aus User-Type kreieren (+StringID+StringID) | |
| SbxObject* createUserTypeImpl( const String& rClassName ); // sb.cxx | |
| void SbiRuntime::StepTCREATE( sal_uInt32 nOp1, sal_uInt32 nOp2 ) | |
| { | |
| String aName( pImg->GetString( static_cast<short>( nOp1 ) ) ); | |
| String aClass( pImg->GetString( static_cast<short>( nOp2 ) ) ); | |
| SbxObject* pCopyObj = createUserTypeImpl( aClass ); | |
| if( pCopyObj ) | |
| pCopyObj->SetName( aName ); | |
| SbxVariable* pNew = new SbxVariable; | |
| pNew->PutObject( pCopyObj ); | |
| pNew->SetDeclareClassName( aClass ); | |
| PushVar( pNew ); | |
| } | |
| void SbiRuntime::implHandleSbxFlags( SbxVariable* pVar, SbxDataType t, sal_uInt32 nOp2 ) | |
| { | |
| bool bWithEvents = ((t & 0xff) == SbxOBJECT && (nOp2 & SBX_TYPE_WITH_EVENTS_FLAG) != 0); | |
| if( bWithEvents ) | |
| pVar->SetFlag( SBX_WITH_EVENTS ); | |
| bool bDimAsNew = ((nOp2 & SBX_TYPE_DIM_AS_NEW_FLAG) != 0); | |
| if( bDimAsNew ) | |
| pVar->SetFlag( SBX_DIM_AS_NEW ); | |
| bool bFixedString = ((t & 0xff) == SbxSTRING && (nOp2 & SBX_FIXED_LEN_STRING_FLAG) != 0); | |
| if( bFixedString ) | |
| { | |
| sal_uInt16 nCount = static_cast<sal_uInt16>( nOp2 >> 17 ); // len = all bits above 0x10000 | |
| String aStr; | |
| aStr.Fill( nCount, 0 ); | |
| pVar->PutString( aStr ); | |
| } | |
| bool bVarToDim = ((nOp2 & SBX_TYPE_VAR_TO_DIM_FLAG) != 0); | |
| if( bVarToDim ) | |
| pVar->SetFlag( SBX_VAR_TO_DIM ); | |
| } | |
| // Einrichten einer lokalen Variablen (+StringID+Typ) | |
| void SbiRuntime::StepLOCAL( sal_uInt32 nOp1, sal_uInt32 nOp2 ) | |
| { | |
| if( !refLocals.Is() ) | |
| refLocals = new SbxArray; | |
| String aName( pImg->GetString( static_cast<short>( nOp1 ) ) ); | |
| if( refLocals->Find( aName, SbxCLASS_DONTCARE ) == NULL ) | |
| { | |
| SbxDataType t = (SbxDataType)(nOp2 & 0xffff); | |
| SbxVariable* p = new SbxVariable( t ); | |
| p->SetName( aName ); | |
| implHandleSbxFlags( p, t, nOp2 ); | |
| refLocals->Put( p, refLocals->Count() ); | |
| } | |
| } | |
| // Einrichten einer modulglobalen Variablen (+StringID+Typ) | |
| void SbiRuntime::StepPUBLIC_Impl( sal_uInt32 nOp1, sal_uInt32 nOp2, bool bUsedForClassModule ) | |
| { | |
| String aName( pImg->GetString( static_cast<short>( nOp1 ) ) ); | |
| SbxDataType t = (SbxDataType)(SbxDataType)(nOp2 & 0xffff); | |
| sal_Bool bFlag = pMod->IsSet( SBX_NO_MODIFY ); | |
| pMod->SetFlag( SBX_NO_MODIFY ); | |
| SbxVariableRef p = pMod->Find( aName, SbxCLASS_PROPERTY ); | |
| if( p.Is() ) | |
| pMod->Remove (p); | |
| SbProperty* pProp = pMod->GetProperty( aName, t ); | |
| if( !bUsedForClassModule ) | |
| pProp->SetFlag( SBX_PRIVATE ); | |
| if( !bFlag ) | |
| pMod->ResetFlag( SBX_NO_MODIFY ); | |
| if( pProp ) | |
| { | |
| pProp->SetFlag( SBX_DONTSTORE ); | |
| // AB: 2.7.1996: HACK wegen 'Referenz kann nicht gesichert werden' | |
| pProp->SetFlag( SBX_NO_MODIFY); | |
| implHandleSbxFlags( pProp, t, nOp2 ); | |
| } | |
| } | |
| void SbiRuntime::StepPUBLIC( sal_uInt32 nOp1, sal_uInt32 nOp2 ) | |
| { | |
| StepPUBLIC_Impl( nOp1, nOp2, false ); | |
| } | |
| void SbiRuntime::StepPUBLIC_P( sal_uInt32 nOp1, sal_uInt32 nOp2 ) | |
| { | |
| // Creates module variable that isn't reinitialised when | |
| // between invocations ( for VBASupport & document basic only ) | |
| if( pMod->pImage->bFirstInit ) | |
| { | |
| bool bUsedForClassModule = pImg->GetFlag( SBIMG_CLASSMODULE ); | |
| StepPUBLIC_Impl( nOp1, nOp2, bUsedForClassModule ); | |
| } | |
| } | |
| // Einrichten einer globalen Variablen (+StringID+Typ) | |
| void SbiRuntime::StepGLOBAL( sal_uInt32 nOp1, sal_uInt32 nOp2 ) | |
| { | |
| if( pImg->GetFlag( SBIMG_CLASSMODULE ) ) | |
| StepPUBLIC_Impl( nOp1, nOp2, true ); | |
| String aName( pImg->GetString( static_cast<short>( nOp1 ) ) ); | |
| SbxDataType t = (SbxDataType)(nOp2 & 0xffff); | |
| // Store module scope variables at module scope | |
| // in non vba mode these are stored at the library level :/ | |
| // not sure if this really should not be enabled for ALL basic | |
| SbxObject* pStorage = &rBasic; | |
| if ( SbiRuntime::isVBAEnabled() ) | |
| { | |
| pStorage = pMod; | |
| pMod->AddVarName( aName ); | |
| } | |
| sal_Bool bFlag = pStorage->IsSet( SBX_NO_MODIFY ); | |
| rBasic.SetFlag( SBX_NO_MODIFY ); | |
| SbxVariableRef p = pStorage->Find( aName, SbxCLASS_PROPERTY ); | |
| if( p.Is() ) | |
| pStorage->Remove (p); | |
| p = pStorage->Make( aName, SbxCLASS_PROPERTY, t ); | |
| if( !bFlag ) | |
| pStorage->ResetFlag( SBX_NO_MODIFY ); | |
| if( p ) | |
| { | |
| p->SetFlag( SBX_DONTSTORE ); | |
| // AB: 2.7.1996: HACK wegen 'Referenz kann nicht gesichert werden' | |
| p->SetFlag( SBX_NO_MODIFY); | |
| } | |
| } | |
| // Creates global variable that isn't reinitialised when | |
| // basic is restarted, P=PERSIST (+StringID+Typ) | |
| void SbiRuntime::StepGLOBAL_P( sal_uInt32 nOp1, sal_uInt32 nOp2 ) | |
| { | |
| if( pMod->pImage->bFirstInit ) | |
| { | |
| StepGLOBAL( nOp1, nOp2 ); | |
| } | |
| } | |
| // Searches for global variable, behavior depends on the fact | |
| // if the variable is initialised for the first time | |
| void SbiRuntime::StepFIND_G( sal_uInt32 nOp1, sal_uInt32 nOp2 ) | |
| { | |
| if( pMod->pImage->bFirstInit ) | |
| { | |
| // Behave like always during first init | |
| StepFIND( nOp1, nOp2 ); | |
| } | |
| else | |
| { | |
| // Return dummy variable | |
| SbxDataType t = (SbxDataType) nOp2; | |
| String aName( pImg->GetString( static_cast<short>( nOp1 & 0x7FFF ) ) ); | |
| SbxVariable* pDummyVar = new SbxVariable( t ); | |
| pDummyVar->SetName( aName ); | |
| PushVar( pDummyVar ); | |
| } | |
| } | |
| SbxVariable* SbiRuntime::StepSTATIC_Impl( String& aName, SbxDataType& t ) | |
| { | |
| SbxVariable* p = NULL; | |
| if ( pMeth ) | |
| { | |
| SbxArray* pStatics = pMeth->GetStatics(); | |
| if( pStatics && ( pStatics->Find( aName, SbxCLASS_DONTCARE ) == NULL ) ) | |
| { | |
| p = new SbxVariable( t ); | |
| if( t != SbxVARIANT ) | |
| p->SetFlag( SBX_FIXED ); | |
| p->SetName( aName ); | |
| pStatics->Put( p, pStatics->Count() ); | |
| } | |
| } | |
| return p; | |
| } | |
| // Einrichten einer statischen Variablen (+StringID+Typ) | |
| void SbiRuntime::StepSTATIC( sal_uInt32 nOp1, sal_uInt32 nOp2 ) | |
| { | |
| String aName( pImg->GetString( static_cast<short>( nOp1 ) ) ); | |
| SbxDataType t = (SbxDataType) nOp2; | |
| StepSTATIC_Impl( aName, t ); | |
| } |