| /************************************************************** |
| * |
| * 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 <tools/fsys.hxx> |
| #include <vcl/svapp.hxx> |
| #include <tools/wldcrd.hxx> |
| #include <svl/zforlist.hxx> |
| #include <unotools/syslocale.hxx> |
| #include "runtime.hxx" |
| #include "sbintern.hxx" |
| #include "opcodes.hxx" |
| #include "codegen.hxx" |
| #include "iosys.hxx" |
| #include "image.hxx" |
| #include "ddectrl.hxx" |
| #include "dllmgr.hxx" |
| #include <comphelper/processfactory.hxx> |
| #include <com/sun/star/container/XEnumerationAccess.hpp> |
| #include "sbunoobj.hxx" |
| #include "errobject.hxx" |
| #include "sbtrace.hxx" |
| #include "comenumwrapper.hxx" |
| |
| using namespace ::com::sun::star; |
| |
| bool SbiRuntime::isVBAEnabled() |
| { |
| bool result = false; |
| SbiInstance* pInst = pINST; |
| if ( pInst && pINST->pRun ) |
| result = pInst->pRun->bVBAEnabled; |
| return result; |
| } |
| |
| // #91147 Global reschedule flag |
| static sal_Bool bStaticGlobalEnableReschedule = sal_True; |
| |
| void StarBASIC::StaticEnableReschedule( sal_Bool bReschedule ) |
| { |
| bStaticGlobalEnableReschedule = bReschedule; |
| } |
| void StarBASIC::SetVBAEnabled( sal_Bool bEnabled ) |
| { |
| if ( bDocBasic ) |
| { |
| bVBAEnabled = bEnabled; |
| } |
| } |
| |
| sal_Bool StarBASIC::isVBAEnabled() |
| { |
| if ( bDocBasic ) |
| { |
| if( SbiRuntime::isVBAEnabled() ) |
| return sal_True; |
| return bVBAEnabled; |
| } |
| return sal_False; |
| } |
| |
| |
| struct SbiArgvStack { // Argv stack: |
| SbiArgvStack* pNext; // Stack Chain |
| SbxArrayRef refArgv; // Argv |
| short nArgc; // Argc |
| }; |
| |
| SbiRuntime::pStep0 SbiRuntime::aStep0[] = { // Alle Opcodes ohne Operanden |
| &SbiRuntime::StepNOP, |
| &SbiRuntime::StepEXP, |
| &SbiRuntime::StepMUL, |
| &SbiRuntime::StepDIV, |
| &SbiRuntime::StepMOD, |
| &SbiRuntime::StepPLUS, |
| &SbiRuntime::StepMINUS, |
| &SbiRuntime::StepNEG, |
| &SbiRuntime::StepEQ, |
| &SbiRuntime::StepNE, |
| &SbiRuntime::StepLT, |
| &SbiRuntime::StepGT, |
| &SbiRuntime::StepLE, |
| &SbiRuntime::StepGE, |
| &SbiRuntime::StepIDIV, |
| &SbiRuntime::StepAND, |
| &SbiRuntime::StepOR, |
| &SbiRuntime::StepXOR, |
| &SbiRuntime::StepEQV, |
| &SbiRuntime::StepIMP, |
| &SbiRuntime::StepNOT, |
| &SbiRuntime::StepCAT, |
| |
| &SbiRuntime::StepLIKE, |
| &SbiRuntime::StepIS, |
| // Laden/speichern |
| &SbiRuntime::StepARGC, // neuen Argv einrichten |
| &SbiRuntime::StepARGV, // TOS ==> aktueller Argv |
| &SbiRuntime::StepINPUT, // Input ==> TOS |
| &SbiRuntime::StepLINPUT, // Line Input ==> TOS |
| &SbiRuntime::StepGET, // TOS anfassen |
| &SbiRuntime::StepSET, // Speichern Objekt TOS ==> TOS-1 |
| &SbiRuntime::StepPUT, // TOS ==> TOS-1 |
| &SbiRuntime::StepPUTC, // TOS ==> TOS-1, dann ReadOnly |
| &SbiRuntime::StepDIM, // DIM |
| &SbiRuntime::StepREDIM, // REDIM |
| &SbiRuntime::StepREDIMP, // REDIM PRESERVE |
| &SbiRuntime::StepERASE, // TOS loeschen |
| // Verzweigen |
| &SbiRuntime::StepSTOP, // Programmende |
| &SbiRuntime::StepINITFOR, // FOR-Variable initialisieren |
| &SbiRuntime::StepNEXT, // FOR-Variable inkrementieren |
| &SbiRuntime::StepCASE, // Anfang CASE |
| &SbiRuntime::StepENDCASE, // Ende CASE |
| &SbiRuntime::StepSTDERROR, // Standard-Fehlerbehandlung |
| &SbiRuntime::StepNOERROR, // keine Fehlerbehandlung |
| &SbiRuntime::StepLEAVE, // UP verlassen |
| // E/A |
| &SbiRuntime::StepCHANNEL, // TOS = Kanalnummer |
| &SbiRuntime::StepPRINT, // print TOS |
| &SbiRuntime::StepPRINTF, // print TOS in field |
| &SbiRuntime::StepWRITE, // write TOS |
| &SbiRuntime::StepRENAME, // Rename Tos+1 to Tos |
| &SbiRuntime::StepPROMPT, // Input Prompt aus TOS definieren |
| &SbiRuntime::StepRESTART, // Set restart point |
| &SbiRuntime::StepCHANNEL0, // E/A-Kanal 0 einstellen |
| &SbiRuntime::StepEMPTY, // Leeren Ausdruck auf Stack |
| &SbiRuntime::StepERROR, // TOS = Fehlercode |
| &SbiRuntime::StepLSET, // Speichern Objekt TOS ==> TOS-1 |
| &SbiRuntime::StepRSET, // Speichern Objekt TOS ==> TOS-1 |
| &SbiRuntime::StepREDIMP_ERASE,// Copy array object for REDIMP |
| &SbiRuntime::StepINITFOREACH,// Init for each loop |
| &SbiRuntime::StepVBASET,// vba-like set statement |
| &SbiRuntime::StepERASE_CLEAR,// vba-like set statement |
| &SbiRuntime::StepARRAYACCESS,// access TOS as array |
| &SbiRuntime::StepBYVAL, // access TOS as array |
| }; |
| |
| SbiRuntime::pStep1 SbiRuntime::aStep1[] = { // Alle Opcodes mit einem Operanden |
| &SbiRuntime::StepLOADNC, // Laden einer numerischen Konstanten (+ID) |
| &SbiRuntime::StepLOADSC, // Laden einer Stringkonstanten (+ID) |
| &SbiRuntime::StepLOADI, // Immediate Load (+Wert) |
| &SbiRuntime::StepARGN, // Speichern eines named Args in Argv (+StringID) |
| &SbiRuntime::StepPAD, // String auf feste Laenge bringen (+Laenge) |
| // Verzweigungen |
| &SbiRuntime::StepJUMP, // Sprung (+Target) |
| &SbiRuntime::StepJUMPT, // TOS auswerten), bedingter Sprung (+Target) |
| &SbiRuntime::StepJUMPF, // TOS auswerten), bedingter Sprung (+Target) |
| &SbiRuntime::StepONJUMP, // TOS auswerten), Sprung in JUMP-Tabelle (+MaxVal) |
| &SbiRuntime::StepGOSUB, // UP-Aufruf (+Target) |
| &SbiRuntime::StepRETURN, // UP-Return (+0 oder Target) |
| &SbiRuntime::StepTESTFOR, // FOR-Variable testen), inkrementieren (+Endlabel) |
| &SbiRuntime::StepCASETO, // Tos+1 <= Case <= Tos), 2xremove (+Target) |
| &SbiRuntime::StepERRHDL, // Fehler-Handler (+Offset) |
| &SbiRuntime::StepRESUME, // Resume nach Fehlern (+0 or 1 or Label) |
| // E/A |
| &SbiRuntime::StepCLOSE, // (+Kanal/0) |
| &SbiRuntime::StepPRCHAR, // (+char) |
| // Verwaltung |
| &SbiRuntime::StepSETCLASS, // Set + Klassennamen testen (+StringId) |
| &SbiRuntime::StepTESTCLASS, // Check TOS class (+StringId) |
| &SbiRuntime::StepLIB, // Lib fuer Declare-Call (+StringId) |
| &SbiRuntime::StepBASED, // TOS wird um BASE erhoeht, BASE davor gepusht |
| &SbiRuntime::StepARGTYP, // Letzten Parameter in Argv konvertieren (+Typ) |
| &SbiRuntime::StepVBASETCLASS,// vba-like set statement |
| }; |
| |
| SbiRuntime::pStep2 SbiRuntime::aStep2[] = {// Alle Opcodes mit zwei Operanden |
| &SbiRuntime::StepRTL, // Laden aus RTL (+StringID+Typ) |
| &SbiRuntime::StepFIND, // Laden (+StringID+Typ) |
| &SbiRuntime::StepELEM, // Laden Element (+StringID+Typ) |
| &SbiRuntime::StepPARAM, // Parameter (+Offset+Typ) |
| // Verzweigen |
| &SbiRuntime::StepCALL, // Declare-Call (+StringID+Typ) |
| &SbiRuntime::StepCALLC, // CDecl-Declare-Call (+StringID+Typ) |
| &SbiRuntime::StepCASEIS, // Case-Test (+Test-Opcode+False-Target) |
| // Verwaltung |
| &SbiRuntime::StepSTMNT, // Beginn eines Statements (+Line+Col) |
| // E/A |
| &SbiRuntime::StepOPEN, // (+SvStreamFlags+Flags) |
| // Objekte |
| &SbiRuntime::StepLOCAL, // Lokale Variable definieren (+StringId+Typ) |
| &SbiRuntime::StepPUBLIC, // Modulglobale Variable (+StringID+Typ) |
| &SbiRuntime::StepGLOBAL, // Globale Variable definieren (+StringID+Typ) |
| &SbiRuntime::StepCREATE, // Objekt kreieren (+StringId+StringId) |
| &SbiRuntime::StepSTATIC, // Statische Variable (+StringId+StringId) |
| &SbiRuntime::StepTCREATE, // User Defined Objekte (+StringId+StringId) |
| &SbiRuntime::StepDCREATE, // Objekt-Array kreieren (+StringID+StringID) |
| &SbiRuntime::StepGLOBAL_P, // Globale Variable definieren, die beim Neustart |
| // von Basic nicht ueberschrieben wird (+StringID+Typ) |
| &SbiRuntime::StepFIND_G, // Sucht globale Variable mit Spezialbehandlung wegen _GLOBAL_P |
| &SbiRuntime::StepDCREATE_REDIMP, // Objekt-Array redimensionieren (+StringID+StringID) |
| &SbiRuntime::StepFIND_CM, // Search inside a class module (CM) to enable global search in time |
| &SbiRuntime::StepPUBLIC_P, // Search inside a class module (CM) to enable global search in time |
| &SbiRuntime::StepFIND_STATIC, // Search inside a class module (CM) to enable global search in time |
| }; |
| |
| |
| ////////////////////////////////////////////////////////////////////////// |
| // SbiRTLData // |
| ////////////////////////////////////////////////////////////////////////// |
| |
| SbiRTLData::SbiRTLData() |
| { |
| pDir = 0; |
| nDirFlags = 0; |
| nCurDirPos = 0; |
| pWildCard = NULL; |
| } |
| |
| SbiRTLData::~SbiRTLData() |
| { |
| delete pDir; |
| pDir = 0; |
| delete pWildCard; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////// |
| // SbiInstance // |
| ////////////////////////////////////////////////////////////////////////// |
| |
| // 16.10.96: #31460 Neues Konzept fuer StepInto/Over/Out |
| // Die Entscheidung, ob StepPoint aufgerufen werden soll, wird anhand des |
| // CallLevels getroffen. Angehalten wird, wenn der aktuelle CallLevel <= |
| // nBreakCallLvl ist. Der aktuelle CallLevel kann niemals kleiner als 1 |
| // sein, da er beim Aufruf einer Methode (auch main) inkrementiert wird. |
| // Daher bedeutet ein BreakCallLvl von 0, dass das Programm gar nicht |
| // angehalten wird. |
| // (siehe auch step2.cxx, SbiRuntime::StepSTMNT() ) |
| |
| // Hilfsfunktion, um den BreakCallLevel gemaess der der Debug-Flags zu ermitteln |
| void SbiInstance::CalcBreakCallLevel( sal_uInt16 nFlags ) |
| { |
| // Break-Flag wegfiltern |
| nFlags &= ~((sal_uInt16)SbDEBUG_BREAK); |
| |
| sal_uInt16 nRet; |
| switch( nFlags ) |
| { |
| case SbDEBUG_STEPINTO: |
| nRet = nCallLvl + 1; // CallLevel+1 wird auch angehalten |
| break; |
| case SbDEBUG_STEPOVER | SbDEBUG_STEPINTO: |
| nRet = nCallLvl; // Aktueller CallLevel wird angehalten |
| break; |
| case SbDEBUG_STEPOUT: |
| nRet = nCallLvl - 1; // Kleinerer CallLevel wird angehalten |
| break; |
| case SbDEBUG_CONTINUE: |
| // Basic-IDE liefert 0 statt SbDEBUG_CONTINUE, also auch default=continue |
| default: |
| nRet = 0; // CallLevel ist immer >0 -> kein StepPoint |
| } |
| nBreakCallLvl = nRet; // Ergebnis uebernehmen |
| } |
| |
| SbiInstance::SbiInstance( StarBASIC* p ) |
| { |
| pBasic = p; |
| pNext = NULL; |
| pRun = NULL; |
| pIosys = new SbiIoSystem; |
| pDdeCtrl = new SbiDdeControl; |
| pDllMgr = 0; // on demand |
| pNumberFormatter = 0; // on demand |
| nCallLvl = 0; |
| nBreakCallLvl = 0; |
| nErr = |
| nErl = 0; |
| bReschedule = sal_True; |
| bCompatibility = sal_False; |
| } |
| |
| SbiInstance::~SbiInstance() |
| { |
| while( pRun ) |
| { |
| SbiRuntime* p = pRun->pNext; |
| delete pRun; |
| pRun = p; |
| } |
| delete pIosys; |
| delete pDdeCtrl; |
| delete pDllMgr; |
| delete pNumberFormatter; |
| |
| try |
| { |
| int nSize = ComponentVector.size(); |
| if( nSize ) |
| { |
| for( int i = nSize - 1 ; i >= 0 ; --i ) |
| { |
| Reference< XComponent > xDlgComponent = ComponentVector[i]; |
| if( xDlgComponent.is() ) |
| xDlgComponent->dispose(); |
| } |
| } |
| } |
| catch( const Exception& ) |
| { |
| DBG_ERROR( "SbiInstance::~SbiInstance: caught an exception while disposing the components!" ); |
| } |
| |
| ComponentVector.clear(); |
| } |
| |
| SbiDllMgr* SbiInstance::GetDllMgr() |
| { |
| if( !pDllMgr ) |
| pDllMgr = new SbiDllMgr; |
| return pDllMgr; |
| } |
| |
| // #39629 NumberFormatter jetzt ueber statische Methode anlegen |
| SvNumberFormatter* SbiInstance::GetNumberFormatter() |
| { |
| LanguageType eLangType = GetpApp()->GetSettings().GetLanguage(); |
| SvtSysLocale aSysLocale; |
| DateFormat eDate = aSysLocale.GetLocaleData().getDateFormat(); |
| if( pNumberFormatter ) |
| { |
| if( eLangType != meFormatterLangType || |
| eDate != meFormatterDateFormat ) |
| { |
| delete pNumberFormatter; |
| pNumberFormatter = NULL; |
| } |
| } |
| meFormatterLangType = eLangType; |
| meFormatterDateFormat = eDate; |
| if( !pNumberFormatter ) |
| PrepareNumberFormatter( pNumberFormatter, nStdDateIdx, nStdTimeIdx, nStdDateTimeIdx, |
| &meFormatterLangType, &meFormatterDateFormat ); |
| return pNumberFormatter; |
| } |
| |
| // #39629 NumberFormatter auch statisch anbieten |
| void SbiInstance::PrepareNumberFormatter( SvNumberFormatter*& rpNumberFormatter, |
| sal_uInt32 &rnStdDateIdx, sal_uInt32 &rnStdTimeIdx, sal_uInt32 &rnStdDateTimeIdx, |
| LanguageType* peFormatterLangType, DateFormat* peFormatterDateFormat ) |
| { |
| com::sun::star::uno::Reference< com::sun::star::lang::XMultiServiceFactory > |
| xFactory = comphelper::getProcessServiceFactory(); |
| |
| LanguageType eLangType; |
| if( peFormatterLangType ) |
| eLangType = *peFormatterLangType; |
| else |
| eLangType = GetpApp()->GetSettings().GetLanguage(); |
| |
| DateFormat eDate; |
| if( peFormatterDateFormat ) |
| eDate = *peFormatterDateFormat; |
| else |
| { |
| SvtSysLocale aSysLocale; |
| eDate = aSysLocale.GetLocaleData().getDateFormat(); |
| } |
| |
| rpNumberFormatter = new SvNumberFormatter( xFactory, eLangType ); |
| |
| xub_StrLen nCheckPos = 0; short nType; |
| rnStdTimeIdx = rpNumberFormatter->GetStandardFormat( NUMBERFORMAT_TIME, eLangType ); |
| |
| // Standard-Vorlagen des Formatters haben nur zweistellige |
| // Jahreszahl. Deshalb eigenes Format registrieren |
| |
| // HACK, da der Numberformatter in PutandConvertEntry die Platzhalter |
| // fuer Monat, Tag, Jahr nicht entsprechend der Systemeinstellung |
| // austauscht. Problem: Print Year(Date) unter engl. BS |
| // siehe auch svtools\source\sbx\sbxdate.cxx |
| |
| String aDateStr; |
| switch( eDate ) |
| { |
| case MDY: aDateStr = String( RTL_CONSTASCII_USTRINGPARAM("MM.TT.JJJJ") ); break; |
| case DMY: aDateStr = String( RTL_CONSTASCII_USTRINGPARAM("TT.MM.JJJJ") ); break; |
| case YMD: aDateStr = String( RTL_CONSTASCII_USTRINGPARAM("JJJJ.MM.TT") ); break; |
| default: aDateStr = String( RTL_CONSTASCII_USTRINGPARAM("MM.TT.JJJJ") ); |
| } |
| String aStr( aDateStr ); |
| rpNumberFormatter->PutandConvertEntry( aStr, nCheckPos, nType, |
| rnStdDateIdx, LANGUAGE_GERMAN, eLangType ); |
| nCheckPos = 0; |
| String aStrHHMMSS( RTL_CONSTASCII_USTRINGPARAM(" HH:MM:SS") ); |
| aStr = aDateStr; |
| aStr += aStrHHMMSS; |
| rpNumberFormatter->PutandConvertEntry( aStr, nCheckPos, nType, |
| rnStdDateTimeIdx, LANGUAGE_GERMAN, eLangType ); |
| } |
| |
| |
| |
| // Engine laufenlassen. Falls Flags == SbDEBUG_CONTINUE, Flags uebernehmen |
| |
| void SbiInstance::Stop() |
| { |
| for( SbiRuntime* p = pRun; p; p = p->pNext ) |
| p->Stop(); |
| } |
| |
| // Allows Basic IDE to set watch mode to suppress errors |
| static bool bWatchMode = false; |
| |
| void setBasicWatchMode( bool bOn ) |
| { |
| bWatchMode = bOn; |
| } |
| |
| void SbiInstance::Error( SbError n ) |
| { |
| Error( n, String() ); |
| } |
| |
| void SbiInstance::Error( SbError n, const String& rMsg ) |
| { |
| if( !bWatchMode ) |
| { |
| aErrorMsg = rMsg; |
| pRun->Error( n ); |
| } |
| } |
| |
| void SbiInstance::ErrorVB( sal_Int32 nVBNumber, const String& rMsg ) |
| { |
| if( !bWatchMode ) |
| { |
| SbError n = StarBASIC::GetSfxFromVBError( static_cast< sal_uInt16 >( nVBNumber ) ); |
| if ( !n ) |
| n = nVBNumber; // force orig number, probably should have a specific table of vb ( localized ) errors |
| |
| aErrorMsg = rMsg; |
| SbiRuntime::translateErrorToVba( n, aErrorMsg ); |
| |
| bool bVBATranslationAlreadyDone = true; |
| pRun->Error( SbERR_BASIC_COMPAT, bVBATranslationAlreadyDone ); |
| } |
| } |
| |
| void SbiInstance::setErrorVB( sal_Int32 nVBNumber, const String& rMsg ) |
| { |
| SbError n = StarBASIC::GetSfxFromVBError( static_cast< sal_uInt16 >( nVBNumber ) ); |
| if( !n ) |
| n = nVBNumber; // force orig number, probably should have a specific table of vb ( localized ) errors |
| |
| aErrorMsg = rMsg; |
| SbiRuntime::translateErrorToVba( n, aErrorMsg ); |
| |
| nErr = n; |
| } |
| |
| |
| void SbiInstance::FatalError( SbError n ) |
| { |
| pRun->FatalError( n ); |
| } |
| |
| void SbiInstance::FatalError( SbError _errCode, const String& _details ) |
| { |
| pRun->FatalError( _errCode, _details ); |
| } |
| |
| void SbiInstance::Abort() |
| { |
| // Basic suchen, in dem der Fehler auftrat |
| StarBASIC* pErrBasic = GetCurrentBasic( pBasic ); |
| pErrBasic->RTError( nErr, aErrorMsg, pRun->nLine, pRun->nCol1, pRun->nCol2 ); |
| pBasic->Stop(); |
| } |
| |
| // Hilfsfunktion, um aktives Basic zu finden, kann ungleich pRTBasic sein |
| StarBASIC* GetCurrentBasic( StarBASIC* pRTBasic ) |
| { |
| StarBASIC* pCurBasic = pRTBasic; |
| SbModule* pActiveModule = pRTBasic->GetActiveModule(); |
| if( pActiveModule ) |
| { |
| SbxObject* pParent = pActiveModule->GetParent(); |
| if( pParent && pParent->ISA(StarBASIC) ) |
| pCurBasic = (StarBASIC*)pParent; |
| } |
| return pCurBasic; |
| } |
| |
| SbModule* SbiInstance::GetActiveModule() |
| { |
| if( pRun ) |
| return pRun->GetModule(); |
| else |
| return NULL; |
| } |
| |
| SbMethod* SbiInstance::GetCaller( sal_uInt16 nLevel ) |
| { |
| SbiRuntime* p = pRun; |
| while( nLevel-- && p ) |
| p = p->pNext; |
| if( p ) |
| return p->GetCaller(); |
| else |
| return NULL; |
| } |
| |
| SbxArray* SbiInstance::GetLocals( SbMethod* pMeth ) |
| { |
| SbiRuntime* p = pRun; |
| while( p && p->GetMethod() != pMeth ) |
| p = p->pNext; |
| if( p ) |
| return p->GetLocals(); |
| else |
| return NULL; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////// |
| // SbiInstance // |
| ////////////////////////////////////////////////////////////////////////// |
| |
| // Achtung: pMeth kann auch NULL sein (beim Aufruf des Init-Codes) |
| |
| SbiRuntime::SbiRuntime( SbModule* pm, SbMethod* pe, sal_uInt32 nStart ) |
| : rBasic( *(StarBASIC*)pm->pParent ), pInst( pINST ), |
| pMod( pm ), pMeth( pe ), pImg( pMod->pImage ), m_nLastTime(0) |
| { |
| nFlags = pe ? pe->GetDebugFlags() : 0; |
| pIosys = pInst->pIosys; |
| pArgvStk = NULL; |
| pGosubStk = NULL; |
| pForStk = NULL; |
| pError = NULL; |
| pErrCode = |
| pErrStmnt = |
| pRestart = NULL; |
| pNext = NULL; |
| pCode = |
| pStmnt = (const sal_uInt8* ) pImg->GetCode() + nStart; |
| bRun = |
| bError = sal_True; |
| bInError = sal_False; |
| bBlocked = sal_False; |
| nLine = 0; |
| nCol1 = 0; |
| nCol2 = 0; |
| nExprLvl = 0; |
| nArgc = 0; |
| nError = 0; |
| nGosubLvl = 0; |
| nForLvl = 0; |
| nOps = 0; |
| refExprStk = new SbxArray; |
| SetVBAEnabled( pMod->IsVBACompat() ); |
| #if defined GCC |
| SetParameters( pe ? pe->GetParameters() : (class SbxArray *)NULL ); |
| #else |
| SetParameters( pe ? pe->GetParameters() : NULL ); |
| #endif |
| pRefSaveList = NULL; |
| pItemStoreList = NULL; |
| } |
| |
| SbiRuntime::~SbiRuntime() |
| { |
| ClearGosubStack(); |
| ClearArgvStack(); |
| ClearForStack(); |
| |
| // #74254 Items zum Sichern temporaere Referenzen freigeben |
| ClearRefs(); |
| while( pItemStoreList ) |
| { |
| RefSaveItem* pToDeleteItem = pItemStoreList; |
| pItemStoreList = pToDeleteItem->pNext; |
| delete pToDeleteItem; |
| } |
| } |
| |
| void SbiRuntime::SetVBAEnabled(bool bEnabled ) |
| { |
| bVBAEnabled = bEnabled; |
| } |
| |
| // Aufbau der Parameterliste. Alle ByRef-Parameter werden direkt |
| // uebernommen; von ByVal-Parametern werden Kopien angelegt. Falls |
| // ein bestimmter Datentyp verlangt wird, wird konvertiert. |
| |
| void SbiRuntime::SetParameters( SbxArray* pParams ) |
| { |
| refParams = new SbxArray; |
| // fuer den Returnwert |
| refParams->Put( pMeth, 0 ); |
| |
| SbxInfo* pInfo = pMeth ? pMeth->GetInfo() : NULL; |
| sal_uInt16 nParamCount = pParams ? pParams->Count() : 1; |
| if( nParamCount > 1 ) |
| { |
| for( sal_uInt16 i = 1 ; i < nParamCount ; i++ ) |
| { |
| const SbxParamInfo* p = pInfo ? pInfo->GetParam( i ) : NULL; |
| |
| // #111897 ParamArray |
| if( p && (p->nUserData & PARAM_INFO_PARAMARRAY) != 0 ) |
| { |
| SbxDimArray* pArray = new SbxDimArray( SbxVARIANT ); |
| sal_uInt16 nParamArrayParamCount = nParamCount - i; |
| pArray->unoAddDim( 0, nParamArrayParamCount - 1 ); |
| for( sal_uInt16 j = i ; j < nParamCount ; j++ ) |
| { |
| SbxVariable* v = pParams->Get( j ); |
| short nDimIndex = j - i; |
| pArray->Put( v, &nDimIndex ); |
| } |
| SbxVariable* pArrayVar = new SbxVariable( SbxVARIANT ); |
| pArrayVar->SetFlag( SBX_READWRITE ); |
| pArrayVar->PutObject( pArray ); |
| refParams->Put( pArrayVar, i ); |
| |
| // Block ParamArray for missing parameter |
| pInfo = NULL; |
| break; |
| } |
| |
| SbxVariable* v = pParams->Get( i ); |
| // Methoden sind immer byval! |
| sal_Bool bByVal = v->IsA( TYPE(SbxMethod) ); |
| SbxDataType t = v->GetType(); |
| bool bTargetTypeIsArray = false; |
| if( p ) |
| { |
| bByVal |= sal_Bool( ( p->eType & SbxBYREF ) == 0 ); |
| t = (SbxDataType) ( p->eType & 0x0FFF ); |
| |
| if( !bByVal && t != SbxVARIANT && |
| (!v->IsFixed() || (SbxDataType)(v->GetType() & 0x0FFF ) != t) ) |
| bByVal = sal_True; |
| |
| bTargetTypeIsArray = (p->nUserData & PARAM_INFO_WITHBRACKETS) != 0; |
| } |
| if( bByVal ) |
| { |
| if( bTargetTypeIsArray ) |
| t = SbxOBJECT; |
| SbxVariable* v2 = new SbxVariable( t ); |
| v2->SetFlag( SBX_READWRITE ); |
| *v2 = *v; |
| refParams->Put( v2, i ); |
| } |
| else |
| { |
| if( t != SbxVARIANT && t != ( v->GetType() & 0x0FFF ) ) |
| { |
| // Array konvertieren?? |
| if( p && (p->eType & SbxARRAY) ) |
| Error( SbERR_CONVERSION ); |
| else |
| v->Convert( t ); |
| } |
| refParams->Put( v, i ); |
| } |
| if( p ) |
| refParams->PutAlias( p->aName, i ); |
| } |
| } |
| |
| // ParamArray for missing parameter |
| if( pInfo ) |
| { |
| // #111897 Check first missing parameter for ParamArray |
| const SbxParamInfo* p = pInfo->GetParam( nParamCount ); |
| if( p && (p->nUserData & PARAM_INFO_PARAMARRAY) != 0 ) |
| { |
| SbxDimArray* pArray = new SbxDimArray( SbxVARIANT ); |
| pArray->unoAddDim( 0, -1 ); |
| SbxVariable* pArrayVar = new SbxVariable( SbxVARIANT ); |
| pArrayVar->SetFlag( SBX_READWRITE ); |
| pArrayVar->PutObject( pArray ); |
| refParams->Put( pArrayVar, nParamCount ); |
| } |
| } |
| } |
| |
| |
| // Einen P-Code ausfuehren |
| |
| sal_Bool SbiRuntime::Step() |
| { |
| if( bRun ) |
| { |
| // Unbedingt gelegentlich die Kontrolle abgeben! |
| if( !( ++nOps & 0xF ) && pInst->IsReschedule() && bStaticGlobalEnableReschedule ) |
| { |
| sal_uInt32 nTime = osl_getGlobalTimer(); |
| if (nTime - m_nLastTime > 5 ) // 20 ms |
| { |
| Application::Reschedule(); |
| m_nLastTime = nTime; |
| } |
| } |
| |
| // #i48868 blocked by next call level? |
| while( bBlocked ) |
| { |
| if( pInst->IsReschedule() && bStaticGlobalEnableReschedule ) |
| Application::Reschedule(); |
| } |
| |
| #ifdef DBG_TRACE_BASIC |
| sal_uInt32 nPC = ( pCode - (const sal_uInt8* )pImg->GetCode() ); |
| dbg_traceStep( pMod, nPC, pINST->nCallLvl ); |
| #endif |
| |
| SbiOpcode eOp = (SbiOpcode ) ( *pCode++ ); |
| sal_uInt32 nOp1, nOp2; |
| if (eOp < SbOP0_END) |
| { |
| (this->*( aStep0[ eOp ] ) )(); |
| } |
| else if (eOp >= SbOP1_START && eOp < SbOP1_END) |
| { |
| nOp1 = *pCode++; nOp1 |= *pCode++ << 8; nOp1 |= *pCode++ << 16; nOp1 |= *pCode++ << 24; |
| |
| (this->*( aStep1[ eOp - SbOP1_START ] ) )( nOp1 ); |
| } |
| else if (eOp >= SbOP2_START && eOp < SbOP2_END) |
| { |
| nOp1 = *pCode++; nOp1 |= *pCode++ << 8; nOp1 |= *pCode++ << 16; nOp1 |= *pCode++ << 24; |
| nOp2 = *pCode++; nOp2 |= *pCode++ << 8; nOp2 |= *pCode++ << 16; nOp2 |= *pCode++ << 24; |
| (this->*( aStep2[ eOp - SbOP2_START ] ) )( nOp1, nOp2 ); |
| } |
| else |
| StarBASIC::FatalError( SbERR_INTERNAL_ERROR ); |
| |
| // SBX-Fehler aufgetreten? |
| SbError nSbError = SbxBase::GetError(); |
| Error( ERRCODE_TOERROR(nSbError) ); // Warnings rausfiltern |
| |
| // AB 13.2.1997, neues Error-Handling: |
| // ACHTUNG: Hier kann nError auch dann gesetzt sein, wenn !nSbError, |
| // da nError jetzt auch von anderen RT-Instanzen gesetzt werden kann |
| |
| if( nError ) |
| SbxBase::ResetError(); |
| |
| // AB,15.3.96: Fehler nur anzeigen, wenn BASIC noch aktiv |
| // (insbesondere nicht nach Compiler-Fehlern zur Laufzeit) |
| if( nError && bRun ) |
| { |
| #ifdef DBG_TRACE_BASIC |
| SbError nTraceErr = nError; |
| String aTraceErrMsg = GetSbData()->aErrMsg; |
| bool bTraceErrHandled = true; |
| #endif |
| SbError err = nError; |
| ClearExprStack(); |
| nError = 0; |
| pInst->nErr = err; |
| pInst->nErl = nLine; |
| pErrCode = pCode; |
| pErrStmnt = pStmnt; |
| // An error occured in an error handler |
| // force parent handler ( if there is one ) |
| // to handle the error |
| bool bLetParentHandleThis = false; |
| |
| // Im Error Handler? Dann Std-Error |
| if ( !bInError ) |
| { |
| bInError = sal_True; |
| |
| if( !bError ) // On Error Resume Next |
| StepRESUME( 1 ); |
| else if( pError ) // On Error Goto ... |
| pCode = pError; |
| else |
| bLetParentHandleThis = true; |
| } |
| else |
| { |
| bLetParentHandleThis = true; |
| pError = NULL; //terminate the handler |
| } |
| if ( bLetParentHandleThis ) |
| { |
| // AB 13.2.1997, neues Error-Handling: |
| // Uebergeordnete Error-Handler beruecksichtigen |
| |
| // Wir haben keinen Error-Handler -> weiter oben suchen |
| SbiRuntime* pRtErrHdl = NULL; |
| SbiRuntime* pRt = this; |
| while( NULL != (pRt = pRt->pNext) ) |
| { |
| // Gibt es einen Error-Handler? |
| if( pRt->bError == sal_False || pRt->pError != NULL ) |
| { |
| pRtErrHdl = pRt; |
| break; |
| } |
| } |
| |
| // Error-Hdl gefunden? |
| if( pRtErrHdl ) |
| { |
| // (Neuen) Error-Stack anlegen |
| SbErrorStack*& rErrStack = GetSbData()->pErrStack; |
| if( rErrStack ) |
| delete rErrStack; |
| rErrStack = new SbErrorStack(); |
| |
| // Alle im Call-Stack darunter stehenden RTs manipulieren |
| pRt = this; |
| do |
| { |
| // Fehler setzen |
| pRt->nError = err; |
| if( pRt != pRtErrHdl ) |
| pRt->bRun = sal_False; |
| |
| // In Error-Stack eintragen |
| SbErrorStackEntry *pEntry = new SbErrorStackEntry |
| ( pRt->pMeth, pRt->nLine, pRt->nCol1, pRt->nCol2 ); |
| rErrStack->C40_INSERT(SbErrorStackEntry, pEntry, rErrStack->Count() ); |
| |
| // Nach RT mit Error-Handler aufhoeren |
| if( pRt == pRtErrHdl ) |
| break; |
| pRt = pRt->pNext; |
| } |
| while( pRt ); |
| } |
| // Kein Error-Hdl gefunden -> altes Vorgehen |
| else |
| { |
| #ifdef DBG_TRACE_BASIC |
| bTraceErrHandled = false; |
| #endif |
| pInst->Abort(); |
| } |
| |
| // ALT: Nur |
| // pInst->Abort(); |
| } |
| |
| #ifdef DBG_TRACE_BASIC |
| dbg_traceNotifyError( nTraceErr, aTraceErrMsg, bTraceErrHandled, pINST->nCallLvl ); |
| #endif |
| } |
| } |
| return bRun; |
| } |
| |
| void SbiRuntime::Error( SbError n, bool bVBATranslationAlreadyDone ) |
| { |
| if( n ) |
| { |
| nError = n; |
| if( isVBAEnabled() && !bVBATranslationAlreadyDone ) |
| { |
| String aMsg = pInst->GetErrorMsg(); |
| sal_Int32 nVBAErrorNumber = translateErrorToVba( nError, aMsg ); |
| SbxVariable* pSbxErrObjVar = SbxErrObject::getErrObject(); |
| SbxErrObject* pGlobErr = static_cast< SbxErrObject* >( pSbxErrObjVar ); |
| if( pGlobErr != NULL ) |
| pGlobErr->setNumberAndDescription( nVBAErrorNumber, aMsg ); |
| |
| pInst->aErrorMsg = aMsg; |
| nError = SbERR_BASIC_COMPAT; |
| } |
| } |
| } |
| |
| void SbiRuntime::Error( SbError _errCode, const String& _details ) |
| { |
| if ( _errCode ) |
| { |
| // Not correct for class module usage, remove for now |
| //OSL_ENSURE( pInst->pRun == this, "SbiRuntime::Error: can't propagate the error message details!" ); |
| if ( pInst->pRun == this ) |
| { |
| pInst->Error( _errCode, _details ); |
| //OSL_POSTCOND( nError == _errCode, "SbiRuntime::Error: the instance is expecte to propagate the error code back to me!" ); |
| } |
| else |
| { |
| nError = _errCode; |
| } |
| } |
| } |
| |
| void SbiRuntime::FatalError( SbError n ) |
| { |
| StepSTDERROR(); |
| Error( n ); |
| } |
| |
| void SbiRuntime::FatalError( SbError _errCode, const String& _details ) |
| { |
| StepSTDERROR(); |
| Error( _errCode, _details ); |
| } |
| |
| sal_Int32 SbiRuntime::translateErrorToVba( SbError nError, String& rMsg ) |
| { |
| // If a message is defined use that ( in preference to |
| // the defined one for the error ) NB #TODO |
| // if there is an error defined it more than likely |
| // is not the one you want ( some are the same though ) |
| // we really need a new vba compatible error list |
| if ( !rMsg.Len() ) |
| { |
| // TEST, has to be vb here always |
| #ifdef DBG_UTIL |
| SbError nTmp = StarBASIC::GetSfxFromVBError( (sal_uInt16)nError ); |
| DBG_ASSERT( nTmp, "No VB error!" ); |
| #endif |
| |
| StarBASIC::MakeErrorText( nError, rMsg ); |
| rMsg = StarBASIC::GetErrorText(); |
| if ( !rMsg.Len() ) // no message for err no, need localized resource here |
| rMsg = String( RTL_CONSTASCII_USTRINGPARAM("Internal Object Error:") ); |
| } |
| // no num? most likely then it *is* really a vba err |
| sal_uInt16 nVBErrorCode = StarBASIC::GetVBErrorCode( nError ); |
| sal_Int32 nVBAErrorNumber = ( nVBErrorCode == 0 ) ? nError : nVBErrorCode; |
| return nVBAErrorNumber; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////// |
| // |
| // Parameter, Locals, Caller |
| // |
| ////////////////////////////////////////////////////////////////////////// |
| |
| SbMethod* SbiRuntime::GetCaller() |
| { |
| return pMeth; |
| } |
| |
| SbxArray* SbiRuntime::GetLocals() |
| { |
| return refLocals; |
| } |
| |
| SbxArray* SbiRuntime::GetParams() |
| { |
| return refParams; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////// |
| // |
| // Stacks |
| // |
| ////////////////////////////////////////////////////////////////////////// |
| |
| // Der Expression-Stack steht fuer die laufende Auswertung von Expressions |
| // zur Verfuegung. |
| |
| void SbiRuntime::PushVar( SbxVariable* pVar ) |
| { |
| if( pVar ) |
| refExprStk->Put( pVar, nExprLvl++ ); |
| } |
| |
| SbxVariableRef SbiRuntime::PopVar() |
| { |
| #ifdef DBG_UTIL |
| if( !nExprLvl ) |
| { |
| StarBASIC::FatalError( SbERR_INTERNAL_ERROR ); |
| return new SbxVariable; |
| } |
| #endif |
| SbxVariableRef xVar = refExprStk->Get( --nExprLvl ); |
| #ifdef DBG_UTIL |
| if ( xVar->GetName().EqualsAscii( "Cells" ) ) |
| DBG_TRACE( "" ); |
| #endif |
| // Methods halten im 0.Parameter sich selbst, also weghauen |
| if( xVar->IsA( TYPE(SbxMethod) ) ) |
| xVar->SetParameters(0); |
| return xVar; |
| } |
| |
| sal_Bool SbiRuntime::ClearExprStack() |
| { |
| // Achtung: Clear() reicht nicht, da Methods geloescht werden muessen |
| while ( nExprLvl ) |
| { |
| PopVar(); |
| } |
| refExprStk->Clear(); |
| return sal_False; |
| } |
| |
| // Variable auf dem Expression-Stack holen, ohne sie zu entfernen |
| // n zaehlt ab 0. |
| |
| SbxVariable* SbiRuntime::GetTOS( short n ) |
| { |
| n = nExprLvl - n - 1; |
| #ifdef DBG_UTIL |
| if( n < 0 ) |
| { |
| StarBASIC::FatalError( SbERR_INTERNAL_ERROR ); |
| return new SbxVariable; |
| } |
| #endif |
| return refExprStk->Get( (sal_uInt16) n ); |
| } |
| |
| // Sicherstellen, dass TOS eine temporaere Variable ist |
| |
| void SbiRuntime::TOSMakeTemp() |
| { |
| SbxVariable* p = refExprStk->Get( nExprLvl - 1 ); |
| if( p->GetRefCount() != 1 ) |
| { |
| SbxVariable* pNew = new SbxVariable( *p ); |
| pNew->SetFlag( SBX_READWRITE ); |
| refExprStk->Put( pNew, nExprLvl - 1 ); |
| } |
| } |
| |
| // Der GOSUB-Stack nimmt Returnadressen fuer GOSUBs auf |
| |
| void SbiRuntime::PushGosub( const sal_uInt8* pc ) |
| { |
| if( ++nGosubLvl > MAXRECURSION ) |
| StarBASIC::FatalError( SbERR_STACK_OVERFLOW ); |
| SbiGosubStack* p = new SbiGosubStack; |
| p->pCode = pc; |
| p->pNext = pGosubStk; |
| p->nStartForLvl = nForLvl; |
| pGosubStk = p; |
| } |
| |
| void SbiRuntime::PopGosub() |
| { |
| if( !pGosubStk ) |
| Error( SbERR_NO_GOSUB ); |
| else |
| { |
| SbiGosubStack* p = pGosubStk; |
| pCode = p->pCode; |
| pGosubStk = p->pNext; |
| delete p; |
| nGosubLvl--; |
| } |
| } |
| |
| // Entleeren des GOSUB-Stacks |
| |
| void SbiRuntime::ClearGosubStack() |
| { |
| SbiGosubStack* p; |
| while(( p = pGosubStk ) != NULL ) |
| pGosubStk = p->pNext, delete p; |
| nGosubLvl = 0; |
| } |
| |
| // Der Argv-Stack nimmt aktuelle Argument-Vektoren auf |
| |
| void SbiRuntime::PushArgv() |
| { |
| SbiArgvStack* p = new SbiArgvStack; |
| p->refArgv = refArgv; |
| p->nArgc = nArgc; |
| nArgc = 1; |
| refArgv.Clear(); |
| p->pNext = pArgvStk; |
| pArgvStk = p; |
| } |
| |
| void SbiRuntime::PopArgv() |
| { |
| if( pArgvStk ) |
| { |
| SbiArgvStack* p = pArgvStk; |
| pArgvStk = p->pNext; |
| refArgv = p->refArgv; |
| nArgc = p->nArgc; |
| delete p; |
| } |
| } |
| |
| // Entleeren des Argv-Stacks |
| |
| void SbiRuntime::ClearArgvStack() |
| { |
| while( pArgvStk ) |
| PopArgv(); |
| } |
| |
| // Push des For-Stacks. Der Stack hat Inkrement, Ende, Beginn und Variable. |
| // Nach Aufbau des Stack-Elements ist der Stack leer. |
| |
| void SbiRuntime::PushFor() |
| { |
| SbiForStack* p = new SbiForStack; |
| p->eForType = FOR_TO; |
| p->pNext = pForStk; |
| pForStk = p; |
| // Der Stack ist wie folgt aufgebaut: |
| p->refInc = PopVar(); |
| p->refEnd = PopVar(); |
| SbxVariableRef xBgn = PopVar(); |
| p->refVar = PopVar(); |
| *(p->refVar) = *xBgn; |
| nForLvl++; |
| } |
| |
| void SbiRuntime::PushForEach() |
| { |
| SbiForStack* p = new SbiForStack; |
| p->pNext = pForStk; |
| pForStk = p; |
| |
| SbxVariableRef xObjVar = PopVar(); |
| SbxBase* pObj = xObjVar.Is() ? xObjVar->GetObject() : NULL; |
| if( pObj == NULL ) |
| { |
| Error( SbERR_NO_OBJECT ); |
| return; |
| } |
| |
| bool bError_ = false; |
| BasicCollection* pCollection; |
| SbxDimArray* pArray; |
| SbUnoObject* pUnoObj; |
| if( (pArray = PTR_CAST(SbxDimArray,pObj)) != NULL ) |
| { |
| p->eForType = FOR_EACH_ARRAY; |
| p->refEnd = (SbxVariable*)pArray; |
| |
| short nDims = pArray->GetDims(); |
| p->pArrayLowerBounds = new sal_Int32[nDims]; |
| p->pArrayUpperBounds = new sal_Int32[nDims]; |
| p->pArrayCurIndices = new sal_Int32[nDims]; |
| sal_Int32 lBound, uBound; |
| for( short i = 0 ; i < nDims ; i++ ) |
| { |
| pArray->GetDim32( i+1, lBound, uBound ); |
| p->pArrayCurIndices[i] = p->pArrayLowerBounds[i] = lBound; |
| p->pArrayUpperBounds[i] = uBound; |
| } |
| } |
| else if( (pCollection = PTR_CAST(BasicCollection,pObj)) != NULL ) |
| { |
| p->eForType = FOR_EACH_COLLECTION; |
| p->refEnd = pCollection; |
| p->nCurCollectionIndex = 0; |
| } |
| else if( (pUnoObj = PTR_CAST(SbUnoObject,pObj)) != NULL ) |
| { |
| // XEnumerationAccess? |
| Any aAny = pUnoObj->getUnoAny(); |
| Reference< XEnumerationAccess > xEnumerationAccess; |
| if( (aAny >>= xEnumerationAccess) ) |
| { |
| p->xEnumeration = xEnumerationAccess->createEnumeration(); |
| p->eForType = FOR_EACH_XENUMERATION; |
| } |
| else if ( isVBAEnabled() && pUnoObj->isNativeCOMObject() ) |
| { |
| uno::Reference< script::XInvocation > xInvocation; |
| if ( ( aAny >>= xInvocation ) && xInvocation.is() ) |
| { |
| try |
| { |
| p->xEnumeration = new ComEnumerationWrapper( xInvocation ); |
| p->eForType = FOR_EACH_XENUMERATION; |
| } |
| catch( uno::Exception& ) |
| {} |
| } |
| |
| if ( !p->xEnumeration.is() ) |
| bError_ = true; |
| } |
| else |
| { |
| bError_ = true; |
| } |
| } |
| else |
| { |
| bError_ = true; |
| } |
| |
| if( bError_ ) |
| { |
| Error( SbERR_CONVERSION ); |
| return; |
| } |
| |
| // Container variable |
| p->refVar = PopVar(); |
| nForLvl++; |
| } |
| |
| // Poppen des FOR-Stacks |
| |
| void SbiRuntime::PopFor() |
| { |
| if( pForStk ) |
| { |
| SbiForStack* p = pForStk; |
| pForStk = p->pNext; |
| delete p; |
| nForLvl--; |
| } |
| } |
| |
| // Entleeren des FOR-Stacks |
| |
| void SbiRuntime::ClearForStack() |
| { |
| while( pForStk ) |
| PopFor(); |
| } |
| |
| SbiForStack* SbiRuntime::FindForStackItemForCollection( class BasicCollection* pCollection ) |
| { |
| SbiForStack* pRet = NULL; |
| |
| SbiForStack* p = pForStk; |
| while( p ) |
| { |
| SbxVariable* pVar = p->refEnd.Is() ? (SbxVariable*)p->refEnd : NULL; |
| if( p->eForType == FOR_EACH_COLLECTION && pVar != NULL && |
| (pCollection = PTR_CAST(BasicCollection,pVar)) == pCollection ) |
| { |
| pRet = p; |
| break; |
| } |
| } |
| |
| return pRet; |
| } |
| |
| |
| ////////////////////////////////////////////////////////////////////////// |
| // |
| // DLL-Aufrufe |
| // |
| ////////////////////////////////////////////////////////////////////////// |
| |
| void SbiRuntime::DllCall |
| ( const String& aFuncName, // Funktionsname |
| const String& aDLLName, // Name der DLL |
| SbxArray* pArgs, // Parameter (ab Index 1, kann NULL sein) |
| SbxDataType eResType, // Returnwert |
| sal_Bool bCDecl ) // sal_True: nach C-Konventionen |
| { |
| // No DllCall for "virtual" portal users |
| if( needSecurityRestrictions() ) |
| { |
| StarBASIC::Error(SbERR_NOT_IMPLEMENTED); |
| return; |
| } |
| |
| // MUSS NOCH IMPLEMENTIERT WERDEN |
| /* |
| String aMsg; |
| aMsg = "FUNC="; |
| aMsg += pFunc; |
| aMsg += " DLL="; |
| aMsg += pDLL; |
| MessBox( NULL, WB_OK, String( "DLL-CALL" ), aMsg ).Execute(); |
| Error( SbERR_NOT_IMPLEMENTED ); |
| */ |
| |
| SbxVariable* pRes = new SbxVariable( eResType ); |
| SbiDllMgr* pDllMgr = pInst->GetDllMgr(); |
| SbError nErr = pDllMgr->Call( aFuncName, aDLLName, pArgs, *pRes, bCDecl ); |
| if( nErr ) |
| Error( nErr ); |
| PushVar( pRes ); |
| } |
| |
| sal_uInt16 SbiRuntime::GetImageFlag( sal_uInt16 n ) const |
| { |
| return pImg->GetFlag( n ); |
| } |
| |
| sal_uInt16 SbiRuntime::GetBase() |
| { |
| return pImg->GetBase(); |
| } |
