1*89b56da7SAndrew Rist /**************************************************************
2cdf0e10cSrcweir *
3*89b56da7SAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
4*89b56da7SAndrew Rist * or more contributor license agreements. See the NOTICE file
5*89b56da7SAndrew Rist * distributed with this work for additional information
6*89b56da7SAndrew Rist * regarding copyright ownership. The ASF licenses this file
7*89b56da7SAndrew Rist * to you under the Apache License, Version 2.0 (the
8*89b56da7SAndrew Rist * "License"); you may not use this file except in compliance
9*89b56da7SAndrew Rist * with the License. You may obtain a copy of the License at
10*89b56da7SAndrew Rist *
11*89b56da7SAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
12*89b56da7SAndrew Rist *
13*89b56da7SAndrew Rist * Unless required by applicable law or agreed to in writing,
14*89b56da7SAndrew Rist * software distributed under the License is distributed on an
15*89b56da7SAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*89b56da7SAndrew Rist * KIND, either express or implied. See the License for the
17*89b56da7SAndrew Rist * specific language governing permissions and limitations
18*89b56da7SAndrew Rist * under the License.
19*89b56da7SAndrew Rist *
20*89b56da7SAndrew Rist *************************************************************/
21*89b56da7SAndrew Rist
22*89b56da7SAndrew Rist
23cdf0e10cSrcweir
24cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove
25cdf0e10cSrcweir #include "precompiled_tools.hxx"
26cdf0e10cSrcweir
27cdf0e10cSrcweir
28cdf0e10cSrcweir #if !defined UNX
29cdf0e10cSrcweir #include <io.h>
30cdf0e10cSrcweir #include <process.h>
31cdf0e10cSrcweir #endif
32cdf0e10cSrcweir
33cdf0e10cSrcweir #if defined(UNX) || defined(OS2)
34cdf0e10cSrcweir #include <unistd.h>
35cdf0e10cSrcweir #include <sys/types.h>
36cdf0e10cSrcweir #include <sys/stat.h>
37cdf0e10cSrcweir #endif
38cdf0e10cSrcweir
39cdf0e10cSrcweir #include <ctype.h>
40cdf0e10cSrcweir #include <errno.h>
41cdf0e10cSrcweir #include <stdlib.h>
42cdf0e10cSrcweir #include <stdio.h>
43cdf0e10cSrcweir #include <string.h>
44cdf0e10cSrcweir #include <tools/debug.hxx>
45cdf0e10cSrcweir #include <tools/list.hxx>
46cdf0e10cSrcweir #include "comdep.hxx"
47cdf0e10cSrcweir #include <tools/fsys.hxx>
48cdf0e10cSrcweir #define _TOOLS_HXX
49cdf0e10cSrcweir #include <tools/urlobj.hxx>
50cdf0e10cSrcweir
51cdf0e10cSrcweir #ifdef UNX
52cdf0e10cSrcweir #define _MAX_PATH 260
53cdf0e10cSrcweir #endif
54cdf0e10cSrcweir #include <tools/stream.hxx>
55cdf0e10cSrcweir
56cdf0e10cSrcweir #ifndef _VOS_MUTEX_HXX
57cdf0e10cSrcweir #include <vos/mutex.hxx>
58cdf0e10cSrcweir #endif
59cdf0e10cSrcweir
60cdf0e10cSrcweir #include <osl/file.hxx>
61cdf0e10cSrcweir #include <rtl/instance.hxx>
62cdf0e10cSrcweir
63cdf0e10cSrcweir
64cdf0e10cSrcweir using namespace osl;
65cdf0e10cSrcweir using namespace rtl;
66cdf0e10cSrcweir
67cdf0e10cSrcweir int ApiRet2ToSolarError_Impl( int nApiRet );
68cdf0e10cSrcweir
69cdf0e10cSrcweir //--------------------------------------------------------------------
Sys2SolarError_Impl(int nSysErr)70cdf0e10cSrcweir int Sys2SolarError_Impl( int nSysErr )
71cdf0e10cSrcweir {
72cdf0e10cSrcweir switch ( nSysErr )
73cdf0e10cSrcweir {
74cdf0e10cSrcweir #ifdef WNT
75cdf0e10cSrcweir case NO_ERROR: return ERRCODE_NONE;
76cdf0e10cSrcweir case ERROR_INVALID_FUNCTION: return ERRCODE_IO_GENERAL;
77cdf0e10cSrcweir case ERROR_FILE_NOT_FOUND: return ERRCODE_IO_NOTEXISTS;
78cdf0e10cSrcweir case ERROR_PATH_NOT_FOUND: return ERRCODE_IO_NOTEXISTSPATH;
79cdf0e10cSrcweir case ERROR_TOO_MANY_OPEN_FILES: return ERRCODE_IO_TOOMANYOPENFILES;
80cdf0e10cSrcweir case ERROR_ACCESS_DENIED: return ERRCODE_IO_ACCESSDENIED;
81cdf0e10cSrcweir case ERROR_INVALID_HANDLE: return ERRCODE_IO_GENERAL;
82cdf0e10cSrcweir case ERROR_NOT_ENOUGH_MEMORY: return ERRCODE_IO_OUTOFMEMORY;
83cdf0e10cSrcweir case ERROR_INVALID_BLOCK: return ERRCODE_IO_GENERAL;
84cdf0e10cSrcweir // case ERROR_BAD_ENVIRONMENT: return ERRCODE_IO_;
85cdf0e10cSrcweir case ERROR_BAD_FORMAT: return ERRCODE_IO_WRONGFORMAT;
86cdf0e10cSrcweir case ERROR_INVALID_ACCESS: return ERRCODE_IO_ACCESSDENIED;
87cdf0e10cSrcweir // case ERROR_INVALID_DATA: return ERRCODE_IO_;
88cdf0e10cSrcweir case ERROR_INVALID_DRIVE: return ERRCODE_IO_INVALIDDEVICE;
89cdf0e10cSrcweir case ERROR_CURRENT_DIRECTORY: return ERRCODE_IO_CURRENTDIR;
90cdf0e10cSrcweir case ERROR_NOT_SAME_DEVICE: return ERRCODE_IO_NOTSAMEDEVICE;
91cdf0e10cSrcweir // case ERROR_NO_MORE_FILES: return ERRCODE_IO_;
92cdf0e10cSrcweir case ERROR_WRITE_PROTECT: return ERRCODE_IO_CANTWRITE;
93cdf0e10cSrcweir case ERROR_BAD_UNIT: return ERRCODE_IO_INVALIDDEVICE;
94cdf0e10cSrcweir case ERROR_NOT_READY: return ERRCODE_IO_DEVICENOTREADY;
95cdf0e10cSrcweir case ERROR_BAD_COMMAND: return ERRCODE_IO_GENERAL;
96cdf0e10cSrcweir case ERROR_CRC: return ERRCODE_IO_BADCRC;
97cdf0e10cSrcweir case ERROR_BAD_LENGTH: return ERRCODE_IO_INVALIDLENGTH;
98cdf0e10cSrcweir case ERROR_SEEK: return ERRCODE_IO_CANTSEEK;
99cdf0e10cSrcweir case ERROR_NOT_DOS_DISK: return ERRCODE_IO_WRONGFORMAT;
100cdf0e10cSrcweir case ERROR_SECTOR_NOT_FOUND: return ERRCODE_IO_GENERAL;
101cdf0e10cSrcweir case ERROR_WRITE_FAULT: return ERRCODE_IO_CANTWRITE;
102cdf0e10cSrcweir case ERROR_READ_FAULT: return ERRCODE_IO_CANTREAD;
103cdf0e10cSrcweir case ERROR_GEN_FAILURE: return ERRCODE_IO_GENERAL;
104cdf0e10cSrcweir case ERROR_SHARING_VIOLATION: return ERRCODE_IO_LOCKVIOLATION;
105cdf0e10cSrcweir case ERROR_LOCK_VIOLATION: return ERRCODE_IO_LOCKVIOLATION;
106cdf0e10cSrcweir case ERROR_WRONG_DISK: return ERRCODE_IO_INVALIDDEVICE;
107cdf0e10cSrcweir case ERROR_NOT_SUPPORTED: return ERRCODE_IO_NOTSUPPORTED;
108cdf0e10cSrcweir #else
109cdf0e10cSrcweir case 0: return ERRCODE_NONE;
110cdf0e10cSrcweir case ENOENT: return ERRCODE_IO_NOTEXISTS;
111cdf0e10cSrcweir case EACCES: return ERRCODE_IO_ACCESSDENIED;
112cdf0e10cSrcweir case EEXIST: return ERRCODE_IO_ALREADYEXISTS;
113cdf0e10cSrcweir case EINVAL: return ERRCODE_IO_INVALIDPARAMETER;
114cdf0e10cSrcweir case EMFILE: return ERRCODE_IO_TOOMANYOPENFILES;
115cdf0e10cSrcweir case ENOMEM: return ERRCODE_IO_OUTOFMEMORY;
116cdf0e10cSrcweir case ENOSPC: return ERRCODE_IO_OUTOFSPACE;
117cdf0e10cSrcweir #endif
118cdf0e10cSrcweir }
119cdf0e10cSrcweir
120cdf0e10cSrcweir DBG_TRACE1( "FSys: unknown system error %d occured", nSysErr );
121cdf0e10cSrcweir return FSYS_ERR_UNKNOWN;
122cdf0e10cSrcweir }
123cdf0e10cSrcweir
124cdf0e10cSrcweir //--------------------------------------------------------------------
125cdf0e10cSrcweir
126cdf0e10cSrcweir #ifndef BOOTSTRAP
127cdf0e10cSrcweir
128cdf0e10cSrcweir FSysRedirector* FSysRedirector::_pRedirector = 0;
129cdf0e10cSrcweir sal_Bool FSysRedirector::_bEnabled = sal_True;
130cdf0e10cSrcweir #ifdef UNX
131cdf0e10cSrcweir sal_Bool bInRedirection = sal_True;
132cdf0e10cSrcweir #else
133cdf0e10cSrcweir sal_Bool bInRedirection = sal_False;
134cdf0e10cSrcweir #endif
135cdf0e10cSrcweir static vos:: OMutex * pRedirectMutex = 0;
136cdf0e10cSrcweir
137cdf0e10cSrcweir //------------------------------------------------------------------------
Register(FSysRedirector * pRedirector)138cdf0e10cSrcweir void FSysRedirector::Register( FSysRedirector *pRedirector )
139cdf0e10cSrcweir {
140cdf0e10cSrcweir if ( pRedirector )
141cdf0e10cSrcweir pRedirectMutex = new vos:: OMutex ;
142cdf0e10cSrcweir else
143cdf0e10cSrcweir DELETEZ( pRedirectMutex );
144cdf0e10cSrcweir _pRedirector = pRedirector;
145cdf0e10cSrcweir }
146cdf0e10cSrcweir
147cdf0e10cSrcweir //------------------------------------------------------------------------
148cdf0e10cSrcweir
DoRedirect(String & rPath)149cdf0e10cSrcweir void FSysRedirector::DoRedirect( String &rPath )
150cdf0e10cSrcweir {
151cdf0e10cSrcweir String aURL(rPath);
152cdf0e10cSrcweir
153cdf0e10cSrcweir // if redirection is disabled or not even registered do nothing
154cdf0e10cSrcweir if ( !_bEnabled || !pRedirectMutex )
155cdf0e10cSrcweir return;
156cdf0e10cSrcweir
157cdf0e10cSrcweir // redirect only removable or remote volumes
158cdf0e10cSrcweir if ( !IsRedirectable_Impl( ByteString( aURL, osl_getThreadTextEncoding() ) ) )
159cdf0e10cSrcweir return;
160cdf0e10cSrcweir
161cdf0e10cSrcweir // Redirection is acessible only by one thread per time
162cdf0e10cSrcweir // dont move the guard behind the bInRedirection check!!!
163cdf0e10cSrcweir // think of nested calls (when called from callback)
164cdf0e10cSrcweir vos:: OGuard aGuard( pRedirectMutex );
165cdf0e10cSrcweir
166cdf0e10cSrcweir // if already in redirection, dont redirect
167cdf0e10cSrcweir if ( bInRedirection )
168cdf0e10cSrcweir return;
169cdf0e10cSrcweir
170cdf0e10cSrcweir // dont redirect on nested calls
171cdf0e10cSrcweir bInRedirection = sal_True;
172cdf0e10cSrcweir
173cdf0e10cSrcweir // convert to URL
174cdf0e10cSrcweir #ifndef UNX
175cdf0e10cSrcweir for ( sal_Unicode *p = (sal_Unicode*)aURL.GetBuffer(); *p; ++p )
176cdf0e10cSrcweir if ( '\\' == *p ) *p = '/';
177cdf0e10cSrcweir else if ( ':' == *p ) *p = '|';
178cdf0e10cSrcweir #endif
179cdf0e10cSrcweir
180cdf0e10cSrcweir aURL.Insert( String("file:///", osl_getThreadTextEncoding()), 0 );
181cdf0e10cSrcweir
182cdf0e10cSrcweir // do redirection
183cdf0e10cSrcweir Redirector();
184cdf0e10cSrcweir
185cdf0e10cSrcweir bInRedirection = sal_False;
186cdf0e10cSrcweir return;
187cdf0e10cSrcweir }
188cdf0e10cSrcweir
189cdf0e10cSrcweir //------------------------------------------------------------------------
190cdf0e10cSrcweir
Redirector()191cdf0e10cSrcweir FSysRedirector* FSysRedirector::Redirector()
192cdf0e10cSrcweir {
193cdf0e10cSrcweir if ( !_pRedirector )
194cdf0e10cSrcweir Register( new FSysRedirector );
195cdf0e10cSrcweir return _pRedirector;
196cdf0e10cSrcweir }
197cdf0e10cSrcweir
198cdf0e10cSrcweir #endif // BOOTSTRAP
199cdf0e10cSrcweir
200cdf0e10cSrcweir //--------------------------------------------------------------------
201cdf0e10cSrcweir
202cdf0e10cSrcweir class DirEntryStack: public List
203cdf0e10cSrcweir {
204cdf0e10cSrcweir public:
DirEntryStack()205cdf0e10cSrcweir DirEntryStack() {};
206cdf0e10cSrcweir ~DirEntryStack();
207cdf0e10cSrcweir
208cdf0e10cSrcweir inline void Push( DirEntry *pEntry );
209cdf0e10cSrcweir inline DirEntry* Pop();
210cdf0e10cSrcweir inline DirEntry* Top();
211cdf0e10cSrcweir inline DirEntry* Bottom();
212cdf0e10cSrcweir };
213cdf0e10cSrcweir
Push(DirEntry * pEntry)214cdf0e10cSrcweir inline void DirEntryStack::Push( DirEntry *pEntry )
215cdf0e10cSrcweir {
216cdf0e10cSrcweir List::Insert( pEntry, LIST_APPEND );
217cdf0e10cSrcweir }
218cdf0e10cSrcweir
Pop()219cdf0e10cSrcweir inline DirEntry* DirEntryStack::Pop()
220cdf0e10cSrcweir {
221cdf0e10cSrcweir return (DirEntry*) List::Remove( Count() - 1 );
222cdf0e10cSrcweir }
223cdf0e10cSrcweir
Top()224cdf0e10cSrcweir inline DirEntry* DirEntryStack::Top()
225cdf0e10cSrcweir {
226cdf0e10cSrcweir return (DirEntry*) List::GetObject( Count() - 1 );
227cdf0e10cSrcweir }
228cdf0e10cSrcweir
Bottom()229cdf0e10cSrcweir inline DirEntry* DirEntryStack::Bottom()
230cdf0e10cSrcweir {
231cdf0e10cSrcweir return (DirEntry*) List::GetObject( 0 );
232cdf0e10cSrcweir }
233cdf0e10cSrcweir
234cdf0e10cSrcweir //--------------------------------------------------------------------
235cdf0e10cSrcweir
236cdf0e10cSrcweir DBG_NAME( DirEntry );
237cdf0e10cSrcweir
238cdf0e10cSrcweir /*************************************************************************
239cdf0e10cSrcweir |*
240cdf0e10cSrcweir |* DirEntry::~DirEntryStack()
241cdf0e10cSrcweir |*
242cdf0e10cSrcweir |* Beschreibung FSYS.SDW
243cdf0e10cSrcweir |* Ersterstellung MI 26.04.91
244cdf0e10cSrcweir |* Letzte Aenderung MI 04.07.91
245cdf0e10cSrcweir |*
246cdf0e10cSrcweir *************************************************************************/
247cdf0e10cSrcweir
~DirEntryStack()248cdf0e10cSrcweir DirEntryStack::~DirEntryStack()
249cdf0e10cSrcweir {
250cdf0e10cSrcweir while ( Count() )
251cdf0e10cSrcweir delete Pop();
252cdf0e10cSrcweir }
253cdf0e10cSrcweir
254cdf0e10cSrcweir /*************************************************************************
255cdf0e10cSrcweir |*
256cdf0e10cSrcweir |* ImpCheckDirEntry()
257cdf0e10cSrcweir |*
258cdf0e10cSrcweir |* Beschreibung Pruefung eines DirEntry fuer DBG_UTIL
259cdf0e10cSrcweir |* Parameter void* p Zeiger auf den DirEntry
260cdf0e10cSrcweir |* Return-Wert char* Fehlermeldungs-TExtension oder NULL
261cdf0e10cSrcweir |* Ersterstellung MI 16.07.91
262cdf0e10cSrcweir |* Letzte Aenderung MI 26.05.93
263cdf0e10cSrcweir |*
264cdf0e10cSrcweir *************************************************************************/
265cdf0e10cSrcweir
266cdf0e10cSrcweir #ifdef DBG_UTIL
ImpCheckDirEntry(const void * p)267cdf0e10cSrcweir const char* ImpCheckDirEntry( const void* p )
268cdf0e10cSrcweir {
269cdf0e10cSrcweir DirEntry* p0 = (DirEntry*)p;
270cdf0e10cSrcweir
271cdf0e10cSrcweir if ( p0->pParent )
272cdf0e10cSrcweir DBG_CHKOBJ( p0->pParent, DirEntry, ImpCheckDirEntry );
273cdf0e10cSrcweir
274cdf0e10cSrcweir return NULL;
275cdf0e10cSrcweir }
276cdf0e10cSrcweir #endif
277cdf0e10cSrcweir
278cdf0e10cSrcweir /*************************************************************************
279cdf0e10cSrcweir |*
280cdf0e10cSrcweir |* ImplCutPath()
281cdf0e10cSrcweir |*
282cdf0e10cSrcweir |* Beschreibung Fuegt ... ein, damit maximal nMaxChars lang
283cdf0e10cSrcweir |* Ersterstellung MI 06.04.94
284cdf0e10cSrcweir |* Letzte Aenderung DV 24.06.96
285cdf0e10cSrcweir |*
286cdf0e10cSrcweir *************************************************************************/
287cdf0e10cSrcweir
ImplCutPath(const ByteString & rStr,sal_uInt16 nMax,char cAccDel)288cdf0e10cSrcweir ByteString ImplCutPath( const ByteString& rStr, sal_uInt16 nMax, char cAccDel )
289cdf0e10cSrcweir {
290cdf0e10cSrcweir sal_uInt16 nMaxPathLen = nMax;
291cdf0e10cSrcweir ByteString aCutPath( rStr );
292cdf0e10cSrcweir sal_Bool bInsertPrefix = sal_False;
293cdf0e10cSrcweir sal_uInt16 nBegin = aCutPath.Search( cAccDel );
294cdf0e10cSrcweir
295cdf0e10cSrcweir if( nBegin == STRING_NOTFOUND )
296cdf0e10cSrcweir nBegin = 0;
297cdf0e10cSrcweir else
298cdf0e10cSrcweir nMaxPathLen += 2; // fuer Prefix <Laufwerk>:
299cdf0e10cSrcweir
300cdf0e10cSrcweir while( aCutPath.Len() > nMaxPathLen )
301cdf0e10cSrcweir {
302cdf0e10cSrcweir sal_uInt16 nEnd = aCutPath.Search( cAccDel, nBegin + 1 );
303cdf0e10cSrcweir sal_uInt16 nCount;
304cdf0e10cSrcweir
305cdf0e10cSrcweir if ( nEnd != STRING_NOTFOUND )
306cdf0e10cSrcweir {
307cdf0e10cSrcweir nCount = nEnd - nBegin;
308cdf0e10cSrcweir aCutPath.Erase( nBegin, nCount );
309cdf0e10cSrcweir bInsertPrefix = sal_True;
310cdf0e10cSrcweir }
311cdf0e10cSrcweir else
312cdf0e10cSrcweir break;
313cdf0e10cSrcweir }
314cdf0e10cSrcweir
315cdf0e10cSrcweir if ( aCutPath.Len() > nMaxPathLen )
316cdf0e10cSrcweir {
317cdf0e10cSrcweir for ( sal_uInt16 n = nMaxPathLen; n > nMaxPathLen/2; --n )
318cdf0e10cSrcweir if ( !ByteString(aCutPath.GetChar(n)).IsAlphaNumericAscii() )
319cdf0e10cSrcweir {
320cdf0e10cSrcweir aCutPath.Erase( n );
321cdf0e10cSrcweir aCutPath += "...";
322cdf0e10cSrcweir break;
323cdf0e10cSrcweir }
324cdf0e10cSrcweir }
325cdf0e10cSrcweir
326cdf0e10cSrcweir if ( bInsertPrefix )
327cdf0e10cSrcweir {
328cdf0e10cSrcweir ByteString aIns( cAccDel );
329cdf0e10cSrcweir aIns += "...";
330cdf0e10cSrcweir aCutPath.Insert( aIns, nBegin );
331cdf0e10cSrcweir }
332cdf0e10cSrcweir
333cdf0e10cSrcweir return aCutPath;
334cdf0e10cSrcweir }
335cdf0e10cSrcweir
336cdf0e10cSrcweir /*************************************************************************
337cdf0e10cSrcweir |*
338cdf0e10cSrcweir |* DirEntry::ImpParseOs2Name()
339cdf0e10cSrcweir |*
340cdf0e10cSrcweir |* Beschreibung FSYS.SDW
341cdf0e10cSrcweir |* Ersterstellung MI 26.04.91
342cdf0e10cSrcweir |* Letzte Aenderung MI 23.06.95
343cdf0e10cSrcweir |*
344cdf0e10cSrcweir *************************************************************************/
345cdf0e10cSrcweir
ImpParseOs2Name(const ByteString & rPfad,FSysPathStyle eStyle)346cdf0e10cSrcweir FSysError DirEntry::ImpParseOs2Name( const ByteString& rPfad, FSysPathStyle eStyle )
347cdf0e10cSrcweir {
348cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
349cdf0e10cSrcweir
350cdf0e10cSrcweir // die einzelnen Namen auf einen Stack packen
351cdf0e10cSrcweir String aPfad( rPfad, osl_getThreadTextEncoding() );
352cdf0e10cSrcweir DirEntryStack aStack;
353cdf0e10cSrcweir
354cdf0e10cSrcweir do
355cdf0e10cSrcweir {
356cdf0e10cSrcweir // den Namen vor dem ersten "\\" abspalten,
357cdf0e10cSrcweir // falls '\\' am Anfang, ist der Name '\\',
358cdf0e10cSrcweir // der Rest immer ohne die fuehrenden '\\'.
359cdf0e10cSrcweir // ein ":" trennt ebenfalls, gehoert aber zum Namen
360cdf0e10cSrcweir // den ersten '\\', '/' oder ':' suchen
361cdf0e10cSrcweir sal_uInt16 nPos;
362cdf0e10cSrcweir for ( nPos = 0;
363cdf0e10cSrcweir nPos < aPfad.Len() && //?O
364cdf0e10cSrcweir aPfad.GetChar(nPos) != '\\' && aPfad.GetChar(nPos) != '/' && //?O
365cdf0e10cSrcweir aPfad.GetChar(nPos) != ':'; //?O
366cdf0e10cSrcweir nPos++ )
367cdf0e10cSrcweir /* do nothing */;
368cdf0e10cSrcweir
369cdf0e10cSrcweir // ist der Name ein UNC Pathname?
370cdf0e10cSrcweir if ( nPos == 0 && aPfad.Len() > 1 &&
371cdf0e10cSrcweir ( ( aPfad.GetChar(0) == '\\' && aPfad.GetChar(1) == '\\' ) ||
372cdf0e10cSrcweir ( aPfad.GetChar(0) == '/' && aPfad.GetChar(1) == '/' ) ) )
373cdf0e10cSrcweir {
374cdf0e10cSrcweir for ( nPos = 2; aPfad.Len() > nPos; ++nPos )
375cdf0e10cSrcweir if ( aPfad.GetChar(nPos) == '\\' || aPfad.GetChar(nPos) == '/' )
376cdf0e10cSrcweir break;
377cdf0e10cSrcweir aName = ByteString( aPfad.Copy( 2, nPos-2 ), osl_getThreadTextEncoding() );
378cdf0e10cSrcweir aStack.Push( new DirEntry( aName, FSYS_FLAG_ABSROOT, eStyle ) );
379cdf0e10cSrcweir }
380cdf0e10cSrcweir // ist der Name die Root des aktuellen Drives?
381cdf0e10cSrcweir else if ( nPos == 0 && aPfad.Len() > 0 &&
382cdf0e10cSrcweir ( aPfad.GetChar(0) == '\\' || aPfad.GetChar(0) == '/' ) )
383cdf0e10cSrcweir {
384cdf0e10cSrcweir // Root-Directory des aktuellen Drives
385cdf0e10cSrcweir aStack.Push( new DirEntry( FSYS_FLAG_ABSROOT ) );
386cdf0e10cSrcweir }
387cdf0e10cSrcweir else
388cdf0e10cSrcweir {
389cdf0e10cSrcweir // ist der Name ein Drive?
390cdf0e10cSrcweir if ( nPos < aPfad.Len() && aPfad.GetChar(nPos) == ':' )
391cdf0e10cSrcweir {
392cdf0e10cSrcweir aName = ByteString( aPfad.Copy( 0, nPos + 1 ), osl_getThreadTextEncoding() );
393cdf0e10cSrcweir
394cdf0e10cSrcweir // ist der Name die Root des Drives
395cdf0e10cSrcweir if ( (nPos + 1) < aPfad.Len() &&
396cdf0e10cSrcweir ( aPfad.GetChar(nPos+1) == '\\' || aPfad.GetChar(nPos+1) == '/' ) )
397cdf0e10cSrcweir {
398cdf0e10cSrcweir // schon was auf dem Stack?
399cdf0e10cSrcweir // oder Novell-Format? (not supported wegen URLs)
400cdf0e10cSrcweir if ( aStack.Count() || aName.Len() > 2 )
401cdf0e10cSrcweir {
402cdf0e10cSrcweir aName = rPfad;
403cdf0e10cSrcweir return FSYS_ERR_MISPLACEDCHAR;
404cdf0e10cSrcweir }
405cdf0e10cSrcweir // Root-Directory des Drive
406cdf0e10cSrcweir aStack.Push( new DirEntry( aName, FSYS_FLAG_ABSROOT, eStyle ) );
407cdf0e10cSrcweir }
408cdf0e10cSrcweir else
409cdf0e10cSrcweir {
410cdf0e10cSrcweir // liegt ein anderes Drive auf dem Stack?
411cdf0e10cSrcweir if ( aStack.Count() &&
412cdf0e10cSrcweir COMPARE_EQUAL != aStack.Bottom()->aName.CompareIgnoreCaseToAscii(aName) )
413cdf0e10cSrcweir aStack.Clear();
414cdf0e10cSrcweir
415cdf0e10cSrcweir // liegt jetzt nichts mehr auf dem Stack?
416cdf0e10cSrcweir if ( !aStack.Count() )
417cdf0e10cSrcweir aStack.Push( new DirEntry( aName, FSYS_FLAG_RELROOT, eStyle ) );
418cdf0e10cSrcweir }
419cdf0e10cSrcweir }
420cdf0e10cSrcweir
421cdf0e10cSrcweir // es ist kein Drive
422cdf0e10cSrcweir else
423cdf0e10cSrcweir {
424cdf0e10cSrcweir // den Namen ohne Trenner abspalten
425cdf0e10cSrcweir aName = ByteString( aPfad.Copy( 0, nPos ), osl_getThreadTextEncoding() );
426cdf0e10cSrcweir
427cdf0e10cSrcweir // stellt der Name die aktuelle Directory dar?
428cdf0e10cSrcweir if ( aName == "." )
429cdf0e10cSrcweir /* do nothing */;
430cdf0e10cSrcweir
431cdf0e10cSrcweir // stellt der Name die Parent-Directory dar?
432cdf0e10cSrcweir else if ( aName == ".." )
433cdf0e10cSrcweir {
434cdf0e10cSrcweir // ist nichts, ein Parent oder eine relative Root
435cdf0e10cSrcweir // auf dem Stack?
436cdf0e10cSrcweir if ( ( aStack.Count() == 0 ) ||
437cdf0e10cSrcweir ( aStack.Top()->eFlag == FSYS_FLAG_PARENT ) ||
438cdf0e10cSrcweir ( aStack.Top()->eFlag == FSYS_FLAG_RELROOT ) )
439cdf0e10cSrcweir // fuehrende Parents kommen auf den Stack
440cdf0e10cSrcweir aStack.Push( new DirEntry( FSYS_FLAG_PARENT ) );
441cdf0e10cSrcweir
442cdf0e10cSrcweir // ist es eine absolute Root
443cdf0e10cSrcweir else if ( aStack.Top()->eFlag == FSYS_FLAG_ABSROOT )
444cdf0e10cSrcweir {
445cdf0e10cSrcweir // die hat keine Parent-Directory
446cdf0e10cSrcweir aName = rPfad;
447cdf0e10cSrcweir return FSYS_ERR_NOTEXISTS;
448cdf0e10cSrcweir }
449cdf0e10cSrcweir else
450cdf0e10cSrcweir // sonst hebt der Parent den TOS auf
451cdf0e10cSrcweir delete aStack.Pop();
452cdf0e10cSrcweir }
453cdf0e10cSrcweir
454cdf0e10cSrcweir else
455cdf0e10cSrcweir {
456cdf0e10cSrcweir if ( eStyle == FSYS_STYLE_FAT )
457cdf0e10cSrcweir {
458cdf0e10cSrcweir // ist der Name grundsaetzlich ungueltig?
459cdf0e10cSrcweir int nPunkte = 0;
460cdf0e10cSrcweir const char *pChar;
461cdf0e10cSrcweir for ( pChar = aName.GetBuffer();
462cdf0e10cSrcweir nPunkte < 2 && *pChar != 0;
463cdf0e10cSrcweir pChar++ )
464cdf0e10cSrcweir {
465cdf0e10cSrcweir if ( *pChar == ';' )
466cdf0e10cSrcweir nPunkte = 0;
467cdf0e10cSrcweir else
468cdf0e10cSrcweir nPunkte += ( *pChar == '.' ) ? 1 : 0;
469cdf0e10cSrcweir }
470cdf0e10cSrcweir if ( nPunkte > 1 )
471cdf0e10cSrcweir {
472cdf0e10cSrcweir aName = rPfad;
473cdf0e10cSrcweir return FSYS_ERR_MISPLACEDCHAR;
474cdf0e10cSrcweir }
475cdf0e10cSrcweir }
476cdf0e10cSrcweir
477cdf0e10cSrcweir // normalen Entries kommen auf den Stack
478cdf0e10cSrcweir DirEntry *pNew = new DirEntry( aName, FSYS_FLAG_NORMAL, eStyle );
479cdf0e10cSrcweir if ( !pNew->IsValid() )
480cdf0e10cSrcweir {
481cdf0e10cSrcweir aName = rPfad;
482cdf0e10cSrcweir ErrCode eErr = pNew->GetError();
483cdf0e10cSrcweir delete pNew;
484cdf0e10cSrcweir return eErr;
485cdf0e10cSrcweir }
486cdf0e10cSrcweir aStack.Push( pNew );
487cdf0e10cSrcweir }
488cdf0e10cSrcweir }
489cdf0e10cSrcweir }
490cdf0e10cSrcweir
491cdf0e10cSrcweir // den Restpfad bestimmen
492cdf0e10cSrcweir aPfad.Erase( 0, nPos + 1 );
493cdf0e10cSrcweir while ( aPfad.Len() && ( aPfad.GetChar(0) == '\\' || aPfad.GetChar(0) == '/' ) )
494cdf0e10cSrcweir aPfad.Erase( 0, 1 );
495cdf0e10cSrcweir }
496cdf0e10cSrcweir while ( aPfad.Len() );
497cdf0e10cSrcweir
498cdf0e10cSrcweir sal_uIntPtr nErr = ERRCODE_NONE;
499cdf0e10cSrcweir // Haupt-Entry (selbst) zuweisen
500cdf0e10cSrcweir if ( aStack.Count() == 0 )
501cdf0e10cSrcweir {
502cdf0e10cSrcweir eFlag = FSYS_FLAG_CURRENT;
503cdf0e10cSrcweir aName.Erase();
504cdf0e10cSrcweir }
505cdf0e10cSrcweir else
506cdf0e10cSrcweir {
507cdf0e10cSrcweir eFlag = aStack.Top()->eFlag;
508cdf0e10cSrcweir aName = aStack.Top()->aName;
509cdf0e10cSrcweir nErr = aStack.Top()->nError;
510cdf0e10cSrcweir delete aStack.Pop();
511cdf0e10cSrcweir }
512cdf0e10cSrcweir
513cdf0e10cSrcweir // die Parent-Entries vom Stack holen
514cdf0e10cSrcweir DirEntry** pTemp = &pParent; // Zeiger auf den Member pParent setzen
515cdf0e10cSrcweir while ( aStack.Count() )
516cdf0e10cSrcweir {
517cdf0e10cSrcweir *pTemp = aStack.Pop();
518cdf0e10cSrcweir
519cdf0e10cSrcweir // Zeiger auf den Member pParent des eigenen Parent setzen
520cdf0e10cSrcweir pTemp = &( (*pTemp)->pParent );
521cdf0e10cSrcweir }
522cdf0e10cSrcweir
523cdf0e10cSrcweir // wird damit ein Volume beschrieben?
524cdf0e10cSrcweir if ( !pParent && eFlag == FSYS_FLAG_RELROOT && aName.Len() )
525cdf0e10cSrcweir eFlag = FSYS_FLAG_VOLUME;
526cdf0e10cSrcweir
527cdf0e10cSrcweir // bei gesetztem ErrorCode den Namen komplett "ubernehmen
528cdf0e10cSrcweir if ( nErr )
529cdf0e10cSrcweir aName = rPfad;
530cdf0e10cSrcweir return nErr;
531cdf0e10cSrcweir }
532cdf0e10cSrcweir
533cdf0e10cSrcweir /*************************************************************************
534cdf0e10cSrcweir |*
535cdf0e10cSrcweir |* DirEntry::ImpParseName()
536cdf0e10cSrcweir |*
537cdf0e10cSrcweir |* Beschreibung FSYS.SDW
538cdf0e10cSrcweir |* Ersterstellung MI 26.08.91
539cdf0e10cSrcweir |* Letzte Aenderung MI 26.05.93
540cdf0e10cSrcweir |*
541cdf0e10cSrcweir *************************************************************************/
542cdf0e10cSrcweir
ImpParseName(const ByteString & rbInitName,FSysPathStyle eStyle)543cdf0e10cSrcweir FSysError DirEntry::ImpParseName( const ByteString& rbInitName,
544cdf0e10cSrcweir FSysPathStyle eStyle )
545cdf0e10cSrcweir {
546cdf0e10cSrcweir String rInitName( rbInitName, osl_getThreadTextEncoding() );
547cdf0e10cSrcweir if ( eStyle == FSYS_STYLE_HOST )
548cdf0e10cSrcweir eStyle = DEFSTYLE;
549cdf0e10cSrcweir
550cdf0e10cSrcweir // KI-Division of FSys
551cdf0e10cSrcweir if ( eStyle == FSYS_STYLE_DETECT )
552cdf0e10cSrcweir {
553cdf0e10cSrcweir sal_Unicode cFirst = rInitName.GetChar(0);
554cdf0e10cSrcweir if ( rInitName.Len() == 2 && rInitName.GetChar(1) == ':' &&
555cdf0e10cSrcweir ((cFirst >= 'A' && cFirst <= 'Z') ||
556cdf0e10cSrcweir (cFirst >= 'a' && cFirst <= 'z')))
557cdf0e10cSrcweir eStyle = FSYS_STYLE_HPFS;
558cdf0e10cSrcweir else if ( rInitName.Len() > 2 && rInitName.GetChar(1) == ':' )
559cdf0e10cSrcweir {
560cdf0e10cSrcweir if ( rInitName.Search( ':', 2 ) == STRING_NOTFOUND )
561cdf0e10cSrcweir eStyle = FSYS_STYLE_HPFS;
562cdf0e10cSrcweir else
563cdf0e10cSrcweir eStyle = FSYS_STYLE_MAC;
564cdf0e10cSrcweir }
565cdf0e10cSrcweir else if ( rInitName.Search( '/' ) != STRING_NOTFOUND )
566cdf0e10cSrcweir eStyle = FSYS_STYLE_BSD;
567cdf0e10cSrcweir else if ( rInitName.Search( '\\' ) != STRING_NOTFOUND )
568cdf0e10cSrcweir eStyle = FSYS_STYLE_HPFS;
569cdf0e10cSrcweir else if ( rInitName.Search( ':' ) != STRING_NOTFOUND )
570cdf0e10cSrcweir eStyle = FSYS_STYLE_MAC;
571cdf0e10cSrcweir else
572cdf0e10cSrcweir eStyle = FSYS_STYLE_HPFS;
573cdf0e10cSrcweir }
574cdf0e10cSrcweir
575cdf0e10cSrcweir switch ( eStyle )
576cdf0e10cSrcweir {
577cdf0e10cSrcweir case FSYS_STYLE_FAT:
578cdf0e10cSrcweir case FSYS_STYLE_VFAT:
579cdf0e10cSrcweir case FSYS_STYLE_HPFS:
580cdf0e10cSrcweir case FSYS_STYLE_NTFS:
581cdf0e10cSrcweir case FSYS_STYLE_NWFS:
582cdf0e10cSrcweir return ImpParseOs2Name( rbInitName, eStyle );
583cdf0e10cSrcweir
584cdf0e10cSrcweir case FSYS_STYLE_BSD:
585cdf0e10cSrcweir case FSYS_STYLE_SYSV:
586cdf0e10cSrcweir return ImpParseUnixName( rbInitName, eStyle );
587cdf0e10cSrcweir
588cdf0e10cSrcweir case FSYS_STYLE_MAC:
589cdf0e10cSrcweir return FSYS_ERR_OK;
590cdf0e10cSrcweir
591cdf0e10cSrcweir default:
592cdf0e10cSrcweir return FSYS_ERR_UNKNOWN;
593cdf0e10cSrcweir }
594cdf0e10cSrcweir }
595cdf0e10cSrcweir
596cdf0e10cSrcweir /*************************************************************************
597cdf0e10cSrcweir |*
598cdf0e10cSrcweir |* GetStyle()
599cdf0e10cSrcweir |*
600cdf0e10cSrcweir |* Beschreibung FSYS.SDW
601cdf0e10cSrcweir |* Ersterstellung MI 15.11.91
602cdf0e10cSrcweir |* Letzte Aenderung MI 15.11.91
603cdf0e10cSrcweir |*
604cdf0e10cSrcweir *************************************************************************/
605cdf0e10cSrcweir
GetStyle(FSysPathStyle eStyle)606cdf0e10cSrcweir static FSysPathStyle GetStyle( FSysPathStyle eStyle )
607cdf0e10cSrcweir {
608cdf0e10cSrcweir if ( eStyle == FSYS_STYLE_HOST || eStyle == FSYS_STYLE_DETECT )
609cdf0e10cSrcweir return DEFSTYLE;
610cdf0e10cSrcweir else
611cdf0e10cSrcweir return eStyle;
612cdf0e10cSrcweir }
613cdf0e10cSrcweir
614cdf0e10cSrcweir /*************************************************************************
615cdf0e10cSrcweir |*
616cdf0e10cSrcweir |* DirEntry::ImpTrim()
617cdf0e10cSrcweir |*
618cdf0e10cSrcweir |* Beschreibung bringt den Namen auf Betriebssystem-Norm
619cdf0e10cSrcweir |* z.B. 8.3 lower beim MS-DOS Formatter
620cdf0e10cSrcweir |* wirkt nicht rekursiv
621cdf0e10cSrcweir |* Ersterstellung MI 12.08.91
622cdf0e10cSrcweir |* Letzte Aenderung MI 21.05.92
623cdf0e10cSrcweir |*
624cdf0e10cSrcweir *************************************************************************/
625cdf0e10cSrcweir
ImpTrim(FSysPathStyle eStyle)626cdf0e10cSrcweir void DirEntry::ImpTrim( FSysPathStyle eStyle )
627cdf0e10cSrcweir {
628cdf0e10cSrcweir // Wildcards werden nicht geclipt
629cdf0e10cSrcweir if ( ( aName.Search( '*' ) != STRING_NOTFOUND ) ||
630cdf0e10cSrcweir ( aName.Search( '?' ) != STRING_NOTFOUND ) ||
631cdf0e10cSrcweir ( aName.Search( ';' ) != STRING_NOTFOUND ) )
632cdf0e10cSrcweir return;
633cdf0e10cSrcweir
634cdf0e10cSrcweir switch ( eStyle )
635cdf0e10cSrcweir {
636cdf0e10cSrcweir case FSYS_STYLE_FAT:
637cdf0e10cSrcweir {
638cdf0e10cSrcweir sal_uInt16 nPunktPos = aName.Search( '.' );
639cdf0e10cSrcweir if ( nPunktPos == STRING_NOTFOUND )
640cdf0e10cSrcweir {
641cdf0e10cSrcweir if ( aName.Len() > 8 )
642cdf0e10cSrcweir {
643cdf0e10cSrcweir nError = ERRCODE_IO_MISPLACEDCHAR|ERRCODE_WARNING_MASK;
644cdf0e10cSrcweir aName.Erase( 8 );
645cdf0e10cSrcweir }
646cdf0e10cSrcweir }
647cdf0e10cSrcweir else
648cdf0e10cSrcweir {
649cdf0e10cSrcweir if ( nPunktPos > 8 )
650cdf0e10cSrcweir {
651cdf0e10cSrcweir nError = ERRCODE_IO_MISPLACEDCHAR|ERRCODE_WARNING_MASK;
652cdf0e10cSrcweir aName.Erase( 8, nPunktPos - 8 );
653cdf0e10cSrcweir nPunktPos = 8;
654cdf0e10cSrcweir }
655cdf0e10cSrcweir if ( aName.Len() > nPunktPos + 3 )
656cdf0e10cSrcweir {
657cdf0e10cSrcweir if ( aName.Len() - nPunktPos > 4 )
658cdf0e10cSrcweir {
659cdf0e10cSrcweir nError = ERRCODE_IO_MISPLACEDCHAR|ERRCODE_WARNING_MASK;
660cdf0e10cSrcweir aName.Erase( nPunktPos + 4 );
661cdf0e10cSrcweir }
662cdf0e10cSrcweir }
663cdf0e10cSrcweir }
664cdf0e10cSrcweir aName.ToLowerAscii();
665cdf0e10cSrcweir break;
666cdf0e10cSrcweir }
667cdf0e10cSrcweir
668cdf0e10cSrcweir case FSYS_STYLE_VFAT:
669cdf0e10cSrcweir case FSYS_STYLE_HPFS:
670cdf0e10cSrcweir case FSYS_STYLE_NTFS:
671cdf0e10cSrcweir case FSYS_STYLE_NWFS:
672cdf0e10cSrcweir if ( aName.Len() > 254 )
673cdf0e10cSrcweir {
674cdf0e10cSrcweir nError = ERRCODE_IO_MISPLACEDCHAR|ERRCODE_WARNING_MASK;
675cdf0e10cSrcweir aName.Erase( 254 );
676cdf0e10cSrcweir }
677cdf0e10cSrcweir
678cdf0e10cSrcweir if ( eStyle == FSYS_STYLE_HPFS &&
679cdf0e10cSrcweir ( eFlag == FSYS_FLAG_ABSROOT || eFlag == FSYS_FLAG_RELROOT ) )
680cdf0e10cSrcweir aName.ToUpperAscii();
681cdf0e10cSrcweir break;
682cdf0e10cSrcweir
683cdf0e10cSrcweir case FSYS_STYLE_SYSV:
684cdf0e10cSrcweir if ( aName.Len() > 14 )
685cdf0e10cSrcweir {
686cdf0e10cSrcweir nError = ERRCODE_IO_MISPLACEDCHAR|ERRCODE_WARNING_MASK;
687cdf0e10cSrcweir aName.Erase( 14 );
688cdf0e10cSrcweir }
689cdf0e10cSrcweir break;
690cdf0e10cSrcweir
691cdf0e10cSrcweir case FSYS_STYLE_BSD:
692cdf0e10cSrcweir if ( aName.Len() > 250 )
693cdf0e10cSrcweir {
694cdf0e10cSrcweir nError = ERRCODE_IO_MISPLACEDCHAR|ERRCODE_WARNING_MASK;
695cdf0e10cSrcweir aName.Erase( 250 );
696cdf0e10cSrcweir }
697cdf0e10cSrcweir break;
698cdf0e10cSrcweir
699cdf0e10cSrcweir case FSYS_STYLE_MAC:
700cdf0e10cSrcweir if ( eFlag & ( FSYS_FLAG_ABSROOT | FSYS_FLAG_VOLUME ) )
701cdf0e10cSrcweir {
702cdf0e10cSrcweir if ( aName.Len() > 27 )
703cdf0e10cSrcweir {
704cdf0e10cSrcweir nError = ERRCODE_IO_MISPLACEDCHAR|ERRCODE_WARNING_MASK;
705cdf0e10cSrcweir aName.Erase( 27 );
706cdf0e10cSrcweir }
707cdf0e10cSrcweir }
708cdf0e10cSrcweir else
709cdf0e10cSrcweir {
710cdf0e10cSrcweir if ( aName.Len() > 31 )
711cdf0e10cSrcweir {
712cdf0e10cSrcweir nError = ERRCODE_IO_MISPLACEDCHAR|ERRCODE_WARNING_MASK;
713cdf0e10cSrcweir aName.Erase( 31 );
714cdf0e10cSrcweir }
715cdf0e10cSrcweir }
716cdf0e10cSrcweir break;
717cdf0e10cSrcweir
718cdf0e10cSrcweir default:
719cdf0e10cSrcweir /* kann nicht sein */;
720cdf0e10cSrcweir }
721cdf0e10cSrcweir }
722cdf0e10cSrcweir
723cdf0e10cSrcweir /*************************************************************************
724cdf0e10cSrcweir |*
725cdf0e10cSrcweir |* DirEntry::DirEntry()
726cdf0e10cSrcweir |*
727cdf0e10cSrcweir |* Beschreibung FSYS.SDW
728cdf0e10cSrcweir |* Ersterstellung MI 26.04.91
729cdf0e10cSrcweir |* Letzte Aenderung MA 02.12.91
730cdf0e10cSrcweir |*
731cdf0e10cSrcweir *************************************************************************/
732cdf0e10cSrcweir
DirEntry(const ByteString & rName,DirEntryFlag eDirFlag,FSysPathStyle eStyle)733cdf0e10cSrcweir DirEntry::DirEntry( const ByteString& rName, DirEntryFlag eDirFlag,
734cdf0e10cSrcweir FSysPathStyle eStyle ) :
735cdf0e10cSrcweir #ifdef FEAT_FSYS_DOUBLESPEED
736cdf0e10cSrcweir pStat( 0 ),
737cdf0e10cSrcweir #endif
738cdf0e10cSrcweir aName( rName )
739cdf0e10cSrcweir {
740cdf0e10cSrcweir DBG_CTOR( DirEntry, ImpCheckDirEntry );
741cdf0e10cSrcweir
742cdf0e10cSrcweir pParent = NULL;
743cdf0e10cSrcweir eFlag = eDirFlag;
744cdf0e10cSrcweir nError = FSYS_ERR_OK;
745cdf0e10cSrcweir
746cdf0e10cSrcweir ImpTrim( eStyle );
747cdf0e10cSrcweir }
748cdf0e10cSrcweir
749cdf0e10cSrcweir /*************************************************************************
750cdf0e10cSrcweir |*
751cdf0e10cSrcweir |* DirEntry::DirEntry()
752cdf0e10cSrcweir |*
753cdf0e10cSrcweir |* Beschreibung FSYS.SDW
754cdf0e10cSrcweir |* Ersterstellung MI 26.04.91
755cdf0e10cSrcweir |* Letzte Aenderung MA 02.12.91
756cdf0e10cSrcweir |*
757cdf0e10cSrcweir *************************************************************************/
758cdf0e10cSrcweir
DirEntry(const DirEntry & rOrig)759cdf0e10cSrcweir DirEntry::DirEntry( const DirEntry& rOrig ) :
760cdf0e10cSrcweir #ifdef FEAT_FSYS_DOUBLESPEED
761cdf0e10cSrcweir pStat( rOrig.pStat ? new FileStat(*rOrig.pStat) : 0 ),
762cdf0e10cSrcweir #endif
763cdf0e10cSrcweir aName( rOrig.aName )
764cdf0e10cSrcweir {
765cdf0e10cSrcweir DBG_CTOR( DirEntry, ImpCheckDirEntry );
766cdf0e10cSrcweir
767cdf0e10cSrcweir eFlag = rOrig.eFlag;
768cdf0e10cSrcweir nError = rOrig.nError;
769cdf0e10cSrcweir
770cdf0e10cSrcweir if ( rOrig.pParent )
771cdf0e10cSrcweir {
772cdf0e10cSrcweir pParent = new DirEntry( *rOrig.pParent );
773cdf0e10cSrcweir }
774cdf0e10cSrcweir else
775cdf0e10cSrcweir {
776cdf0e10cSrcweir pParent = NULL;
777cdf0e10cSrcweir }
778cdf0e10cSrcweir }
779cdf0e10cSrcweir
780cdf0e10cSrcweir /*************************************************************************
781cdf0e10cSrcweir |*
782cdf0e10cSrcweir |* DirEntry::DirEntry()
783cdf0e10cSrcweir |*
784cdf0e10cSrcweir |* Beschreibung FSYS.SDW
785cdf0e10cSrcweir |* Ersterstellung MI 26.04.91
786cdf0e10cSrcweir |* Letzte Aenderung MA 02.12.91
787cdf0e10cSrcweir |*
788cdf0e10cSrcweir *************************************************************************/
789cdf0e10cSrcweir
DirEntry(const String & rInitName,FSysPathStyle eStyle)790cdf0e10cSrcweir DirEntry::DirEntry( const String& rInitName, FSysPathStyle eStyle )
791cdf0e10cSrcweir #ifdef FEAT_FSYS_DOUBLESPEED
792cdf0e10cSrcweir : pStat( 0 )
793cdf0e10cSrcweir #endif
794cdf0e10cSrcweir {
795cdf0e10cSrcweir DBG_CTOR( DirEntry, ImpCheckDirEntry );
796cdf0e10cSrcweir
797cdf0e10cSrcweir pParent = NULL;
798cdf0e10cSrcweir
799cdf0e10cSrcweir // schnelle Loesung fuer Leerstring
800cdf0e10cSrcweir if ( !rInitName.Len())
801cdf0e10cSrcweir {
802cdf0e10cSrcweir eFlag = FSYS_FLAG_CURRENT;
803cdf0e10cSrcweir nError = FSYS_ERR_OK;
804cdf0e10cSrcweir return;
805cdf0e10cSrcweir }
806cdf0e10cSrcweir
807cdf0e10cSrcweir ByteString aTmpName(rInitName, osl_getThreadTextEncoding());
808cdf0e10cSrcweir if( eStyle == FSYS_STYLE_URL || aTmpName.CompareIgnoreCaseToAscii("file:",5 ) == COMPARE_EQUAL )
809cdf0e10cSrcweir {
810cdf0e10cSrcweir #ifndef BOOTSTRAP
811cdf0e10cSrcweir DBG_WARNING( "File URLs are not permitted but accepted" );
812cdf0e10cSrcweir aTmpName = ByteString(String(INetURLObject( rInitName ).PathToFileName()), osl_getThreadTextEncoding());
813cdf0e10cSrcweir eStyle = FSYS_STYLE_HOST;
814cdf0e10cSrcweir #endif // BOOTSTRAP
815cdf0e10cSrcweir }
816cdf0e10cSrcweir else
817cdf0e10cSrcweir {
818cdf0e10cSrcweir ::rtl::OUString aTmp;
819cdf0e10cSrcweir ::rtl::OUString aOInitName;
820cdf0e10cSrcweir if ( FileBase::getFileURLFromSystemPath( OUString( rInitName ), aTmp ) == FileBase::E_None )
821cdf0e10cSrcweir {
822cdf0e10cSrcweir aOInitName = OUString( rInitName );
823cdf0e10cSrcweir aTmpName = ByteString( String(aOInitName), osl_getThreadTextEncoding() );
824cdf0e10cSrcweir }
825cdf0e10cSrcweir
826cdf0e10cSrcweir #ifdef DBG_UTIL
827cdf0e10cSrcweir // ASF nur bei Default eStyle, nicht z.B. aus MakeShortName()
828cdf0e10cSrcweir if( eStyle == FSYS_STYLE_HOST &&
829cdf0e10cSrcweir aTmpName.Search( "://" ) != STRING_NOTFOUND )
830cdf0e10cSrcweir {
831cdf0e10cSrcweir ByteString aErr = "DirEntries akzeptieren nur File URLS: ";
832cdf0e10cSrcweir aErr += aTmpName;
833cdf0e10cSrcweir DBG_WARNING( aErr.GetBuffer() );
834cdf0e10cSrcweir }
835cdf0e10cSrcweir #endif
836cdf0e10cSrcweir }
837cdf0e10cSrcweir
838cdf0e10cSrcweir nError = ImpParseName( aTmpName, eStyle );
839cdf0e10cSrcweir
840cdf0e10cSrcweir if ( nError != FSYS_ERR_OK )
841cdf0e10cSrcweir eFlag = FSYS_FLAG_INVALID;
842cdf0e10cSrcweir }
843cdf0e10cSrcweir
844cdf0e10cSrcweir /*************************************************************************/
845cdf0e10cSrcweir
DirEntry(const ByteString & rInitName,FSysPathStyle eStyle)846cdf0e10cSrcweir DirEntry::DirEntry( const ByteString& rInitName, FSysPathStyle eStyle )
847cdf0e10cSrcweir #ifdef FEAT_FSYS_DOUBLESPEED
848cdf0e10cSrcweir : pStat( 0 )
849cdf0e10cSrcweir #endif
850cdf0e10cSrcweir {
851cdf0e10cSrcweir DBG_CTOR( DirEntry, ImpCheckDirEntry );
852cdf0e10cSrcweir
853cdf0e10cSrcweir pParent = NULL;
854cdf0e10cSrcweir
855cdf0e10cSrcweir // schnelle Loesung fuer Leerstring
856cdf0e10cSrcweir if ( !rInitName.Len() )
857cdf0e10cSrcweir {
858cdf0e10cSrcweir eFlag = FSYS_FLAG_CURRENT;
859cdf0e10cSrcweir nError = FSYS_ERR_OK;
860cdf0e10cSrcweir return;
861cdf0e10cSrcweir }
862cdf0e10cSrcweir
863cdf0e10cSrcweir ByteString aTmpName( rInitName );
864cdf0e10cSrcweir if( eStyle == FSYS_STYLE_URL || rInitName.CompareIgnoreCaseToAscii("file:",5 ) == COMPARE_EQUAL )
865cdf0e10cSrcweir {
866cdf0e10cSrcweir #ifndef BOOTSTRAP
867cdf0e10cSrcweir DBG_WARNING( "File URLs are not permitted but accepted" );
868cdf0e10cSrcweir aTmpName = ByteString(String(INetURLObject( rInitName ).PathToFileName()), osl_getThreadTextEncoding());
869cdf0e10cSrcweir eStyle = FSYS_STYLE_HOST;
870cdf0e10cSrcweir #endif
871cdf0e10cSrcweir }
872cdf0e10cSrcweir #ifdef DBG_UTIL
873cdf0e10cSrcweir else
874cdf0e10cSrcweir // ASF nur bei Default eStyle, nicht z.B. aus MakeShortName()
875cdf0e10cSrcweir if( eStyle == FSYS_STYLE_HOST &&
876cdf0e10cSrcweir rInitName.Search( "://" ) != STRING_NOTFOUND )
877cdf0e10cSrcweir {
878cdf0e10cSrcweir ByteString aErr = "DirEntries akzeptieren nur File URLS: ";
879cdf0e10cSrcweir aErr += rInitName;
880cdf0e10cSrcweir DBG_WARNING( aErr.GetBuffer() );
881cdf0e10cSrcweir }
882cdf0e10cSrcweir #endif
883cdf0e10cSrcweir
884cdf0e10cSrcweir nError = ImpParseName( aTmpName, eStyle );
885cdf0e10cSrcweir
886cdf0e10cSrcweir if ( nError != FSYS_ERR_OK )
887cdf0e10cSrcweir eFlag = FSYS_FLAG_INVALID;
888cdf0e10cSrcweir }
889cdf0e10cSrcweir
890cdf0e10cSrcweir /*************************************************************************
891cdf0e10cSrcweir |*
892cdf0e10cSrcweir |* DirEntry::DirEntry()
893cdf0e10cSrcweir |*
894cdf0e10cSrcweir |* Beschreibung FSYS.SDW
895cdf0e10cSrcweir |* Ersterstellung MI 26.04.91
896cdf0e10cSrcweir |* Letzte Aenderung MA 02.12.91
897cdf0e10cSrcweir |*
898cdf0e10cSrcweir *************************************************************************/
899cdf0e10cSrcweir
DirEntry(DirEntryFlag eDirFlag)900cdf0e10cSrcweir DirEntry::DirEntry( DirEntryFlag eDirFlag )
901cdf0e10cSrcweir #ifdef FEAT_FSYS_DOUBLESPEED
902cdf0e10cSrcweir : pStat( 0 )
903cdf0e10cSrcweir #endif
904cdf0e10cSrcweir {
905cdf0e10cSrcweir DBG_CTOR( DirEntry, ImpCheckDirEntry );
906cdf0e10cSrcweir
907cdf0e10cSrcweir eFlag = eDirFlag;
908cdf0e10cSrcweir nError = ( eFlag == FSYS_FLAG_INVALID ) ? FSYS_ERR_UNKNOWN : FSYS_ERR_OK;
909cdf0e10cSrcweir pParent = NULL;
910cdf0e10cSrcweir }
911cdf0e10cSrcweir
912cdf0e10cSrcweir /*************************************************************************
913cdf0e10cSrcweir |*
914cdf0e10cSrcweir |* DirEntry::~DirEntry()
915cdf0e10cSrcweir |*
916cdf0e10cSrcweir |* Beschreibung FSYS.SDW
917cdf0e10cSrcweir |* Ersterstellung MI 26.04.91
918cdf0e10cSrcweir |* Letzte Aenderung MA 02.12.91
919cdf0e10cSrcweir |*
920cdf0e10cSrcweir *************************************************************************/
921cdf0e10cSrcweir
~DirEntry()922cdf0e10cSrcweir DirEntry::~DirEntry()
923cdf0e10cSrcweir {
924cdf0e10cSrcweir DBG_DTOR( DirEntry, ImpCheckDirEntry );
925cdf0e10cSrcweir
926cdf0e10cSrcweir delete pParent;
927cdf0e10cSrcweir #ifdef FEAT_FSYS_DOUBLESPEED
928cdf0e10cSrcweir delete pStat;
929cdf0e10cSrcweir #endif
930cdf0e10cSrcweir
931cdf0e10cSrcweir }
932cdf0e10cSrcweir
933cdf0e10cSrcweir /*************************************************************************
934cdf0e10cSrcweir |*
935cdf0e10cSrcweir |* DirEntry::ImpGetTopPtr() const
936cdf0e10cSrcweir |*
937cdf0e10cSrcweir |* Beschreibung FSYS.SDW
938cdf0e10cSrcweir |* Ersterstellung MI 26.04.91
939cdf0e10cSrcweir |* Letzte Aenderung MA 02.12.91
940cdf0e10cSrcweir |*
941cdf0e10cSrcweir *************************************************************************/
942cdf0e10cSrcweir
ImpGetTopPtr() const943cdf0e10cSrcweir const DirEntry* DirEntry::ImpGetTopPtr() const
944cdf0e10cSrcweir {
945cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
946cdf0e10cSrcweir
947cdf0e10cSrcweir const DirEntry *pTemp = this;
948cdf0e10cSrcweir while ( pTemp->pParent )
949cdf0e10cSrcweir pTemp = pTemp->pParent;
950cdf0e10cSrcweir
951cdf0e10cSrcweir return pTemp;
952cdf0e10cSrcweir }
953cdf0e10cSrcweir
954cdf0e10cSrcweir /*************************************************************************
955cdf0e10cSrcweir |*
956cdf0e10cSrcweir |* DirEntry::ImpGetTopPtr()
957cdf0e10cSrcweir |*
958cdf0e10cSrcweir |* Beschreibung FSYS.SDW
959cdf0e10cSrcweir |* Ersterstellung MI 13.11.91
960cdf0e10cSrcweir |* Letzte Aenderung MA 02.12.91
961cdf0e10cSrcweir |*
962cdf0e10cSrcweir *************************************************************************/
963cdf0e10cSrcweir
ImpGetTopPtr()964cdf0e10cSrcweir DirEntry* DirEntry::ImpGetTopPtr()
965cdf0e10cSrcweir {
966cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
967cdf0e10cSrcweir
968cdf0e10cSrcweir DirEntry *pTemp = this;
969cdf0e10cSrcweir while ( pTemp->pParent )
970cdf0e10cSrcweir pTemp = pTemp->pParent;
971cdf0e10cSrcweir
972cdf0e10cSrcweir return pTemp;
973cdf0e10cSrcweir }
974cdf0e10cSrcweir
975cdf0e10cSrcweir /*************************************************************************
976cdf0e10cSrcweir |*
977cdf0e10cSrcweir |* DirEntry::ImpGetPreTopPtr()
978cdf0e10cSrcweir |*
979cdf0e10cSrcweir |* Beschreibung liefert einen Pointer auf den vorletzten Entry
980cdf0e10cSrcweir |* Ersterstellung MI 01.11.91
981cdf0e10cSrcweir |* Letzte Aenderung MA 02.12.91
982cdf0e10cSrcweir |*
983cdf0e10cSrcweir *************************************************************************/
984cdf0e10cSrcweir
ImpGetPreTopPtr()985cdf0e10cSrcweir DirEntry* DirEntry::ImpGetPreTopPtr()
986cdf0e10cSrcweir {
987cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
988cdf0e10cSrcweir
989cdf0e10cSrcweir DirEntry *pTemp = this;
990cdf0e10cSrcweir if ( pTemp->pParent )
991cdf0e10cSrcweir {
992cdf0e10cSrcweir while ( pTemp->pParent->pParent )
993cdf0e10cSrcweir pTemp = pTemp->pParent;
994cdf0e10cSrcweir }
995cdf0e10cSrcweir
996cdf0e10cSrcweir return pTemp;
997cdf0e10cSrcweir }
998cdf0e10cSrcweir
999cdf0e10cSrcweir /*************************************************************************
1000cdf0e10cSrcweir |*
1001cdf0e10cSrcweir |* DirEntry::ImpChangeParent()
1002cdf0e10cSrcweir |*
1003cdf0e10cSrcweir |* Beschreibung FSYS.SDW
1004cdf0e10cSrcweir |* Ersterstellung MI 26.04.91
1005cdf0e10cSrcweir |* Letzte Aenderung MI 21.05.92
1006cdf0e10cSrcweir |*
1007cdf0e10cSrcweir *************************************************************************/
1008cdf0e10cSrcweir
ImpChangeParent(DirEntry * pNewParent,sal_Bool bNormalize)1009cdf0e10cSrcweir DirEntry* DirEntry::ImpChangeParent( DirEntry* pNewParent, sal_Bool bNormalize )
1010cdf0e10cSrcweir {
1011cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
1012cdf0e10cSrcweir
1013cdf0e10cSrcweir DirEntry *pTemp = pParent;
1014cdf0e10cSrcweir if ( bNormalize && pNewParent &&
1015cdf0e10cSrcweir pNewParent->eFlag == FSYS_FLAG_RELROOT && !pNewParent->aName.Len() )
1016cdf0e10cSrcweir {
1017cdf0e10cSrcweir pParent = 0;
1018cdf0e10cSrcweir delete pNewParent;
1019cdf0e10cSrcweir }
1020cdf0e10cSrcweir else
1021cdf0e10cSrcweir pParent = pNewParent;
1022cdf0e10cSrcweir
1023cdf0e10cSrcweir return pTemp;
1024cdf0e10cSrcweir }
1025cdf0e10cSrcweir
1026cdf0e10cSrcweir /*************************************************************************
1027cdf0e10cSrcweir |*
1028cdf0e10cSrcweir |* DirEntry::Exists()
1029cdf0e10cSrcweir |*
1030cdf0e10cSrcweir |* Beschreibung FSYS.SDW
1031cdf0e10cSrcweir |* Ersterstellung MI 26.04.91
1032cdf0e10cSrcweir |* Letzte Aenderung MI 24.09.91
1033cdf0e10cSrcweir |*
1034cdf0e10cSrcweir *************************************************************************/
1035cdf0e10cSrcweir
Exists(FSysAccess nAccess) const1036cdf0e10cSrcweir sal_Bool DirEntry::Exists( FSysAccess nAccess ) const
1037cdf0e10cSrcweir {
1038cdf0e10cSrcweir #ifndef BOOTSTRAP
1039cdf0e10cSrcweir static vos::OMutex aLocalMutex;
1040cdf0e10cSrcweir vos::OGuard aGuard( aLocalMutex );
1041cdf0e10cSrcweir #endif
1042cdf0e10cSrcweir if ( !IsValid() )
1043cdf0e10cSrcweir return sal_False;
1044cdf0e10cSrcweir
1045cdf0e10cSrcweir #if defined WNT || defined OS2
1046cdf0e10cSrcweir // spezielle Filenamen sind vom System da
1047cdf0e10cSrcweir if ( ( aName.CompareIgnoreCaseToAscii("CLOCK$") == COMPARE_EQUAL ||
1048cdf0e10cSrcweir aName.CompareIgnoreCaseToAscii("CON") == COMPARE_EQUAL ||
1049cdf0e10cSrcweir aName.CompareIgnoreCaseToAscii("AUX") == COMPARE_EQUAL ||
1050cdf0e10cSrcweir aName.CompareIgnoreCaseToAscii("COM1") == COMPARE_EQUAL ||
1051cdf0e10cSrcweir aName.CompareIgnoreCaseToAscii("COM2") == COMPARE_EQUAL ||
1052cdf0e10cSrcweir aName.CompareIgnoreCaseToAscii("COM3") == COMPARE_EQUAL ||
1053cdf0e10cSrcweir aName.CompareIgnoreCaseToAscii("COM4") == COMPARE_EQUAL ||
1054cdf0e10cSrcweir aName.CompareIgnoreCaseToAscii("LPT1") == COMPARE_EQUAL ||
1055cdf0e10cSrcweir aName.CompareIgnoreCaseToAscii("LPT2") == COMPARE_EQUAL ||
1056cdf0e10cSrcweir aName.CompareIgnoreCaseToAscii("LPT3") == COMPARE_EQUAL ||
1057cdf0e10cSrcweir aName.CompareIgnoreCaseToAscii("NUL") == COMPARE_EQUAL ||
1058cdf0e10cSrcweir aName.CompareIgnoreCaseToAscii("PRN") == COMPARE_EQUAL ) )
1059cdf0e10cSrcweir return sal_True;
1060cdf0e10cSrcweir #endif
1061cdf0e10cSrcweir
1062cdf0e10cSrcweir FSysFailOnErrorImpl();
1063cdf0e10cSrcweir DirEntryKind eKind = FileStat( *this, nAccess ).GetKind();
1064cdf0e10cSrcweir if ( eKind & ( FSYS_KIND_FILE | FSYS_KIND_DIR ) )
1065cdf0e10cSrcweir {
1066cdf0e10cSrcweir return sal_True;
1067cdf0e10cSrcweir }
1068cdf0e10cSrcweir
1069cdf0e10cSrcweir #if defined WNT || defined OS2
1070cdf0e10cSrcweir if ( 0 != ( eKind & FSYS_KIND_DEV ) )
1071cdf0e10cSrcweir {
1072cdf0e10cSrcweir return DRIVE_EXISTS( ImpGetTopPtr()->aName.GetChar(0) );
1073cdf0e10cSrcweir }
1074cdf0e10cSrcweir #endif
1075cdf0e10cSrcweir
1076cdf0e10cSrcweir return 0 != ( eKind & ( FSYS_KIND_FILE | FSYS_KIND_DIR ) );
1077cdf0e10cSrcweir }
1078cdf0e10cSrcweir
1079cdf0e10cSrcweir /*************************************************************************
1080cdf0e10cSrcweir |*
1081cdf0e10cSrcweir |* DirEntry::First()
1082cdf0e10cSrcweir |*
1083cdf0e10cSrcweir |* Beschreibung FSYS.SDW
1084cdf0e10cSrcweir |* Ersterstellung MI 26.04.91
1085cdf0e10cSrcweir |* Letzte Aenderung MA 15.01.92
1086cdf0e10cSrcweir |*
1087cdf0e10cSrcweir *************************************************************************/
1088cdf0e10cSrcweir
First()1089cdf0e10cSrcweir sal_Bool DirEntry::First()
1090cdf0e10cSrcweir {
1091cdf0e10cSrcweir FSysFailOnErrorImpl();
1092cdf0e10cSrcweir
1093cdf0e10cSrcweir String aUniPathName( GetPath().GetFull() );
1094cdf0e10cSrcweir #ifndef BOOTSTRAP
1095cdf0e10cSrcweir FSysRedirector::DoRedirect( aUniPathName );
1096cdf0e10cSrcweir ByteString aPathName(aUniPathName, osl_getThreadTextEncoding());
1097cdf0e10cSrcweir #else
1098cdf0e10cSrcweir ByteString aPathName(aUniPathName, gsl_getSystemTextEncoding());
1099cdf0e10cSrcweir #endif
1100cdf0e10cSrcweir aPathName = GUI2FSYS( aPathName );
1101cdf0e10cSrcweir
1102cdf0e10cSrcweir DIR *pDir = opendir( (char*) aPathName.GetBuffer() );
1103cdf0e10cSrcweir if ( pDir )
1104cdf0e10cSrcweir {
1105cdf0e10cSrcweir #ifndef BOOTSTRAP
1106cdf0e10cSrcweir WildCard aWildeKarte( String(CMP_LOWER( aName ), osl_getThreadTextEncoding()) );
1107cdf0e10cSrcweir #else
1108cdf0e10cSrcweir WildCard aWildeKarte( String(CMP_LOWER( aName ), gsl_getSystemTextEncoding()) );
1109cdf0e10cSrcweir #endif
1110cdf0e10cSrcweir for ( dirent* pEntry = readdir( pDir );
1111cdf0e10cSrcweir pEntry;
1112cdf0e10cSrcweir pEntry = readdir( pDir ) )
1113cdf0e10cSrcweir {
1114cdf0e10cSrcweir ByteString aFound( FSYS2GUI( ByteString( pEntry->d_name ) ) );
1115cdf0e10cSrcweir if ( aWildeKarte.Matches( String(CMP_LOWER( aFound ), osl_getThreadTextEncoding())))
1116cdf0e10cSrcweir {
1117cdf0e10cSrcweir aName = aFound;
1118cdf0e10cSrcweir closedir( pDir );
1119cdf0e10cSrcweir return sal_True;
1120cdf0e10cSrcweir }
1121cdf0e10cSrcweir }
1122cdf0e10cSrcweir closedir( pDir );
1123cdf0e10cSrcweir }
1124cdf0e10cSrcweir return sal_False;
1125cdf0e10cSrcweir }
1126cdf0e10cSrcweir
1127cdf0e10cSrcweir /*************************************************************************
1128cdf0e10cSrcweir |*
1129cdf0e10cSrcweir |* DirEntry::GetFull()
1130cdf0e10cSrcweir |*
1131cdf0e10cSrcweir |* Beschreibung FSYS.SDW
1132cdf0e10cSrcweir |* Ersterstellung MI 26.04.91
1133cdf0e10cSrcweir |* Letzte Aenderung MA 02.12.91
1134cdf0e10cSrcweir |*
1135cdf0e10cSrcweir *************************************************************************/
1136cdf0e10cSrcweir
GetFull(FSysPathStyle eStyle,sal_Bool bWithDelimiter,sal_uInt16 nMaxChars) const1137cdf0e10cSrcweir String DirEntry::GetFull( FSysPathStyle eStyle, sal_Bool bWithDelimiter,
1138cdf0e10cSrcweir sal_uInt16 nMaxChars ) const
1139cdf0e10cSrcweir {
1140cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
1141cdf0e10cSrcweir
1142cdf0e10cSrcweir ByteString aRet;
1143cdf0e10cSrcweir eStyle = GetStyle( eStyle );
1144cdf0e10cSrcweir if ( pParent )
1145cdf0e10cSrcweir {
1146cdf0e10cSrcweir if ( ( pParent->eFlag == FSYS_FLAG_ABSROOT ||
1147cdf0e10cSrcweir pParent->eFlag == FSYS_FLAG_RELROOT ||
1148cdf0e10cSrcweir pParent->eFlag == FSYS_FLAG_VOLUME ) )
1149cdf0e10cSrcweir {
1150cdf0e10cSrcweir aRet = ByteString(pParent->GetName( eStyle ), osl_getThreadTextEncoding());
1151cdf0e10cSrcweir aRet += ByteString(GetName( eStyle ), osl_getThreadTextEncoding());
1152cdf0e10cSrcweir }
1153cdf0e10cSrcweir else
1154cdf0e10cSrcweir {
1155cdf0e10cSrcweir aRet = ByteString(pParent->GetFull( eStyle ), osl_getThreadTextEncoding());
1156cdf0e10cSrcweir aRet += ACCESSDELIM_C(eStyle);
1157cdf0e10cSrcweir aRet += ByteString(GetName( eStyle ), osl_getThreadTextEncoding());
1158cdf0e10cSrcweir }
1159cdf0e10cSrcweir }
1160cdf0e10cSrcweir else
1161cdf0e10cSrcweir {
1162cdf0e10cSrcweir aRet = ByteString(GetName( eStyle ), osl_getThreadTextEncoding());
1163cdf0e10cSrcweir }
1164cdf0e10cSrcweir
1165cdf0e10cSrcweir if ( ( eStyle == FSYS_STYLE_MAC ) &&
1166cdf0e10cSrcweir ( ImpGetTopPtr()->eFlag != FSYS_FLAG_VOLUME ) &&
1167cdf0e10cSrcweir ( ImpGetTopPtr()->eFlag != FSYS_FLAG_ABSROOT ) &&
1168cdf0e10cSrcweir ( aRet.GetChar(0) != ':' ) )
1169cdf0e10cSrcweir aRet.Insert( ACCESSDELIM_C(eStyle), 0 );
1170cdf0e10cSrcweir
1171cdf0e10cSrcweir //! Hack
1172cdf0e10cSrcweir if ( bWithDelimiter )
1173cdf0e10cSrcweir if ( aRet.GetChar( aRet.Len()-1 ) != ACCESSDELIM_C(eStyle) )
1174cdf0e10cSrcweir aRet += ACCESSDELIM_C(eStyle);
1175cdf0e10cSrcweir
1176cdf0e10cSrcweir //! noch ein Hack
1177cdf0e10cSrcweir if ( nMaxChars < STRING_MAXLEN )
1178cdf0e10cSrcweir aRet = ImplCutPath( aRet, nMaxChars, ACCESSDELIM_C(eStyle) );
1179cdf0e10cSrcweir
1180cdf0e10cSrcweir return String(aRet, osl_getThreadTextEncoding());
1181cdf0e10cSrcweir }
1182cdf0e10cSrcweir
1183cdf0e10cSrcweir /*************************************************************************
1184cdf0e10cSrcweir |*
1185cdf0e10cSrcweir |* DirEntry::GetPath()
1186cdf0e10cSrcweir |*
1187cdf0e10cSrcweir |* Beschreibung FSYS.SDW
1188cdf0e10cSrcweir |* Ersterstellung MI 26.04.91
1189cdf0e10cSrcweir |* Letzte Aenderung MA 02.12.91
1190cdf0e10cSrcweir |*
1191cdf0e10cSrcweir *************************************************************************/
1192cdf0e10cSrcweir
GetPath() const1193cdf0e10cSrcweir DirEntry DirEntry::GetPath() const
1194cdf0e10cSrcweir {
1195cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
1196cdf0e10cSrcweir
1197cdf0e10cSrcweir if ( pParent )
1198cdf0e10cSrcweir return DirEntry( *pParent );
1199cdf0e10cSrcweir
1200cdf0e10cSrcweir return DirEntry();
1201cdf0e10cSrcweir }
1202cdf0e10cSrcweir
1203cdf0e10cSrcweir /*************************************************************************
1204cdf0e10cSrcweir |*
1205cdf0e10cSrcweir |* DirEntry::GetExtension()
1206cdf0e10cSrcweir |*
1207cdf0e10cSrcweir |* Beschreibung FSYS.SDW
1208cdf0e10cSrcweir |* Ersterstellung MI 26.04.91
1209cdf0e10cSrcweir |* Letzte Aenderung MA 02.12.91
1210cdf0e10cSrcweir |*
1211cdf0e10cSrcweir *************************************************************************/
1212cdf0e10cSrcweir
GetExtension(char cSep) const1213cdf0e10cSrcweir String DirEntry::GetExtension( char cSep ) const
1214cdf0e10cSrcweir {
1215cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
1216cdf0e10cSrcweir
1217cdf0e10cSrcweir const char *p0 = ( aName.GetBuffer() );
1218cdf0e10cSrcweir const char *p1 = p0 + aName.Len() - 1;
1219cdf0e10cSrcweir while ( p1 >= p0 && *p1 != cSep )
1220cdf0e10cSrcweir p1--;
1221cdf0e10cSrcweir
1222cdf0e10cSrcweir if ( p1 >= p0 )
1223cdf0e10cSrcweir // es wurde ein cSep an der Position p1 gefunden
1224cdf0e10cSrcweir return String(
1225cdf0e10cSrcweir aName.Copy( static_cast< xub_StrLen >(p1 - p0 + 1) ),
1226cdf0e10cSrcweir osl_getThreadTextEncoding());
1227cdf0e10cSrcweir return String();
1228cdf0e10cSrcweir }
1229cdf0e10cSrcweir
1230cdf0e10cSrcweir /*************************************************************************
1231cdf0e10cSrcweir |*
1232cdf0e10cSrcweir |* DirEntry::GetBase()
1233cdf0e10cSrcweir |*
1234cdf0e10cSrcweir |* Beschreibung FSYS.SDW
1235cdf0e10cSrcweir |* Ersterstellung MI 26.04.91
1236cdf0e10cSrcweir |* Letzte Aenderung MA 02.12.91
1237cdf0e10cSrcweir |*
1238cdf0e10cSrcweir *************************************************************************/
1239cdf0e10cSrcweir
GetBase(char cSep) const1240cdf0e10cSrcweir String DirEntry::GetBase( char cSep ) const
1241cdf0e10cSrcweir {
1242cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
1243cdf0e10cSrcweir
1244cdf0e10cSrcweir const char *p0 = ( aName.GetBuffer() );
1245cdf0e10cSrcweir const char *p1 = p0 + aName.Len() - 1;
1246cdf0e10cSrcweir while ( p1 >= p0 && *p1 != cSep )
1247cdf0e10cSrcweir p1--;
1248cdf0e10cSrcweir
1249cdf0e10cSrcweir if ( p1 >= p0 )
1250cdf0e10cSrcweir // es wurde ein cSep an der Position p1 gefunden
1251cdf0e10cSrcweir return String(
1252cdf0e10cSrcweir aName.Copy( 0, static_cast< xub_StrLen >(p1 - p0) ),
1253cdf0e10cSrcweir osl_getThreadTextEncoding());
1254cdf0e10cSrcweir
1255cdf0e10cSrcweir else
1256cdf0e10cSrcweir // es wurde kein cSep gefunden
1257cdf0e10cSrcweir return String(aName, osl_getThreadTextEncoding());
1258cdf0e10cSrcweir }
1259cdf0e10cSrcweir
1260cdf0e10cSrcweir /*************************************************************************
1261cdf0e10cSrcweir |*
1262cdf0e10cSrcweir |* DirEntry::GetName()
1263cdf0e10cSrcweir |*
1264cdf0e10cSrcweir |* Beschreibung FSYS.SDW
1265cdf0e10cSrcweir |* Ersterstellung MI 26.04.91
1266cdf0e10cSrcweir |* Letzte Aenderung MA 02.12.91 13:47
1267cdf0e10cSrcweir |*
1268cdf0e10cSrcweir *************************************************************************/
1269cdf0e10cSrcweir
GetName(FSysPathStyle eStyle) const1270cdf0e10cSrcweir String DirEntry::GetName( FSysPathStyle eStyle ) const
1271cdf0e10cSrcweir {
1272cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
1273cdf0e10cSrcweir
1274cdf0e10cSrcweir ByteString aRet;
1275cdf0e10cSrcweir eStyle = GetStyle( eStyle );
1276cdf0e10cSrcweir
1277cdf0e10cSrcweir switch( eFlag )
1278cdf0e10cSrcweir {
1279cdf0e10cSrcweir case FSYS_FLAG_PARENT:
1280cdf0e10cSrcweir aRet = ACTPARENT(eStyle);
1281cdf0e10cSrcweir break;
1282cdf0e10cSrcweir
1283cdf0e10cSrcweir case FSYS_FLAG_ABSROOT:
1284cdf0e10cSrcweir {
1285cdf0e10cSrcweir if ( eStyle == FSYS_STYLE_URL )
1286cdf0e10cSrcweir {
1287cdf0e10cSrcweir aRet = "file:///";
1288cdf0e10cSrcweir aRet += aName;
1289cdf0e10cSrcweir
1290cdf0e10cSrcweir #ifndef UNX
1291cdf0e10cSrcweir if ( aName.Len())
1292cdf0e10cSrcweir {
1293cdf0e10cSrcweir if ( aName.GetChar(aName.Len()-1) == ':' )
1294cdf0e10cSrcweir {
1295cdf0e10cSrcweir aRet.SetChar(aRet.Len()-1, '|');
1296cdf0e10cSrcweir }
1297cdf0e10cSrcweir else
1298cdf0e10cSrcweir {
1299cdf0e10cSrcweir aRet.Insert( '/', 5 );
1300cdf0e10cSrcweir }
1301cdf0e10cSrcweir aRet += "/";
1302cdf0e10cSrcweir }
1303cdf0e10cSrcweir #endif
1304cdf0e10cSrcweir }
1305cdf0e10cSrcweir else if ( eStyle != FSYS_STYLE_MAC &&
1306cdf0e10cSrcweir aName.Len() > 1 && aName.GetChar( 1 ) != ':' )
1307cdf0e10cSrcweir {
1308cdf0e10cSrcweir // UNC-Pathname
1309cdf0e10cSrcweir aRet = ACCESSDELIM_C(eStyle);
1310cdf0e10cSrcweir aRet += ACCESSDELIM_C(eStyle);
1311cdf0e10cSrcweir aRet += aName ;
1312cdf0e10cSrcweir aRet += ACCESSDELIM_C(eStyle);
1313cdf0e10cSrcweir }
1314cdf0e10cSrcweir else
1315cdf0e10cSrcweir {
1316cdf0e10cSrcweir aRet = aName;
1317cdf0e10cSrcweir aRet += ACCESSDELIM_C(eStyle);
1318cdf0e10cSrcweir }
1319cdf0e10cSrcweir break;
1320cdf0e10cSrcweir }
1321cdf0e10cSrcweir
1322cdf0e10cSrcweir case FSYS_FLAG_INVALID:
1323cdf0e10cSrcweir case FSYS_FLAG_VOLUME:
1324cdf0e10cSrcweir {
1325cdf0e10cSrcweir if ( eStyle == FSYS_STYLE_URL )
1326cdf0e10cSrcweir {
1327cdf0e10cSrcweir aRet = "file:///";
1328cdf0e10cSrcweir aRet += aName;
1329cdf0e10cSrcweir #ifndef UNX
1330cdf0e10cSrcweir if ( aName.Len() && aName.GetChar(aName.Len()-1) == ':' )
1331cdf0e10cSrcweir {
1332cdf0e10cSrcweir aRet.SetChar(aRet.Len()-1, '|');
1333cdf0e10cSrcweir }
1334cdf0e10cSrcweir #endif
1335cdf0e10cSrcweir }
1336cdf0e10cSrcweir else
1337cdf0e10cSrcweir {
1338cdf0e10cSrcweir aRet = aName;
1339cdf0e10cSrcweir }
1340cdf0e10cSrcweir
1341cdf0e10cSrcweir break;
1342cdf0e10cSrcweir }
1343cdf0e10cSrcweir
1344cdf0e10cSrcweir case FSYS_FLAG_RELROOT:
1345cdf0e10cSrcweir if ( !aName.Len() )
1346cdf0e10cSrcweir {
1347cdf0e10cSrcweir aRet = ACTCURRENT(eStyle);
1348cdf0e10cSrcweir break;
1349cdf0e10cSrcweir }
1350cdf0e10cSrcweir
1351cdf0e10cSrcweir default:
1352cdf0e10cSrcweir aRet = aName;
1353cdf0e10cSrcweir }
1354cdf0e10cSrcweir
1355cdf0e10cSrcweir return String(aRet, osl_getThreadTextEncoding());
1356cdf0e10cSrcweir }
1357cdf0e10cSrcweir
1358cdf0e10cSrcweir /*************************************************************************
1359cdf0e10cSrcweir |*
1360cdf0e10cSrcweir |* DirEntry::IsAbs()
1361cdf0e10cSrcweir |*
1362cdf0e10cSrcweir |* Beschreibung FSYS.SDW
1363cdf0e10cSrcweir |* Ersterstellung MI 26.04.91
1364cdf0e10cSrcweir |* Letzte Aenderung MA 02.12.91
1365cdf0e10cSrcweir |*
1366cdf0e10cSrcweir *************************************************************************/
1367cdf0e10cSrcweir
IsAbs() const1368cdf0e10cSrcweir bool DirEntry::IsAbs() const
1369cdf0e10cSrcweir {
1370cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
1371cdf0e10cSrcweir
1372cdf0e10cSrcweir #ifdef UNX
1373cdf0e10cSrcweir return ( pParent ? pParent->IsAbs() : eFlag == FSYS_FLAG_ABSROOT );
1374cdf0e10cSrcweir #else
1375cdf0e10cSrcweir return ( pParent ? pParent->IsAbs() : eFlag == FSYS_FLAG_ABSROOT && aName.Len() > 0 );
1376cdf0e10cSrcweir #endif
1377cdf0e10cSrcweir }
1378cdf0e10cSrcweir
1379cdf0e10cSrcweir /*************************************************************************
1380cdf0e10cSrcweir |*
1381cdf0e10cSrcweir |* DirEntry::CutName()
1382cdf0e10cSrcweir |*
1383cdf0e10cSrcweir |* Beschreibung FSYS.SDW
1384cdf0e10cSrcweir |* Ersterstellung MI 26.04.91
1385cdf0e10cSrcweir |* Letzte Aenderung MA 02.12.91
1386cdf0e10cSrcweir |*
1387cdf0e10cSrcweir *************************************************************************/
1388cdf0e10cSrcweir
CutName(FSysPathStyle eStyle)1389cdf0e10cSrcweir String DirEntry::CutName( FSysPathStyle eStyle )
1390cdf0e10cSrcweir {
1391cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
1392cdf0e10cSrcweir
1393cdf0e10cSrcweir eStyle = GetStyle( eStyle );
1394cdf0e10cSrcweir
1395cdf0e10cSrcweir String aOldName( GetName( eStyle ) );
1396cdf0e10cSrcweir
1397cdf0e10cSrcweir if ( pParent )
1398cdf0e10cSrcweir {
1399cdf0e10cSrcweir DirEntry *pOldParent = pParent;
1400cdf0e10cSrcweir if ( pOldParent )
1401cdf0e10cSrcweir {
1402cdf0e10cSrcweir pParent = pOldParent->pParent;
1403cdf0e10cSrcweir eFlag = pOldParent->eFlag;
1404cdf0e10cSrcweir aName = pOldParent->aName;
1405cdf0e10cSrcweir pOldParent->pParent = NULL;
1406cdf0e10cSrcweir delete pOldParent;
1407cdf0e10cSrcweir }
1408cdf0e10cSrcweir else
1409cdf0e10cSrcweir {
1410cdf0e10cSrcweir eFlag = FSYS_FLAG_CURRENT;
1411cdf0e10cSrcweir aName.Erase();
1412cdf0e10cSrcweir }
1413cdf0e10cSrcweir }
1414cdf0e10cSrcweir else
1415cdf0e10cSrcweir {
1416cdf0e10cSrcweir eFlag = FSYS_FLAG_CURRENT;
1417cdf0e10cSrcweir aName.Erase();
1418cdf0e10cSrcweir delete pParent;
1419cdf0e10cSrcweir pParent = NULL;
1420cdf0e10cSrcweir }
1421cdf0e10cSrcweir
1422cdf0e10cSrcweir return aOldName;
1423cdf0e10cSrcweir }
1424cdf0e10cSrcweir
1425cdf0e10cSrcweir /*************************************************************************
1426cdf0e10cSrcweir |*
1427cdf0e10cSrcweir |* DirEntry::NameCompare
1428cdf0e10cSrcweir |*
1429cdf0e10cSrcweir |* Beschreibung Vergleich nur die Namen (ohne Pfad, aber mit Gross/Klein)
1430cdf0e10cSrcweir |* Ersterstellung MI 26.04.91
1431cdf0e10cSrcweir |* Letzte Aenderung MA 02.12.91
1432cdf0e10cSrcweir |*
1433cdf0e10cSrcweir *************************************************************************/
1434cdf0e10cSrcweir
NameCompare(const DirEntry & rWith) const1435cdf0e10cSrcweir StringCompare DirEntry::NameCompare( const DirEntry &rWith ) const
1436cdf0e10cSrcweir {
1437cdf0e10cSrcweir ByteString aThisName;
1438cdf0e10cSrcweir ByteString aParameterName;
1439cdf0e10cSrcweir
1440cdf0e10cSrcweir #ifdef UNX
1441cdf0e10cSrcweir aThisName = aName;
1442cdf0e10cSrcweir aParameterName = rWith.aName;
1443cdf0e10cSrcweir #else
1444cdf0e10cSrcweir aThisName = ByteString(aName).ToLowerAscii();
1445cdf0e10cSrcweir aParameterName = ByteString(rWith.aName).ToLowerAscii();
1446cdf0e10cSrcweir #endif
1447cdf0e10cSrcweir
1448cdf0e10cSrcweir return aThisName.CompareTo( aParameterName );
1449cdf0e10cSrcweir }
1450cdf0e10cSrcweir
1451cdf0e10cSrcweir
1452cdf0e10cSrcweir /*************************************************************************
1453cdf0e10cSrcweir |*
1454cdf0e10cSrcweir |* DirEntry::operator==()
1455cdf0e10cSrcweir |*
1456cdf0e10cSrcweir |* Beschreibung FSYS.SDW
1457cdf0e10cSrcweir |* Ersterstellung MI 26.04.91
1458cdf0e10cSrcweir |* Letzte Aenderung MA 02.12.91
1459cdf0e10cSrcweir |*
1460cdf0e10cSrcweir *************************************************************************/
1461cdf0e10cSrcweir
operator ==(const DirEntry & rEntry) const1462cdf0e10cSrcweir sal_Bool DirEntry::operator==( const DirEntry& rEntry ) const
1463cdf0e10cSrcweir {
1464cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
1465cdf0e10cSrcweir
1466cdf0e10cSrcweir // test wheather the contents are textual the same
1467cdf0e10cSrcweir
1468cdf0e10cSrcweir if ( nError && ( nError == rEntry.nError ) )
1469cdf0e10cSrcweir return sal_True;
1470cdf0e10cSrcweir if ( nError || rEntry.nError ||
1471cdf0e10cSrcweir ( eFlag == FSYS_FLAG_INVALID ) ||
1472cdf0e10cSrcweir ( rEntry.eFlag == FSYS_FLAG_INVALID ) )
1473cdf0e10cSrcweir return sal_False;
1474cdf0e10cSrcweir
1475cdf0e10cSrcweir #ifndef OS2
1476cdf0e10cSrcweir const
1477cdf0e10cSrcweir #endif
1478cdf0e10cSrcweir DirEntry *pThis = (DirEntry *)this;
1479cdf0e10cSrcweir #ifndef OS2
1480cdf0e10cSrcweir const
1481cdf0e10cSrcweir #endif
1482cdf0e10cSrcweir DirEntry *pWith = (DirEntry *)&rEntry;
1483cdf0e10cSrcweir while( pThis && pWith && (pThis->eFlag == pWith->eFlag) )
1484cdf0e10cSrcweir {
1485cdf0e10cSrcweir if ( CMP_LOWER(pThis->aName) != CMP_LOWER(pWith->aName) )
1486cdf0e10cSrcweir break;
1487cdf0e10cSrcweir pThis = pThis->pParent;
1488cdf0e10cSrcweir pWith = pWith->pParent;
1489cdf0e10cSrcweir }
1490cdf0e10cSrcweir
1491cdf0e10cSrcweir return ( !pThis && !pWith );
1492cdf0e10cSrcweir }
1493cdf0e10cSrcweir
1494cdf0e10cSrcweir /*************************************************************************
1495cdf0e10cSrcweir |*
1496cdf0e10cSrcweir |* DirEntry::operator=()
1497cdf0e10cSrcweir |*
1498cdf0e10cSrcweir |* Beschreibung FSYS.SDW
1499cdf0e10cSrcweir |* Ersterstellung MI 26.04.91
1500cdf0e10cSrcweir |* Letzte Aenderung MA 02.12.91
1501cdf0e10cSrcweir |*
1502cdf0e10cSrcweir *************************************************************************/
1503cdf0e10cSrcweir
operator =(const DirEntry & rEntry)1504cdf0e10cSrcweir DirEntry& DirEntry::operator=( const DirEntry& rEntry )
1505cdf0e10cSrcweir {
1506cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
1507cdf0e10cSrcweir
1508cdf0e10cSrcweir if ( this == &rEntry )
1509cdf0e10cSrcweir return *this;
1510cdf0e10cSrcweir if ( rEntry.nError != FSYS_ERR_OK ) {
1511cdf0e10cSrcweir DBG_ERROR("Zuweisung mit invalidem DirEntry");
1512cdf0e10cSrcweir nError = rEntry.nError;
1513cdf0e10cSrcweir return *this;
1514cdf0e10cSrcweir }
1515cdf0e10cSrcweir
1516cdf0e10cSrcweir // Name und Typ uebernehmen, Refs beibehalten
1517cdf0e10cSrcweir aName = rEntry.aName;
1518cdf0e10cSrcweir eFlag = rEntry.eFlag;
1519cdf0e10cSrcweir nError = FSYS_ERR_OK;
1520cdf0e10cSrcweir
1521cdf0e10cSrcweir DirEntry *pOldParent = pParent;
1522cdf0e10cSrcweir if ( rEntry.pParent )
1523cdf0e10cSrcweir pParent = new DirEntry( *rEntry.pParent );
1524cdf0e10cSrcweir else
1525cdf0e10cSrcweir pParent = NULL;
1526cdf0e10cSrcweir
1527cdf0e10cSrcweir if ( pOldParent )
1528cdf0e10cSrcweir delete pOldParent;
1529cdf0e10cSrcweir return *this;
1530cdf0e10cSrcweir }
1531cdf0e10cSrcweir
1532cdf0e10cSrcweir /*************************************************************************
1533cdf0e10cSrcweir |*
1534cdf0e10cSrcweir |* DirEntry::operator+()
1535cdf0e10cSrcweir |*
1536cdf0e10cSrcweir |* Beschreibung FSYS.SDW
1537cdf0e10cSrcweir |* Ersterstellung MI 26.04.91
1538cdf0e10cSrcweir |* Letzte Aenderung MA 02.12.91
1539cdf0e10cSrcweir |*
1540cdf0e10cSrcweir *************************************************************************/
1541cdf0e10cSrcweir
operator +(const DirEntry & rEntry) const1542cdf0e10cSrcweir DirEntry DirEntry::operator+( const DirEntry& rEntry ) const
1543cdf0e10cSrcweir {
1544cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
1545cdf0e10cSrcweir #ifdef DBG_UTIL
1546cdf0e10cSrcweir static sal_Bool bTested = sal_False;
1547cdf0e10cSrcweir if ( !bTested )
1548cdf0e10cSrcweir {
1549cdf0e10cSrcweir bTested = sal_True;
1550cdf0e10cSrcweir FSysTest();
1551cdf0e10cSrcweir }
1552cdf0e10cSrcweir #endif
1553cdf0e10cSrcweir
1554cdf0e10cSrcweir const DirEntry *pEntryTop = rEntry.ImpGetTopPtr();
1555cdf0e10cSrcweir const DirEntry *pThisTop = ImpGetTopPtr();
1556cdf0e10cSrcweir
1557cdf0e10cSrcweir // "." + irgendwas oder irgendwas + "d:irgendwas"
1558cdf0e10cSrcweir /* TPF:org
1559cdf0e10cSrcweir if ( ( eFlag == FSYS_FLAG_RELROOT && !aName ) ||
1560cdf0e10cSrcweir ( pEntryTop->aName.Len() &&
1561cdf0e10cSrcweir ( pEntryTop->eFlag == FSYS_FLAG_ABSROOT ||
1562cdf0e10cSrcweir pEntryTop->eFlag == FSYS_FLAG_RELROOT ||
1563cdf0e10cSrcweir pEntryTop->eFlag == FSYS_FLAG_VOLUME ) ) )
1564cdf0e10cSrcweir return rEntry;
1565cdf0e10cSrcweir */
1566cdf0e10cSrcweir
1567cdf0e10cSrcweir if (
1568cdf0e10cSrcweir (eFlag == FSYS_FLAG_RELROOT && !aName.Len()) ||
1569cdf0e10cSrcweir (
1570cdf0e10cSrcweir (pEntryTop->aName.Len() ||
1571cdf0e10cSrcweir ((rEntry.Level()>1)?(rEntry[rEntry.Level()-2].aName.CompareIgnoreCaseToAscii(RFS_IDENTIFIER)==COMPARE_EQUAL):sal_False))
1572cdf0e10cSrcweir &&
1573cdf0e10cSrcweir (pEntryTop->eFlag == FSYS_FLAG_ABSROOT ||
1574cdf0e10cSrcweir pEntryTop->eFlag == FSYS_FLAG_RELROOT ||
1575cdf0e10cSrcweir pEntryTop->eFlag == FSYS_FLAG_VOLUME)
1576cdf0e10cSrcweir )
1577cdf0e10cSrcweir )
1578cdf0e10cSrcweir {
1579cdf0e10cSrcweir return rEntry;
1580cdf0e10cSrcweir }
1581cdf0e10cSrcweir
1582cdf0e10cSrcweir // irgendwas + "." (=> pEntryTop == &rEntry)
1583cdf0e10cSrcweir if ( pEntryTop->eFlag == FSYS_FLAG_RELROOT && !pEntryTop->aName.Len() )
1584cdf0e10cSrcweir {
1585cdf0e10cSrcweir DBG_ASSERT( pEntryTop == &rEntry, "DirEntry::op+ buggy" );
1586cdf0e10cSrcweir return *this;
1587cdf0e10cSrcweir }
1588cdf0e10cSrcweir
1589cdf0e10cSrcweir // root += ".." (=> unmoeglich)
1590cdf0e10cSrcweir if ( pEntryTop->eFlag == FSYS_FLAG_PARENT && pThisTop == this &&
1591cdf0e10cSrcweir ( eFlag == FSYS_FLAG_ABSROOT ) )
1592cdf0e10cSrcweir return DirEntry( FSYS_FLAG_INVALID );
1593cdf0e10cSrcweir
1594cdf0e10cSrcweir // irgendwas += abs (=> nur Device uebernehmen falls vorhanden)
1595cdf0e10cSrcweir if ( pEntryTop->eFlag == FSYS_FLAG_ABSROOT )
1596cdf0e10cSrcweir {
1597cdf0e10cSrcweir ByteString aDevice;
1598cdf0e10cSrcweir if ( pThisTop->eFlag == FSYS_FLAG_ABSROOT )
1599cdf0e10cSrcweir aDevice = pThisTop->aName;
1600cdf0e10cSrcweir DirEntry aRet = rEntry;
1601cdf0e10cSrcweir if ( aDevice.Len() )
1602cdf0e10cSrcweir aRet.ImpGetTopPtr()->aName = aDevice;
1603cdf0e10cSrcweir return aRet;
1604cdf0e10cSrcweir }
1605cdf0e10cSrcweir
1606cdf0e10cSrcweir // irgendwas += ".." (=> aufloesen)
1607cdf0e10cSrcweir if ( eFlag == FSYS_FLAG_NORMAL && pEntryTop->eFlag == FSYS_FLAG_PARENT )
1608cdf0e10cSrcweir {
1609cdf0e10cSrcweir String aConcated( GetFull() );
1610cdf0e10cSrcweir aConcated += ACCESSDELIM_C(FSYS_STYLE_HOST);
1611cdf0e10cSrcweir aConcated += rEntry.GetFull();
1612cdf0e10cSrcweir return DirEntry( aConcated );
1613cdf0e10cSrcweir }
1614cdf0e10cSrcweir
1615cdf0e10cSrcweir // sonst einfach hintereinander haengen
1616cdf0e10cSrcweir DirEntry aRet( rEntry );
1617cdf0e10cSrcweir DirEntry *pTop = aRet.ImpGetTopPtr();
1618cdf0e10cSrcweir pTop->pParent = new DirEntry( *this );
1619cdf0e10cSrcweir
1620cdf0e10cSrcweir return aRet;
1621cdf0e10cSrcweir }
1622cdf0e10cSrcweir
1623cdf0e10cSrcweir /*************************************************************************
1624cdf0e10cSrcweir |*
1625cdf0e10cSrcweir |* DirEntry::operator+=()
1626cdf0e10cSrcweir |*
1627cdf0e10cSrcweir |* Beschreibung FSYS.SDW
1628cdf0e10cSrcweir |* Ersterstellung MI 26.04.91
1629cdf0e10cSrcweir |* Letzte Aenderung MA 02.12.91
1630cdf0e10cSrcweir |*
1631cdf0e10cSrcweir *************************************************************************/
1632cdf0e10cSrcweir
operator +=(const DirEntry & rEntry)1633cdf0e10cSrcweir DirEntry &DirEntry::operator+=( const DirEntry& rEntry )
1634cdf0e10cSrcweir {
1635cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
1636cdf0e10cSrcweir
1637cdf0e10cSrcweir return *this = *this + rEntry;
1638cdf0e10cSrcweir }
1639cdf0e10cSrcweir
1640cdf0e10cSrcweir /*************************************************************************
1641cdf0e10cSrcweir |*
1642cdf0e10cSrcweir |* DirEntry::GetAccessDelimiter()
1643cdf0e10cSrcweir |*
1644cdf0e10cSrcweir |* Beschreibung FSYS.SDW
1645cdf0e10cSrcweir |* Ersterstellung MI 27.05.93
1646cdf0e10cSrcweir |* Letzte Aenderung MI 10.06.93
1647cdf0e10cSrcweir |*
1648cdf0e10cSrcweir *************************************************************************/
1649cdf0e10cSrcweir
GetAccessDelimiter(FSysPathStyle eFormatter)1650cdf0e10cSrcweir String DirEntry::GetAccessDelimiter( FSysPathStyle eFormatter )
1651cdf0e10cSrcweir {
1652cdf0e10cSrcweir return String( ACCESSDELIM_C( GetStyle( eFormatter ) ) );
1653cdf0e10cSrcweir }
1654cdf0e10cSrcweir
1655cdf0e10cSrcweir /*************************************************************************
1656cdf0e10cSrcweir |*
1657cdf0e10cSrcweir |* DirEntry::SetExtension()
1658cdf0e10cSrcweir |*
1659cdf0e10cSrcweir |* Beschreibung FSYS.SDW
1660cdf0e10cSrcweir |* Ersterstellung MI 02.08.91
1661cdf0e10cSrcweir |* Letzte Aenderung MA 02.12.91
1662cdf0e10cSrcweir |*
1663cdf0e10cSrcweir *************************************************************************/
1664cdf0e10cSrcweir
SetExtension(const String & rExtension,char cSep)1665cdf0e10cSrcweir void DirEntry::SetExtension( const String& rExtension, char cSep )
1666cdf0e10cSrcweir {
1667cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
1668cdf0e10cSrcweir
1669cdf0e10cSrcweir // do not set extensions for drives
1670cdf0e10cSrcweir if(eFlag == FSYS_FLAG_ABSROOT)
1671cdf0e10cSrcweir {
1672cdf0e10cSrcweir nError = FSYS_ERR_NOTSUPPORTED;
1673cdf0e10cSrcweir return;
1674cdf0e10cSrcweir }
1675cdf0e10cSrcweir
1676cdf0e10cSrcweir // cSep im Namen suchen
1677cdf0e10cSrcweir const char *p0 = ( aName.GetBuffer() );
1678cdf0e10cSrcweir const char *p1 = p0 + aName.Len() - 1;
1679cdf0e10cSrcweir while ( p1 >= p0 && *p1 != cSep )
1680cdf0e10cSrcweir p1--;
1681cdf0e10cSrcweir if ( p1 >= p0 )
1682cdf0e10cSrcweir {
1683cdf0e10cSrcweir // es wurde ein cSep an der Position p1 gefunden
1684cdf0e10cSrcweir aName.Erase(
1685cdf0e10cSrcweir static_cast< xub_StrLen >(
1686cdf0e10cSrcweir p1 - p0 + 1 - ( rExtension.Len() ? 0 : 1 )) );
1687cdf0e10cSrcweir aName += ByteString(rExtension, osl_getThreadTextEncoding());
1688cdf0e10cSrcweir }
1689cdf0e10cSrcweir else if ( rExtension.Len() )
1690cdf0e10cSrcweir {
1691cdf0e10cSrcweir // es wurde kein cSep gefunden
1692cdf0e10cSrcweir aName += cSep;
1693cdf0e10cSrcweir aName += ByteString(rExtension, osl_getThreadTextEncoding());
1694cdf0e10cSrcweir }
1695cdf0e10cSrcweir }
1696cdf0e10cSrcweir
1697cdf0e10cSrcweir /*************************************************************************
1698cdf0e10cSrcweir |*
1699cdf0e10cSrcweir |* DirEntry::CutExtension()
1700cdf0e10cSrcweir |*
1701cdf0e10cSrcweir |* Beschreibung FSYS.SDW
1702cdf0e10cSrcweir |* Ersterstellung MI 23.07.93
1703cdf0e10cSrcweir |* Letzte Aenderung MI 23.07.93
1704cdf0e10cSrcweir |*
1705cdf0e10cSrcweir *************************************************************************/
1706cdf0e10cSrcweir
CutExtension(char cSep)1707cdf0e10cSrcweir String DirEntry::CutExtension( char cSep )
1708cdf0e10cSrcweir {
1709cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
1710cdf0e10cSrcweir
1711cdf0e10cSrcweir const char *p0 = ( aName.GetBuffer() );
1712cdf0e10cSrcweir const char *p1 = p0 + aName.Len() - 1;
1713cdf0e10cSrcweir while ( p1 >= p0 && *p1 != cSep )
1714cdf0e10cSrcweir p1--;
1715cdf0e10cSrcweir
1716cdf0e10cSrcweir if ( p1 >= p0 )
1717cdf0e10cSrcweir {
1718cdf0e10cSrcweir // es wurde ein cSep an der Position p1 gefunden
1719cdf0e10cSrcweir aName.Erase( static_cast< xub_StrLen >(p1-p0) );
1720cdf0e10cSrcweir return String(p1 + 1, osl_getThreadTextEncoding());
1721cdf0e10cSrcweir }
1722cdf0e10cSrcweir
1723cdf0e10cSrcweir return String();
1724cdf0e10cSrcweir }
1725cdf0e10cSrcweir
1726cdf0e10cSrcweir /*************************************************************************
1727cdf0e10cSrcweir |*
1728cdf0e10cSrcweir |* DirEntry::SetName()
1729cdf0e10cSrcweir |*
1730cdf0e10cSrcweir |* Beschreibung FSYS.SDW
1731cdf0e10cSrcweir |* Ersterstellung MI 04.09.93
1732cdf0e10cSrcweir |* Letzte Aenderung MI 04.09.93
1733cdf0e10cSrcweir |*
1734cdf0e10cSrcweir *************************************************************************/
1735cdf0e10cSrcweir
SetName(const String & rName,FSysPathStyle eFormatter)1736cdf0e10cSrcweir void DirEntry::SetName( const String& rName, FSysPathStyle eFormatter )
1737cdf0e10cSrcweir {
1738cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
1739cdf0e10cSrcweir
1740cdf0e10cSrcweir if ( eFormatter == FSYS_STYLE_HOST || eFormatter == FSYS_STYLE_DETECT )
1741cdf0e10cSrcweir eFormatter = DEFSTYLE;
1742cdf0e10cSrcweir ByteString aAccDelim( ACCESSDELIM_C( eFormatter ) );
1743cdf0e10cSrcweir
1744cdf0e10cSrcweir if ( (eFlag != FSYS_FLAG_NORMAL) ||
1745cdf0e10cSrcweir (aName.Search( ':' ) != STRING_NOTFOUND) ||
1746cdf0e10cSrcweir (aName.Search( aAccDelim ) != STRING_NOTFOUND) ||
1747cdf0e10cSrcweir (eFormatter == FSYS_STYLE_FAT && (aName.GetTokenCount( '.' ) > 2) ) )
1748cdf0e10cSrcweir {
1749cdf0e10cSrcweir eFlag = FSYS_FLAG_INVALID;
1750cdf0e10cSrcweir }
1751cdf0e10cSrcweir else
1752cdf0e10cSrcweir {
1753cdf0e10cSrcweir aName = ByteString(rName, osl_getThreadTextEncoding());
1754cdf0e10cSrcweir }
1755cdf0e10cSrcweir }
1756cdf0e10cSrcweir
1757cdf0e10cSrcweir /*************************************************************************
1758cdf0e10cSrcweir |*
1759cdf0e10cSrcweir |* DirEntry::Find()
1760cdf0e10cSrcweir |*
1761cdf0e10cSrcweir |* Beschreibung FSYS.SDW
1762cdf0e10cSrcweir |* Ersterstellung MI 26.04.91
1763cdf0e10cSrcweir |* Letzte Aenderung MA 02.12.91
1764cdf0e10cSrcweir |*
1765cdf0e10cSrcweir *************************************************************************/
Find(const String & rPfad,char cDelim)1766cdf0e10cSrcweir sal_Bool DirEntry::Find( const String& rPfad, char cDelim )
1767cdf0e10cSrcweir {
1768cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
1769cdf0e10cSrcweir
1770cdf0e10cSrcweir if ( ImpGetTopPtr()->eFlag == FSYS_FLAG_ABSROOT )
1771cdf0e10cSrcweir return sal_True;
1772cdf0e10cSrcweir
1773cdf0e10cSrcweir sal_Bool bWild = aName.Search( '*' ) != STRING_NOTFOUND ||
1774cdf0e10cSrcweir aName.Search( '?' ) != STRING_NOTFOUND;
1775cdf0e10cSrcweir if ( !cDelim )
1776cdf0e10cSrcweir cDelim = SEARCHDELIM(DEFSTYLE)[0];
1777cdf0e10cSrcweir
1778cdf0e10cSrcweir sal_uInt16 nTokenCount = rPfad.GetTokenCount( cDelim );
1779cdf0e10cSrcweir sal_uInt16 nIndex = 0;
1780cdf0e10cSrcweir ByteString aThis = ACCESSDELIM(DEFSTYLE);
1781cdf0e10cSrcweir aThis += ByteString(GetFull(), osl_getThreadTextEncoding());
1782cdf0e10cSrcweir for ( sal_uInt16 nToken = 0; nToken < nTokenCount; ++nToken )
1783cdf0e10cSrcweir {
1784cdf0e10cSrcweir ByteString aPath = ByteString(rPfad, osl_getThreadTextEncoding()).GetToken( 0, cDelim, nIndex );
1785cdf0e10cSrcweir
1786cdf0e10cSrcweir if ( aPath.Len() )
1787cdf0e10cSrcweir {
1788cdf0e10cSrcweir if (aPath.GetChar(aPath.Len()-1)== ACCESSDELIM(DEFSTYLE)[0])
1789cdf0e10cSrcweir aPath.Erase(aPath.Len()-1);
1790cdf0e10cSrcweir aPath += aThis;
1791cdf0e10cSrcweir DirEntry aEntry( String(aPath, osl_getThreadTextEncoding()));
1792cdf0e10cSrcweir if ( aEntry.ToAbs() &&
1793cdf0e10cSrcweir ( ( !bWild && aEntry.Exists() ) || ( bWild && aEntry.First() ) ) )
1794cdf0e10cSrcweir {
1795cdf0e10cSrcweir (*this) = aEntry;
1796cdf0e10cSrcweir return sal_True;
1797cdf0e10cSrcweir }
1798cdf0e10cSrcweir }
1799cdf0e10cSrcweir }
1800cdf0e10cSrcweir return sal_False;
1801cdf0e10cSrcweir }
1802cdf0e10cSrcweir
1803cdf0e10cSrcweir /*************************************************************************
1804cdf0e10cSrcweir |*
1805cdf0e10cSrcweir |* DirEntry::ImpToRel()
1806cdf0e10cSrcweir |*
1807cdf0e10cSrcweir |* Beschreibung
1808cdf0e10cSrcweir |* Ersterstellung MI 17.06.93
1809cdf0e10cSrcweir |* Letzte Aenderung MI 17.06.93
1810cdf0e10cSrcweir |*
1811cdf0e10cSrcweir *************************************************************************/
1812cdf0e10cSrcweir
ImpToRel(String aCurStr)1813cdf0e10cSrcweir sal_Bool DirEntry::ImpToRel( String aCurStr )
1814cdf0e10cSrcweir {
1815cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
1816cdf0e10cSrcweir
1817cdf0e10cSrcweir DirEntry aThis(*this);
1818cdf0e10cSrcweir aThis.ToAbs();
1819cdf0e10cSrcweir String aThisStr( aThis.GetFull( FSYS_STYLE_HPFS ) );
1820cdf0e10cSrcweir
1821cdf0e10cSrcweir // #109512 preserve case of path even if caseinsensitive
1822cdf0e10cSrcweir String aThisCompareStr( aThisStr ), aCurCompareStr( aCurStr );
1823cdf0e10cSrcweir if ( ! IsCaseSensitive() )
1824cdf0e10cSrcweir {
1825cdf0e10cSrcweir aThisCompareStr.ToLowerAscii();
1826cdf0e10cSrcweir aCurCompareStr.ToLowerAscii();
1827cdf0e10cSrcweir }
1828cdf0e10cSrcweir
1829cdf0e10cSrcweir // "Ubereinstimmung pr"ufen
1830cdf0e10cSrcweir sal_uInt16 nPos = aThisCompareStr.Match( aCurCompareStr );
1831cdf0e10cSrcweir if ( nPos == STRING_MATCH && aThisStr.Len() != aCurStr.Len() )
1832cdf0e10cSrcweir nPos = Min( aThisStr.Len(), aCurStr.Len() );
1833cdf0e10cSrcweir
1834cdf0e10cSrcweir // Sonderfall, die DirEntries sind identisch
1835cdf0e10cSrcweir if ( nPos == STRING_MATCH )
1836cdf0e10cSrcweir {
1837cdf0e10cSrcweir // dann ist der relative Pfad das aktuelle Verzeichnis
1838cdf0e10cSrcweir *this = DirEntry();
1839cdf0e10cSrcweir return sal_True;
1840cdf0e10cSrcweir }
1841cdf0e10cSrcweir
1842cdf0e10cSrcweir // Sonderfall, die DirEntries sind total verschieden
1843cdf0e10cSrcweir if ( nPos == 0 )
1844cdf0e10cSrcweir {
1845cdf0e10cSrcweir // dann ist der relativste Pfad absolut
1846cdf0e10cSrcweir *this = aThis;
1847cdf0e10cSrcweir return sal_False;
1848cdf0e10cSrcweir }
1849cdf0e10cSrcweir
1850cdf0e10cSrcweir // sonst nehmen wir die identischen Einzelteile vorne weg
1851cdf0e10cSrcweir while ( nPos > 0 && aThisStr.GetChar(nPos) != '\\' )
1852cdf0e10cSrcweir --nPos;
1853cdf0e10cSrcweir aThisStr.Erase( 0, nPos + ( ( aThisStr.GetChar(nPos) == '\\' ) ? 1 : 0 ) );
1854cdf0e10cSrcweir aCurStr.Erase( 0, nPos + ( ( aCurStr.GetChar(nPos) == '\\' ) ? 1 : 0 ) );
1855cdf0e10cSrcweir
1856cdf0e10cSrcweir // und fuellen mit dem Level der Directories auf
1857cdf0e10cSrcweir for ( nPos = 0; nPos < aCurStr.Len(); ++nPos )
1858cdf0e10cSrcweir if ( aCurStr.GetChar(nPos) == '\\' )
1859cdf0e10cSrcweir aThisStr.Insert( String( "..\\", osl_getThreadTextEncoding() ), 0 );
1860cdf0e10cSrcweir
1861cdf0e10cSrcweir // das ist dann unser relativer Pfad
1862cdf0e10cSrcweir *this = DirEntry( aThisStr, FSYS_STYLE_HPFS );
1863cdf0e10cSrcweir return sal_True;
1864cdf0e10cSrcweir }
1865cdf0e10cSrcweir
1866cdf0e10cSrcweir /*************************************************************************
1867cdf0e10cSrcweir |*
1868cdf0e10cSrcweir |* DirEntry::CutRelParents()
1869cdf0e10cSrcweir |*
1870cdf0e10cSrcweir |* Beschreibung
1871cdf0e10cSrcweir |* Ersterstellung MI 01.08.95
1872cdf0e10cSrcweir |* Letzte Aenderung MI 01.08.95
1873cdf0e10cSrcweir |*
1874cdf0e10cSrcweir *************************************************************************/
1875cdf0e10cSrcweir
CutRelParents()1876cdf0e10cSrcweir sal_uInt16 DirEntry::CutRelParents()
1877cdf0e10cSrcweir {
1878cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
1879cdf0e10cSrcweir
1880cdf0e10cSrcweir // erstes '..' finden
1881cdf0e10cSrcweir DirEntry *pDir = 0;
1882cdf0e10cSrcweir DirEntry *pPar;
1883cdf0e10cSrcweir
1884cdf0e10cSrcweir for ( pPar = this;
1885cdf0e10cSrcweir pPar && pPar->eFlag != FSYS_FLAG_PARENT;
1886cdf0e10cSrcweir pPar = pPar->pParent )
1887cdf0e10cSrcweir pDir = pPar;
1888cdf0e10cSrcweir
1889cdf0e10cSrcweir // '..' zaehlen
1890cdf0e10cSrcweir sal_uInt16 nParCount = 0;
1891cdf0e10cSrcweir while ( pPar && pPar->eFlag == FSYS_FLAG_PARENT )
1892cdf0e10cSrcweir {
1893cdf0e10cSrcweir ++nParCount;
1894cdf0e10cSrcweir pPar = pPar->pParent;
1895cdf0e10cSrcweir }
1896cdf0e10cSrcweir
1897cdf0e10cSrcweir // cutten
1898cdf0e10cSrcweir if ( pDir )
1899cdf0e10cSrcweir DELETEZ(pDir->pParent);
1900cdf0e10cSrcweir else
1901cdf0e10cSrcweir eFlag = FSYS_FLAG_CURRENT;
1902cdf0e10cSrcweir
1903cdf0e10cSrcweir return nParCount;
1904cdf0e10cSrcweir }
1905cdf0e10cSrcweir
1906cdf0e10cSrcweir /*************************************************************************
1907cdf0e10cSrcweir |*
1908cdf0e10cSrcweir |* DirEntry::ToRel()
1909cdf0e10cSrcweir |*
1910cdf0e10cSrcweir |* Beschreibung FSYS.SDW
1911cdf0e10cSrcweir |* Ersterstellung MI 26.06.93
1912cdf0e10cSrcweir |* Letzte Aenderung MI 17.06.93
1913cdf0e10cSrcweir |*
1914cdf0e10cSrcweir *************************************************************************/
1915cdf0e10cSrcweir
ToRel()1916cdf0e10cSrcweir sal_Bool DirEntry::ToRel()
1917cdf0e10cSrcweir {
1918cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
1919cdf0e10cSrcweir
1920cdf0e10cSrcweir DirEntry aCur;
1921cdf0e10cSrcweir aCur.ToAbs();
1922cdf0e10cSrcweir return ImpToRel( aCur.GetFull( FSYS_STYLE_HPFS ) );
1923cdf0e10cSrcweir }
1924cdf0e10cSrcweir
1925cdf0e10cSrcweir /*************************************************************************
1926cdf0e10cSrcweir |*
1927cdf0e10cSrcweir |* DirEntry::ToRel()
1928cdf0e10cSrcweir |*
1929cdf0e10cSrcweir |* Beschreibung FSYS.SDW
1930cdf0e10cSrcweir |* Ersterstellung MI 26.04.91
1931cdf0e10cSrcweir |* Letzte Aenderung MA 02.12.91
1932cdf0e10cSrcweir |*
1933cdf0e10cSrcweir *************************************************************************/
1934cdf0e10cSrcweir
ToRel(const DirEntry & rStart)1935cdf0e10cSrcweir sal_Bool DirEntry::ToRel( const DirEntry& rStart )
1936cdf0e10cSrcweir {
1937cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
1938cdf0e10cSrcweir
1939cdf0e10cSrcweir DirEntry aStart( rStart );
1940cdf0e10cSrcweir aStart.ToAbs();
1941cdf0e10cSrcweir return ImpToRel( aStart.GetFull( FSYS_STYLE_HPFS ) );
1942cdf0e10cSrcweir }
1943cdf0e10cSrcweir
1944cdf0e10cSrcweir /*************************************************************************
1945cdf0e10cSrcweir |*
1946cdf0e10cSrcweir |* DirEntry::GetDevice()
1947cdf0e10cSrcweir |*
1948cdf0e10cSrcweir |* Beschreibung FSYS.SDW
1949cdf0e10cSrcweir |* Ersterstellung MI 26.04.91
1950cdf0e10cSrcweir |* Letzte Aenderung MA 02.12.91
1951cdf0e10cSrcweir |*
1952cdf0e10cSrcweir *************************************************************************/
1953cdf0e10cSrcweir
1954cdf0e10cSrcweir #ifndef UNX
1955cdf0e10cSrcweir
GetDevice() const1956cdf0e10cSrcweir DirEntry DirEntry::GetDevice() const
1957cdf0e10cSrcweir {
1958cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
1959cdf0e10cSrcweir
1960cdf0e10cSrcweir const DirEntry *pTop = ImpGetTopPtr();
1961cdf0e10cSrcweir
1962cdf0e10cSrcweir if ( ( pTop->eFlag == FSYS_FLAG_ABSROOT || pTop->eFlag == FSYS_FLAG_RELROOT ) &&
1963cdf0e10cSrcweir pTop->aName.Len() )
1964cdf0e10cSrcweir return DirEntry( pTop->aName, FSYS_FLAG_VOLUME, FSYS_STYLE_HOST );
1965cdf0e10cSrcweir else
1966cdf0e10cSrcweir return DirEntry( ByteString(), FSYS_FLAG_INVALID, FSYS_STYLE_HOST );
1967cdf0e10cSrcweir }
1968cdf0e10cSrcweir
1969cdf0e10cSrcweir #endif
1970cdf0e10cSrcweir
1971cdf0e10cSrcweir /*************************************************************************
1972cdf0e10cSrcweir |*
1973cdf0e10cSrcweir |* DirEntry::SetBase()
1974cdf0e10cSrcweir |*
1975cdf0e10cSrcweir |* Beschreibung FSYS.SDW
1976cdf0e10cSrcweir |* Ersterstellung MI 23.10.91
1977cdf0e10cSrcweir |* Letzte Aenderung MA 02.12.91
1978cdf0e10cSrcweir |*
1979cdf0e10cSrcweir *************************************************************************/
1980cdf0e10cSrcweir
SetBase(const String & rBase,char cSep)1981cdf0e10cSrcweir void DirEntry::SetBase( const String& rBase, char cSep )
1982cdf0e10cSrcweir {
1983cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
1984cdf0e10cSrcweir
1985cdf0e10cSrcweir const char *p0 = ( aName.GetBuffer() );
1986cdf0e10cSrcweir const char *p1 = p0 + aName.Len() - 1;
1987cdf0e10cSrcweir while ( p1 >= p0 && *p1 != cSep )
1988cdf0e10cSrcweir p1--;
1989cdf0e10cSrcweir
1990cdf0e10cSrcweir if ( p1 >= p0 )
1991cdf0e10cSrcweir {
1992cdf0e10cSrcweir // es wurde ein cSep an der Position p1 gefunden
1993cdf0e10cSrcweir aName.Erase( 0, static_cast< xub_StrLen >(p1 - p0) );
1994cdf0e10cSrcweir aName.Insert( ByteString(rBase, osl_getThreadTextEncoding()), 0 );
1995cdf0e10cSrcweir }
1996cdf0e10cSrcweir else
1997cdf0e10cSrcweir aName = ByteString(rBase, osl_getThreadTextEncoding());
1998cdf0e10cSrcweir }
1999cdf0e10cSrcweir
2000cdf0e10cSrcweir /*************************************************************************
2001cdf0e10cSrcweir |*
2002cdf0e10cSrcweir |* DirEntry::GetSearchDelimiter()
2003cdf0e10cSrcweir |*
2004cdf0e10cSrcweir |* Beschreibung FSYS.SDW
2005cdf0e10cSrcweir |* Ersterstellung MI 10.06.93
2006cdf0e10cSrcweir |* Letzte Aenderung MI 10.06.93
2007cdf0e10cSrcweir |*
2008cdf0e10cSrcweir *************************************************************************/
2009cdf0e10cSrcweir
GetSearchDelimiter(FSysPathStyle eFormatter)2010cdf0e10cSrcweir String DirEntry::GetSearchDelimiter( FSysPathStyle eFormatter )
2011cdf0e10cSrcweir {
2012cdf0e10cSrcweir return String( ByteString(SEARCHDELIM( GetStyle( eFormatter ) ) ), osl_getThreadTextEncoding());
2013cdf0e10cSrcweir }
2014cdf0e10cSrcweir
2015cdf0e10cSrcweir /*************************************************************************
2016cdf0e10cSrcweir |*
2017cdf0e10cSrcweir |* DirEntry::GetMaxNameLen()
2018cdf0e10cSrcweir |*
2019cdf0e10cSrcweir |* Beschreibung Liefert die maximale Anzahl von Zeichen in
2020cdf0e10cSrcweir |* einzelnen Namensteile. Bei FileSystmen mit
2021cdf0e10cSrcweir |* fester Extension (FAT) zaehlt diese nicht mit.
2022cdf0e10cSrcweir |* Bei unbekannten FileSytemen und FSYS_STYLE_URL
2023cdf0e10cSrcweir |* wird USHRT_MAX zurueckgegeben.
2024cdf0e10cSrcweir |* Ersterstellung MI 17.06.97
2025cdf0e10cSrcweir |* Letzte Aenderung MI 17.06.97
2026cdf0e10cSrcweir |*
2027cdf0e10cSrcweir *************************************************************************/
2028cdf0e10cSrcweir
GetMaxNameLen(FSysPathStyle eFormatter)2029cdf0e10cSrcweir sal_uInt16 DirEntry::GetMaxNameLen( FSysPathStyle eFormatter )
2030cdf0e10cSrcweir {
2031cdf0e10cSrcweir eFormatter = GetStyle( eFormatter );
2032cdf0e10cSrcweir switch ( eFormatter )
2033cdf0e10cSrcweir {
2034cdf0e10cSrcweir case FSYS_STYLE_MAC: return 31;
2035cdf0e10cSrcweir
2036cdf0e10cSrcweir case FSYS_STYLE_FAT: return 8;
2037cdf0e10cSrcweir
2038cdf0e10cSrcweir case FSYS_STYLE_VFAT:
2039cdf0e10cSrcweir case FSYS_STYLE_NTFS:
2040cdf0e10cSrcweir case FSYS_STYLE_NWFS:
2041cdf0e10cSrcweir case FSYS_STYLE_HPFS: return 255;
2042cdf0e10cSrcweir
2043cdf0e10cSrcweir
2044cdf0e10cSrcweir case FSYS_STYLE_SYSV: return 14;
2045cdf0e10cSrcweir
2046cdf0e10cSrcweir case FSYS_STYLE_BSD: return 250;
2047cdf0e10cSrcweir
2048cdf0e10cSrcweir default:
2049cdf0e10cSrcweir return USHRT_MAX;
2050cdf0e10cSrcweir }
2051cdf0e10cSrcweir }
2052cdf0e10cSrcweir
2053cdf0e10cSrcweir /*************************************************************************
2054cdf0e10cSrcweir |*
2055cdf0e10cSrcweir |* DirEntry::TempName()
2056cdf0e10cSrcweir |*
2057cdf0e10cSrcweir |* Beschreibung FSYS.SDW - Aha, wo?
2058cdf0e10cSrcweir |* Ersterstellung VB 06.09.93 (im SWG)
2059cdf0e10cSrcweir |* Letzte Aenderung MI 06.02.98
2060cdf0e10cSrcweir |*
2061cdf0e10cSrcweir *************************************************************************/
2062cdf0e10cSrcweir namespace { struct TempNameBase_Impl : public rtl::Static< DirEntry, TempNameBase_Impl > {}; }
2063cdf0e10cSrcweir
SetTempNameBase(const String & rBase)2064cdf0e10cSrcweir const DirEntry& DirEntry::SetTempNameBase( const String &rBase )
2065cdf0e10cSrcweir {
2066cdf0e10cSrcweir DirEntry aTempDir = DirEntry().TempName().GetPath();
2067cdf0e10cSrcweir aTempDir += DirEntry( rBase );
2068cdf0e10cSrcweir #ifdef UNX
2069cdf0e10cSrcweir ByteString aName( aTempDir.GetFull(), osl_getThreadTextEncoding());
2070cdf0e10cSrcweir if ( access( aName.GetBuffer(), W_OK | X_OK | R_OK ) )
2071cdf0e10cSrcweir {
2072cdf0e10cSrcweir // Create the directory and only on success give all rights to
2073cdf0e10cSrcweir // everyone. Use mkdir instead of DirEntry::MakeDir because
2074cdf0e10cSrcweir // this returns sal_True even if directory already exists.
2075cdf0e10cSrcweir
2076cdf0e10cSrcweir if ( !mkdir( aName.GetBuffer(), S_IRWXU | S_IRWXG | S_IRWXO ) )
2077cdf0e10cSrcweir chmod( aName.GetBuffer(), S_IRWXU | S_IRWXG | S_IRWXO );
2078cdf0e10cSrcweir
2079cdf0e10cSrcweir // This will not create a directory but perhaps FileStat called
2080cdf0e10cSrcweir // there modifies the DirEntry
2081cdf0e10cSrcweir
2082cdf0e10cSrcweir aTempDir.MakeDir();
2083cdf0e10cSrcweir }
2084cdf0e10cSrcweir #else
2085cdf0e10cSrcweir aTempDir.MakeDir();
2086cdf0e10cSrcweir #endif
2087cdf0e10cSrcweir DirEntry &rEntry = TempNameBase_Impl::get();
2088cdf0e10cSrcweir rEntry = aTempDir.TempName( FSYS_KIND_DIR );
2089cdf0e10cSrcweir return rEntry;
2090cdf0e10cSrcweir }
2091cdf0e10cSrcweir
TempName(DirEntryKind eKind) const2092cdf0e10cSrcweir DirEntry DirEntry::TempName( DirEntryKind eKind ) const
2093cdf0e10cSrcweir {
2094cdf0e10cSrcweir // ggf. Base-Temp-Dir verwenden (macht Remote keinen Sinn => vorher)
2095cdf0e10cSrcweir const DirEntry &rEntry = TempNameBase_Impl::get();
2096cdf0e10cSrcweir if ( !pParent && FSYS_FLAG_CURRENT != rEntry.eFlag && FSYS_FLAG_ABSROOT != eFlag )
2097cdf0e10cSrcweir
2098cdf0e10cSrcweir {
2099cdf0e10cSrcweir DirEntry aFactory( rEntry );
2100cdf0e10cSrcweir aFactory += GetName();
2101cdf0e10cSrcweir return aFactory.TempName();
2102cdf0e10cSrcweir }
2103cdf0e10cSrcweir
2104cdf0e10cSrcweir ByteString aDirName; // hiermit hatte MPW C++ Probleme - immmer noch??
2105cdf0e10cSrcweir char *ret_val;
2106cdf0e10cSrcweir size_t i;
2107cdf0e10cSrcweir
2108cdf0e10cSrcweir // dertermine Directory, Prefix and Extension
2109cdf0e10cSrcweir char pfx[6];
2110cdf0e10cSrcweir char ext[5];
2111cdf0e10cSrcweir const char *dir;
2112cdf0e10cSrcweir const char *pWild = strchr( aName.GetBuffer(), '*' );
2113cdf0e10cSrcweir if ( !pWild )
2114cdf0e10cSrcweir pWild = strchr( aName.GetBuffer(), '?' );
2115cdf0e10cSrcweir
2116cdf0e10cSrcweir if ( pWild )
2117cdf0e10cSrcweir {
2118cdf0e10cSrcweir if ( pParent )
2119cdf0e10cSrcweir aDirName = ByteString(pParent->GetFull(), osl_getThreadTextEncoding());
2120cdf0e10cSrcweir strncpy( pfx, aName.GetBuffer(), Min( (int)5, (int)(pWild-aName.GetBuffer()) ) );
2121cdf0e10cSrcweir pfx[ pWild-aName.GetBuffer() ] = 0;
2122cdf0e10cSrcweir const char *pExt = strchr( pWild, '.' );
2123cdf0e10cSrcweir if ( pExt )
2124cdf0e10cSrcweir {
2125cdf0e10cSrcweir strncpy( ext, pExt, 4 );
2126cdf0e10cSrcweir ext[4] = 0;
2127cdf0e10cSrcweir }
2128cdf0e10cSrcweir else
2129cdf0e10cSrcweir strcpy( ext, ".tmp" );
2130cdf0e10cSrcweir }
2131cdf0e10cSrcweir else
2132cdf0e10cSrcweir {
2133cdf0e10cSrcweir aDirName = ByteString(GetFull(), osl_getThreadTextEncoding());
2134cdf0e10cSrcweir strcpy( pfx, "sv" );
2135cdf0e10cSrcweir strcpy( ext, ".tmp" );
2136cdf0e10cSrcweir }
2137cdf0e10cSrcweir dir = aDirName.GetBuffer();
2138cdf0e10cSrcweir
2139cdf0e10cSrcweir // wurde kein Dir angegeben, dann nehmen wir ein passendes TEMP-Verz.
2140cdf0e10cSrcweir char sBuf[_MAX_PATH];
2141cdf0e10cSrcweir if ( eFlag == FSYS_FLAG_CURRENT || ( !pParent && pWild ) )
2142cdf0e10cSrcweir dir = TempDirImpl(sBuf);
2143cdf0e10cSrcweir
2144cdf0e10cSrcweir // ab hier leicht modifizierter Code von VB
2145cdf0e10cSrcweir DirEntry aRet(FSYS_FLAG_INVALID);
2146cdf0e10cSrcweir i = strlen(dir);
2147cdf0e10cSrcweir // need to add ?\\? + prefix + number + pid + .ext + '\0'
2148cdf0e10cSrcweir # define TMPNAME_SIZE ( 1 + 5 + 5 + 10 + 4 + 1 )
2149cdf0e10cSrcweir ret_val = new char[i + TMPNAME_SIZE ];
2150cdf0e10cSrcweir if (ret_val)
2151cdf0e10cSrcweir {
2152cdf0e10cSrcweir strcpy(ret_val,dir);
2153cdf0e10cSrcweir
2154cdf0e10cSrcweir /* Make sure directory ends with a separator */
2155cdf0e10cSrcweir #if defined(WNT) || defined(OS2)
2156cdf0e10cSrcweir if ( i>0 && ret_val[i-1] != '\\' && ret_val[i-1] != '/' &&
2157cdf0e10cSrcweir ret_val[i-1] != ':')
2158cdf0e10cSrcweir ret_val[i++] = '\\';
2159cdf0e10cSrcweir #elif defined UNX
2160cdf0e10cSrcweir if (i>0 && ret_val[i-1] != '/')
2161cdf0e10cSrcweir ret_val[i++] = '/';
2162cdf0e10cSrcweir #else
2163cdf0e10cSrcweir #error unknown operating system
2164cdf0e10cSrcweir #endif
2165cdf0e10cSrcweir
2166cdf0e10cSrcweir strncpy(ret_val + i, pfx, 5);
2167cdf0e10cSrcweir ret_val[i + 5] = '\0'; /* strncpy doesn't put a 0 if more */
2168cdf0e10cSrcweir i = strlen(ret_val); /* than 'n' chars. */
2169cdf0e10cSrcweir
2170cdf0e10cSrcweir /* Prefix can have 5 chars, leaving 3 for numbers. 26 ** 3 == 17576
2171cdf0e10cSrcweir * Welcome to the 21st century, we can have longer filenames now ;)
2172cdf0e10cSrcweir * New format: pfx + "5 char milli/micro second res" + "current pid" + ".tmp"
2173cdf0e10cSrcweir */
2174cdf0e10cSrcweir #if (defined MSC || defined __MINGW32__) && defined WNT
2175cdf0e10cSrcweir /* Milliseconds !! */
2176cdf0e10cSrcweir static unsigned long u = GetTickCount();
2177cdf0e10cSrcweir unsigned long mypid = static_cast<unsigned long>(_getpid());
2178cdf0e10cSrcweir #else
2179cdf0e10cSrcweir /* Microseconds !! */
2180cdf0e10cSrcweir static unsigned long u = clock();
2181cdf0e10cSrcweir unsigned long mypid = static_cast<unsigned long>(getpid());
2182cdf0e10cSrcweir #endif
2183cdf0e10cSrcweir for ( unsigned long nOld = u; ++u != nOld; ) /* Hae??? */
2184cdf0e10cSrcweir {
2185cdf0e10cSrcweir u %= 100000; /* on *NIX repeats every 100ms, maybe less if CLOCKS_PER_SEC > 10^6 */
2186cdf0e10cSrcweir snprintf(ret_val+i, TMPNAME_SIZE, "%05lu%lu", u, mypid);
2187cdf0e10cSrcweir
2188cdf0e10cSrcweir strcat(ret_val,ext);
2189cdf0e10cSrcweir
2190cdf0e10cSrcweir if ( FSYS_KIND_FILE == eKind )
2191cdf0e10cSrcweir {
2192cdf0e10cSrcweir SvFileStream aStream( String( ret_val, osl_getThreadTextEncoding()),
2193cdf0e10cSrcweir STREAM_WRITE|STREAM_SHARE_DENYALL );
2194cdf0e10cSrcweir if ( aStream.IsOpen() )
2195cdf0e10cSrcweir {
2196cdf0e10cSrcweir aStream.Seek( STREAM_SEEK_TO_END );
2197cdf0e10cSrcweir if ( 0 == aStream.Tell() )
2198cdf0e10cSrcweir {
2199cdf0e10cSrcweir aRet = DirEntry( String( ret_val, osl_getThreadTextEncoding()));
2200cdf0e10cSrcweir break;
2201cdf0e10cSrcweir }
2202cdf0e10cSrcweir aStream.Close();
2203cdf0e10cSrcweir }
2204cdf0e10cSrcweir }
2205cdf0e10cSrcweir else
2206cdf0e10cSrcweir {
2207cdf0e10cSrcweir // Redirect
2208cdf0e10cSrcweir String aRetVal(ret_val, osl_getThreadTextEncoding());
2209cdf0e10cSrcweir String aRedirected (aRetVal);
2210cdf0e10cSrcweir #ifndef BOOTSTRAP
2211cdf0e10cSrcweir FSysRedirector::DoRedirect( aRedirected );
2212cdf0e10cSrcweir #endif
2213cdf0e10cSrcweir if ( FSYS_KIND_DIR == eKind )
2214cdf0e10cSrcweir {
2215cdf0e10cSrcweir if ( 0 == _mkdir( ByteString(aRedirected.GetBuffer(), osl_getThreadTextEncoding()).GetBuffer() ) )
2216cdf0e10cSrcweir {
2217cdf0e10cSrcweir aRet = DirEntry( aRetVal );
2218cdf0e10cSrcweir break;
2219cdf0e10cSrcweir }
2220cdf0e10cSrcweir }
2221cdf0e10cSrcweir else
2222cdf0e10cSrcweir {
2223cdf0e10cSrcweir #if defined(UNX) || defined(OS2)
2224cdf0e10cSrcweir if( access( ByteString(aRedirected, osl_getThreadTextEncoding()).GetBuffer(), F_OK ) )
2225cdf0e10cSrcweir {
2226cdf0e10cSrcweir aRet = DirEntry( aRetVal );
2227cdf0e10cSrcweir break;
2228cdf0e10cSrcweir }
2229cdf0e10cSrcweir #else
2230cdf0e10cSrcweir struct stat aStat;
2231cdf0e10cSrcweir if ( stat( ByteString(aRedirected, osl_getThreadTextEncoding()).GetBuffer(), &aStat ) )
2232cdf0e10cSrcweir {
2233cdf0e10cSrcweir aRet = DirEntry( aRetVal );
2234cdf0e10cSrcweir break;
2235cdf0e10cSrcweir }
2236cdf0e10cSrcweir #endif
2237cdf0e10cSrcweir }
2238cdf0e10cSrcweir }
2239cdf0e10cSrcweir }
2240cdf0e10cSrcweir
2241cdf0e10cSrcweir delete[] ret_val;
2242cdf0e10cSrcweir ret_val = 0;
2243cdf0e10cSrcweir }
2244cdf0e10cSrcweir
2245cdf0e10cSrcweir return aRet;
2246cdf0e10cSrcweir }
2247cdf0e10cSrcweir
2248cdf0e10cSrcweir /*************************************************************************
2249cdf0e10cSrcweir |*
2250cdf0e10cSrcweir |* DirEntry::operator[]()
2251cdf0e10cSrcweir |*
2252cdf0e10cSrcweir |* Beschreibung FSYS.SDW
2253cdf0e10cSrcweir |* Ersterstellung MI 03.03.92
2254cdf0e10cSrcweir |* Letzte Aenderung MI 03.03.92
2255cdf0e10cSrcweir |*
2256cdf0e10cSrcweir *************************************************************************/
2257cdf0e10cSrcweir
operator [](sal_uInt16 nParentLevel) const2258cdf0e10cSrcweir const DirEntry &DirEntry::operator[]( sal_uInt16 nParentLevel ) const
2259cdf0e10cSrcweir {
2260cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
2261cdf0e10cSrcweir
2262cdf0e10cSrcweir //TPF: maybe to be implemented (FastFSys)
2263cdf0e10cSrcweir
2264cdf0e10cSrcweir const DirEntry *pRes = this;
2265cdf0e10cSrcweir while ( pRes && nParentLevel-- )
2266cdf0e10cSrcweir pRes = pRes->pParent;
2267cdf0e10cSrcweir
2268cdf0e10cSrcweir return *pRes;
2269cdf0e10cSrcweir }
2270cdf0e10cSrcweir
2271cdf0e10cSrcweir /*************************************************************************
2272cdf0e10cSrcweir |*
2273cdf0e10cSrcweir |* DirEntry::ImpParseUnixName()
2274cdf0e10cSrcweir |*
2275cdf0e10cSrcweir |* Beschreibung FSYS.SDW
2276cdf0e10cSrcweir |* Ersterstellung MI 26.04.91
2277cdf0e10cSrcweir |* Letzte Aenderung MI 26.05.93
2278cdf0e10cSrcweir |*
2279cdf0e10cSrcweir *************************************************************************/
2280cdf0e10cSrcweir
ImpParseUnixName(const ByteString & rPfad,FSysPathStyle eStyle)2281cdf0e10cSrcweir FSysError DirEntry::ImpParseUnixName( const ByteString& rPfad, FSysPathStyle eStyle )
2282cdf0e10cSrcweir {
2283cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
2284cdf0e10cSrcweir
2285cdf0e10cSrcweir // die einzelnen Namen auf einen Stack packen
2286cdf0e10cSrcweir DirEntryStack aStack;
2287cdf0e10cSrcweir ByteString aPfad( rPfad );
2288cdf0e10cSrcweir do
2289cdf0e10cSrcweir {
2290cdf0e10cSrcweir // den Namen vor dem ersten "/" abspalten,
2291cdf0e10cSrcweir // falls '/' am Anfang, ist der Name '/',
2292cdf0e10cSrcweir // der Rest immer ohne die fuehrenden '/'.
2293cdf0e10cSrcweir // den ersten '/' suchen
2294cdf0e10cSrcweir sal_uInt16 nPos;
2295cdf0e10cSrcweir for ( nPos = 0;
2296cdf0e10cSrcweir nPos < aPfad.Len() && aPfad.GetChar(nPos) != '/';
2297cdf0e10cSrcweir nPos++ )
2298cdf0e10cSrcweir /* do nothing */;
2299cdf0e10cSrcweir
2300cdf0e10cSrcweir // ist der Name die Root des aktuellen Drives?
2301cdf0e10cSrcweir if ( nPos == 0 && aPfad.Len() > 0 && ( aPfad.GetChar(0) == '/' ) )
2302cdf0e10cSrcweir {
2303cdf0e10cSrcweir // Root-Directory des aktuellen Drives
2304cdf0e10cSrcweir aStack.Push( new DirEntry( FSYS_FLAG_ABSROOT ) );
2305cdf0e10cSrcweir }
2306cdf0e10cSrcweir else
2307cdf0e10cSrcweir {
2308cdf0e10cSrcweir // den Namen ohne Trenner abspalten
2309cdf0e10cSrcweir aName = aPfad.Copy( 0, nPos );
2310cdf0e10cSrcweir
2311cdf0e10cSrcweir // stellt der Name die aktuelle Directory dar?
2312cdf0e10cSrcweir if ( aName == "." )
2313cdf0e10cSrcweir /* do nothing */;
2314cdf0e10cSrcweir
2315cdf0e10cSrcweir #ifdef UNX
2316cdf0e10cSrcweir // stellt der Name das User-Dir dar?
2317cdf0e10cSrcweir else if ( aName == "~" )
2318cdf0e10cSrcweir {
2319cdf0e10cSrcweir DirEntry aHome( String( (const char *) getenv( "HOME" ), osl_getThreadTextEncoding()) );
2320cdf0e10cSrcweir for ( sal_uInt16 n = aHome.Level(); n; --n )
2321cdf0e10cSrcweir aStack.Push( new DirEntry( aHome[ (sal_uInt16) n-1 ] ) );
2322cdf0e10cSrcweir }
2323cdf0e10cSrcweir #endif
2324cdf0e10cSrcweir
2325cdf0e10cSrcweir // stellt der Name die Parent-Directory dar?
2326cdf0e10cSrcweir else if ( aName == ".." )
2327cdf0e10cSrcweir {
2328cdf0e10cSrcweir // ist nichts, ein Parent oder eine relative Root
2329cdf0e10cSrcweir // auf dem Stack?
2330cdf0e10cSrcweir if ( ( aStack.Count() == 0 ) ||
2331cdf0e10cSrcweir ( aStack.Top()->eFlag == FSYS_FLAG_PARENT ) )
2332cdf0e10cSrcweir // fuehrende Parents kommen auf den Stack
2333cdf0e10cSrcweir aStack.Push( new DirEntry( ByteString(), FSYS_FLAG_PARENT, eStyle ) );
2334cdf0e10cSrcweir
2335cdf0e10cSrcweir // ist es eine absolute Root
2336cdf0e10cSrcweir else if ( aStack.Top()->eFlag == FSYS_FLAG_ABSROOT ) {
2337cdf0e10cSrcweir // die hat keine Parent-Directory
2338cdf0e10cSrcweir return FSYS_ERR_NOTEXISTS;
2339cdf0e10cSrcweir }
2340cdf0e10cSrcweir else
2341cdf0e10cSrcweir // sonst hebt der Parent den TOS auf
2342cdf0e10cSrcweir delete aStack.Pop();
2343cdf0e10cSrcweir }
2344cdf0e10cSrcweir else
2345cdf0e10cSrcweir {
2346cdf0e10cSrcweir DirEntry *pNew = NULL;
2347cdf0e10cSrcweir // normalen Entries kommen auf den Stack
2348cdf0e10cSrcweir pNew = new DirEntry( aName, FSYS_FLAG_NORMAL, eStyle );
2349cdf0e10cSrcweir if ( !pNew->IsValid() )
2350cdf0e10cSrcweir {
2351cdf0e10cSrcweir aName = rPfad;
2352cdf0e10cSrcweir ErrCode eErr = pNew->GetError();
2353cdf0e10cSrcweir delete pNew;
2354cdf0e10cSrcweir return eErr;
2355cdf0e10cSrcweir }
2356cdf0e10cSrcweir aStack.Push( pNew );
2357cdf0e10cSrcweir }
2358cdf0e10cSrcweir }
2359cdf0e10cSrcweir
2360cdf0e10cSrcweir // den Restpfad bestimmen
2361cdf0e10cSrcweir aPfad.Erase( 0, nPos + 1 );
2362cdf0e10cSrcweir while ( aPfad.Len() && ( aPfad.GetChar(0) == '/' ) )
2363cdf0e10cSrcweir aPfad.Erase( 0, 1 );
2364cdf0e10cSrcweir }
2365cdf0e10cSrcweir while ( aPfad.Len() );
2366cdf0e10cSrcweir
2367cdf0e10cSrcweir // Haupt-Entry (selbst) zuweisen
2368cdf0e10cSrcweir if ( aStack.Count() == 0 )
2369cdf0e10cSrcweir {
2370cdf0e10cSrcweir eFlag = FSYS_FLAG_CURRENT;
2371cdf0e10cSrcweir aName.Erase();
2372cdf0e10cSrcweir }
2373cdf0e10cSrcweir else
2374cdf0e10cSrcweir {
2375cdf0e10cSrcweir eFlag = aStack.Top()->eFlag;
2376cdf0e10cSrcweir aName = aStack.Top()->aName;
2377cdf0e10cSrcweir delete aStack.Pop();
2378cdf0e10cSrcweir }
2379cdf0e10cSrcweir
2380cdf0e10cSrcweir // die Parent-Entries vom Stack holen
2381cdf0e10cSrcweir DirEntry** pTemp = &pParent;
2382cdf0e10cSrcweir while ( aStack.Count() )
2383cdf0e10cSrcweir {
2384cdf0e10cSrcweir *pTemp = aStack.Pop();
2385cdf0e10cSrcweir pTemp = &( (*pTemp)->pParent );
2386cdf0e10cSrcweir }
2387cdf0e10cSrcweir
2388cdf0e10cSrcweir return FSYS_ERR_OK;
2389cdf0e10cSrcweir }
2390cdf0e10cSrcweir
2391cdf0e10cSrcweir /*************************************************************************
2392cdf0e10cSrcweir |*
2393cdf0e10cSrcweir |* DirEntry::MakeShortName()
2394cdf0e10cSrcweir |*
2395cdf0e10cSrcweir |* Beschreibung
2396cdf0e10cSrcweir |* Ersterstellung TLX
2397cdf0e10cSrcweir |* Letzte Aenderung PB 21.08.97 (in CreateEntry_Impl())
2398cdf0e10cSrcweir |*
2399cdf0e10cSrcweir *************************************************************************/
2400cdf0e10cSrcweir
CreateEntry_Impl(const DirEntry & rPath,DirEntryKind eKind)2401cdf0e10cSrcweir ErrCode CreateEntry_Impl( const DirEntry &rPath, DirEntryKind eKind )
2402cdf0e10cSrcweir {
2403cdf0e10cSrcweir // versuchen, anzulegen (ausser bei FSYS_KIND_ALL)
2404cdf0e10cSrcweir ErrCode eErr = ERRCODE_NONE;
2405cdf0e10cSrcweir if ( FSYS_KIND_FILE == eKind )
2406cdf0e10cSrcweir {
2407cdf0e10cSrcweir SvFileStream aStream( rPath.GetFull(), STREAM_STD_WRITE );
2408cdf0e10cSrcweir aStream.WriteLine( "" );
2409cdf0e10cSrcweir eErr = aStream.GetError();
2410cdf0e10cSrcweir }
2411cdf0e10cSrcweir else if ( FSYS_KIND_ALL != eKind )
2412cdf0e10cSrcweir eErr = rPath.MakeDir() ? ERRCODE_NONE : ERRCODE_IO_UNKNOWN;
2413cdf0e10cSrcweir
2414cdf0e10cSrcweir // erfolgreich?
2415cdf0e10cSrcweir if ( !rPath.Exists() )
2416cdf0e10cSrcweir eErr = ERRCODE_IO_UNKNOWN; // Doch was schiefgegangen ?
2417cdf0e10cSrcweir
2418cdf0e10cSrcweir // ggf. wieder l"oschen
2419cdf0e10cSrcweir if ( FSYS_KIND_NONE == eKind )
2420cdf0e10cSrcweir rPath.Kill();
2421cdf0e10cSrcweir
2422cdf0e10cSrcweir // Fehlercode zur?ckliefern
2423cdf0e10cSrcweir return eErr;
2424cdf0e10cSrcweir }
2425cdf0e10cSrcweir
IsValidEntry_Impl(const DirEntry & rPath,const String & rLongName,DirEntryKind eKind,sal_Bool bIsShortened,sal_Bool bUseDelim)2426cdf0e10cSrcweir sal_Bool IsValidEntry_Impl( const DirEntry &rPath,
2427cdf0e10cSrcweir const String &rLongName,
2428cdf0e10cSrcweir DirEntryKind eKind,
2429cdf0e10cSrcweir sal_Bool bIsShortened,
2430cdf0e10cSrcweir sal_Bool bUseDelim )
2431cdf0e10cSrcweir {
2432cdf0e10cSrcweir // Parameter-Pr"uefung
2433cdf0e10cSrcweir DBG_ASSERT( eKind == FSYS_KIND_NONE || eKind == FSYS_KIND_ALL ||
2434cdf0e10cSrcweir eKind == FSYS_KIND_FILE || eKind == FSYS_KIND_DIR,
2435cdf0e10cSrcweir "invalid entry-kind" );
2436cdf0e10cSrcweir
2437cdf0e10cSrcweir // Alle von MSDOS erreichbaren FSYS_STYLES muessen den
2438cdf0e10cSrcweir // MSDOS Filenamenanforderungen genuegen. Sonst wird probiert,
2439cdf0e10cSrcweir // ob sich eine Datei des gewuenschten Names anlegen laesst.
2440cdf0e10cSrcweir FSysPathStyle eStyle = DirEntry::GetPathStyle( rPath.GetDevice().GetName() );
2441cdf0e10cSrcweir DirEntry aPath(rPath);
2442cdf0e10cSrcweir DirEntry aName(rLongName, eStyle);
2443cdf0e10cSrcweir if ( !aName.IsValid() || aName.Level() != 1 )
2444cdf0e10cSrcweir return sal_False;
2445cdf0e10cSrcweir aPath += aName;
2446cdf0e10cSrcweir if ( 1 == aPath.Level() )
2447cdf0e10cSrcweir return sal_False;
2448cdf0e10cSrcweir if ( eStyle == FSYS_STYLE_FAT || eStyle == FSYS_STYLE_NWFS ||
2449cdf0e10cSrcweir eStyle == FSYS_STYLE_UNKNOWN )
2450cdf0e10cSrcweir {
2451cdf0e10cSrcweir DirEntry aDosEntry( rLongName, FSYS_STYLE_FAT );
2452cdf0e10cSrcweir if ( !aDosEntry.IsValid() )
2453cdf0e10cSrcweir return sal_False;
2454cdf0e10cSrcweir }
2455cdf0e10cSrcweir
2456cdf0e10cSrcweir // Pfad-Trenner sind nicht erlaubt (bei ungek"urzten auch nicht FSYS_SHORTNAME_DELIMITER)
2457cdf0e10cSrcweir char cDelim = bUseDelim == 2 ? FSYS_SHORTNAME_DELIMITER : char(0);
2458cdf0e10cSrcweir if (
2459cdf0e10cSrcweir rLongName.Search(DirEntry::GetAccessDelimiter()) != STRING_NOTFOUND ||
2460cdf0e10cSrcweir (!bIsShortened && rLongName.Search(cDelim) != STRING_NOTFOUND)
2461cdf0e10cSrcweir )
2462cdf0e10cSrcweir {
2463cdf0e10cSrcweir return sal_False;
2464cdf0e10cSrcweir }
2465cdf0e10cSrcweir
2466cdf0e10cSrcweir // MI: Abfrage nach 'CON:' etc. wird jetzt in Exists() mitgemacht
2467cdf0e10cSrcweir if ( aPath.Exists() )
2468cdf0e10cSrcweir return sal_False;
2469cdf0e10cSrcweir
2470cdf0e10cSrcweir return (ERRCODE_NONE == CreateEntry_Impl( aPath, eKind ));
2471cdf0e10cSrcweir }
2472cdf0e10cSrcweir
2473cdf0e10cSrcweir //-------------------------------------------------------------------------
2474cdf0e10cSrcweir
2475cdf0e10cSrcweir #define MAX_EXT_FAT 3
2476cdf0e10cSrcweir #define MAX_LEN_FAT 8
2477cdf0e10cSrcweir #define INVALID_CHARS_FAT "\\/\"':|^<>[]?* "
2478cdf0e10cSrcweir
2479cdf0e10cSrcweir #define MAX_EXT_MAC 16 // nur wegen sinnvoller Namensk"rzung
2480cdf0e10cSrcweir #define MAX_LEN_MAC 31
2481cdf0e10cSrcweir #define INVALID_CHARS_MAC "\":"
2482cdf0e10cSrcweir
2483cdf0e10cSrcweir #define MAX_EXT_MAX 250
2484cdf0e10cSrcweir #define MAX_LEN_MAX 255
2485cdf0e10cSrcweir #define INVALID_CHARS_DEF "\\/\"':|^<>?*"
2486cdf0e10cSrcweir
MakeShortName(const String & rLongName,DirEntryKind eKind,sal_Bool bUseDelim,FSysPathStyle eStyle)2487cdf0e10cSrcweir sal_Bool DirEntry::MakeShortName( const String& rLongName, DirEntryKind eKind,
2488cdf0e10cSrcweir sal_Bool bUseDelim, FSysPathStyle eStyle )
2489cdf0e10cSrcweir {
2490cdf0e10cSrcweir String aLongName(rLongName);
2491cdf0e10cSrcweir
2492cdf0e10cSrcweir // Alle '#' aus den Dateinamen entfernen, weil das INetURLObject
2493cdf0e10cSrcweir // damit Probleme hat. Siehe auch #51246#
2494cdf0e10cSrcweir aLongName.EraseAllChars( '#' );
2495cdf0e10cSrcweir ByteString bLongName(aLongName, osl_getThreadTextEncoding());
2496cdf0e10cSrcweir
2497cdf0e10cSrcweir // Auf Novell-Servern (wegen der rottigen Clients) nur 7bit ASCII
2498cdf0e10cSrcweir
2499cdf0e10cSrcweir // HRO: #69627# Weg mit dem Scheiss. Wenn es Client gibt, die so einen
2500cdf0e10cSrcweir // BUG haben, dann muss halt der Client ersetzt werden, aber doch nicht das
2501cdf0e10cSrcweir // Office kastrieren !!!
2502cdf0e10cSrcweir
2503cdf0e10cSrcweir #if 0
2504cdf0e10cSrcweir if ( FSYS_STYLE_NWFS == GetPathStyle( ImpGetTopPtr()->GetName() ) )
2505cdf0e10cSrcweir {
2506cdf0e10cSrcweir for ( sal_uInt16 n = aLongName.Len(); n; --n )
2507cdf0e10cSrcweir {
2508cdf0e10cSrcweir short nChar = aLongName(n-1);
2509cdf0e10cSrcweir if ( nChar < 32 || nChar >= 127 )
2510cdf0e10cSrcweir aLongName.Erase( n-1, 1 );
2511cdf0e10cSrcweir }
2512cdf0e10cSrcweir }
2513cdf0e10cSrcweir #endif
2514cdf0e10cSrcweir
2515cdf0e10cSrcweir // bei FSYS_KIND_ALL den alten Namen merken und abh"angen (rename)
2516cdf0e10cSrcweir ByteString aOldName;
2517cdf0e10cSrcweir if ( FSYS_KIND_ALL == eKind )
2518cdf0e10cSrcweir {
2519cdf0e10cSrcweir aOldName = ByteString(CutName(), osl_getThreadTextEncoding());
2520cdf0e10cSrcweir aOldName = CMP_LOWER(aOldName);
2521cdf0e10cSrcweir }
2522cdf0e10cSrcweir
2523cdf0e10cSrcweir // ist der Langname direkt verwendbar?
2524cdf0e10cSrcweir if ( IsValidEntry_Impl( *this, aLongName, eKind, sal_False, bUseDelim ) )
2525cdf0e10cSrcweir {
2526cdf0e10cSrcweir operator+=( DirEntry(aLongName) );
2527cdf0e10cSrcweir return sal_True;
2528cdf0e10cSrcweir }
2529cdf0e10cSrcweir
2530cdf0e10cSrcweir // max L"angen feststellen
2531cdf0e10cSrcweir sal_uInt16 nMaxExt, nMaxLen;
2532cdf0e10cSrcweir if ( FSYS_STYLE_DETECT == eStyle )
2533cdf0e10cSrcweir eStyle = DirEntry::GetPathStyle( GetDevice().GetName() );
2534cdf0e10cSrcweir ByteString aInvalidChars;
2535cdf0e10cSrcweir switch ( eStyle )
2536cdf0e10cSrcweir {
2537cdf0e10cSrcweir case FSYS_STYLE_FAT:
2538cdf0e10cSrcweir nMaxExt = MAX_EXT_FAT;
2539cdf0e10cSrcweir nMaxLen = MAX_LEN_FAT;
2540cdf0e10cSrcweir aInvalidChars = INVALID_CHARS_FAT;
2541cdf0e10cSrcweir break;
2542cdf0e10cSrcweir
2543cdf0e10cSrcweir case FSYS_STYLE_MAC:
2544cdf0e10cSrcweir nMaxExt = MAX_EXT_MAC;
2545cdf0e10cSrcweir nMaxLen = MAX_LEN_MAC;
2546cdf0e10cSrcweir aInvalidChars = INVALID_CHARS_MAC;
2547cdf0e10cSrcweir break;
2548cdf0e10cSrcweir
2549cdf0e10cSrcweir default:
2550cdf0e10cSrcweir nMaxExt = MAX_EXT_MAX;
2551cdf0e10cSrcweir nMaxLen = MAX_LEN_MAX;
2552cdf0e10cSrcweir aInvalidChars = INVALID_CHARS_DEF;
2553cdf0e10cSrcweir }
2554cdf0e10cSrcweir
2555cdf0e10cSrcweir // Extension abschneiden und kuerzen
2556cdf0e10cSrcweir ByteString aExt;
2557cdf0e10cSrcweir ByteString aFName = bLongName;
2558cdf0e10cSrcweir if ( FSYS_STYLE_MAC != eStyle )
2559cdf0e10cSrcweir {
2560cdf0e10cSrcweir DirEntry aUnparsed;
2561cdf0e10cSrcweir aUnparsed.aName = bLongName;
2562cdf0e10cSrcweir aExt = ByteString(aUnparsed.CutExtension(), osl_getThreadTextEncoding());
2563cdf0e10cSrcweir aFName = aUnparsed.aName;
2564cdf0e10cSrcweir if ( aExt.Len() > nMaxExt )
2565cdf0e10cSrcweir {
2566cdf0e10cSrcweir char c = aExt.GetChar( aExt.Len() - 1 );
2567cdf0e10cSrcweir aExt.Erase(nMaxExt-1);
2568cdf0e10cSrcweir aExt += c;
2569cdf0e10cSrcweir }
2570cdf0e10cSrcweir }
2571cdf0e10cSrcweir
2572cdf0e10cSrcweir if ( FSYS_STYLE_FAT != eStyle )
2573cdf0e10cSrcweir {
2574cdf0e10cSrcweir // ausser auf einem FAT-System geh"ort die Extension zur
2575cdf0e10cSrcweir // Maxl"ange. Muss also vorher mit dem Punkt abgezogen werden.
2576cdf0e10cSrcweir nMaxLen -= ( aExt.Len() + 1 );
2577cdf0e10cSrcweir }
2578cdf0e10cSrcweir
2579cdf0e10cSrcweir // Name k"urzen
2580cdf0e10cSrcweir ByteString aSName;
2581cdf0e10cSrcweir for ( const char *pc = aFName.GetBuffer(); aSName.Len() < nMaxLen && *pc; ++pc )
2582cdf0e10cSrcweir {
2583cdf0e10cSrcweir if ( STRING_NOTFOUND == aInvalidChars.Search( *pc ) &&
2584cdf0e10cSrcweir (unsigned char) *pc >= (unsigned char) 32 &&
2585cdf0e10cSrcweir ( !aSName.Len() || *pc != ' ' || aSName.GetChar(aSName.Len()-1) != ' ' ) )
2586cdf0e10cSrcweir aSName += *pc;
2587cdf0e10cSrcweir }
2588cdf0e10cSrcweir aSName.EraseTrailingChars();
2589cdf0e10cSrcweir
2590cdf0e10cSrcweir // HRO: #74246# Also cut leading spaces
2591cdf0e10cSrcweir aSName.EraseLeadingChars();
2592cdf0e10cSrcweir
2593cdf0e10cSrcweir if ( !aSName.Len() )
2594cdf0e10cSrcweir aSName = "noname";
2595cdf0e10cSrcweir
2596cdf0e10cSrcweir // kommt dabei der alte Name raus?
2597cdf0e10cSrcweir ByteString aNewName = aSName;
2598cdf0e10cSrcweir if ( aExt.Len() )
2599cdf0e10cSrcweir ( aNewName += '.' ) += aExt;
2600cdf0e10cSrcweir operator+=( DirEntry(String(aNewName, osl_getThreadTextEncoding())) );
2601cdf0e10cSrcweir if ( FSYS_KIND_ALL == eKind && CMP_LOWER(aName) == aOldName )
2602cdf0e10cSrcweir if ( FSYS_KIND_ALL == eKind && CMP_LOWER(ByteString(GetName(), osl_getThreadTextEncoding())) == aOldName )
2603cdf0e10cSrcweir return sal_True;
2604cdf0e10cSrcweir
2605cdf0e10cSrcweir // kann der gek"urzte Name direkt verwendet werden?
2606cdf0e10cSrcweir if ( !Exists() && (ERRCODE_NONE == CreateEntry_Impl( *this, eKind )) )
2607cdf0e10cSrcweir return sal_True;
2608cdf0e10cSrcweir
2609cdf0e10cSrcweir // darf '?##' verwendet werden, um eindeutigen Name zu erzeugen?
2610cdf0e10cSrcweir if ( bUseDelim )
2611cdf0e10cSrcweir {
2612cdf0e10cSrcweir // eindeutigen Namen per '?##' erzeugen
2613cdf0e10cSrcweir aSName.Erase( nMaxLen-3 );
2614cdf0e10cSrcweir if ( bUseDelim != 2 )
2615cdf0e10cSrcweir aSName += FSYS_SHORTNAME_DELIMITER;
2616cdf0e10cSrcweir for ( int n = 1; n < 99; ++n )
2617cdf0e10cSrcweir {
2618cdf0e10cSrcweir // Name zusammensetzen
2619cdf0e10cSrcweir ByteString aTmpStr( aSName );
2620cdf0e10cSrcweir aTmpStr += ByteString::CreateFromInt32(n);
2621cdf0e10cSrcweir if ( aExt.Len() )
2622cdf0e10cSrcweir ( aTmpStr += '.' ) += aExt;
2623cdf0e10cSrcweir
2624cdf0e10cSrcweir // noch nicht vorhanden?
2625cdf0e10cSrcweir SetName( String(aTmpStr, osl_getThreadTextEncoding()) );
2626cdf0e10cSrcweir
2627cdf0e10cSrcweir if ( !Exists() )
2628cdf0e10cSrcweir {
2629cdf0e10cSrcweir // Fehler setzen !!!
2630cdf0e10cSrcweir nError = CreateEntry_Impl( *this, eKind );
2631cdf0e10cSrcweir return (ERRCODE_NONE == nError);
2632cdf0e10cSrcweir }
2633cdf0e10cSrcweir }
2634cdf0e10cSrcweir }
2635cdf0e10cSrcweir
2636cdf0e10cSrcweir // keine ## mehr frei / ?## soll nicht verwendet werden
2637cdf0e10cSrcweir nError = ERRCODE_IO_ALREADYEXISTS;
2638cdf0e10cSrcweir return sal_False;
2639cdf0e10cSrcweir }
2640cdf0e10cSrcweir
2641cdf0e10cSrcweir /*************************************************************************
2642cdf0e10cSrcweir |*
2643cdf0e10cSrcweir |* DirEntry::CreatePath()
2644cdf0e10cSrcweir |*
2645cdf0e10cSrcweir |* Beschreibung FSYS.SDW
2646cdf0e10cSrcweir |* Ersterstellung MI 26.04.91
2647cdf0e10cSrcweir |* Letzte Aenderung MA 02.12.91
2648cdf0e10cSrcweir |*
2649cdf0e10cSrcweir *************************************************************************/
2650cdf0e10cSrcweir
MakeDir(sal_Bool bSloppy) const2651cdf0e10cSrcweir sal_Bool DirEntry::MakeDir( sal_Bool bSloppy ) const
2652cdf0e10cSrcweir {
2653cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
2654cdf0e10cSrcweir
2655cdf0e10cSrcweir // Schnellpruefung, ob vorhanden
2656cdf0e10cSrcweir if ( FileStat( *this ).IsKind( FSYS_KIND_DIR ) )
2657cdf0e10cSrcweir return sal_True;
2658cdf0e10cSrcweir if ( bSloppy && pParent )
2659cdf0e10cSrcweir if ( FileStat( *pParent ).IsKind( FSYS_KIND_DIR ) )
2660cdf0e10cSrcweir return sal_True;
2661cdf0e10cSrcweir
2662cdf0e10cSrcweir const DirEntry *pNewDir = bSloppy ? pParent : this;
2663cdf0e10cSrcweir if ( pNewDir )
2664cdf0e10cSrcweir {
2665cdf0e10cSrcweir // den Path zum Dir erzeugen
2666cdf0e10cSrcweir if ( pNewDir->pParent && !pNewDir->pParent->MakeDir(sal_False) )
2667cdf0e10cSrcweir return sal_False;
2668cdf0e10cSrcweir
2669cdf0e10cSrcweir // das Dir selbst erzeugen
2670cdf0e10cSrcweir if ( pNewDir->eFlag == FSYS_FLAG_ABSROOT ||
2671cdf0e10cSrcweir pNewDir->eFlag == FSYS_FLAG_ABSROOT ||
2672cdf0e10cSrcweir pNewDir->eFlag == FSYS_FLAG_VOLUME )
2673cdf0e10cSrcweir return sal_True;
2674cdf0e10cSrcweir else
2675cdf0e10cSrcweir {
2676cdf0e10cSrcweir //? nError = ???
2677cdf0e10cSrcweir if ( FileStat( *pNewDir ).IsKind( FSYS_KIND_DIR ) )
2678cdf0e10cSrcweir return sal_True;
2679cdf0e10cSrcweir else
2680cdf0e10cSrcweir {
2681cdf0e10cSrcweir FSysFailOnErrorImpl();
2682cdf0e10cSrcweir String aDirName(pNewDir->GetFull());
2683cdf0e10cSrcweir #ifndef BOOTSTRAP
2684cdf0e10cSrcweir FSysRedirector::DoRedirect( aDirName );
2685cdf0e10cSrcweir #endif
2686cdf0e10cSrcweir ByteString bDirName( aDirName, osl_getThreadTextEncoding() );
2687cdf0e10cSrcweir bDirName = GUI2FSYS( bDirName );
2688cdf0e10cSrcweir
2689cdf0e10cSrcweir #ifdef WIN32
2690cdf0e10cSrcweir SetLastError(0);
2691cdf0e10cSrcweir #endif
2692cdf0e10cSrcweir sal_Bool bResult = (0 == _mkdir( (char*) bDirName.GetBuffer() ));
2693cdf0e10cSrcweir if ( !bResult )
2694cdf0e10cSrcweir {
2695cdf0e10cSrcweir // Wer hat diese Methode const gemacht ?
2696cdf0e10cSrcweir #ifdef WIN32
2697cdf0e10cSrcweir ((DirEntry *)this)->SetError( Sys2SolarError_Impl( GetLastError() ) );
2698cdf0e10cSrcweir #else
2699cdf0e10cSrcweir ((DirEntry *)this)->SetError( Sys2SolarError_Impl( errno ) );
2700cdf0e10cSrcweir #endif
2701cdf0e10cSrcweir }
2702cdf0e10cSrcweir
2703cdf0e10cSrcweir return bResult;
2704cdf0e10cSrcweir }
2705cdf0e10cSrcweir }
2706cdf0e10cSrcweir }
2707cdf0e10cSrcweir return sal_True;
2708cdf0e10cSrcweir }
2709cdf0e10cSrcweir
2710cdf0e10cSrcweir /*************************************************************************
2711cdf0e10cSrcweir |*
2712cdf0e10cSrcweir |* DirEntry::CopyTo()
2713cdf0e10cSrcweir |*
2714cdf0e10cSrcweir |* Beschreibung FSYS.SDW
2715cdf0e10cSrcweir |* Ersterstellung MI 26.04.91
2716cdf0e10cSrcweir |* Letzte Aenderung MI 07.08.96
2717cdf0e10cSrcweir |*
2718cdf0e10cSrcweir *************************************************************************/
2719cdf0e10cSrcweir
CopyTo(const DirEntry & rDest,FSysAction nActions) const2720cdf0e10cSrcweir FSysError DirEntry::CopyTo( const DirEntry& rDest, FSysAction nActions ) const
2721cdf0e10cSrcweir {
2722cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
2723cdf0e10cSrcweir
2724cdf0e10cSrcweir if ( FSYS_ACTION_COPYFILE != (nActions & FSYS_ACTION_COPYFILE) )
2725cdf0e10cSrcweir #ifdef UNX
2726cdf0e10cSrcweir {
2727cdf0e10cSrcweir // Hardlink anlegen
2728cdf0e10cSrcweir HACK(redirection missing)
2729cdf0e10cSrcweir ByteString aThis(GUI2FSYS(GetFull()), osl_getThreadTextEncoding());
2730cdf0e10cSrcweir ByteString aDest(GUI2FSYS(rDest.GetFull()), osl_getThreadTextEncoding());
2731cdf0e10cSrcweir if (link( aThis.GetBuffer(), aDest.GetBuffer() ) == -1)
2732cdf0e10cSrcweir return Sys2SolarError_Impl( errno );
2733cdf0e10cSrcweir else
2734cdf0e10cSrcweir return FSYS_ERR_OK;
2735cdf0e10cSrcweir }
2736cdf0e10cSrcweir #else
2737cdf0e10cSrcweir return FSYS_ERR_NOTSUPPORTED;
2738cdf0e10cSrcweir #endif
2739cdf0e10cSrcweir
2740cdf0e10cSrcweir FileCopier fc(*this, rDest);
2741cdf0e10cSrcweir return fc.Execute(nActions);
2742cdf0e10cSrcweir }
2743cdf0e10cSrcweir
2744cdf0e10cSrcweir /*************************************************************************
2745cdf0e10cSrcweir |*
2746cdf0e10cSrcweir |* DirEntry::MoveTo()
2747cdf0e10cSrcweir |*
2748cdf0e10cSrcweir |* Beschreibung FSYS.SDW
2749cdf0e10cSrcweir |* Ersterstellung MI 26.04.91
2750cdf0e10cSrcweir |* Letzte Aenderung HRO 24.03.99
2751cdf0e10cSrcweir |*
2752cdf0e10cSrcweir *************************************************************************/
2753cdf0e10cSrcweir
2754cdf0e10cSrcweir #if defined WNT || defined UNX || defined OS2
2755cdf0e10cSrcweir
MoveTo(const DirEntry & rNewName) const2756cdf0e10cSrcweir FSysError DirEntry::MoveTo( const DirEntry& rNewName ) const
2757cdf0e10cSrcweir {
2758cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
2759cdf0e10cSrcweir
2760cdf0e10cSrcweir /*
2761cdf0e10cSrcweir FileStat aSourceStat(*this);
2762cdf0e10cSrcweir if ( !aSourceStat.IsKind(FSYS_KIND_FILE) )
2763cdf0e10cSrcweir return FSYS_ERR_NOTAFILE;
2764cdf0e10cSrcweir */
2765cdf0e10cSrcweir
2766cdf0e10cSrcweir DirEntry aDest(rNewName);
2767cdf0e10cSrcweir FileStat aDestStat(rNewName);
2768cdf0e10cSrcweir if ( aDestStat.IsKind(FSYS_KIND_DIR ) )
2769cdf0e10cSrcweir {
2770cdf0e10cSrcweir aDest += String(aName, osl_getThreadTextEncoding());
2771cdf0e10cSrcweir }
2772cdf0e10cSrcweir if ( aDest.Exists() )
2773cdf0e10cSrcweir {
2774cdf0e10cSrcweir return FSYS_ERR_ALREADYEXISTS;
2775cdf0e10cSrcweir }
2776cdf0e10cSrcweir
2777cdf0e10cSrcweir #if defined(OS2)
2778cdf0e10cSrcweir if ( FileStat(*this).IsKind(FSYS_KIND_DIR) && aDest.GetPath() != GetPath() )
2779cdf0e10cSrcweir {
2780cdf0e10cSrcweir return FSYS_ERR_NOTSUPPORTED;
2781cdf0e10cSrcweir }
2782cdf0e10cSrcweir #endif
2783cdf0e10cSrcweir
2784cdf0e10cSrcweir FSysFailOnErrorImpl();
2785cdf0e10cSrcweir String aFrom( GetFull() );
2786cdf0e10cSrcweir
2787cdf0e10cSrcweir #ifndef BOOTSTRAP
2788cdf0e10cSrcweir FSysRedirector::DoRedirect(aFrom);
2789cdf0e10cSrcweir #endif
2790cdf0e10cSrcweir
2791cdf0e10cSrcweir String aTo( aDest.GetFull() );
2792cdf0e10cSrcweir
2793cdf0e10cSrcweir #ifndef BOOTSTRAP
2794cdf0e10cSrcweir FSysRedirector::DoRedirect(aTo);
2795cdf0e10cSrcweir #endif
2796cdf0e10cSrcweir
2797cdf0e10cSrcweir ByteString bFrom(aFrom, osl_getThreadTextEncoding());
2798cdf0e10cSrcweir ByteString bTo(aTo, osl_getThreadTextEncoding());
2799cdf0e10cSrcweir bFrom = GUI2FSYS(bFrom);
2800cdf0e10cSrcweir bTo = GUI2FSYS(bTo);
2801cdf0e10cSrcweir
2802cdf0e10cSrcweir #ifdef WNT
2803cdf0e10cSrcweir // MoveTo nun atomar
2804cdf0e10cSrcweir SetLastError(0);
2805cdf0e10cSrcweir
2806cdf0e10cSrcweir DirEntry aFromDevice(String(bFrom, osl_getThreadTextEncoding()));
2807cdf0e10cSrcweir DirEntry aToDevice(String(bTo,osl_getThreadTextEncoding()));
2808cdf0e10cSrcweir aFromDevice.ToAbs();
2809cdf0e10cSrcweir aToDevice.ToAbs();
2810cdf0e10cSrcweir aFromDevice=aFromDevice.GetDevice();
2811cdf0e10cSrcweir aToDevice=aToDevice.GetDevice();
2812cdf0e10cSrcweir
2813cdf0e10cSrcweir //Quelle und Ziel auf gleichem device?
2814cdf0e10cSrcweir if (aFromDevice==aToDevice)
2815cdf0e10cSrcweir {
2816cdf0e10cSrcweir // ja, also intra-device-move mit MoveFile
2817cdf0e10cSrcweir MoveFile( bFrom.GetBuffer(), bTo.GetBuffer() );
2818cdf0e10cSrcweir // MoveFile ist buggy bei cross-device operationen.
2819cdf0e10cSrcweir // Der R?ckgabewert ist auch dann sal_True, wenn nur ein Teil der Operation geklappt hat.
2820cdf0e10cSrcweir // Zudem zeigt MoveFile unterschiedliches Verhalten bei unterschiedlichen NT-Versionen.
2821cdf0e10cSrcweir return Sys2SolarError_Impl( GetLastError() );
2822cdf0e10cSrcweir }
2823cdf0e10cSrcweir else
2824cdf0e10cSrcweir {
2825cdf0e10cSrcweir //nein, also inter-device-move mit copy/delete
2826cdf0e10cSrcweir FSysError nCopyError = CopyTo(rNewName, FSYS_ACTION_COPYFILE);
2827cdf0e10cSrcweir
2828cdf0e10cSrcweir DirEntry aKill(String(bTo, osl_getThreadTextEncoding()));
2829cdf0e10cSrcweir FileStat aKillStat(String(bTo, osl_getThreadTextEncoding()));
2830cdf0e10cSrcweir if ( aKillStat.IsKind(FSYS_KIND_DIR ) )
2831cdf0e10cSrcweir {
2832cdf0e10cSrcweir aKill += String(aName, osl_getThreadTextEncoding());
2833cdf0e10cSrcweir }
2834cdf0e10cSrcweir
2835cdf0e10cSrcweir if (nCopyError==FSYS_ERR_OK)
2836cdf0e10cSrcweir {
2837cdf0e10cSrcweir if (Kill()==FSYS_ERR_OK)
2838cdf0e10cSrcweir {
2839cdf0e10cSrcweir return FSYS_ERR_OK;
2840cdf0e10cSrcweir }
2841cdf0e10cSrcweir else
2842cdf0e10cSrcweir {
2843cdf0e10cSrcweir aKill.Kill();
2844cdf0e10cSrcweir return FSYS_ERR_ACCESSDENIED;
2845cdf0e10cSrcweir }
2846cdf0e10cSrcweir }
2847cdf0e10cSrcweir else
2848cdf0e10cSrcweir {
2849cdf0e10cSrcweir aKill.Kill();
2850cdf0e10cSrcweir return nCopyError;
2851cdf0e10cSrcweir }
2852cdf0e10cSrcweir }
2853cdf0e10cSrcweir #else
2854cdf0e10cSrcweir // #68639#
2855cdf0e10cSrcweir // on some nfs connections rename with from == to
2856cdf0e10cSrcweir // leads to destruction of file
2857cdf0e10cSrcweir if ( ( aFrom != aTo ) && ( 0 != rename( bFrom.GetBuffer(), bTo.GetBuffer() ) ) )
2858cdf0e10cSrcweir #if !defined(UNX) && !defined(OS2)
2859cdf0e10cSrcweir return Sys2SolarError_Impl( GetLastError() );
2860cdf0e10cSrcweir #else
2861cdf0e10cSrcweir {
2862cdf0e10cSrcweir if( errno == EXDEV )
2863cdf0e10cSrcweir // cross device geht latuernich nicht mit rename
2864cdf0e10cSrcweir {
2865cdf0e10cSrcweir FILE *fpIN = fopen( bFrom.GetBuffer(), "r" );
2866cdf0e10cSrcweir FILE *fpOUT = fopen( bTo.GetBuffer(), "w" );
2867cdf0e10cSrcweir if( fpIN && fpOUT )
2868cdf0e10cSrcweir {
2869cdf0e10cSrcweir char pBuf[ 16384 ];
2870cdf0e10cSrcweir int nBytes, nWritten, nErr = 0;
2871cdf0e10cSrcweir errno = 0;
2872cdf0e10cSrcweir while( ( nBytes = fread( pBuf, 1, sizeof(pBuf), fpIN ) ) && ! nErr )
2873cdf0e10cSrcweir {
2874cdf0e10cSrcweir nWritten = fwrite( pBuf, 1, nBytes, fpOUT );
2875cdf0e10cSrcweir // Fehler im fwrite ?
2876cdf0e10cSrcweir if( nWritten < nBytes )
2877cdf0e10cSrcweir {
2878cdf0e10cSrcweir nErr = errno;
2879cdf0e10cSrcweir break;
2880cdf0e10cSrcweir }
2881cdf0e10cSrcweir }
2882cdf0e10cSrcweir fclose( fpIN );
2883cdf0e10cSrcweir fclose( fpOUT );
2884cdf0e10cSrcweir if ( nErr )
2885cdf0e10cSrcweir {
2886cdf0e10cSrcweir unlink( bTo.GetBuffer() );
2887cdf0e10cSrcweir return Sys2SolarError_Impl( nErr );
2888cdf0e10cSrcweir }
2889cdf0e10cSrcweir else
2890cdf0e10cSrcweir {
2891cdf0e10cSrcweir unlink( bFrom.GetBuffer() );
2892cdf0e10cSrcweir }
2893cdf0e10cSrcweir }
2894cdf0e10cSrcweir else
2895cdf0e10cSrcweir {
2896cdf0e10cSrcweir return Sys2SolarError_Impl( EXDEV );
2897cdf0e10cSrcweir }
2898cdf0e10cSrcweir }
2899cdf0e10cSrcweir else
2900cdf0e10cSrcweir {
2901cdf0e10cSrcweir return Sys2SolarError_Impl( errno );
2902cdf0e10cSrcweir }
2903cdf0e10cSrcweir }
2904cdf0e10cSrcweir #endif
2905cdf0e10cSrcweir #endif
2906cdf0e10cSrcweir return ERRCODE_NONE;
2907cdf0e10cSrcweir }
2908cdf0e10cSrcweir
2909cdf0e10cSrcweir #endif
2910cdf0e10cSrcweir
2911cdf0e10cSrcweir /*************************************************************************
2912cdf0e10cSrcweir |*
2913cdf0e10cSrcweir |* DirEntry::Kill()
2914cdf0e10cSrcweir |*
2915cdf0e10cSrcweir |* Beschreibung FSYS.SDW
2916cdf0e10cSrcweir |* Ersterstellung MI 26.04.91
2917cdf0e10cSrcweir |* Letzte Aenderung MI 07.08.96
2918cdf0e10cSrcweir |*
2919cdf0e10cSrcweir *************************************************************************/
2920cdf0e10cSrcweir
Kill(FSysAction nActions) const2921cdf0e10cSrcweir FSysError DirEntry::Kill( FSysAction nActions ) const
2922cdf0e10cSrcweir {
2923cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
2924cdf0e10cSrcweir
2925cdf0e10cSrcweir FSysError eError = FSYS_ERR_OK;
2926cdf0e10cSrcweir FSysFailOnErrorImpl();
2927cdf0e10cSrcweir
2928cdf0e10cSrcweir // Name als doppelt 0-terminierter String
2929cdf0e10cSrcweir String aTmpName( GetFull() );
2930cdf0e10cSrcweir #ifndef BOOTSTRAP
2931cdf0e10cSrcweir FSysRedirector::DoRedirect( aTmpName );
2932cdf0e10cSrcweir #endif
2933cdf0e10cSrcweir ByteString bTmpName( aTmpName, osl_getThreadTextEncoding());
2934cdf0e10cSrcweir bTmpName = GUI2FSYS(bTmpName);
2935cdf0e10cSrcweir
2936cdf0e10cSrcweir char *pName = new char[bTmpName.Len()+2];
2937cdf0e10cSrcweir strcpy( pName, bTmpName.GetBuffer() );
2938cdf0e10cSrcweir pName[bTmpName.Len()+1] = (char) 0;
2939cdf0e10cSrcweir
2940cdf0e10cSrcweir //read-only files sollen auch geloescht werden koennen
2941cdf0e10cSrcweir sal_Bool isReadOnly = FileStat::GetReadOnlyFlag(*this);
2942cdf0e10cSrcweir if (isReadOnly)
2943cdf0e10cSrcweir {
2944cdf0e10cSrcweir FileStat::SetReadOnlyFlag(*this, sal_False);
2945cdf0e10cSrcweir }
2946cdf0e10cSrcweir
2947cdf0e10cSrcweir // directory?
2948cdf0e10cSrcweir if ( FileStat( *this ).IsKind(FSYS_KIND_DIR) )
2949cdf0e10cSrcweir {
2950cdf0e10cSrcweir // Inhalte recursiv loeschen?
2951cdf0e10cSrcweir if ( FSYS_ACTION_RECURSIVE == (nActions & FSYS_ACTION_RECURSIVE) )
2952cdf0e10cSrcweir {
2953cdf0e10cSrcweir Dir aDir( *this, FSYS_KIND_DIR|FSYS_KIND_FILE );
2954cdf0e10cSrcweir for ( sal_uInt16 n = 0; eError == FSYS_ERR_OK && n < aDir.Count(); ++n )
2955cdf0e10cSrcweir {
2956cdf0e10cSrcweir const DirEntry &rSubDir = aDir[n];
2957cdf0e10cSrcweir DirEntryFlag flag = rSubDir.GetFlag();
2958cdf0e10cSrcweir if ( flag != FSYS_FLAG_CURRENT && flag != FSYS_FLAG_PARENT )
2959cdf0e10cSrcweir eError = rSubDir.Kill(nActions);
2960cdf0e10cSrcweir }
2961cdf0e10cSrcweir }
2962cdf0e10cSrcweir
2963cdf0e10cSrcweir // das Dir selbst loeschen
2964cdf0e10cSrcweir #ifdef WIN32
2965cdf0e10cSrcweir SetLastError(0);
2966cdf0e10cSrcweir #endif
2967cdf0e10cSrcweir if ( eError == FSYS_ERR_OK && 0 != _rmdir( (char*) pName ) )
2968cdf0e10cSrcweir //
2969cdf0e10cSrcweir {
2970cdf0e10cSrcweir // falls L"oschen nicht ging, CWD umsetzen
2971cdf0e10cSrcweir #ifdef WIN32
2972cdf0e10cSrcweir eError = Sys2SolarError_Impl( GetLastError() );
2973cdf0e10cSrcweir #else
2974cdf0e10cSrcweir eError = Sys2SolarError_Impl( errno );
2975cdf0e10cSrcweir #endif
2976cdf0e10cSrcweir if ( eError )
2977cdf0e10cSrcweir {
2978cdf0e10cSrcweir GetPath().SetCWD();
2979cdf0e10cSrcweir #ifdef WIN32
2980cdf0e10cSrcweir SetLastError(0);
2981cdf0e10cSrcweir #endif
2982cdf0e10cSrcweir if (_rmdir( (char*) pName) != 0)
2983cdf0e10cSrcweir {
2984cdf0e10cSrcweir #ifdef WIN32
2985cdf0e10cSrcweir eError = Sys2SolarError_Impl( GetLastError() );
2986cdf0e10cSrcweir #else
2987cdf0e10cSrcweir eError = Sys2SolarError_Impl( errno );
2988cdf0e10cSrcweir #endif
2989cdf0e10cSrcweir }
2990cdf0e10cSrcweir else
2991cdf0e10cSrcweir {
2992cdf0e10cSrcweir eError = FSYS_ERR_OK;
2993cdf0e10cSrcweir }
2994cdf0e10cSrcweir }
2995cdf0e10cSrcweir }
2996cdf0e10cSrcweir }
2997cdf0e10cSrcweir else
2998cdf0e10cSrcweir {
2999cdf0e10cSrcweir if ( FSYS_ACTION_USERECYCLEBIN == (nActions & FSYS_ACTION_USERECYCLEBIN) )
3000cdf0e10cSrcweir {
3001cdf0e10cSrcweir #ifdef OS2
3002cdf0e10cSrcweir eError = ApiRet2ToSolarError_Impl( DosDelete( (PSZ) pName ) );
3003cdf0e10cSrcweir #elif defined(WNT)
3004cdf0e10cSrcweir SHFILEOPSTRUCT aOp;
3005cdf0e10cSrcweir aOp.hwnd = 0;
3006cdf0e10cSrcweir aOp.wFunc = FO_DELETE;
3007cdf0e10cSrcweir aOp.pFrom = pName;
3008cdf0e10cSrcweir aOp.pTo = 0;
3009cdf0e10cSrcweir aOp.fFlags = FOF_ALLOWUNDO|FOF_SILENT|FOF_NOCONFIRMATION;
3010cdf0e10cSrcweir aOp.hNameMappings = 0;
3011cdf0e10cSrcweir aOp.lpszProgressTitle = 0;
3012cdf0e10cSrcweir eError = Sys2SolarError_Impl( SHFileOperation( &aOp ) );
3013cdf0e10cSrcweir #else
3014cdf0e10cSrcweir eError = ERRCODE_IO_NOTSUPPORTED;
3015cdf0e10cSrcweir #endif
3016cdf0e10cSrcweir }
3017cdf0e10cSrcweir else
3018cdf0e10cSrcweir {
3019cdf0e10cSrcweir #ifdef WIN32
3020cdf0e10cSrcweir SetLastError(0);
3021cdf0e10cSrcweir #endif
3022cdf0e10cSrcweir if ( 0 != _unlink( (char*) pName ) )
3023cdf0e10cSrcweir {
3024cdf0e10cSrcweir #ifdef WIN32
3025cdf0e10cSrcweir eError = Sys2SolarError_Impl( GetLastError() );
3026cdf0e10cSrcweir #else
3027cdf0e10cSrcweir eError = Sys2SolarError_Impl( errno );
3028cdf0e10cSrcweir #endif
3029cdf0e10cSrcweir }
3030cdf0e10cSrcweir else
3031cdf0e10cSrcweir {
3032cdf0e10cSrcweir eError = ERRCODE_NONE;
3033cdf0e10cSrcweir }
3034cdf0e10cSrcweir }
3035cdf0e10cSrcweir }
3036cdf0e10cSrcweir
3037cdf0e10cSrcweir //falls Fehler, originales read-only flag wieder herstellen
3038cdf0e10cSrcweir if ( isReadOnly && (eError!=ERRCODE_NONE) )
3039cdf0e10cSrcweir {
3040cdf0e10cSrcweir FileStat::SetReadOnlyFlag(*this, isReadOnly);
3041cdf0e10cSrcweir }
3042cdf0e10cSrcweir
3043cdf0e10cSrcweir delete[] pName;
3044cdf0e10cSrcweir return eError;
3045cdf0e10cSrcweir }
3046cdf0e10cSrcweir
3047cdf0e10cSrcweir /*************************************************************************
3048cdf0e10cSrcweir |*
3049cdf0e10cSrcweir |* DirEntry::Contains()
3050cdf0e10cSrcweir |*
3051cdf0e10cSrcweir |* Beschreibung ob rSubEntry direkt oder indirect in *this liegt
3052cdf0e10cSrcweir |* Ersterstellung MI 20.03.97
3053cdf0e10cSrcweir |* Letzte Aenderung MI 20.03.97
3054cdf0e10cSrcweir |*
3055cdf0e10cSrcweir *************************************************************************/
3056cdf0e10cSrcweir
Contains(const DirEntry & rSubEntry) const3057cdf0e10cSrcweir sal_Bool DirEntry::Contains( const DirEntry &rSubEntry ) const
3058cdf0e10cSrcweir {
3059cdf0e10cSrcweir DBG_ASSERT( IsAbs() && rSubEntry.IsAbs(), "must be absolute entries" );
3060cdf0e10cSrcweir
3061cdf0e10cSrcweir sal_uInt16 nThisLevel = Level();
3062cdf0e10cSrcweir sal_uInt16 nSubLevel = rSubEntry.Level();
3063cdf0e10cSrcweir if ( nThisLevel < nSubLevel )
3064cdf0e10cSrcweir {
3065cdf0e10cSrcweir for ( ; nThisLevel; --nThisLevel, --nSubLevel )
3066cdf0e10cSrcweir if ( (*this)[nThisLevel-1] != rSubEntry[nSubLevel-1] )
3067cdf0e10cSrcweir return sal_False;
3068cdf0e10cSrcweir return sal_True;
3069cdf0e10cSrcweir }
3070cdf0e10cSrcweir return sal_False;
3071cdf0e10cSrcweir }
3072cdf0e10cSrcweir
3073cdf0e10cSrcweir /*************************************************************************
3074cdf0e10cSrcweir |*
3075cdf0e10cSrcweir |* DirEntry::Level()
3076cdf0e10cSrcweir |*
3077cdf0e10cSrcweir |* Beschreibung FSYS.SDW
3078cdf0e10cSrcweir |* Ersterstellung MI 03.03.92
3079cdf0e10cSrcweir |* Letzte Aenderung MI 03.03.92
3080cdf0e10cSrcweir |*
3081cdf0e10cSrcweir *************************************************************************/
3082cdf0e10cSrcweir
Level() const3083cdf0e10cSrcweir sal_uInt16 DirEntry::Level() const
3084cdf0e10cSrcweir {
3085cdf0e10cSrcweir DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
3086cdf0e10cSrcweir
3087cdf0e10cSrcweir sal_uInt16 nLevel = 0;
3088cdf0e10cSrcweir const DirEntry *pRes = this;
3089cdf0e10cSrcweir while ( pRes )
3090cdf0e10cSrcweir {
3091cdf0e10cSrcweir pRes = pRes->pParent;
3092cdf0e10cSrcweir nLevel++;
3093cdf0e10cSrcweir }
3094cdf0e10cSrcweir
3095cdf0e10cSrcweir return nLevel;
3096cdf0e10cSrcweir }
3097cdf0e10cSrcweir
3098cdf0e10cSrcweir /*************************************************************************
3099cdf0e10cSrcweir |*
3100cdf0e10cSrcweir |* DirEntry::ConvertNameToSystem()
3101cdf0e10cSrcweir |*
3102cdf0e10cSrcweir |* Beschreibung
3103cdf0e10cSrcweir |* Ersterstellung DV 29.03.96
3104cdf0e10cSrcweir |* Letzte Aenderung DV 29.03.96
3105cdf0e10cSrcweir |*
3106cdf0e10cSrcweir *************************************************************************/
3107cdf0e10cSrcweir
ConvertNameToSystem(const String & rName)3108cdf0e10cSrcweir String DirEntry::ConvertNameToSystem( const String &rName )
3109cdf0e10cSrcweir {
3110cdf0e10cSrcweir return rName;
3111cdf0e10cSrcweir }
3112cdf0e10cSrcweir
3113cdf0e10cSrcweir /*************************************************************************
3114cdf0e10cSrcweir |*
3115cdf0e10cSrcweir |* DirEntry::ConvertSystemToName()
3116cdf0e10cSrcweir |*
3117cdf0e10cSrcweir |* Beschreibung
3118cdf0e10cSrcweir |* Ersterstellung DV 29.03.96
3119cdf0e10cSrcweir |* Letzte Aenderung DV 29.03.96
3120cdf0e10cSrcweir |*
3121cdf0e10cSrcweir *************************************************************************/
3122cdf0e10cSrcweir
ConvertSystemToName(const String & rName)3123cdf0e10cSrcweir String DirEntry::ConvertSystemToName( const String &rName )
3124cdf0e10cSrcweir {
3125cdf0e10cSrcweir return rName;
3126cdf0e10cSrcweir }
3127cdf0e10cSrcweir
3128cdf0e10cSrcweir /*************************************************************************
3129cdf0e10cSrcweir |*
3130cdf0e10cSrcweir |* DirEntry::IsValid()
3131cdf0e10cSrcweir |*
3132cdf0e10cSrcweir |* Beschreibung
3133cdf0e10cSrcweir |* Ersterstellung MI 18.09.93
3134cdf0e10cSrcweir |* Letzte Aenderung TPF 18.09.98
3135cdf0e10cSrcweir |*
3136cdf0e10cSrcweir *************************************************************************/
3137cdf0e10cSrcweir
IsValid() const3138cdf0e10cSrcweir sal_Bool DirEntry::IsValid() const
3139cdf0e10cSrcweir {
3140cdf0e10cSrcweir return (nError == FSYS_ERR_OK);
3141cdf0e10cSrcweir }
3142cdf0e10cSrcweir
3143cdf0e10cSrcweir /*************************************************************************
3144cdf0e10cSrcweir |*
3145cdf0e10cSrcweir |* DirEntry::IsRFSAvailable()
3146cdf0e10cSrcweir |*
3147cdf0e10cSrcweir |* Beschreibung
3148cdf0e10cSrcweir |* Ersterstellung TPF 21.10.98
3149cdf0e10cSrcweir |* Letzte Aenderung TPF 21.10.98
3150cdf0e10cSrcweir |*
3151cdf0e10cSrcweir *************************************************************************/
3152cdf0e10cSrcweir
IsRFSAvailable()3153cdf0e10cSrcweir sal_Bool DirEntry::IsRFSAvailable()
3154cdf0e10cSrcweir {
3155cdf0e10cSrcweir return sal_False;
3156cdf0e10cSrcweir }
3157cdf0e10cSrcweir
3158cdf0e10cSrcweir /*************************************************************************
3159cdf0e10cSrcweir |*
3160cdf0e10cSrcweir |* IsLongNameOnFAT()
3161cdf0e10cSrcweir |*
3162cdf0e10cSrcweir |* Beschreibung ?berpr?ft , ob das DirEntry einen langen
3163cdf0e10cSrcweir |* Filenamen auf einer FAT-Partition enth?lt (EAs).
3164cdf0e10cSrcweir |* (eigentlich nur f?r OS2 interessant)
3165cdf0e10cSrcweir |* Ersterstellung TPF 02.10.98
3166cdf0e10cSrcweir |* Letzte Aenderung TPF 01.03.1999
3167cdf0e10cSrcweir |*
3168cdf0e10cSrcweir *************************************************************************/
3169cdf0e10cSrcweir
IsLongNameOnFAT() const3170cdf0e10cSrcweir sal_Bool DirEntry::IsLongNameOnFAT() const
3171cdf0e10cSrcweir {
3172cdf0e10cSrcweir // FAT-System?
3173cdf0e10cSrcweir DirEntry aTempDirEntry(*this);
3174cdf0e10cSrcweir aTempDirEntry.ToAbs();
3175cdf0e10cSrcweir if (DirEntry::GetPathStyle(aTempDirEntry.GetDevice().GetName().GetChar(0)) != FSYS_STYLE_FAT)
3176cdf0e10cSrcweir {
3177cdf0e10cSrcweir return sal_False; // nein, also false
3178cdf0e10cSrcweir }
3179cdf0e10cSrcweir
3180cdf0e10cSrcweir // DirEntry-Kette auf lange Dateinamen pr?fen
3181cdf0e10cSrcweir for( sal_uInt16 iLevel = this->Level(); iLevel > 0; iLevel-- )
3182cdf0e10cSrcweir {
3183cdf0e10cSrcweir const DirEntry& rEntry = (const DirEntry&) (*this)[iLevel-1];
3184cdf0e10cSrcweir String aBase( rEntry.GetBase() );
3185cdf0e10cSrcweir String aExtension( rEntry.GetExtension() );
3186cdf0e10cSrcweir
3187cdf0e10cSrcweir if (aBase.Len()>8) // Name > 8?
3188cdf0e10cSrcweir {
3189cdf0e10cSrcweir return sal_True;
3190cdf0e10cSrcweir }
3191cdf0e10cSrcweir
3192cdf0e10cSrcweir if (aExtension.Len()>3) // Extension > 3?
3193cdf0e10cSrcweir {
3194cdf0e10cSrcweir return sal_True;
3195cdf0e10cSrcweir }
3196cdf0e10cSrcweir }
3197cdf0e10cSrcweir return sal_False;
3198cdf0e10cSrcweir }
3199cdf0e10cSrcweir
3200cdf0e10cSrcweir //========================================================================
3201cdf0e10cSrcweir
3202cdf0e10cSrcweir #if defined(DBG_UTIL)
3203cdf0e10cSrcweir
FSysTest()3204cdf0e10cSrcweir void FSysTest()
3205cdf0e10cSrcweir {
3206cdf0e10cSrcweir }
3207cdf0e10cSrcweir
3208cdf0e10cSrcweir #endif
3209cdf0e10cSrcweir
3210