1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 #ifndef _SBRUNTIME_HXX 25 #define _SBRUNTIME_HXX 26 27 #ifndef _SBX_HXX 28 #include <basic/sbx.hxx> 29 #endif 30 31 #include "sb.hxx" 32 33 // Define activates class UCBStream in iosys.cxx 34 #define _USE_UNO 35 36 #ifdef _USE_UNO 37 #include <rtl/ustring.hxx> 38 #include <com/sun/star/uno/Sequence.hxx> 39 #include <osl/file.hxx> 40 #include <rtl/math.hxx> 41 #include <i18npool/lang.h> 42 43 #include <vector> 44 #include <com/sun/star/lang/XComponent.hpp> 45 #include <com/sun/star/container/XEnumeration.hpp> 46 #include <unotools/localedatawrapper.hxx> 47 48 using namespace com::sun::star::uno; 49 using namespace com::sun::star::lang; 50 using namespace com::sun::star::container; 51 52 53 // Define activates old file implementation 54 // (only in non UCB case) 55 // #define _OLD_FILE_IMPL 56 57 58 //#include <sal/types.h> 59 //#include <rtl/byteseq.hxx> 60 //#include <rtl/ustring> 61 62 63 namespace basicEncoder 64 { 65 66 // TODO: Use exported functionality (code is copied from deamons2/ucb) 67 class AsciiEncoder 68 { 69 public: 70 static ::rtl::OUString decodeUnoUrlParamValue(const rtl::OUString & rSource); 71 //static ::rtl::OUString encodeUnoUrlParamValue(const rtl::OUString & rSource); 72 //static ::rtl::ByteSequence decode(const ::rtl::OUString & string); 73 //static ::rtl::OUString encode(const ::rtl::ByteSequence & bytes); 74 //static void test(); 75 }; 76 77 } 78 79 #endif /* _USE_UNO */ 80 81 class SbiInstance; // aktiver StarBASIC-Prozess 82 class SbiRuntime; // aktive StarBASIC-Prozedur-Instanz 83 84 struct SbiArgvStack; // Argv stack element 85 struct SbiGosubStack; // GOSUB stack element 86 class SbiImage; // Code-Image 87 class SbiIoSystem; // Dateisystem 88 class SbiDdeControl; // DDE-Steuerung 89 class SbiDllMgr; // Aufrufe in DLLs 90 class SvNumberFormatter; // Zeit/Datumsfunktionen 91 92 enum ForType 93 { 94 FOR_TO, 95 FOR_EACH_ARRAY, 96 FOR_EACH_COLLECTION, 97 FOR_EACH_XENUMERATION 98 }; 99 100 struct SbiForStack { // for/next stack: 101 SbiForStack* pNext; // Chain 102 SbxVariableRef refVar; // loop variable 103 SbxVariableRef refEnd; // end expression / for each: Array/BasicCollection object 104 SbxVariableRef refInc; // increment expression 105 106 // For each support 107 ForType eForType; 108 sal_Int32 nCurCollectionIndex; 109 sal_Int32* pArrayCurIndices; 110 sal_Int32* pArrayLowerBounds; 111 sal_Int32* pArrayUpperBounds; 112 Reference< XEnumeration > xEnumeration; 113 114 SbiForStack( void ) 115 : pArrayCurIndices( NULL ) 116 , pArrayLowerBounds( NULL ) 117 , pArrayUpperBounds( NULL ) 118 {} 119 ~SbiForStack() 120 { 121 delete[] pArrayCurIndices; 122 delete[] pArrayLowerBounds; 123 delete[] pArrayUpperBounds; 124 } 125 }; 126 127 struct SbiGosubStack { // GOSUB-Stack: 128 SbiGosubStack* pNext; // Chain 129 const sal_uInt8* pCode; // Return-Pointer 130 sal_uInt16 nStartForLvl; // #118235: For Level in moment of gosub 131 }; 132 133 #define MAXRECURSION 500 // max. 500 Rekursionen 134 135 #define Sb_ATTR_NORMAL 0x0000 136 #define Sb_ATTR_HIDDEN 0x0002 137 #define Sb_ATTR_SYSTEM 0x0004 138 #define Sb_ATTR_VOLUME 0x0008 139 #define Sb_ATTR_DIRECTORY 0x0010 140 #define Sb_ATTR_ARCHIVE 0x0020 141 142 143 class Dir; 144 class WildCard; 145 146 class SbiRTLData 147 { 148 public: 149 150 #ifdef _OLD_FILE_IMPL 151 Dir* pDir; 152 #else 153 ::osl::Directory* pDir; 154 #endif 155 sal_Int16 nDirFlags; 156 short nCurDirPos; 157 158 String sFullNameToBeChecked; 159 WildCard* pWildCard; 160 161 #ifdef _USE_UNO 162 Sequence< ::rtl::OUString > aDirSeq; 163 #endif /* _USE_UNO */ 164 165 SbiRTLData(); 166 ~SbiRTLData(); 167 }; 168 169 // Die Instanz entspricht einem laufenden StarBASIC. Mehrere gleichzeitig 170 // laufende BASICs werden ueber verkettete Instanzen verwaltet. Hier liegen 171 // alle Daten, die nur leben, wenn BASIC auch lebt, wie z.B. das I/O-System. 172 173 typedef ::std::vector 174 < 175 ::com::sun::star::uno::Reference< ::com::sun::star::lang::XComponent > 176 > 177 ComponentVector_t; 178 179 180 class SbiInstance 181 { 182 friend class SbiRuntime; 183 184 SbiRTLData aRTLData; 185 186 SbiIoSystem* pIosys; // Dateisystem 187 SbiDdeControl* pDdeCtrl; // DDE 188 SbiDllMgr* pDllMgr; // DLL-Calls (DECLARE) 189 StarBASIC* pBasic; 190 SvNumberFormatter* pNumberFormatter; 191 LanguageType meFormatterLangType; 192 DateFormat meFormatterDateFormat; 193 sal_uInt32 nStdDateIdx, nStdTimeIdx, nStdDateTimeIdx; 194 195 SbError nErr; // aktueller Fehlercode 196 String aErrorMsg; // letzte Error-Message fuer $ARG 197 sal_uInt16 nErl; // aktuelle Fehlerzeile 198 sal_Bool bReschedule; // Flag: sal_True = Reschedule in Hauptschleife 199 sal_Bool bCompatibility; // Flag: sal_True = VBA runtime compatibility mode 200 201 ComponentVector_t ComponentVector; 202 203 public: 204 SbiRuntime* pRun; // Call-Stack 205 SbiInstance* pNext; // Instanzen-Chain 206 207 // #31460 Neues Konzept fuer StepInto/Over/Out, 208 // Erklaerung siehe runtime.cxx bei SbiInstance::CalcBreakCallLevel() 209 sal_uInt16 nCallLvl; // Call-Level (wg. Rekursion) 210 sal_uInt16 nBreakCallLvl; // Call-Level zum Anhalten 211 void CalcBreakCallLevel( sal_uInt16 nFlags ); // Gemaess Flags setzen 212 213 SbiInstance( StarBASIC* ); 214 ~SbiInstance(); 215 216 void Error( SbError ); // trappable Error 217 void Error( SbError, const String& rMsg ); // trappable Error mit Message 218 void ErrorVB( sal_Int32 nVBNumber, const String& rMsg ); 219 void setErrorVB( sal_Int32 nVBNumber, const String& rMsg ); 220 void FatalError( SbError ); // non-trappable Error 221 void FatalError( SbError, const String& ); // non-trappable Error 222 void Abort(); // Abbruch mit aktuellem Fehlercode 223 224 void Stop(); 225 SbError GetErr() { return nErr; } 226 String GetErrorMsg() { return aErrorMsg; } 227 xub_StrLen GetErl() { return nErl; } 228 void EnableReschedule( sal_Bool bEnable ) { bReschedule = bEnable; } 229 sal_Bool IsReschedule( void ) { return bReschedule; } 230 void EnableCompatibility( sal_Bool bEnable ) { bCompatibility = bEnable; } 231 sal_Bool IsCompatibility( void ) { return bCompatibility; } 232 233 ComponentVector_t& getComponentVector( void ) { return ComponentVector; } 234 235 SbMethod* GetCaller( sal_uInt16 ); 236 SbModule* GetActiveModule(); 237 SbxArray* GetLocals( SbMethod* ); 238 239 SbiIoSystem* GetIoSystem() { return pIosys; } 240 SbiDdeControl* GetDdeControl() { return pDdeCtrl; } 241 StarBASIC* GetBasic( void ) { return pBasic; } 242 SbiDllMgr* GetDllMgr(); 243 SbiRTLData* GetRTLData() const { return (SbiRTLData*)&aRTLData; } 244 245 SvNumberFormatter* GetNumberFormatter(); 246 sal_uInt32 GetStdDateIdx() const { return nStdDateIdx; } 247 sal_uInt32 GetStdTimeIdx() const { return nStdTimeIdx; } 248 sal_uInt32 GetStdDateTimeIdx() const { return nStdDateTimeIdx; } 249 250 // #39629# NumberFormatter auch statisch anbieten 251 static void PrepareNumberFormatter( SvNumberFormatter*& rpNumberFormatter, 252 sal_uInt32 &rnStdDateIdx, sal_uInt32 &rnStdTimeIdx, sal_uInt32 &rnStdDateTimeIdx, 253 LanguageType* peFormatterLangType=NULL, DateFormat* peFormatterDateFormat=NULL ); 254 }; 255 256 SbiIoSystem* SbGetIoSystem(); // das aktuelle I/O-System 257 258 259 // Verkettbare Items, um Referenzen temporaer zu halten 260 struct RefSaveItem 261 { 262 SbxVariableRef xRef; 263 RefSaveItem* pNext; 264 265 RefSaveItem() { pNext = NULL; } 266 }; 267 268 269 // Eine Instanz dieser Klasse wird fuer jedes ausgefuehrte Unterprogramm 270 // aufgesetzt. Diese Instanz ist das Herz der BASIC-Maschine und enthaelt 271 // nur lokale Daten. 272 273 class SbiRuntime 274 { 275 friend void SbRtl_CallByName( StarBASIC* pBasic, SbxArray& rPar, sal_Bool bWrite ); 276 277 typedef void( SbiRuntime::*pStep0 )(); 278 typedef void( SbiRuntime::*pStep1 )( sal_uInt32 nOp1 ); 279 typedef void( SbiRuntime::*pStep2 )( sal_uInt32 nOp1, sal_uInt32 nOp2 ); 280 static pStep0 aStep0[]; // Opcode-Tabelle Gruppe 0 281 static pStep1 aStep1[]; // Opcode-Tabelle Gruppe 1 282 static pStep2 aStep2[]; // Opcode-Tabelle Gruppe 2 283 284 StarBASIC& rBasic; // StarBASIC-Instanz 285 SbiInstance* pInst; // aktiver Thread 286 SbModule* pMod; // aktuelles Modul 287 SbMethod* pMeth; // Methoden-Instanz 288 SbiIoSystem* pIosys; // I/O-System 289 const SbiImage* pImg; // Code-Image 290 SbxArrayRef refExprStk; // expression stack 291 SbxArrayRef refCaseStk; // CASE expression stack 292 SbxArrayRef refRedimpArray; // Array saved to use for REDIM PRESERVE 293 SbxVariableRef xDummyVar; // Ersatz fuer nicht gefundene Variablen 294 SbiArgvStack* pArgvStk; // ARGV-Stack 295 SbiGosubStack* pGosubStk; // GOSUB stack 296 SbiForStack* pForStk; // FOR/NEXT-Stack 297 sal_uInt16 nExprLvl; // Tiefe des Expr-Stacks 298 sal_uInt16 nGosubLvl; // Zum Vermeiden von Tot-Rekursionen 299 sal_uInt16 nForLvl; // #118235: Maintain for level 300 const sal_uInt8* pCode; // aktueller Code-Pointer 301 const sal_uInt8* pStmnt; // Beginn des lezten Statements 302 const sal_uInt8* pError; // Adresse des aktuellen Error-Handlers 303 const sal_uInt8* pRestart; // Restart-Adresse 304 const sal_uInt8* pErrCode; // Restart-Adresse RESUME NEXT 305 const sal_uInt8* pErrStmnt; // Restart-Adresse RESUMT 0 306 String aLibName; // Lib-Name fuer Declare-Call 307 SbxArrayRef refParams; // aktuelle Prozedur-Parameter 308 SbxArrayRef refLocals; // lokale Variable 309 SbxArrayRef refArgv; // aktueller Argv 310 // AB, 28.3.2000 #74254, Ein refSaveObj reicht nicht! Neu: pRefSaveList (s.u.) 311 //SbxVariableRef refSaveObj; // #56368 Bei StepElem Referenz sichern 312 short nArgc; // aktueller Argc 313 sal_Bool bRun; // sal_True: Programm ist aktiv 314 sal_Bool bError; // sal_True: Fehler behandeln 315 sal_Bool bInError; // sal_True: in einem Fehler-Handler 316 sal_Bool bBlocked; // sal_True: blocked by next call level, #i48868 317 sal_Bool bVBAEnabled; 318 sal_uInt16 nFlags; // Debugging-Flags 319 SbError nError; // letzter Fehler 320 sal_uInt16 nOps; // Opcode-Zaehler 321 sal_uInt32 m_nLastTime; 322 323 RefSaveItem* pRefSaveList; // #74254 Temporaere Referenzen sichern 324 RefSaveItem* pItemStoreList; // Unbenutzte Items aufbewahren 325 void SaveRef( SbxVariable* pVar ) 326 { 327 RefSaveItem* pItem = pItemStoreList; 328 if( pItem ) 329 pItemStoreList = pItem->pNext; 330 else 331 pItem = new RefSaveItem(); 332 pItem->pNext = pRefSaveList; 333 pItem->xRef = pVar; 334 pRefSaveList = pItem; 335 } 336 void ClearRefs( void ) 337 { 338 while( pRefSaveList ) 339 { 340 RefSaveItem* pToClearItem = pRefSaveList; 341 pRefSaveList = pToClearItem->pNext; 342 pToClearItem->xRef = NULL; 343 pToClearItem->pNext = pItemStoreList; 344 pItemStoreList = pToClearItem; 345 } 346 } 347 348 SbxVariable* FindElement 349 ( SbxObject* pObj, sal_uInt32 nOp1, sal_uInt32 nOp2, SbError, sal_Bool bLocal, sal_Bool bStatic = sal_False ); 350 void SetupArgs( SbxVariable*, sal_uInt32 ); 351 SbxVariable* CheckArray( SbxVariable* ); 352 353 void PushVar( SbxVariable* ); // Variable push 354 SbxVariableRef PopVar(); // Variable pop 355 SbxVariable* GetTOS( short=0 ); // Variable vom TOS holen 356 void TOSMakeTemp(); // TOS in temp. Variable wandeln 357 sal_Bool ClearExprStack(); // Expr-Stack freigeben 358 359 void PushGosub( const sal_uInt8* ); // GOSUB-Element push 360 void PopGosub(); // GOSUB-Element pop 361 void ClearGosubStack(); // GOSUB-Stack freigeben 362 363 void PushArgv(); // Argv-Element push 364 void PopArgv(); // Argv-Element pop 365 void ClearArgvStack(); // Argv-Stack freigeben 366 367 void PushFor(); // For-Element push 368 void PushForEach(); // For-Each-Element push 369 void PopFor(); // For-Element pop 370 void ClearForStack(); // For-Stack freigeben 371 372 void StepArith( SbxOperator ); // arithmetische Verknuepfungen 373 void StepUnary( SbxOperator ); // unaere Verknuepfungen 374 void StepCompare( SbxOperator );// Vergleiche 375 376 void SetParameters( SbxArray* );// Parameter uebernehmen 377 378 // MUSS NOCH IMPLEMENTIERT WERDEN 379 void DllCall( const String&, const String&, SbxArray*, SbxDataType, sal_Bool ); 380 381 // #56204 DIM-Funktionalitaet in Hilfsmethode auslagern (step0.cxx) 382 void DimImpl( SbxVariableRef refVar ); 383 384 // #115829 385 bool implIsClass( SbxObject* pObj, const String& aClass ); 386 387 void StepSETCLASS_impl( sal_uInt32 nOp1, bool bHandleDflt = false ); 388 389 // Die nachfolgenden Routinen werden vom Single Stepper 390 // gerufen und implementieren die einzelnen Opcodes 391 void StepNOP(), StepEXP(), StepMUL(), StepDIV(); 392 void StepMOD(), StepPLUS(), StepMINUS(), StepNEG(); 393 void StepEQ(), StepNE(), StepLT(), StepGT(); 394 void StepLE(), StepGE(), StepIDIV(), StepAND(); 395 void StepOR(), StepXOR(), StepEQV(), StepIMP(); 396 void StepNOT(), StepCAT(), StepLIKE(), StepIS(); 397 void StepCLONE(), StepOLDBASED(), StepARGC(); 398 void StepARGV(), StepINPUT(), StepLINPUT(), StepSTOP(); 399 void StepGET(), StepSET(), StepVBASET(), StepPUT(), StepPUTC(); 400 void StepSET_Impl( SbxVariableRef& refVal, SbxVariableRef& refVar, bool bDefaultHandling = false ); 401 void StepDIM(), StepREDIM(), StepREDIMP(), StepERASE(); 402 void StepINITFOR(), StepNEXT(), StepERROR(), StepINITFOREACH(); 403 void StepCASE(), StepENDCASE(), StepSTDERROR(); 404 void StepNOERROR(), StepCHANNEL(), StepCHANNEL0(), StepPRINT(); 405 void StepPRINTF(), StepWRITE(), StepRENAME(), StepPROMPT(); 406 void StepRESTART(), StepEMPTY(), StepLEAVE(); 407 void StepLSET(), StepRSET(), StepREDIMP_ERASE(), StepERASE_CLEAR(); 408 void StepARRAYACCESS(), StepBYVAL(); 409 // Alle Opcodes mit einem Operanden 410 void StepLOADNC( sal_uInt32 ), StepLOADSC( sal_uInt32 ), StepLOADI( sal_uInt32 ); 411 void StepARGN( sal_uInt32 ), StepBASED( sal_uInt32 ), StepPAD( sal_uInt32 ); 412 void StepJUMP( sal_uInt32 ), StepJUMPT( sal_uInt32 ); 413 void StepJUMPF( sal_uInt32 ), StepONJUMP( sal_uInt32 ); 414 void StepGOSUB( sal_uInt32 ), StepRETURN( sal_uInt32 ); 415 void StepTESTFOR( sal_uInt32 ), StepCASETO( sal_uInt32 ), StepERRHDL( sal_uInt32 ); 416 void StepRESUME( sal_uInt32 ), StepSETCLASS( sal_uInt32 ), StepVBASETCLASS( sal_uInt32 ), StepTESTCLASS( sal_uInt32 ), StepLIB( sal_uInt32 ); 417 bool checkClass_Impl( const SbxVariableRef& refVal, const String& aClass, bool bRaiseErrors, bool bDefault = true ); 418 void StepCLOSE( sal_uInt32 ), StepPRCHAR( sal_uInt32 ), StepARGTYP( sal_uInt32 ); 419 // Alle Opcodes mit zwei Operanden 420 void StepRTL( sal_uInt32, sal_uInt32 ), StepPUBLIC( sal_uInt32, sal_uInt32 ), StepPUBLIC_P( sal_uInt32, sal_uInt32 ); 421 void StepPUBLIC_Impl( sal_uInt32, sal_uInt32, bool bUsedForClassModule ); 422 void StepFIND_Impl( SbxObject* pObj, sal_uInt32 nOp1, sal_uInt32 nOp2, SbError, sal_Bool bLocal, sal_Bool bStatic = sal_False ); 423 void StepFIND( sal_uInt32, sal_uInt32 ), StepELEM( sal_uInt32, sal_uInt32 ); 424 void StepGLOBAL( sal_uInt32, sal_uInt32 ), StepLOCAL( sal_uInt32, sal_uInt32 ); 425 void StepPARAM( sal_uInt32, sal_uInt32), StepCREATE( sal_uInt32, sal_uInt32 ); 426 void StepCALL( sal_uInt32, sal_uInt32 ), StepCALLC( sal_uInt32, sal_uInt32 ); 427 void StepCASEIS( sal_uInt32, sal_uInt32 ), StepSTMNT( sal_uInt32, sal_uInt32 ); 428 SbxVariable* StepSTATIC_Impl( String& aName, SbxDataType& t ); 429 void StepOPEN( sal_uInt32, sal_uInt32 ), StepSTATIC( sal_uInt32, sal_uInt32 ); 430 void StepTCREATE(sal_uInt32,sal_uInt32), StepDCREATE(sal_uInt32,sal_uInt32); 431 void StepGLOBAL_P( sal_uInt32, sal_uInt32 ),StepFIND_G( sal_uInt32, sal_uInt32 ); 432 void StepDCREATE_REDIMP(sal_uInt32,sal_uInt32), StepDCREATE_IMPL(sal_uInt32,sal_uInt32); 433 void StepFIND_CM( sal_uInt32, sal_uInt32 ); 434 void StepFIND_STATIC( sal_uInt32, sal_uInt32 ); 435 void implHandleSbxFlags( SbxVariable* pVar, SbxDataType t, sal_uInt32 nOp2 ); 436 public: 437 void SetVBAEnabled( bool bEnabled ); 438 sal_uInt16 GetImageFlag( sal_uInt16 n ) const; 439 sal_uInt16 GetBase(); 440 xub_StrLen nLine,nCol1,nCol2; // aktuelle Zeile, Spaltenbereich 441 SbiRuntime* pNext; // Stack-Chain 442 443 SbiRuntime( SbModule*, SbMethod*, sal_uInt32 ); 444 ~SbiRuntime(); 445 void Error( SbError, bool bVBATranslationAlreadyDone = false ); // Fehler setzen, falls != 0 446 void Error( SbError, const String& ); // Fehler setzen, falls != 0 447 void FatalError( SbError ); // Fehlerbehandlung=Standard, Fehler setzen 448 void FatalError( SbError, const String& ); // Fehlerbehandlung=Standard, Fehler setzen 449 static sal_Int32 translateErrorToVba( SbError nError, String& rMsg ); 450 void DumpPCode(); 451 sal_Bool Step(); // Einzelschritt (ein Opcode) 452 void Stop() { bRun = sal_False; } 453 sal_Bool IsRun() { return bRun; } 454 void block( void ) { bBlocked = sal_True; } 455 void unblock( void ) { bBlocked = sal_False; } 456 SbMethod* GetMethod() { return pMeth; } 457 SbModule* GetModule() { return pMod; } 458 sal_uInt16 GetDebugFlags() { return nFlags; } 459 void SetDebugFlags( sal_uInt16 nFl ) { nFlags = nFl; } 460 SbMethod* GetCaller(); 461 SbxArray* GetLocals(); 462 SbxArray* GetParams(); 463 464 SbiForStack* FindForStackItemForCollection( class BasicCollection* pCollection ); 465 466 SbxBase* FindElementExtern( const String& rName ); 467 static bool isVBAEnabled(); 468 469 }; 470 471 inline void checkArithmeticOverflow( double d ) 472 { 473 if( !::rtl::math::isFinite( d ) ) 474 StarBASIC::Error( SbERR_MATH_OVERFLOW ); 475 } 476 477 inline void checkArithmeticOverflow( SbxVariable* pVar ) 478 { 479 if( pVar->GetType() == SbxDOUBLE ) 480 { 481 double d = pVar->GetDouble(); 482 checkArithmeticOverflow( d ); 483 } 484 } 485 486 // Hilfsfunktion, um aktives Basic zu finden 487 StarBASIC* GetCurrentBasic( StarBASIC* pRTBasic ); 488 489 // Get information if security restrictions should be 490 // used (File IO based on UCB, no RTL function SHELL 491 // no DDE functionality, no DLLCALL) in basic because 492 // of portal "virtual" users (portal user != UNIX user) 493 // (Implemented in iosys.cxx) 494 sal_Bool needSecurityRestrictions( void ); 495 496 // Returns sal_True if UNO is available, otherwise the old 497 // file system implementation has to be used 498 // (Implemented in iosys.cxx) 499 sal_Bool hasUno( void ); 500 501 // Converts possibly relative paths to absolute paths 502 // according to the setting done by ChDir/ChDrive 503 // (Implemented in methods.cxx) 504 String getFullPath( const String& aRelPath ); 505 506 // Sets (virtual) current path for UCB file access 507 void implChDir( const String& aDir ); 508 509 // Sets (virtual) current drive for UCB file access 510 void implChDrive( const String& aDrive ); 511 512 // Returns (virtual) current path for UCB file access 513 String implGetCurDir( void ); 514 515 // Implementation of StepRENAME with UCB 516 // (Implemented in methods.cxx, so step0.cxx 517 // has not to be infected with UNO) 518 void implStepRenameUCB( const String& aSource, const String& aDest ); 519 520 //*** OSL file access *** 521 // #87427 OSL need File URLs, so map to getFullPath 522 inline String getFullPathUNC( const String& aRelPath ) 523 { 524 return getFullPath( aRelPath ); 525 } 526 void implStepRenameOSL( const String& aSource, const String& aDest ); 527 bool IsBaseIndexOne(); 528 529 #endif 530 531