| /************************************************************** | |
| * | |
| * 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. | |
| * | |
| *************************************************************/ | |
| #ifndef _SBRUNTIME_HXX | |
| #define _SBRUNTIME_HXX | |
| #ifndef _SBX_HXX | |
| #include <basic/sbx.hxx> | |
| #endif | |
| #include "sb.hxx" | |
| // Define activates class UCBStream in iosys.cxx | |
| #define _USE_UNO | |
| #ifdef _USE_UNO | |
| #include <rtl/ustring.hxx> | |
| #include <com/sun/star/uno/Sequence.hxx> | |
| #include <osl/file.hxx> | |
| #include <rtl/math.hxx> | |
| #include <i18npool/lang.h> | |
| #include <vector> | |
| #include <com/sun/star/lang/XComponent.hpp> | |
| #include <com/sun/star/container/XEnumeration.hpp> | |
| #include <unotools/localedatawrapper.hxx> | |
| using namespace com::sun::star::uno; | |
| using namespace com::sun::star::lang; | |
| using namespace com::sun::star::container; | |
| // Define activates old file implementation | |
| // (only in non UCB case) | |
| // #define _OLD_FILE_IMPL | |
| //#include <sal/types.h> | |
| //#include <rtl/byteseq.hxx> | |
| //#include <rtl/ustring> | |
| namespace basicEncoder | |
| { | |
| // TODO: Use exported functionality (code is copied from deamons2/ucb) | |
| class AsciiEncoder | |
| { | |
| public: | |
| static ::rtl::OUString decodeUnoUrlParamValue(const rtl::OUString & rSource); | |
| //static ::rtl::OUString encodeUnoUrlParamValue(const rtl::OUString & rSource); | |
| //static ::rtl::ByteSequence decode(const ::rtl::OUString & string); | |
| //static ::rtl::OUString encode(const ::rtl::ByteSequence & bytes); | |
| //static void test(); | |
| }; | |
| } | |
| #endif /* _USE_UNO */ | |
| class SbiInstance; // aktiver StarBASIC-Prozess | |
| class SbiRuntime; // aktive StarBASIC-Prozedur-Instanz | |
| struct SbiArgvStack; // Argv stack element | |
| struct SbiGosubStack; // GOSUB stack element | |
| class SbiImage; // Code-Image | |
| class SbiIoSystem; // Dateisystem | |
| class SbiDdeControl; // DDE-Steuerung | |
| class SbiDllMgr; // Aufrufe in DLLs | |
| class SvNumberFormatter; // Zeit/Datumsfunktionen | |
| enum ForType | |
| { | |
| FOR_TO, | |
| FOR_EACH_ARRAY, | |
| FOR_EACH_COLLECTION, | |
| FOR_EACH_XENUMERATION | |
| }; | |
| struct SbiForStack { // for/next stack: | |
| SbiForStack* pNext; // Chain | |
| SbxVariableRef refVar; // loop variable | |
| SbxVariableRef refEnd; // end expression / for each: Array/BasicCollection object | |
| SbxVariableRef refInc; // increment expression | |
| // For each support | |
| ForType eForType; | |
| sal_Int32 nCurCollectionIndex; | |
| sal_Int32* pArrayCurIndices; | |
| sal_Int32* pArrayLowerBounds; | |
| sal_Int32* pArrayUpperBounds; | |
| Reference< XEnumeration > xEnumeration; | |
| SbiForStack( void ) | |
| : pArrayCurIndices( NULL ) | |
| , pArrayLowerBounds( NULL ) | |
| , pArrayUpperBounds( NULL ) | |
| {} | |
| ~SbiForStack() | |
| { | |
| delete[] pArrayCurIndices; | |
| delete[] pArrayLowerBounds; | |
| delete[] pArrayUpperBounds; | |
| } | |
| }; | |
| struct SbiGosubStack { // GOSUB-Stack: | |
| SbiGosubStack* pNext; // Chain | |
| const sal_uInt8* pCode; // Return-Pointer | |
| sal_uInt16 nStartForLvl; // #118235: For Level in moment of gosub | |
| }; | |
| #define MAXRECURSION 500 // max. 500 Rekursionen | |
| #define Sb_ATTR_NORMAL 0x0000 | |
| #define Sb_ATTR_HIDDEN 0x0002 | |
| #define Sb_ATTR_SYSTEM 0x0004 | |
| #define Sb_ATTR_VOLUME 0x0008 | |
| #define Sb_ATTR_DIRECTORY 0x0010 | |
| #define Sb_ATTR_ARCHIVE 0x0020 | |
| class Dir; | |
| class WildCard; | |
| class SbiRTLData | |
| { | |
| public: | |
| #ifdef _OLD_FILE_IMPL | |
| Dir* pDir; | |
| #else | |
| ::osl::Directory* pDir; | |
| #endif | |
| sal_Int16 nDirFlags; | |
| short nCurDirPos; | |
| String sFullNameToBeChecked; | |
| WildCard* pWildCard; | |
| #ifdef _USE_UNO | |
| Sequence< ::rtl::OUString > aDirSeq; | |
| #endif /* _USE_UNO */ | |
| SbiRTLData(); | |
| ~SbiRTLData(); | |
| }; | |
| // Die Instanz entspricht einem laufenden StarBASIC. Mehrere gleichzeitig | |
| // laufende BASICs werden ueber verkettete Instanzen verwaltet. Hier liegen | |
| // alle Daten, die nur leben, wenn BASIC auch lebt, wie z.B. das I/O-System. | |
| typedef ::std::vector | |
| < | |
| ::com::sun::star::uno::Reference< ::com::sun::star::lang::XComponent > | |
| > | |
| ComponentVector_t; | |
| class SbiInstance | |
| { | |
| friend class SbiRuntime; | |
| SbiRTLData aRTLData; | |
| SbiIoSystem* pIosys; // Dateisystem | |
| SbiDdeControl* pDdeCtrl; // DDE | |
| SbiDllMgr* pDllMgr; // DLL-Calls (DECLARE) | |
| StarBASIC* pBasic; | |
| SvNumberFormatter* pNumberFormatter; | |
| LanguageType meFormatterLangType; | |
| DateFormat meFormatterDateFormat; | |
| sal_uInt32 nStdDateIdx, nStdTimeIdx, nStdDateTimeIdx; | |
| SbError nErr; // aktueller Fehlercode | |
| String aErrorMsg; // letzte Error-Message fuer $ARG | |
| sal_uInt16 nErl; // aktuelle Fehlerzeile | |
| sal_Bool bReschedule; // Flag: sal_True = Reschedule in Hauptschleife | |
| sal_Bool bCompatibility; // Flag: sal_True = VBA runtime compatibility mode | |
| ComponentVector_t ComponentVector; | |
| public: | |
| SbiRuntime* pRun; // Call-Stack | |
| SbiInstance* pNext; // Instanzen-Chain | |
| // #31460 Neues Konzept fuer StepInto/Over/Out, | |
| // Erklaerung siehe runtime.cxx bei SbiInstance::CalcBreakCallLevel() | |
| sal_uInt16 nCallLvl; // Call-Level (wg. Rekursion) | |
| sal_uInt16 nBreakCallLvl; // Call-Level zum Anhalten | |
| void CalcBreakCallLevel( sal_uInt16 nFlags ); // Gemaess Flags setzen | |
| SbiInstance( StarBASIC* ); | |
| ~SbiInstance(); | |
| void Error( SbError ); // trappable Error | |
| void Error( SbError, const String& rMsg ); // trappable Error mit Message | |
| void ErrorVB( sal_Int32 nVBNumber, const String& rMsg ); | |
| void setErrorVB( sal_Int32 nVBNumber, const String& rMsg ); | |
| void FatalError( SbError ); // non-trappable Error | |
| void FatalError( SbError, const String& ); // non-trappable Error | |
| void Abort(); // Abbruch mit aktuellem Fehlercode | |
| void Stop(); | |
| SbError GetErr() { return nErr; } | |
| String GetErrorMsg() { return aErrorMsg; } | |
| xub_StrLen GetErl() { return nErl; } | |
| void EnableReschedule( sal_Bool bEnable ) { bReschedule = bEnable; } | |
| sal_Bool IsReschedule( void ) { return bReschedule; } | |
| void EnableCompatibility( sal_Bool bEnable ) { bCompatibility = bEnable; } | |
| sal_Bool IsCompatibility( void ) { return bCompatibility; } | |
| ComponentVector_t& getComponentVector( void ) { return ComponentVector; } | |
| SbMethod* GetCaller( sal_uInt16 ); | |
| SbModule* GetActiveModule(); | |
| SbxArray* GetLocals( SbMethod* ); | |
| SbiIoSystem* GetIoSystem() { return pIosys; } | |
| SbiDdeControl* GetDdeControl() { return pDdeCtrl; } | |
| StarBASIC* GetBasic( void ) { return pBasic; } | |
| SbiDllMgr* GetDllMgr(); | |
| SbiRTLData* GetRTLData() const { return (SbiRTLData*)&aRTLData; } | |
| SvNumberFormatter* GetNumberFormatter(); | |
| sal_uInt32 GetStdDateIdx() const { return nStdDateIdx; } | |
| sal_uInt32 GetStdTimeIdx() const { return nStdTimeIdx; } | |
| sal_uInt32 GetStdDateTimeIdx() const { return nStdDateTimeIdx; } | |
| // #39629# NumberFormatter auch statisch anbieten | |
| static void PrepareNumberFormatter( SvNumberFormatter*& rpNumberFormatter, | |
| sal_uInt32 &rnStdDateIdx, sal_uInt32 &rnStdTimeIdx, sal_uInt32 &rnStdDateTimeIdx, | |
| LanguageType* peFormatterLangType=NULL, DateFormat* peFormatterDateFormat=NULL ); | |
| }; | |
| SbiIoSystem* SbGetIoSystem(); // das aktuelle I/O-System | |
| // Verkettbare Items, um Referenzen temporaer zu halten | |
| struct RefSaveItem | |
| { | |
| SbxVariableRef xRef; | |
| RefSaveItem* pNext; | |
| RefSaveItem() { pNext = NULL; } | |
| }; | |
| // Eine Instanz dieser Klasse wird fuer jedes ausgefuehrte Unterprogramm | |
| // aufgesetzt. Diese Instanz ist das Herz der BASIC-Maschine und enthaelt | |
| // nur lokale Daten. | |
| class SbiRuntime | |
| { | |
| friend void SbRtl_CallByName( StarBASIC* pBasic, SbxArray& rPar, sal_Bool bWrite ); | |
| typedef void( SbiRuntime::*pStep0 )(); | |
| typedef void( SbiRuntime::*pStep1 )( sal_uInt32 nOp1 ); | |
| typedef void( SbiRuntime::*pStep2 )( sal_uInt32 nOp1, sal_uInt32 nOp2 ); | |
| static pStep0 aStep0[]; // Opcode-Tabelle Gruppe 0 | |
| static pStep1 aStep1[]; // Opcode-Tabelle Gruppe 1 | |
| static pStep2 aStep2[]; // Opcode-Tabelle Gruppe 2 | |
| StarBASIC& rBasic; // StarBASIC-Instanz | |
| SbiInstance* pInst; // aktiver Thread | |
| SbModule* pMod; // aktuelles Modul | |
| SbMethod* pMeth; // Methoden-Instanz | |
| SbiIoSystem* pIosys; // I/O-System | |
| const SbiImage* pImg; // Code-Image | |
| SbxArrayRef refExprStk; // expression stack | |
| SbxArrayRef refCaseStk; // CASE expression stack | |
| SbxArrayRef refRedimpArray; // Array saved to use for REDIM PRESERVE | |
| SbxVariableRef xDummyVar; // Ersatz fuer nicht gefundene Variablen | |
| SbiArgvStack* pArgvStk; // ARGV-Stack | |
| SbiGosubStack* pGosubStk; // GOSUB stack | |
| SbiForStack* pForStk; // FOR/NEXT-Stack | |
| sal_uInt16 nExprLvl; // Tiefe des Expr-Stacks | |
| sal_uInt16 nGosubLvl; // Zum Vermeiden von Tot-Rekursionen | |
| sal_uInt16 nForLvl; // #118235: Maintain for level | |
| const sal_uInt8* pCode; // aktueller Code-Pointer | |
| const sal_uInt8* pStmnt; // Beginn des lezten Statements | |
| const sal_uInt8* pError; // Adresse des aktuellen Error-Handlers | |
| const sal_uInt8* pRestart; // Restart-Adresse | |
| const sal_uInt8* pErrCode; // Restart-Adresse RESUME NEXT | |
| const sal_uInt8* pErrStmnt; // Restart-Adresse RESUMT 0 | |
| String aLibName; // Lib-Name fuer Declare-Call | |
| SbxArrayRef refParams; // aktuelle Prozedur-Parameter | |
| SbxArrayRef refLocals; // lokale Variable | |
| SbxArrayRef refArgv; // aktueller Argv | |
| // AB, 28.3.2000 #74254, Ein refSaveObj reicht nicht! Neu: pRefSaveList (s.u.) | |
| //SbxVariableRef refSaveObj; // #56368 Bei StepElem Referenz sichern | |
| short nArgc; // aktueller Argc | |
| sal_Bool bRun; // sal_True: Programm ist aktiv | |
| sal_Bool bError; // sal_True: Fehler behandeln | |
| sal_Bool bInError; // sal_True: in einem Fehler-Handler | |
| sal_Bool bBlocked; // sal_True: blocked by next call level, #i48868 | |
| sal_Bool bVBAEnabled; | |
| sal_uInt16 nFlags; // Debugging-Flags | |
| SbError nError; // letzter Fehler | |
| sal_uInt16 nOps; // Opcode-Zaehler | |
| sal_uInt32 m_nLastTime; | |
| RefSaveItem* pRefSaveList; // #74254 Temporaere Referenzen sichern | |
| RefSaveItem* pItemStoreList; // Unbenutzte Items aufbewahren | |
| void SaveRef( SbxVariable* pVar ) | |
| { | |
| RefSaveItem* pItem = pItemStoreList; | |
| if( pItem ) | |
| pItemStoreList = pItem->pNext; | |
| else | |
| pItem = new RefSaveItem(); | |
| pItem->pNext = pRefSaveList; | |
| pItem->xRef = pVar; | |
| pRefSaveList = pItem; | |
| } | |
| void ClearRefs( void ) | |
| { | |
| while( pRefSaveList ) | |
| { | |
| RefSaveItem* pToClearItem = pRefSaveList; | |
| pRefSaveList = pToClearItem->pNext; | |
| pToClearItem->xRef = NULL; | |
| pToClearItem->pNext = pItemStoreList; | |
| pItemStoreList = pToClearItem; | |
| } | |
| } | |
| SbxVariable* FindElement | |
| ( SbxObject* pObj, sal_uInt32 nOp1, sal_uInt32 nOp2, SbError, sal_Bool bLocal, sal_Bool bStatic = sal_False ); | |
| void SetupArgs( SbxVariable*, sal_uInt32 ); | |
| SbxVariable* CheckArray( SbxVariable* ); | |
| void PushVar( SbxVariable* ); // Variable push | |
| SbxVariableRef PopVar(); // Variable pop | |
| SbxVariable* GetTOS( short=0 ); // Variable vom TOS holen | |
| void TOSMakeTemp(); // TOS in temp. Variable wandeln | |
| sal_Bool ClearExprStack(); // Expr-Stack freigeben | |
| void PushGosub( const sal_uInt8* ); // GOSUB-Element push | |
| void PopGosub(); // GOSUB-Element pop | |
| void ClearGosubStack(); // GOSUB-Stack freigeben | |
| void PushArgv(); // Argv-Element push | |
| void PopArgv(); // Argv-Element pop | |
| void ClearArgvStack(); // Argv-Stack freigeben | |
| void PushFor(); // For-Element push | |
| void PushForEach(); // For-Each-Element push | |
| void PopFor(); // For-Element pop | |
| void ClearForStack(); // For-Stack freigeben | |
| void StepArith( SbxOperator ); // arithmetische Verknuepfungen | |
| void StepUnary( SbxOperator ); // unaere Verknuepfungen | |
| void StepCompare( SbxOperator );// Vergleiche | |
| void SetParameters( SbxArray* );// Parameter uebernehmen | |
| // MUSS NOCH IMPLEMENTIERT WERDEN | |
| void DllCall( const String&, const String&, SbxArray*, SbxDataType, sal_Bool ); | |
| // #56204 DIM-Funktionalitaet in Hilfsmethode auslagern (step0.cxx) | |
| void DimImpl( SbxVariableRef refVar ); | |
| // #115829 | |
| bool implIsClass( SbxObject* pObj, const String& aClass ); | |
| void StepSETCLASS_impl( sal_uInt32 nOp1, bool bHandleDflt = false ); | |
| // Die nachfolgenden Routinen werden vom Single Stepper | |
| // gerufen und implementieren die einzelnen Opcodes | |
| void StepNOP(), StepEXP(), StepMUL(), StepDIV(); | |
| void StepMOD(), StepPLUS(), StepMINUS(), StepNEG(); | |
| void StepEQ(), StepNE(), StepLT(), StepGT(); | |
| void StepLE(), StepGE(), StepIDIV(), StepAND(); | |
| void StepOR(), StepXOR(), StepEQV(), StepIMP(); | |
| void StepNOT(), StepCAT(), StepLIKE(), StepIS(); | |
| void StepCLONE(), StepOLDBASED(), StepARGC(); | |
| void StepARGV(), StepINPUT(), StepLINPUT(), StepSTOP(); | |
| void StepGET(), StepSET(), StepVBASET(), StepPUT(), StepPUTC(); | |
| void StepSET_Impl( SbxVariableRef& refVal, SbxVariableRef& refVar, bool bDefaultHandling = false ); | |
| void StepDIM(), StepREDIM(), StepREDIMP(), StepERASE(); | |
| void StepINITFOR(), StepNEXT(), StepERROR(), StepINITFOREACH(); | |
| void StepCASE(), StepENDCASE(), StepSTDERROR(); | |
| void StepNOERROR(), StepCHANNEL(), StepCHANNEL0(), StepPRINT(); | |
| void StepPRINTF(), StepWRITE(), StepRENAME(), StepPROMPT(); | |
| void StepRESTART(), StepEMPTY(), StepLEAVE(); | |
| void StepLSET(), StepRSET(), StepREDIMP_ERASE(), StepERASE_CLEAR(); | |
| void StepARRAYACCESS(), StepBYVAL(); | |
| // Alle Opcodes mit einem Operanden | |
| void StepLOADNC( sal_uInt32 ), StepLOADSC( sal_uInt32 ), StepLOADI( sal_uInt32 ); | |
| void StepARGN( sal_uInt32 ), StepBASED( sal_uInt32 ), StepPAD( sal_uInt32 ); | |
| void StepJUMP( sal_uInt32 ), StepJUMPT( sal_uInt32 ); | |
| void StepJUMPF( sal_uInt32 ), StepONJUMP( sal_uInt32 ); | |
| void StepGOSUB( sal_uInt32 ), StepRETURN( sal_uInt32 ); | |
| void StepTESTFOR( sal_uInt32 ), StepCASETO( sal_uInt32 ), StepERRHDL( sal_uInt32 ); | |
| void StepRESUME( sal_uInt32 ), StepSETCLASS( sal_uInt32 ), StepVBASETCLASS( sal_uInt32 ), StepTESTCLASS( sal_uInt32 ), StepLIB( sal_uInt32 ); | |
| bool checkClass_Impl( const SbxVariableRef& refVal, const String& aClass, bool bRaiseErrors, bool bDefault = true ); | |
| void StepCLOSE( sal_uInt32 ), StepPRCHAR( sal_uInt32 ), StepARGTYP( sal_uInt32 ); | |
| // Alle Opcodes mit zwei Operanden | |
| void StepRTL( sal_uInt32, sal_uInt32 ), StepPUBLIC( sal_uInt32, sal_uInt32 ), StepPUBLIC_P( sal_uInt32, sal_uInt32 ); | |
| void StepPUBLIC_Impl( sal_uInt32, sal_uInt32, bool bUsedForClassModule ); | |
| void StepFIND_Impl( SbxObject* pObj, sal_uInt32 nOp1, sal_uInt32 nOp2, SbError, sal_Bool bLocal, sal_Bool bStatic = sal_False ); | |
| void StepFIND( sal_uInt32, sal_uInt32 ), StepELEM( sal_uInt32, sal_uInt32 ); | |
| void StepGLOBAL( sal_uInt32, sal_uInt32 ), StepLOCAL( sal_uInt32, sal_uInt32 ); | |
| void StepPARAM( sal_uInt32, sal_uInt32), StepCREATE( sal_uInt32, sal_uInt32 ); | |
| void StepCALL( sal_uInt32, sal_uInt32 ), StepCALLC( sal_uInt32, sal_uInt32 ); | |
| void StepCASEIS( sal_uInt32, sal_uInt32 ), StepSTMNT( sal_uInt32, sal_uInt32 ); | |
| SbxVariable* StepSTATIC_Impl( String& aName, SbxDataType& t ); | |
| void StepOPEN( sal_uInt32, sal_uInt32 ), StepSTATIC( sal_uInt32, sal_uInt32 ); | |
| void StepTCREATE(sal_uInt32,sal_uInt32), StepDCREATE(sal_uInt32,sal_uInt32); | |
| void StepGLOBAL_P( sal_uInt32, sal_uInt32 ),StepFIND_G( sal_uInt32, sal_uInt32 ); | |
| void StepDCREATE_REDIMP(sal_uInt32,sal_uInt32), StepDCREATE_IMPL(sal_uInt32,sal_uInt32); | |
| void StepFIND_CM( sal_uInt32, sal_uInt32 ); | |
| void StepFIND_STATIC( sal_uInt32, sal_uInt32 ); | |
| void implHandleSbxFlags( SbxVariable* pVar, SbxDataType t, sal_uInt32 nOp2 ); | |
| public: | |
| void SetVBAEnabled( bool bEnabled ); | |
| sal_uInt16 GetImageFlag( sal_uInt16 n ) const; | |
| sal_uInt16 GetBase(); | |
| xub_StrLen nLine,nCol1,nCol2; // aktuelle Zeile, Spaltenbereich | |
| SbiRuntime* pNext; // Stack-Chain | |
| SbiRuntime( SbModule*, SbMethod*, sal_uInt32 ); | |
| ~SbiRuntime(); | |
| void Error( SbError, bool bVBATranslationAlreadyDone = false ); // Fehler setzen, falls != 0 | |
| void Error( SbError, const String& ); // Fehler setzen, falls != 0 | |
| void FatalError( SbError ); // Fehlerbehandlung=Standard, Fehler setzen | |
| void FatalError( SbError, const String& ); // Fehlerbehandlung=Standard, Fehler setzen | |
| static sal_Int32 translateErrorToVba( SbError nError, String& rMsg ); | |
| void DumpPCode(); | |
| sal_Bool Step(); // Einzelschritt (ein Opcode) | |
| void Stop() { bRun = sal_False; } | |
| sal_Bool IsRun() { return bRun; } | |
| void block( void ) { bBlocked = sal_True; } | |
| void unblock( void ) { bBlocked = sal_False; } | |
| SbMethod* GetMethod() { return pMeth; } | |
| SbModule* GetModule() { return pMod; } | |
| sal_uInt16 GetDebugFlags() { return nFlags; } | |
| void SetDebugFlags( sal_uInt16 nFl ) { nFlags = nFl; } | |
| SbMethod* GetCaller(); | |
| SbxArray* GetLocals(); | |
| SbxArray* GetParams(); | |
| SbiForStack* FindForStackItemForCollection( class BasicCollection* pCollection ); | |
| SbxBase* FindElementExtern( const String& rName ); | |
| static bool isVBAEnabled(); | |
| }; | |
| inline void checkArithmeticOverflow( double d ) | |
| { | |
| if( !::rtl::math::isFinite( d ) ) | |
| StarBASIC::Error( SbERR_MATH_OVERFLOW ); | |
| } | |
| inline void checkArithmeticOverflow( SbxVariable* pVar ) | |
| { | |
| if( pVar->GetType() == SbxDOUBLE ) | |
| { | |
| double d = pVar->GetDouble(); | |
| checkArithmeticOverflow( d ); | |
| } | |
| } | |
| // Hilfsfunktion, um aktives Basic zu finden | |
| StarBASIC* GetCurrentBasic( StarBASIC* pRTBasic ); | |
| // Get information if security restrictions should be | |
| // used (File IO based on UCB, no RTL function SHELL | |
| // no DDE functionality, no DLLCALL) in basic because | |
| // of portal "virtual" users (portal user != UNIX user) | |
| // (Implemented in iosys.cxx) | |
| sal_Bool needSecurityRestrictions( void ); | |
| // Returns sal_True if UNO is available, otherwise the old | |
| // file system implementation has to be used | |
| // (Implemented in iosys.cxx) | |
| sal_Bool hasUno( void ); | |
| // Converts possibly relative paths to absolute paths | |
| // according to the setting done by ChDir/ChDrive | |
| // (Implemented in methods.cxx) | |
| String getFullPath( const String& aRelPath ); | |
| // Sets (virtual) current path for UCB file access | |
| void implChDir( const String& aDir ); | |
| // Sets (virtual) current drive for UCB file access | |
| void implChDrive( const String& aDrive ); | |
| // Returns (virtual) current path for UCB file access | |
| String implGetCurDir( void ); | |
| // Implementation of StepRENAME with UCB | |
| // (Implemented in methods.cxx, so step0.cxx | |
| // has not to be infected with UNO) | |
| void implStepRenameUCB( const String& aSource, const String& aDest ); | |
| //*** OSL file access *** | |
| // #87427 OSL need File URLs, so map to getFullPath | |
| inline String getFullPathUNC( const String& aRelPath ) | |
| { | |
| return getFullPath( aRelPath ); | |
| } | |
| void implStepRenameOSL( const String& aSource, const String& aDest ); | |
| bool IsBaseIndexOne(); | |
| #endif |