Commit | Line | Data |
---|---|---|
c801d85f KB |
1 | ///////////////////////////////////////////////////////////////////////////// |
2 | // Name: filefn.cpp | |
3 | // Purpose: File- and directory-related functions | |
4 | // Author: Julian Smart | |
5 | // Modified by: | |
6 | // Created: 29/01/98 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) 1998 Julian Smart | |
3f4a0c5b | 9 | // Licence: wxWindows license |
c801d85f KB |
10 | ///////////////////////////////////////////////////////////////////////////// |
11 | ||
e90c1d2a VZ |
12 | // ============================================================================ |
13 | // declarations | |
14 | // ============================================================================ | |
15 | ||
16 | // ---------------------------------------------------------------------------- | |
17 | // headers | |
18 | // ---------------------------------------------------------------------------- | |
19 | ||
c801d85f | 20 | #ifdef __GNUG__ |
7af89395 | 21 | #pragma implementation "filefn.h" |
c801d85f KB |
22 | #endif |
23 | ||
24 | // For compilers that support precompilation, includes "wx.h". | |
25 | #include "wx/wxprec.h" | |
26 | #include "wx/defs.h" | |
27 | ||
28 | #ifdef __BORLANDC__ | |
7af89395 | 29 | #pragma hdrstop |
c801d85f KB |
30 | #endif |
31 | ||
c801d85f | 32 | #include "wx/utils.h" |
3096bd2f | 33 | #include "wx/intl.h" |
32f31043 | 34 | #include "wx/file.h" |
9e8d8607 | 35 | #include "wx/filename.h" |
8ff12342 | 36 | #include "wx/dir.h" |
c801d85f | 37 | |
fd3f686c | 38 | // there are just too many of those... |
3f4a0c5b | 39 | #ifdef __VISUALC__ |
fd3f686c VZ |
40 | #pragma warning(disable:4706) // assignment within conditional expression |
41 | #endif // VC++ | |
42 | ||
c801d85f KB |
43 | #include <ctype.h> |
44 | #include <stdio.h> | |
45 | #include <stdlib.h> | |
46 | #include <string.h> | |
47 | #if !defined(__WATCOMC__) | |
3f4a0c5b VZ |
48 | #if !(defined(_MSC_VER) && (_MSC_VER > 800)) |
49 | #include <errno.h> | |
50 | #endif | |
c801d85f | 51 | #endif |
3f4a0c5b | 52 | |
76a5e5d2 SC |
53 | #if defined(__WXMAC__) |
54 | #include "wx/mac/private.h" // includes mac headers | |
55 | #endif | |
56 | ||
c801d85f | 57 | #include <time.h> |
3f4a0c5b | 58 | |
469e1e5c | 59 | #ifndef __MWERKS__ |
7af89395 VZ |
60 | #include <sys/types.h> |
61 | #include <sys/stat.h> | |
469e1e5c | 62 | #else |
7af89395 VZ |
63 | #include <stat.h> |
64 | #include <unistd.h> | |
5b781a67 | 65 | #include <unix.h> |
469e1e5c | 66 | #endif |
c801d85f | 67 | |
aad5220b | 68 | #ifdef __UNIX__ |
7af89395 VZ |
69 | #include <unistd.h> |
70 | #include <dirent.h> | |
92980e90 | 71 | #include <fcntl.h> |
aad5220b | 72 | #endif |
c801d85f | 73 | |
f6bcfd97 | 74 | #ifdef __WXPM__ |
c2ff79b1 | 75 | #include <process.h> |
f6bcfd97 | 76 | #include "wx/os2/private.h" |
c2ff79b1 | 77 | #endif |
c67d6888 | 78 | #if defined(__WINDOWS__) && !defined(__WXMICROWIN__) |
a3ef5bf5 | 79 | #if !defined( __GNUWIN32__ ) && !defined( __MWERKS__ ) && !defined(__SALFORDC__) |
7af89395 VZ |
80 | #include <direct.h> |
81 | #include <dos.h> | |
32f31043 | 82 | #include <io.h> |
7af89395 VZ |
83 | #endif // __WINDOWS__ |
84 | #endif // native Win compiler | |
c801d85f | 85 | |
b916f809 VS |
86 | #if defined(__DOS__) |
87 | #ifdef __WATCOMC__ | |
88 | #include <direct.h> | |
89 | #include <dos.h> | |
90 | #include <io.h> | |
91 | #endif | |
92 | #ifdef __DJGPP__ | |
93 | #include <unistd.h> | |
94 | #endif | |
f48fa475 VS |
95 | #endif |
96 | ||
c801d85f KB |
97 | #ifdef __BORLANDC__ // Please someone tell me which version of Borland needs |
98 | // this (3.1 I believe) and how to test for it. | |
99 | // If this works for Borland 4.0 as well, then no worries. | |
7af89395 | 100 | #include <dir.h> |
c801d85f KB |
101 | #endif |
102 | ||
a3ef5bf5 | 103 | #ifdef __SALFORDC__ |
7af89395 VZ |
104 | #include <dir.h> |
105 | #include <unix.h> | |
a3ef5bf5 JS |
106 | #endif |
107 | ||
dfcb1ae0 | 108 | #include "wx/setup.h" |
f5abe911 | 109 | #include "wx/log.h" |
99cc00ed | 110 | |
7be1f0d9 JS |
111 | // No, Cygwin doesn't appear to have fnmatch.h after all. |
112 | #if defined(HAVE_FNMATCH_H) | |
7af89395 | 113 | #include "fnmatch.h" |
dfcb1ae0 KB |
114 | #endif |
115 | ||
34138703 | 116 | #ifdef __WINDOWS__ |
659d096c | 117 | #include <windows.h> |
3d5231db | 118 | #include "wx/msw/mslu.h" |
b0091f58 | 119 | |
3ffbc733 VZ |
120 | // sys/cygwin.h is needed for cygwin_conv_to_full_win32_path() |
121 | // | |
122 | // note that it must be included after <windows.h> | |
123 | #ifdef __GNUWIN32__ | |
e02e8816 MB |
124 | #ifdef __CYGWIN__ |
125 | #include <sys/cygwin.h> | |
126 | #endif | |
3ffbc733 VZ |
127 | #include <wchar.h> |
128 | #ifndef __TWIN32__ | |
129 | #include <sys/unistd.h> | |
130 | #endif | |
131 | #endif // __GNUWIN32__ | |
132 | #endif // __WINDOWS__ | |
c801d85f | 133 | |
13b1f8a7 VZ |
134 | // TODO: Borland probably has _wgetcwd as well? |
135 | #ifdef _MSC_VER | |
136 | #define HAVE_WGETCWD | |
137 | #endif | |
138 | ||
e90c1d2a VZ |
139 | // ---------------------------------------------------------------------------- |
140 | // constants | |
141 | // ---------------------------------------------------------------------------- | |
142 | ||
13b1f8a7 VZ |
143 | #ifndef _MAXPATHLEN |
144 | #define _MAXPATHLEN 1024 | |
145 | #endif | |
c801d85f | 146 | |
da2b4b7a GD |
147 | #ifdef __WXMAC__ |
148 | # include "MoreFiles.h" | |
149 | # include "MoreFilesExtras.h" | |
150 | # include "FullPath.h" | |
151 | # include "FSpCompat.h" | |
17dff81c | 152 | #endif |
c801d85f | 153 | |
e90c1d2a VZ |
154 | // ---------------------------------------------------------------------------- |
155 | // private globals | |
156 | // ---------------------------------------------------------------------------- | |
157 | ||
1f1070e2 | 158 | // MT-FIXME: get rid of this horror and all code using it |
e90c1d2a VZ |
159 | static wxChar wxFileFunctionsBuffer[4*_MAXPATHLEN]; |
160 | ||
5d33ed2c DW |
161 | #if defined(__VISAGECPP__) && __IBMCPP__ >= 400 |
162 | // | |
32e768ae | 163 | // VisualAge C++ V4.0 cannot have any external linkage const decs |
5d33ed2c DW |
164 | // in headers included by more than one primary source |
165 | // | |
166 | const off_t wxInvalidOffset = (off_t)-1; | |
167 | #endif | |
168 | ||
a339970a VZ |
169 | // ---------------------------------------------------------------------------- |
170 | // macros | |
171 | // ---------------------------------------------------------------------------- | |
172 | ||
173 | // we need to translate Mac filenames before passing them to OS functions | |
334d2448 | 174 | #define OS_FILENAME(s) (s.fn_str()) |
a339970a | 175 | |
e90c1d2a VZ |
176 | // ============================================================================ |
177 | // implementation | |
178 | // ============================================================================ | |
179 | ||
92980e90 RR |
180 | #ifdef wxNEED_WX_UNISTD_H |
181 | ||
182 | WXDLLEXPORT int wxStat( const wxChar *file_name, wxStructStat *buf ) | |
183 | { | |
184 | return stat( wxConvFile.cWX2MB( file_name ), buf ); | |
185 | } | |
186 | ||
187 | WXDLLEXPORT int wxAccess( const wxChar *pathname, int mode ) | |
188 | { | |
189 | return access( wxConvFile.cWX2MB( pathname ), mode ); | |
190 | } | |
191 | ||
192 | WXDLLEXPORT int wxOpen( const wxChar *pathname, int flags, mode_t mode ) | |
193 | { | |
194 | return open( wxConvFile.cWX2MB( pathname ), flags, mode ); | |
195 | } | |
196 | ||
197 | #endif | |
198 | // wxNEED_WX_UNISTD_H | |
199 | ||
200 | // ---------------------------------------------------------------------------- | |
201 | // wxPathList | |
202 | // ---------------------------------------------------------------------------- | |
203 | ||
204 | IMPLEMENT_DYNAMIC_CLASS(wxPathList, wxStringList) | |
205 | ||
c801d85f KB |
206 | void wxPathList::Add (const wxString& path) |
207 | { | |
50920146 | 208 | wxStringList::Add (WXSTRINGCAST path); |
c801d85f KB |
209 | } |
210 | ||
211 | // Add paths e.g. from the PATH environment variable | |
212 | void wxPathList::AddEnvList (const wxString& envVariable) | |
213 | { | |
50920146 | 214 | static const wxChar PATH_TOKS[] = |
34138703 | 215 | #ifdef __WINDOWS__ |
223d09f6 | 216 | wxT(" ;"); // Don't seperate with colon in DOS (used for drive) |
c801d85f | 217 | #else |
223d09f6 | 218 | wxT(" :;"); |
c801d85f KB |
219 | #endif |
220 | ||
50920146 | 221 | wxChar *val = wxGetenv (WXSTRINGCAST envVariable); |
c801d85f KB |
222 | if (val && *val) |
223 | { | |
50920146 OK |
224 | wxChar *s = copystring (val); |
225 | wxChar *save_ptr, *token = wxStrtok (s, PATH_TOKS, &save_ptr); | |
c801d85f KB |
226 | |
227 | if (token) | |
a17e237f | 228 | { |
3f4a0c5b VZ |
229 | Add (copystring (token)); |
230 | while (token) | |
a17e237f | 231 | { |
50920146 | 232 | if ((token = wxStrtok ((wxChar *) NULL, PATH_TOKS, &save_ptr)) != NULL) |
a17e237f VZ |
233 | Add (wxString(token)); |
234 | } | |
235 | } | |
236 | ||
237 | // suppress warning about unused variable save_ptr when wxStrtok() is a | |
238 | // macro which throws away its third argument | |
239 | save_ptr = token; | |
240 | ||
241 | delete [] s; | |
c801d85f KB |
242 | } |
243 | } | |
244 | ||
245 | // Given a full filename (with path), ensure that that file can | |
246 | // be accessed again USING FILENAME ONLY by adding the path | |
247 | // to the list if not already there. | |
248 | void wxPathList::EnsureFileAccessible (const wxString& path) | |
249 | { | |
7af89395 VZ |
250 | wxString path_only(wxPathOnly(path)); |
251 | if ( !path_only.IsEmpty() ) | |
252 | { | |
253 | if ( !Member(path_only) ) | |
254 | Add(path_only); | |
255 | } | |
c801d85f KB |
256 | } |
257 | ||
258 | bool wxPathList::Member (const wxString& path) | |
259 | { | |
260 | for (wxNode * node = First (); node != NULL; node = node->Next ()) | |
261 | { | |
50920146 | 262 | wxString path2((wxChar *) node->Data ()); |
c801d85f | 263 | if ( |
17dff81c | 264 | #if defined(__WINDOWS__) || defined(__VMS__) || defined (__WXMAC__) |
c801d85f | 265 | // Case INDEPENDENT |
3f4a0c5b | 266 | path.CompareTo (path2, wxString::ignoreCase) == 0 |
c801d85f | 267 | #else |
3f4a0c5b VZ |
268 | // Case sensitive File System |
269 | path.CompareTo (path2) == 0 | |
c801d85f | 270 | #endif |
3f4a0c5b VZ |
271 | ) |
272 | return TRUE; | |
c801d85f KB |
273 | } |
274 | return FALSE; | |
275 | } | |
276 | ||
277 | wxString wxPathList::FindValidPath (const wxString& file) | |
278 | { | |
e90c1d2a VZ |
279 | if (wxFileExists (wxExpandPath(wxFileFunctionsBuffer, file))) |
280 | return wxString(wxFileFunctionsBuffer); | |
c801d85f | 281 | |
50920146 | 282 | wxChar buf[_MAXPATHLEN]; |
e90c1d2a | 283 | wxStrcpy(buf, wxFileFunctionsBuffer); |
c801d85f | 284 | |
50920146 OK |
285 | wxChar *filename = (wxChar*) NULL; /* shut up buggy egcs warning */ |
286 | filename = IsAbsolutePath (buf) ? wxFileNameFromPath (buf) : (wxChar *)buf; | |
c801d85f KB |
287 | |
288 | for (wxNode * node = First (); node; node = node->Next ()) | |
289 | { | |
50920146 | 290 | wxChar *path = (wxChar *) node->Data (); |
e90c1d2a VZ |
291 | wxStrcpy (wxFileFunctionsBuffer, path); |
292 | wxChar ch = wxFileFunctionsBuffer[wxStrlen(wxFileFunctionsBuffer)-1]; | |
223d09f6 KB |
293 | if (ch != wxT('\\') && ch != wxT('/')) |
294 | wxStrcat (wxFileFunctionsBuffer, wxT("/")); | |
e90c1d2a | 295 | wxStrcat (wxFileFunctionsBuffer, filename); |
34138703 | 296 | #ifdef __WINDOWS__ |
e90c1d2a | 297 | Unix2DosFilename (wxFileFunctionsBuffer); |
c801d85f | 298 | #endif |
e90c1d2a | 299 | if (wxFileExists (wxFileFunctionsBuffer)) |
c801d85f | 300 | { |
e90c1d2a | 301 | return wxString(wxFileFunctionsBuffer); // Found! |
c801d85f | 302 | } |
3f4a0c5b | 303 | } // for() |
c801d85f | 304 | |
223d09f6 | 305 | return wxString(wxT("")); // Not found |
c801d85f KB |
306 | } |
307 | ||
308 | wxString wxPathList::FindAbsoluteValidPath (const wxString& file) | |
309 | { | |
e90c1d2a VZ |
310 | wxString f = FindValidPath(file); |
311 | if ( wxIsAbsolutePath(f) ) | |
312 | return f; | |
313 | ||
314 | wxString buf; | |
13b1f8a7 VZ |
315 | wxGetWorkingDirectory(wxStringBuffer(buf, _MAXPATHLEN), _MAXPATHLEN); |
316 | ||
e90c1d2a | 317 | if ( !wxEndsWithPathSeparator(buf) ) |
c801d85f | 318 | { |
e90c1d2a | 319 | buf += wxFILE_SEP_PATH; |
c801d85f | 320 | } |
e90c1d2a VZ |
321 | buf += f; |
322 | ||
323 | return buf; | |
c801d85f KB |
324 | } |
325 | ||
3f4a0c5b | 326 | bool |
c801d85f KB |
327 | wxFileExists (const wxString& filename) |
328 | { | |
2db300c6 | 329 | #if defined(__WIN32__) && !defined(__WXMICROWIN__) |
e32d659d | 330 | // GetFileAttributes can copy with network paths unlike stat() |
2db300c6 | 331 | DWORD ret = ::GetFileAttributes(filename); |
2db300c6 | 332 | |
a28ae409 | 333 | return (ret != (DWORD)-1) && !(ret & FILE_ATTRIBUTE_DIRECTORY); |
6b037754 | 334 | #else |
a339970a | 335 | wxStructStat stbuf; |
92980e90 | 336 | if ( !filename.empty() && wxStat( filename, &stbuf) == 0 ) |
a339970a | 337 | return TRUE; |
a3ef5bf5 | 338 | |
a339970a | 339 | return FALSE; |
6b037754 | 340 | #endif |
c801d85f KB |
341 | } |
342 | ||
3f4a0c5b | 343 | bool |
c801d85f KB |
344 | wxIsAbsolutePath (const wxString& filename) |
345 | { | |
2985ad5d RR |
346 | if (filename != wxT("")) |
347 | { | |
e8e1d09e GD |
348 | #if defined(__WXMAC__) && !defined(__DARWIN__) |
349 | // Classic or Carbon CodeWarrior like | |
350 | // Carbon with Apple DevTools is Unix like | |
2db300c6 | 351 | |
2985ad5d RR |
352 | // This seems wrong to me, but there is no fix. since |
353 | // "MacOS:MyText.txt" is absolute whereas "MyDir:MyText.txt" | |
354 | // is not. Or maybe ":MyDir:MyText.txt" has to be used? RR. | |
2985ad5d RR |
355 | if (filename.Find(':') != wxNOT_FOUND && filename[0] != ':') |
356 | return TRUE ; | |
cd378f94 | 357 | #else |
e8e1d09e GD |
358 | // Unix like or Windows |
359 | if (filename[0] == wxT('/')) | |
360 | return TRUE; | |
361 | #endif | |
c801d85f | 362 | #ifdef __VMS__ |
e8e1d09e GD |
363 | if ((filename[0] == wxT('[') && filename[1] != wxT('.'))) |
364 | return TRUE; | |
c801d85f | 365 | #endif |
34138703 | 366 | #ifdef __WINDOWS__ |
e8e1d09e GD |
367 | // MSDOS like |
368 | if (filename[0] == wxT('\\') || (wxIsalpha (filename[0]) && filename[1] == wxT(':'))) | |
369 | return TRUE; | |
c801d85f | 370 | #endif |
c801d85f | 371 | } |
e8e1d09e | 372 | return FALSE ; |
c801d85f KB |
373 | } |
374 | ||
375 | /* | |
376 | * Strip off any extension (dot something) from end of file, | |
377 | * IF one exists. Inserts zero into buffer. | |
378 | * | |
379 | */ | |
3f4a0c5b | 380 | |
50920146 | 381 | void wxStripExtension(wxChar *buffer) |
c801d85f | 382 | { |
50920146 | 383 | int len = wxStrlen(buffer); |
c801d85f KB |
384 | int i = len-1; |
385 | while (i > 0) | |
386 | { | |
223d09f6 | 387 | if (buffer[i] == wxT('.')) |
c801d85f KB |
388 | { |
389 | buffer[i] = 0; | |
390 | break; | |
391 | } | |
392 | i --; | |
393 | } | |
394 | } | |
395 | ||
47fa7969 JS |
396 | void wxStripExtension(wxString& buffer) |
397 | { | |
398 | size_t len = buffer.Length(); | |
399 | size_t i = len-1; | |
400 | while (i > 0) | |
401 | { | |
223d09f6 | 402 | if (buffer.GetChar(i) == wxT('.')) |
47fa7969 JS |
403 | { |
404 | buffer = buffer.Left(i); | |
405 | break; | |
406 | } | |
407 | i --; | |
408 | } | |
409 | } | |
410 | ||
c801d85f | 411 | // Destructive removal of /./ and /../ stuff |
50920146 | 412 | wxChar *wxRealPath (wxChar *path) |
c801d85f | 413 | { |
2049ba38 | 414 | #ifdef __WXMSW__ |
223d09f6 | 415 | static const wxChar SEP = wxT('\\'); |
c801d85f KB |
416 | Unix2DosFilename(path); |
417 | #else | |
223d09f6 | 418 | static const wxChar SEP = wxT('/'); |
c801d85f KB |
419 | #endif |
420 | if (path[0] && path[1]) { | |
421 | /* MATTHEW: special case "/./x" */ | |
50920146 | 422 | wxChar *p; |
223d09f6 | 423 | if (path[2] == SEP && path[1] == wxT('.')) |
c801d85f KB |
424 | p = &path[0]; |
425 | else | |
426 | p = &path[2]; | |
427 | for (; *p; p++) | |
428 | { | |
3f4a0c5b VZ |
429 | if (*p == SEP) |
430 | { | |
223d09f6 | 431 | if (p[1] == wxT('.') && p[2] == wxT('.') && (p[3] == SEP || p[3] == wxT('\0'))) |
3f4a0c5b | 432 | { |
50920146 | 433 | wxChar *q; |
3f4a0c5b | 434 | for (q = p - 1; q >= path && *q != SEP; q--); |
223d09f6 | 435 | if (q[0] == SEP && (q[1] != wxT('.') || q[2] != wxT('.') || q[3] != SEP) |
3f4a0c5b VZ |
436 | && (q - 1 <= path || q[-1] != SEP)) |
437 | { | |
50920146 | 438 | wxStrcpy (q, p + 3); |
223d09f6 | 439 | if (path[0] == wxT('\0')) |
3f4a0c5b VZ |
440 | { |
441 | path[0] = SEP; | |
223d09f6 | 442 | path[1] = wxT('\0'); |
3f4a0c5b | 443 | } |
2049ba38 | 444 | #ifdef __WXMSW__ |
3f4a0c5b | 445 | /* Check that path[2] is NULL! */ |
223d09f6 | 446 | else if (path[1] == wxT(':') && !path[2]) |
3f4a0c5b VZ |
447 | { |
448 | path[2] = SEP; | |
223d09f6 | 449 | path[3] = wxT('\0'); |
3f4a0c5b VZ |
450 | } |
451 | #endif | |
452 | p = q - 1; | |
453 | } | |
454 | } | |
223d09f6 | 455 | else if (p[1] == wxT('.') && (p[2] == SEP || p[2] == wxT('\0'))) |
50920146 | 456 | wxStrcpy (p, p + 2); |
3f4a0c5b | 457 | } |
c801d85f KB |
458 | } |
459 | } | |
460 | return path; | |
461 | } | |
462 | ||
463 | // Must be destroyed | |
50920146 | 464 | wxChar *wxCopyAbsolutePath(const wxString& filename) |
c801d85f | 465 | { |
223d09f6 | 466 | if (filename == wxT("")) |
50920146 | 467 | return (wxChar *) NULL; |
c801d85f | 468 | |
e90c1d2a | 469 | if (! IsAbsolutePath(wxExpandPath(wxFileFunctionsBuffer, filename))) { |
50920146 | 470 | wxChar buf[_MAXPATHLEN]; |
223d09f6 | 471 | buf[0] = wxT('\0'); |
7af89395 | 472 | wxGetWorkingDirectory(buf, WXSIZEOF(buf)); |
50920146 | 473 | wxChar ch = buf[wxStrlen(buf) - 1]; |
2049ba38 | 474 | #ifdef __WXMSW__ |
223d09f6 KB |
475 | if (ch != wxT('\\') && ch != wxT('/')) |
476 | wxStrcat(buf, wxT("\\")); | |
c801d85f | 477 | #else |
223d09f6 KB |
478 | if (ch != wxT('/')) |
479 | wxStrcat(buf, wxT("/")); | |
c801d85f | 480 | #endif |
e90c1d2a | 481 | wxStrcat(buf, wxFileFunctionsBuffer); |
c801d85f KB |
482 | return copystring( wxRealPath(buf) ); |
483 | } | |
e90c1d2a | 484 | return copystring( wxFileFunctionsBuffer ); |
c801d85f KB |
485 | } |
486 | ||
487 | /*- | |
488 | Handles: | |
489 | ~/ => home dir | |
490 | ~user/ => user's home dir | |
491 | If the environment variable a = "foo" and b = "bar" then: | |
492 | Unix: | |
3f4a0c5b VZ |
493 | $a => foo |
494 | $a$b => foobar | |
495 | $a.c => foo.c | |
496 | xxx$a => xxxfoo | |
497 | ${a}! => foo! | |
498 | $(b)! => bar! | |
499 | \$a => \$a | |
c801d85f | 500 | MSDOS: |
3f4a0c5b VZ |
501 | $a ==> $a |
502 | $(a) ==> foo | |
503 | $(a)$b ==> foo$b | |
504 | $(a)$(b)==> foobar | |
505 | test.$$ ==> test.$$ | |
c801d85f KB |
506 | */ |
507 | ||
508 | /* input name in name, pathname output to buf. */ | |
509 | ||
50920146 | 510 | wxChar *wxExpandPath(wxChar *buf, const wxChar *name) |
c801d85f | 511 | { |
50920146 OK |
512 | register wxChar *d, *s, *nm; |
513 | wxChar lnm[_MAXPATHLEN]; | |
33ac7e6f | 514 | int q; |
c801d85f KB |
515 | |
516 | // Some compilers don't like this line. | |
223d09f6 | 517 | // const wxChar trimchars[] = wxT("\n \t"); |
c801d85f | 518 | |
50920146 | 519 | wxChar trimchars[4]; |
223d09f6 KB |
520 | trimchars[0] = wxT('\n'); |
521 | trimchars[1] = wxT(' '); | |
522 | trimchars[2] = wxT('\t'); | |
c801d85f KB |
523 | trimchars[3] = 0; |
524 | ||
2049ba38 | 525 | #ifdef __WXMSW__ |
223d09f6 | 526 | const wxChar SEP = wxT('\\'); |
c801d85f | 527 | #else |
223d09f6 | 528 | const wxChar SEP = wxT('/'); |
c801d85f | 529 | #endif |
223d09f6 KB |
530 | buf[0] = wxT('\0'); |
531 | if (name == NULL || *name == wxT('\0')) | |
3f4a0c5b | 532 | return buf; |
c801d85f | 533 | nm = copystring(name); // Make a scratch copy |
50920146 | 534 | wxChar *nm_tmp = nm; |
c801d85f KB |
535 | |
536 | /* Skip leading whitespace and cr */ | |
50920146 | 537 | while (wxStrchr((wxChar *)trimchars, *nm) != NULL) |
3f4a0c5b | 538 | nm++; |
c801d85f | 539 | /* And strip off trailing whitespace and cr */ |
50920146 OK |
540 | s = nm + (q = wxStrlen(nm)) - 1; |
541 | while (q-- && wxStrchr((wxChar *)trimchars, *s) != NULL) | |
223d09f6 | 542 | *s = wxT('\0'); |
c801d85f KB |
543 | |
544 | s = nm; | |
545 | d = lnm; | |
2049ba38 | 546 | #ifdef __WXMSW__ |
c801d85f KB |
547 | q = FALSE; |
548 | #else | |
223d09f6 | 549 | q = nm[0] == wxT('\\') && nm[1] == wxT('~'); |
c801d85f KB |
550 | #endif |
551 | ||
552 | /* Expand inline environment variables */ | |
c2ff79b1 DW |
553 | #ifdef __VISAGECPP__ |
554 | while (*d) | |
555 | { | |
556 | *d++ = *s; | |
223d09f6 | 557 | if(*s == wxT('\\')) |
c2ff79b1 DW |
558 | { |
559 | *(d - 1) = *++s; | |
560 | if (*d) | |
561 | { | |
562 | s++; | |
563 | continue; | |
564 | } | |
565 | else | |
566 | break; | |
567 | } | |
568 | else | |
569 | #else | |
22394d24 | 570 | while ((*d++ = *s) != 0) { |
c2ff79b1 | 571 | # ifndef __WXMSW__ |
223d09f6 | 572 | if (*s == wxT('\\')) { |
3f4a0c5b VZ |
573 | if ((*(d - 1) = *++s)) { |
574 | s++; | |
575 | continue; | |
576 | } else | |
577 | break; | |
578 | } else | |
c2ff79b1 | 579 | # endif |
c801d85f | 580 | #endif |
2049ba38 | 581 | #ifdef __WXMSW__ |
223d09f6 | 582 | if (*s++ == wxT('$') && (*s == wxT('{') || *s == wxT(')'))) |
c801d85f | 583 | #else |
223d09f6 | 584 | if (*s++ == wxT('$')) |
3f4a0c5b VZ |
585 | #endif |
586 | { | |
50920146 | 587 | register wxChar *start = d; |
223d09f6 | 588 | register int braces = (*s == wxT('{') || *s == wxT('(')); |
50920146 | 589 | register wxChar *value; |
22394d24 | 590 | while ((*d++ = *s) != 0) |
223d09f6 | 591 | if (braces ? (*s == wxT('}') || *s == wxT(')')) : !(wxIsalnum(*s) || *s == wxT('_')) ) |
3f4a0c5b VZ |
592 | break; |
593 | else | |
594 | s++; | |
595 | *--d = 0; | |
50920146 | 596 | value = wxGetenv(braces ? start + 1 : start); |
3f4a0c5b | 597 | if (value) { |
22394d24 | 598 | for ((d = start - 1); (*d++ = *value++) != 0;); |
3f4a0c5b VZ |
599 | d--; |
600 | if (braces && *s) | |
601 | s++; | |
602 | } | |
603 | } | |
c801d85f KB |
604 | } |
605 | ||
606 | /* Expand ~ and ~user */ | |
607 | nm = lnm; | |
223d09f6 | 608 | if (nm[0] == wxT('~') && !q) |
c801d85f | 609 | { |
3f4a0c5b VZ |
610 | /* prefix ~ */ |
611 | if (nm[1] == SEP || nm[1] == 0) | |
612 | { /* ~/filename */ | |
f6bcfd97 | 613 | // FIXME: wxGetUserHome could return temporary storage in Unicode mode |
223d09f6 | 614 | if ((s = WXSTRINGCAST wxGetUserHome(wxT(""))) != NULL) { |
3f4a0c5b VZ |
615 | if (*++nm) |
616 | nm++; | |
617 | } | |
c801d85f | 618 | } else |
3f4a0c5b | 619 | { /* ~user/filename */ |
50920146 OK |
620 | register wxChar *nnm; |
621 | register wxChar *home; | |
3f4a0c5b VZ |
622 | for (s = nm; *s && *s != SEP; s++); |
623 | int was_sep; /* MATTHEW: Was there a separator, or NULL? */ | |
c801d85f | 624 | was_sep = (*s == SEP); |
3f4a0c5b VZ |
625 | nnm = *s ? s + 1 : s; |
626 | *s = 0; | |
f6bcfd97 | 627 | // FIXME: wxGetUserHome could return temporary storage in Unicode mode |
0e6667e2 | 628 | if ((home = WXSTRINGCAST wxGetUserHome(wxString(nm + 1))) == NULL) { |
c801d85f | 629 | if (was_sep) /* replace only if it was there: */ |
3f4a0c5b | 630 | *s = SEP; |
295272bd | 631 | s = NULL; |
3f4a0c5b VZ |
632 | } else { |
633 | nm = nnm; | |
634 | s = home; | |
635 | } | |
636 | } | |
c801d85f KB |
637 | } |
638 | ||
639 | d = buf; | |
640 | if (s && *s) { /* MATTHEW: s could be NULL if user '~' didn't exist */ | |
3f4a0c5b | 641 | /* Copy home dir */ |
223d09f6 | 642 | while (wxT('\0') != (*d++ = *s++)) |
3f4a0c5b VZ |
643 | /* loop */; |
644 | // Handle root home | |
645 | if (d - 1 > buf && *(d - 2) != SEP) | |
646 | *(d - 1) = SEP; | |
c801d85f KB |
647 | } |
648 | s = nm; | |
22394d24 | 649 | while ((*d++ = *s++) != 0); |
c801d85f KB |
650 | delete[] nm_tmp; // clean up alloc |
651 | /* Now clean up the buffer */ | |
652 | return wxRealPath(buf); | |
653 | } | |
654 | ||
c801d85f KB |
655 | /* Contract Paths to be build upon an environment variable |
656 | component: | |
657 | ||
658 | example: "/usr/openwin/lib", OPENWINHOME --> ${OPENWINHOME}/lib | |
659 | ||
660 | The call wxExpandPath can convert these back! | |
661 | */ | |
50920146 | 662 | wxChar * |
c801d85f KB |
663 | wxContractPath (const wxString& filename, const wxString& envname, const wxString& user) |
664 | { | |
50920146 | 665 | static wxChar dest[_MAXPATHLEN]; |
c801d85f | 666 | |
223d09f6 | 667 | if (filename == wxT("")) |
50920146 | 668 | return (wxChar *) NULL; |
c801d85f | 669 | |
50920146 | 670 | wxStrcpy (dest, WXSTRINGCAST filename); |
2049ba38 | 671 | #ifdef __WXMSW__ |
c801d85f KB |
672 | Unix2DosFilename(dest); |
673 | #endif | |
674 | ||
675 | // Handle environment | |
0e6667e2 | 676 | const wxChar *val = (const wxChar *) NULL; |
50920146 OK |
677 | wxChar *tcp = (wxChar *) NULL; |
678 | if (envname != WXSTRINGCAST NULL && (val = wxGetenv (WXSTRINGCAST envname)) != NULL && | |
679 | (tcp = wxStrstr (dest, val)) != NULL) | |
c801d85f | 680 | { |
e90c1d2a | 681 | wxStrcpy (wxFileFunctionsBuffer, tcp + wxStrlen (val)); |
223d09f6 KB |
682 | *tcp++ = wxT('$'); |
683 | *tcp++ = wxT('{'); | |
50920146 | 684 | wxStrcpy (tcp, WXSTRINGCAST envname); |
223d09f6 | 685 | wxStrcat (tcp, wxT("}")); |
e90c1d2a | 686 | wxStrcat (tcp, wxFileFunctionsBuffer); |
c801d85f KB |
687 | } |
688 | ||
689 | // Handle User's home (ignore root homes!) | |
690 | size_t len = 0; | |
691 | if ((val = wxGetUserHome (user)) != NULL && | |
50920146 OK |
692 | (len = wxStrlen(val)) > 2 && |
693 | wxStrncmp(dest, val, len) == 0) | |
c801d85f | 694 | { |
223d09f6 KB |
695 | wxStrcpy(wxFileFunctionsBuffer, wxT("~")); |
696 | if (user != wxT("")) | |
e90c1d2a | 697 | wxStrcat(wxFileFunctionsBuffer, (const wxChar*) user); |
e90c1d2a VZ |
698 | wxStrcat(wxFileFunctionsBuffer, dest + len); |
699 | wxStrcpy (dest, wxFileFunctionsBuffer); | |
c801d85f KB |
700 | } |
701 | ||
702 | return dest; | |
703 | } | |
704 | ||
1f1070e2 | 705 | // Return just the filename, not the path (basename) |
50920146 | 706 | wxChar *wxFileNameFromPath (wxChar *path) |
c801d85f | 707 | { |
1f1070e2 VZ |
708 | wxString p = path; |
709 | wxString n = wxFileNameFromPath(p); | |
2db300c6 | 710 | |
1f1070e2 | 711 | return path + p.length() - n.length(); |
c801d85f KB |
712 | } |
713 | ||
1f1070e2 | 714 | wxString wxFileNameFromPath (const wxString& path) |
c801d85f | 715 | { |
1f1070e2 VZ |
716 | wxString name, ext; |
717 | wxFileName::SplitPath(path, NULL, &name, &ext); | |
2db300c6 | 718 | |
1f1070e2 VZ |
719 | wxString fullname = name; |
720 | if ( !ext.empty() ) | |
721 | { | |
722 | fullname << wxFILE_SEP_EXT << ext; | |
c801d85f | 723 | } |
1f1070e2 VZ |
724 | |
725 | return fullname; | |
c801d85f KB |
726 | } |
727 | ||
728 | // Return just the directory, or NULL if no directory | |
50920146 OK |
729 | wxChar * |
730 | wxPathOnly (wxChar *path) | |
c801d85f | 731 | { |
e8e1d09e | 732 | if (path && *path) |
c801d85f | 733 | { |
e8e1d09e | 734 | static wxChar buf[_MAXPATHLEN]; |
2db300c6 | 735 | |
e8e1d09e GD |
736 | // Local copy |
737 | wxStrcpy (buf, path); | |
2db300c6 | 738 | |
e8e1d09e GD |
739 | int l = wxStrlen(path); |
740 | int i = l - 1; | |
2db300c6 | 741 | |
e8e1d09e GD |
742 | // Search backward for a backward or forward slash |
743 | while (i > -1) | |
744 | { | |
745 | #if defined(__WXMAC__) && !defined(__DARWIN__) | |
746 | // Classic or Carbon CodeWarrior like | |
747 | // Carbon with Apple DevTools is Unix like | |
748 | if (path[i] == wxT(':') ) | |
749 | { | |
750 | buf[i] = 0; | |
751 | return buf; | |
752 | } | |
bedaf53e | 753 | #else |
e8e1d09e GD |
754 | // Unix like or Windows |
755 | if (path[i] == wxT('/') || path[i] == wxT('\\')) | |
756 | { | |
757 | buf[i] = 0; | |
758 | return buf; | |
759 | } | |
bedaf53e | 760 | #endif |
c801d85f | 761 | #ifdef __VMS__ |
e8e1d09e GD |
762 | if (path[i] == wxT(']')) |
763 | { | |
764 | buf[i+1] = 0; | |
765 | return buf; | |
766 | } | |
a339970a | 767 | #endif |
e8e1d09e | 768 | i --; |
c801d85f | 769 | } |
2db300c6 | 770 | |
c2ff79b1 | 771 | #if defined(__WXMSW__) || defined(__WXPM__) |
e8e1d09e GD |
772 | // Try Drive specifier |
773 | if (wxIsalpha (buf[0]) && buf[1] == wxT(':')) | |
3f4a0c5b | 774 | { |
e8e1d09e GD |
775 | // A:junk --> A:. (since A:.\junk Not A:\junk) |
776 | buf[2] = wxT('.'); | |
777 | buf[3] = wxT('\0'); | |
778 | return buf; | |
3f4a0c5b | 779 | } |
c801d85f KB |
780 | #endif |
781 | } | |
e8e1d09e | 782 | return (wxChar *) NULL; |
c801d85f KB |
783 | } |
784 | ||
785 | // Return just the directory, or NULL if no directory | |
786 | wxString wxPathOnly (const wxString& path) | |
787 | { | |
e8e1d09e | 788 | if (path != wxT("")) |
c801d85f | 789 | { |
e8e1d09e | 790 | wxChar buf[_MAXPATHLEN]; |
2db300c6 | 791 | |
e8e1d09e GD |
792 | // Local copy |
793 | wxStrcpy (buf, WXSTRINGCAST path); | |
2db300c6 | 794 | |
e8e1d09e GD |
795 | int l = path.Length(); |
796 | int i = l - 1; | |
797 | ||
798 | // Search backward for a backward or forward slash | |
799 | while (i > -1) | |
800 | { | |
801 | #if defined(__WXMAC__) && !defined(__DARWIN__) | |
802 | // Classic or Carbon CodeWarrior like | |
803 | // Carbon with Apple DevTools is Unix like | |
804 | if (path[i] == wxT(':') ) | |
805 | { | |
806 | buf[i] = 0; | |
807 | return wxString(buf); | |
808 | } | |
bedaf53e | 809 | #else |
e8e1d09e GD |
810 | // Unix like or Windows |
811 | if (path[i] == wxT('/') || path[i] == wxT('\\')) | |
812 | { | |
813 | buf[i] = 0; | |
814 | return wxString(buf); | |
815 | } | |
bedaf53e | 816 | #endif |
c801d85f | 817 | #ifdef __VMS__ |
e8e1d09e GD |
818 | if (path[i] == wxT(']')) |
819 | { | |
820 | buf[i+1] = 0; | |
821 | return wxString(buf); | |
822 | } | |
a339970a | 823 | #endif |
e8e1d09e | 824 | i --; |
c801d85f | 825 | } |
2db300c6 | 826 | |
c2ff79b1 | 827 | #if defined(__WXMSW__) || defined(__WXPM__) |
e8e1d09e GD |
828 | // Try Drive specifier |
829 | if (wxIsalpha (buf[0]) && buf[1] == wxT(':')) | |
3f4a0c5b | 830 | { |
e8e1d09e GD |
831 | // A:junk --> A:. (since A:.\junk Not A:\junk) |
832 | buf[2] = wxT('.'); | |
833 | buf[3] = wxT('\0'); | |
834 | return wxString(buf); | |
3f4a0c5b | 835 | } |
c801d85f KB |
836 | #endif |
837 | } | |
e8e1d09e | 838 | return wxString(wxT("")); |
c801d85f KB |
839 | } |
840 | ||
841 | // Utility for converting delimiters in DOS filenames to UNIX style | |
842 | // and back again - or we get nasty problems with delimiters. | |
843 | // Also, convert to lower case, since case is significant in UNIX. | |
844 | ||
da2b4b7a | 845 | #if defined(__WXMAC__) |
bedaf53e SC |
846 | wxString wxMacFSSpec2MacFilename( const FSSpec *spec ) |
847 | { | |
a1c34a78 | 848 | #ifdef __DARWIN__ |
8372d79d GD |
849 | int i; |
850 | int j; | |
851 | OSErr theErr; | |
852 | OSStatus theStatus; | |
853 | Boolean isDirectory = false; | |
854 | Str255 theParentPath = "\p"; | |
855 | FSSpec theParentSpec; | |
856 | FSRef theParentRef; | |
857 | char theFileName[FILENAME_MAX]; | |
858 | char thePath[FILENAME_MAX]; | |
859 | ||
860 | strcpy(thePath, ""); | |
861 | ||
862 | // GD: Separate file name from path and make a FSRef to the parent | |
863 | // directory. This is necessary since FSRefs cannot reference files | |
864 | // that have not yet been created. | |
865 | // Based on example code from Apple Technical Note TN2022 | |
866 | // http://developer.apple.com/technotes/tn/tn2022.html | |
867 | ||
868 | // check whether we are converting a directory | |
869 | isDirectory = ((spec->name)[spec->name[0]] == ':'); | |
870 | // count length of file name | |
871 | for (i = spec->name[0] - (isDirectory ? 1 : 0); ((spec->name[i] != ':') && (i > 0)); i--); | |
872 | // copy file name | |
873 | // prepend path separator since it will later be appended to the path | |
874 | theFileName[0] = wxFILE_SEP_PATH; | |
875 | for (j = i + 1; j <= spec->name[0] - (isDirectory ? 1 : 0); j++) { | |
876 | theFileName[j - i] = spec->name[j]; | |
877 | } | |
878 | theFileName[j - i] = '\0'; | |
879 | // copy path if any | |
880 | for (j = 1; j <= i; j++) { | |
881 | theParentPath[++theParentPath[0]] = spec->name[j]; | |
882 | } | |
883 | theErr = FSMakeFSSpec(spec->vRefNum, spec->parID, theParentPath, &theParentSpec); | |
884 | if (theErr == noErr) { | |
885 | // convert the FSSpec to an FSRef | |
886 | theErr = FSpMakeFSRef(&theParentSpec, &theParentRef); | |
887 | } | |
888 | if (theErr == noErr) { | |
889 | // get the POSIX path associated with the FSRef | |
890 | theStatus = FSRefMakePath(&theParentRef, | |
891 | (UInt8 *)thePath, sizeof(thePath)); | |
892 | } | |
893 | if (theStatus == noErr) { | |
894 | // append file name to path | |
895 | // includes previously prepended path separator | |
896 | strcat(thePath, theFileName); | |
897 | } | |
b0091f58 | 898 | |
a1c34a78 GD |
899 | // create path string for return value |
900 | wxString result( thePath ) ; | |
901 | #else | |
bedaf53e SC |
902 | Handle myPath ; |
903 | short length ; | |
904 | ||
a1c34a78 | 905 | // get length of path and allocate handle |
bedaf53e SC |
906 | FSpGetFullPath( spec , &length , &myPath ) ; |
907 | ::SetHandleSize( myPath , length + 1 ) ; | |
908 | ::HLock( myPath ) ; | |
909 | (*myPath)[length] = 0 ; | |
a1c34a78 | 910 | if ((length > 0) && ((*myPath)[length-1] == ':')) |
bedaf53e | 911 | (*myPath)[length-1] = 0 ; |
2db300c6 | 912 | |
a1c34a78 | 913 | // create path string for return value |
334d2448 | 914 | wxString result( (char*) *myPath ) ; |
a1c34a78 GD |
915 | |
916 | // free allocated handle | |
bedaf53e SC |
917 | ::HUnlock( myPath ) ; |
918 | ::DisposeHandle( myPath ) ; | |
a1c34a78 GD |
919 | #endif |
920 | ||
bedaf53e SC |
921 | return result ; |
922 | } | |
e7549107 | 923 | |
bedaf53e SC |
924 | void wxMacFilename2FSSpec( const char *path , FSSpec *spec ) |
925 | { | |
334d2448 | 926 | #ifdef __DARWIN__ |
a1c34a78 GD |
927 | FSRef theRef; |
928 | ||
929 | // get the FSRef associated with the POSIX path | |
930 | (void) FSPathMakeRef((const UInt8 *) path, &theRef, NULL); | |
931 | // convert the FSRef to an FSSpec | |
932 | (void) FSGetCatalogInfo(&theRef, kFSCatInfoNone, NULL, NULL, spec, NULL); | |
334d2448 GD |
933 | #else |
934 | FSpLocationFromFullPath( strlen(path) , path , spec ) ; | |
935 | #endif | |
bedaf53e SC |
936 | } |
937 | ||
a1c34a78 GD |
938 | #ifndef __DARWIN__ |
939 | // Mac file names are POSIX (Unix style) under Darwin | |
940 | // therefore the conversion functions below are not needed | |
941 | ||
e7549107 SC |
942 | static char sMacFileNameConversion[ 1000 ] ; |
943 | ||
944 | wxString wxMac2UnixFilename (const char *str) | |
17dff81c | 945 | { |
f6bcfd97 BP |
946 | char *s = sMacFileNameConversion ; |
947 | strcpy( s , str ) ; | |
a1c34a78 GD |
948 | if (s) |
949 | { | |
950 | memmove( s+1 , s ,strlen( s ) + 1) ; | |
951 | if ( *s == ':' ) | |
e7549107 | 952 | *s = '.' ; |
a1c34a78 | 953 | else |
e7549107 | 954 | *s = '/' ; |
2db300c6 | 955 | |
a1c34a78 GD |
956 | while (*s) |
957 | { | |
e7549107 | 958 | if (*s == ':') |
a1c34a78 | 959 | *s = '/'; |
e7549107 | 960 | else |
a1c34a78 | 961 | *s = wxTolower(*s); // Case INDEPENDENT |
e7549107 | 962 | s++; |
a1c34a78 | 963 | } |
e7549107 | 964 | } |
a1c34a78 | 965 | return wxString(sMacFileNameConversion) ; |
17dff81c SC |
966 | } |
967 | ||
e7549107 | 968 | wxString wxUnix2MacFilename (const char *str) |
17dff81c | 969 | { |
f6bcfd97 BP |
970 | char *s = sMacFileNameConversion ; |
971 | strcpy( s , str ) ; | |
a1c34a78 | 972 | if (s) |
e7549107 | 973 | { |
a1c34a78 GD |
974 | if ( *s == '.' ) |
975 | { | |
976 | // relative path , since it goes on with slash which is translated to a : | |
977 | memmove( s , s+1 ,strlen( s ) ) ; | |
978 | } | |
979 | else if ( *s == '/' ) | |
980 | { | |
981 | // absolute path -> on mac just start with the drive name | |
982 | memmove( s , s+1 ,strlen( s ) ) ; | |
983 | } | |
984 | else | |
985 | { | |
986 | wxASSERT_MSG( 1 , "unkown path beginning" ) ; | |
987 | } | |
988 | while (*s) | |
989 | { | |
990 | if (*s == '/' || *s == '\\') | |
991 | { | |
992 | // convert any back-directory situations | |
993 | if ( *(s+1) == '.' && *(s+2) == '.' && ( (*(s+3) == '/' || *(s+3) == '\\') ) ) | |
994 | { | |
995 | *s = ':'; | |
996 | memmove( s+1 , s+3 ,strlen( s+3 ) + 1 ) ; | |
997 | } | |
998 | else | |
999 | *s = ':'; | |
1000 | } | |
1001 | s++ ; | |
1002 | } | |
e7549107 | 1003 | } |
a1c34a78 | 1004 | return wxString (sMacFileNameConversion) ; |
17dff81c | 1005 | } |
e7549107 | 1006 | |
e7549107 SC |
1007 | wxString wxMacFSSpec2UnixFilename( const FSSpec *spec ) |
1008 | { | |
f6bcfd97 | 1009 | return wxMac2UnixFilename( wxMacFSSpec2MacFilename( spec) ) ; |
e7549107 SC |
1010 | } |
1011 | ||
e7549107 SC |
1012 | void wxUnixFilename2FSSpec( const char *path , FSSpec *spec ) |
1013 | { | |
f6bcfd97 BP |
1014 | wxString var = wxUnix2MacFilename( path ) ; |
1015 | wxMacFilename2FSSpec( var , spec ) ; | |
e7549107 | 1016 | } |
a1c34a78 | 1017 | #endif // ! __DARWIN__ |
12d67f8a | 1018 | |
e8e1d09e GD |
1019 | #endif // __WXMAC__ |
1020 | ||
3f4a0c5b | 1021 | void |
e7549107 | 1022 | wxDos2UnixFilename (char *s) |
c801d85f KB |
1023 | { |
1024 | if (s) | |
1025 | while (*s) | |
1026 | { | |
e7549107 SC |
1027 | if (*s == '\\') |
1028 | *s = '/'; | |
1029 | #ifdef __WXMSW__ | |
3f4a0c5b | 1030 | else |
e7549107 | 1031 | *s = wxTolower (*s); // Case INDEPENDENT |
c801d85f | 1032 | #endif |
3f4a0c5b | 1033 | s++; |
c801d85f KB |
1034 | } |
1035 | } | |
1036 | ||
3f4a0c5b | 1037 | void |
f28538c5 | 1038 | #if defined(__WXMSW__) || defined(__WXPM__) |
5b735202 | 1039 | wxUnix2DosFilename (wxChar *s) |
46dc76ba | 1040 | #else |
5b735202 | 1041 | wxUnix2DosFilename (wxChar *WXUNUSED(s) ) |
46dc76ba | 1042 | #endif |
c801d85f KB |
1043 | { |
1044 | // Yes, I really mean this to happen under DOS only! JACS | |
c2ff79b1 | 1045 | #if defined(__WXMSW__) || defined(__WXPM__) |
c801d85f KB |
1046 | if (s) |
1047 | while (*s) | |
1048 | { | |
223d09f6 KB |
1049 | if (*s == wxT('/')) |
1050 | *s = wxT('\\'); | |
3f4a0c5b | 1051 | s++; |
c801d85f KB |
1052 | } |
1053 | #endif | |
1054 | } | |
1055 | ||
1056 | // Concatenate two files to form third | |
3f4a0c5b | 1057 | bool |
c801d85f KB |
1058 | wxConcatFiles (const wxString& file1, const wxString& file2, const wxString& file3) |
1059 | { | |
a339970a VZ |
1060 | wxString outfile; |
1061 | if ( !wxGetTempFileName("cat", outfile) ) | |
1062 | return FALSE; | |
c801d85f | 1063 | |
c67daf87 UR |
1064 | FILE *fp1 = (FILE *) NULL; |
1065 | FILE *fp2 = (FILE *) NULL; | |
1066 | FILE *fp3 = (FILE *) NULL; | |
c801d85f | 1067 | // Open the inputs and outputs |
401eb3de RR |
1068 | if ((fp1 = wxFopen ( file1, wxT("rb"))) == NULL || |
1069 | (fp2 = wxFopen ( file2, wxT("rb"))) == NULL || | |
1070 | (fp3 = wxFopen ( outfile, wxT("wb"))) == NULL) | |
c801d85f KB |
1071 | { |
1072 | if (fp1) | |
3f4a0c5b | 1073 | fclose (fp1); |
c801d85f | 1074 | if (fp2) |
3f4a0c5b | 1075 | fclose (fp2); |
c801d85f | 1076 | if (fp3) |
3f4a0c5b | 1077 | fclose (fp3); |
c801d85f KB |
1078 | return FALSE; |
1079 | } | |
1080 | ||
1081 | int ch; | |
1082 | while ((ch = getc (fp1)) != EOF) | |
1083 | (void) putc (ch, fp3); | |
1084 | fclose (fp1); | |
1085 | ||
1086 | while ((ch = getc (fp2)) != EOF) | |
1087 | (void) putc (ch, fp3); | |
1088 | fclose (fp2); | |
1089 | ||
1090 | fclose (fp3); | |
1091 | bool result = wxRenameFile(outfile, file3); | |
c801d85f KB |
1092 | return result; |
1093 | } | |
1094 | ||
1095 | // Copy files | |
3f4a0c5b | 1096 | bool |
4658c44e | 1097 | wxCopyFile (const wxString& file1, const wxString& file2, bool overwrite) |
c801d85f | 1098 | { |
04ef50df | 1099 | #if defined(__WIN32__) && !defined(__WXMICROWIN__) |
4658c44e VZ |
1100 | // CopyFile() copies file attributes and modification time too, so use it |
1101 | // instead of our code if available | |
1102 | // | |
1103 | // NB: 3rd parameter is bFailIfExists i.e. the inverse of overwrite | |
564225a1 VZ |
1104 | if ( !::CopyFile(file1, file2, !overwrite) ) |
1105 | { | |
1106 | wxLogSysError(_("Failed to copy the file '%s' to '%s'"), | |
1107 | file1.c_str(), file2.c_str()); | |
1108 | ||
1109 | return FALSE; | |
1110 | } | |
19193a2c | 1111 | #elif defined(__WXPM__) |
564225a1 | 1112 | if ( ::DosCopy(file2, file2, overwrite ? DCPY_EXISTING : 0) != 0 ) |
19193a2c | 1113 | return FALSE; |
4658c44e | 1114 | #else // !Win32 |
32f31043 VZ |
1115 | wxStructStat fbuf; |
1116 | ||
1117 | // get permissions of file1 | |
92980e90 | 1118 | if ( wxStat( file1, &fbuf) != 0 ) |
32f31043 VZ |
1119 | { |
1120 | // the file probably doesn't exist or we haven't the rights to read | |
1121 | // from it anyhow | |
1122 | wxLogSysError(_("Impossible to get permissions for file '%s'"), | |
1123 | file1.c_str()); | |
1124 | return FALSE; | |
1125 | } | |
1126 | ||
1127 | // open file1 for reading | |
1128 | wxFile fileIn(file1, wxFile::read); | |
a339970a VZ |
1129 | if ( !fileIn.IsOpened() ) |
1130 | return FALSE; | |
c801d85f | 1131 | |
32f31043 VZ |
1132 | // remove file2, if it exists. This is needed for creating |
1133 | // file2 with the correct permissions in the next step | |
4658c44e | 1134 | if ( wxFileExists(file2) && (!overwrite || !wxRemoveFile(file2))) |
32f31043 VZ |
1135 | { |
1136 | wxLogSysError(_("Impossible to overwrite the file '%s'"), | |
1137 | file2.c_str()); | |
1138 | return FALSE; | |
1139 | } | |
1140 | ||
1141 | #ifdef __UNIX__ | |
1142 | // reset the umask as we want to create the file with exactly the same | |
1143 | // permissions as the original one | |
1144 | mode_t oldUmask = umask( 0 ); | |
1145 | #endif // __UNIX__ | |
1146 | ||
1147 | // create file2 with the same permissions than file1 and open it for | |
1148 | // writing | |
1149 | wxFile fileOut; | |
4658c44e | 1150 | if ( !fileOut.Create(file2, overwrite, fbuf.st_mode & 0777) ) |
a339970a | 1151 | return FALSE; |
c801d85f | 1152 | |
32f31043 VZ |
1153 | #ifdef __UNIX__ |
1154 | /// restore the old umask | |
1155 | umask(oldUmask); | |
1156 | #endif // __UNIX__ | |
1157 | ||
1158 | // copy contents of file1 to file2 | |
a339970a VZ |
1159 | char buf[4096]; |
1160 | size_t count; | |
1161 | for ( ;; ) | |
c7386783 | 1162 | { |
a339970a VZ |
1163 | count = fileIn.Read(buf, WXSIZEOF(buf)); |
1164 | if ( fileIn.Error() ) | |
1165 | return FALSE; | |
1166 | ||
1167 | // end of file? | |
1168 | if ( !count ) | |
1169 | break; | |
1170 | ||
1171 | if ( fileOut.Write(buf, count) < count ) | |
1172 | return FALSE; | |
c7386783 | 1173 | } |
c801d85f | 1174 | |
abb74e97 VZ |
1175 | // we can expect fileIn to be closed successfully, but we should ensure |
1176 | // that fileOut was closed as some write errors (disk full) might not be | |
1177 | // detected before doing this | |
1178 | if ( !fileIn.Close() || !fileOut.Close() ) | |
1179 | return FALSE; | |
1180 | ||
5fde6fcc | 1181 | #if !defined(__VISAGECPP__) && !defined(__WXMAC__) || defined(__UNIX__) |
abb74e97 VZ |
1182 | // no chmod in VA. Should be some permission API for HPFS386 partitions |
1183 | // however | |
c3396917 | 1184 | if ( chmod(OS_FILENAME(file2), fbuf.st_mode) != 0 ) |
32f31043 VZ |
1185 | { |
1186 | wxLogSysError(_("Impossible to set permissions for the file '%s'"), | |
1187 | file2.c_str()); | |
1188 | return FALSE; | |
1189 | } | |
4658c44e | 1190 | #endif // OS/2 || Mac |
564225a1 | 1191 | #endif // __WXMSW__ && __WIN32__ |
4658c44e | 1192 | |
a339970a | 1193 | return TRUE; |
c801d85f KB |
1194 | } |
1195 | ||
3f4a0c5b | 1196 | bool |
c801d85f KB |
1197 | wxRenameFile (const wxString& file1, const wxString& file2) |
1198 | { | |
1199 | // Normal system call | |
c3396917 | 1200 | if ( wxRename (file1, file2) == 0 ) |
c801d85f | 1201 | return TRUE; |
a339970a | 1202 | |
c801d85f KB |
1203 | // Try to copy |
1204 | if (wxCopyFile(file1, file2)) { | |
1205 | wxRemoveFile(file1); | |
1206 | return TRUE; | |
1207 | } | |
1208 | // Give up | |
1209 | return FALSE; | |
1210 | } | |
1211 | ||
1212 | bool wxRemoveFile(const wxString& file) | |
1213 | { | |
161f4f73 VZ |
1214 | #if defined(__VISUALC__) \ |
1215 | || defined(__BORLANDC__) \ | |
1216 | || defined(__WATCOMC__) \ | |
1217 | || defined(__GNUWIN32__) | |
a339970a | 1218 | int res = wxRemove(file); |
c801d85f | 1219 | #else |
a339970a | 1220 | int res = unlink(OS_FILENAME(file)); |
c801d85f | 1221 | #endif |
a339970a VZ |
1222 | |
1223 | return res == 0; | |
c801d85f KB |
1224 | } |
1225 | ||
1a33c3ba | 1226 | bool wxMkdir(const wxString& dir, int perm) |
c801d85f | 1227 | { |
5fde6fcc | 1228 | #if defined(__WXMAC__) && !defined(__UNIX__) |
bedaf53e | 1229 | return (mkdir( dir , 0 ) == 0); |
7708abe9 | 1230 | #else // !Mac |
50920146 | 1231 | const wxChar *dirname = dir.c_str(); |
1a33c3ba | 1232 | |
c2ff79b1 | 1233 | // assume mkdir() has 2 args on non Windows-OS/2 platforms and on Windows too |
7708abe9 | 1234 | // for the GNU compiler |
f48fa475 | 1235 | #if (!(defined(__WXMSW__) || defined(__WXPM__) || defined(__DOS__))) || (defined(__GNUWIN32__) && !defined(__MINGW32__)) || defined(__WXWINE__) || defined(__WXMICROWIN__) |
50920146 | 1236 | if ( mkdir(wxFNCONV(dirname), perm) != 0 ) |
f6bcfd97 BP |
1237 | #elif defined(__WXPM__) |
1238 | if (::DosCreateDir((PSZ)dirname, NULL) != 0) // enhance for EAB's?? | |
b916f809 VS |
1239 | #elif defined(__DOS__) |
1240 | #if defined(__WATCOMC__) | |
1241 | (void)perm; | |
1242 | if ( wxMkDir(wxFNSTRINGCAST wxFNCONV(dirname)) != 0 ) | |
1243 | #elif defined(__DJGPP__) | |
1244 | if ( mkdir(wxFNCONV(dirname), perm) != 0 ) | |
1245 | #else | |
1246 | #error "Unsupported DOS compiler!" | |
1247 | #endif | |
1248 | #else // !MSW, !DOS and !OS/2 VAC++ | |
19193a2c | 1249 | (void)perm; |
f6bcfd97 | 1250 | if ( wxMkDir(wxFNSTRINGCAST wxFNCONV(dirname)) != 0 ) |
7708abe9 | 1251 | #endif // !MSW/MSW |
1a33c3ba VZ |
1252 | { |
1253 | wxLogSysError(_("Directory '%s' couldn't be created"), dirname); | |
1254 | ||
1255 | return FALSE; | |
1256 | } | |
1257 | ||
1258 | return TRUE; | |
e7549107 | 1259 | #endif // Mac/!Mac |
c801d85f KB |
1260 | } |
1261 | ||
1262 | bool wxRmdir(const wxString& dir, int WXUNUSED(flags)) | |
1263 | { | |
1264 | #ifdef __VMS__ | |
acdc3b6b | 1265 | return FALSE; //to be changed since rmdir exists in VMS7.x |
f6bcfd97 BP |
1266 | #elif defined(__WXPM__) |
1267 | return (::DosDeleteDir((PSZ)dir.c_str()) == 0); | |
c801d85f | 1268 | #else |
a3ef5bf5 JS |
1269 | |
1270 | #ifdef __SALFORDC__ | |
1271 | return FALSE; // What to do? | |
1272 | #else | |
a339970a | 1273 | return (wxRmDir(OS_FILENAME(dir)) == 0); |
c801d85f KB |
1274 | #endif |
1275 | ||
1276 | #endif | |
1277 | } | |
1278 | ||
c801d85f | 1279 | // does the path exists? (may have or not '/' or '\\' at the end) |
50920146 | 1280 | bool wxPathExists(const wxChar *pszPathName) |
c801d85f | 1281 | { |
f6bcfd97 | 1282 | wxString strPath(pszPathName); |
e32d659d | 1283 | |
f6bcfd97 BP |
1284 | #ifdef __WINDOWS__ |
1285 | // Windows fails to find directory named "c:\dir\" even if "c:\dir" exists, | |
1286 | // so remove all trailing backslashes from the path - but don't do this for | |
1287 | // the pathes "d:\" (which are different from "d:") nor for just "\" | |
1288 | while ( wxEndsWithPathSeparator(strPath) ) | |
1289 | { | |
1290 | size_t len = strPath.length(); | |
cc4a1ce1 | 1291 | if ( len == 1 || (len == 3 && strPath[len - 2] == _T(':')) ) |
f6bcfd97 | 1292 | break; |
c801d85f | 1293 | |
f6bcfd97 BP |
1294 | strPath.Truncate(len - 1); |
1295 | } | |
1296 | #endif // __WINDOWS__ | |
1297 | ||
2db300c6 | 1298 | #if defined(__WIN32__) && !defined(__WXMICROWIN__) |
e32d659d VZ |
1299 | // stat() can't cope with network paths |
1300 | DWORD ret = ::GetFileAttributes(strPath); | |
2db300c6 | 1301 | |
a28ae409 | 1302 | return (ret != (DWORD)-1) && (ret & FILE_ATTRIBUTE_DIRECTORY); |
e32d659d | 1303 | #else // !__WIN32__ |
4c97e024 | 1304 | |
f6bcfd97 | 1305 | wxStructStat st; |
71c97a89 | 1306 | #ifndef __VISAGECPP__ |
92980e90 | 1307 | return wxStat(pszPathName, &st) == 0 && ((st.st_mode & S_IFMT) == S_IFDIR); |
71c97a89 DW |
1308 | #else |
1309 | // S_IFMT not supported in VA compilers.. st_mode is a 2byte value only | |
92980e90 | 1310 | return wxStat(pszPathName, &st) == 0 && (st.st_mode == S_IFDIR); |
71c97a89 DW |
1311 | #endif |
1312 | ||
e32d659d | 1313 | #endif // __WIN32__/!__WIN32__ |
c801d85f KB |
1314 | } |
1315 | ||
1316 | // Get a temporary filename, opening and closing the file. | |
50920146 | 1317 | wxChar *wxGetTempFileName(const wxString& prefix, wxChar *buf) |
c801d85f | 1318 | { |
ade35f11 VZ |
1319 | wxString filename = wxFileName::CreateTempFileName(prefix); |
1320 | if ( filename.empty() ) | |
1321 | return NULL; | |
c801d85f | 1322 | |
ade35f11 VZ |
1323 | if ( buf ) |
1324 | wxStrcpy(buf, filename); | |
1325 | else | |
1326 | buf = copystring(filename); | |
c801d85f | 1327 | |
ade35f11 | 1328 | return buf; |
c801d85f KB |
1329 | } |
1330 | ||
c0ab6adf JS |
1331 | bool wxGetTempFileName(const wxString& prefix, wxString& buf) |
1332 | { | |
ade35f11 VZ |
1333 | buf = wxFileName::CreateTempFileName(prefix); |
1334 | ||
1335 | return !buf.empty(); | |
c0ab6adf JS |
1336 | } |
1337 | ||
c801d85f KB |
1338 | // Get first file name matching given wild card. |
1339 | ||
8ff12342 VS |
1340 | static wxDir *gs_dir = NULL; |
1341 | static wxString gs_dirPath; | |
1342 | ||
1343 | wxString wxFindFirstFile(const wxChar *spec, int flags) | |
1344 | { | |
9a5ead1e | 1345 | wxSplitPath(spec, &gs_dirPath, NULL, NULL); |
8ff12342 VS |
1346 | if ( gs_dirPath.IsEmpty() ) |
1347 | gs_dirPath = wxT("."); | |
1348 | if ( gs_dirPath.Last() != wxFILE_SEP_PATH ) | |
1349 | gs_dirPath << wxFILE_SEP_PATH; | |
1350 | ||
1351 | if (gs_dir) | |
1352 | delete gs_dir; | |
1353 | gs_dir = new wxDir(gs_dirPath); | |
2db300c6 | 1354 | |
8ff12342 VS |
1355 | if ( !gs_dir->IsOpened() ) |
1356 | { | |
1357 | wxLogSysError(_("Can not enumerate files '%s'"), spec); | |
1358 | return wxEmptyString; | |
1359 | } | |
2db300c6 | 1360 | |
8ff12342 VS |
1361 | int dirFlags = 0; |
1362 | switch (flags) | |
1363 | { | |
1364 | case wxDIR: dirFlags = wxDIR_DIRS; break; | |
1365 | case wxFILE: dirFlags = wxDIR_FILES; break; | |
1366 | default: dirFlags = wxDIR_DIRS | wxDIR_FILES; break; | |
1367 | } | |
2db300c6 | 1368 | |
8ff12342 | 1369 | wxString result; |
1f1070e2 | 1370 | gs_dir->GetFirst(&result, wxFileNameFromPath(wxString(spec)), dirFlags); |
8ff12342 | 1371 | if ( result.IsEmpty() ) |
e168b6ac | 1372 | { |
8ff12342 | 1373 | wxDELETE(gs_dir); |
e168b6ac VS |
1374 | return result; |
1375 | } | |
8ff12342 VS |
1376 | |
1377 | return gs_dirPath + result; | |
1378 | } | |
1379 | ||
1380 | wxString wxFindNextFile() | |
1381 | { | |
1382 | wxASSERT_MSG( gs_dir, wxT("You must call wxFindFirstFile before!") ); | |
1383 | ||
1384 | wxString result; | |
1385 | gs_dir->GetNext(&result); | |
2db300c6 | 1386 | |
8ff12342 | 1387 | if ( result.IsEmpty() ) |
e168b6ac | 1388 | { |
8ff12342 | 1389 | wxDELETE(gs_dir); |
e168b6ac VS |
1390 | return result; |
1391 | } | |
2db300c6 | 1392 | |
8ff12342 VS |
1393 | return gs_dirPath + result; |
1394 | } | |
1395 | ||
c801d85f KB |
1396 | |
1397 | // Get current working directory. | |
1398 | // If buf is NULL, allocates space using new, else | |
1399 | // copies into buf. | |
50920146 | 1400 | wxChar *wxGetWorkingDirectory(wxChar *buf, int sz) |
c801d85f | 1401 | { |
13b1f8a7 | 1402 | if ( !buf ) |
f6bcfd97 | 1403 | { |
13b1f8a7 VZ |
1404 | buf = new wxChar[sz + 1]; |
1405 | } | |
1406 | ||
dbc38199 | 1407 | bool ok = FALSE; |
13b1f8a7 VZ |
1408 | |
1409 | // for the compilers which have Unicode version of _getcwd(), call it | |
1410 | // directly, for the others call the ANSI version and do the translation | |
dbc38199 | 1411 | #if !wxUSE_UNICODE |
247f8a77 | 1412 | #define cbuf buf |
dbc38199 | 1413 | #else // wxUSE_UNICODE |
247f8a77 | 1414 | bool needsANSI = TRUE; |
dbc38199 | 1415 | |
247f8a77 | 1416 | #if !defined(HAVE_WGETCWD) || wxUSE_UNICODE_MSLU |
dbc38199 | 1417 | wxCharBuffer c_buffer(sz); |
247f8a77 VS |
1418 | char *cbuf = (char*)(const char*)c_buffer; |
1419 | #endif | |
dbc38199 | 1420 | |
13b1f8a7 | 1421 | #ifdef HAVE_WGETCWD |
247f8a77 VS |
1422 | #if wxUSE_UNICODE_MSLU |
1423 | if ( wxGetOsVersion() != wxWIN95 ) | |
f5c0e657 VS |
1424 | #else |
1425 | char *cbuf = NULL; // never really used because needsANSI will always be FALSE | |
247f8a77 VS |
1426 | #endif |
1427 | { | |
1428 | ok = _wgetcwd(buf, sz) != NULL; | |
1429 | needsANSI = FALSE; | |
1430 | } | |
13b1f8a7 | 1431 | #endif |
13b1f8a7 | 1432 | |
247f8a77 | 1433 | if ( needsANSI ) |
dbc38199 | 1434 | #endif // wxUSE_UNICODE |
247f8a77 | 1435 | { |
13b1f8a7 | 1436 | #ifdef _MSC_VER |
dbc38199 | 1437 | ok = _getcwd(cbuf, sz) != NULL; |
13b1f8a7 VZ |
1438 | #elif defined(__WXMAC__) && !defined(__DARWIN__) |
1439 | FSSpec cwdSpec ; | |
1440 | FCBPBRec pb; | |
1441 | OSErr error; | |
1442 | Str255 fileName ; | |
1443 | pb.ioNamePtr = (StringPtr) &fileName; | |
1444 | pb.ioVRefNum = 0; | |
1445 | pb.ioRefNum = LMGetCurApRefNum(); | |
1446 | pb.ioFCBIndx = 0; | |
1447 | error = PBGetFCBInfoSync(&pb); | |
1448 | if ( error == noErr ) | |
1449 | { | |
1450 | cwdSpec.vRefNum = pb.ioFCBVRefNum; | |
1451 | cwdSpec.parID = pb.ioFCBParID; | |
1452 | cwdSpec.name[0] = 0 ; | |
1453 | wxString res = wxMacFSSpec2MacFilename( &cwdSpec ) ; | |
1454 | ||
dbc38199 VS |
1455 | strcpy( cbuf , res ) ; |
1456 | cbuf[res.length()]=0 ; | |
13b1f8a7 VZ |
1457 | |
1458 | ok = TRUE; | |
1459 | } | |
1460 | else | |
1461 | { | |
1462 | ok = FALSE; | |
1463 | } | |
1464 | #elif defined(__VISAGECPP__) || (defined (__OS2__) && defined (__WATCOMC__)) | |
1465 | APIRET rc; | |
1466 | rc = ::DosQueryCurrentDir( 0 // current drive | |
dbc38199 | 1467 | ,cbuf |
13b1f8a7 VZ |
1468 | ,(PULONG)&sz |
1469 | ); | |
1470 | ok = rc != 0; | |
1471 | #else // !Win32/VC++ !Mac !OS2 | |
dbc38199 | 1472 | ok = getcwd(cbuf, sz) != NULL; |
13b1f8a7 | 1473 | #endif // platform |
247f8a77 VS |
1474 | |
1475 | #if wxUSE_UNICODE | |
1476 | // finally convert the result to Unicode if needed | |
1477 | wxConvFile.MB2WC(buf, cbuf, sz); | |
1478 | #endif // wxUSE_UNICODE | |
1479 | } | |
13b1f8a7 VZ |
1480 | |
1481 | if ( !ok ) | |
19193a2c | 1482 | { |
13b1f8a7 | 1483 | wxLogSysError(_("Failed to get the working directory")); |
19193a2c | 1484 | |
13b1f8a7 VZ |
1485 | // VZ: the old code used to return "." on error which didn't make any |
1486 | // sense at all to me - empty string is a better error indicator | |
1487 | // (NULL might be even better but I'm afraid this could lead to | |
1488 | // problems with the old code assuming the return is never NULL) | |
1489 | buf[0] = _T('\0'); | |
19193a2c | 1490 | } |
13b1f8a7 | 1491 | else // ok, but we might need to massage the path into the right format |
19193a2c | 1492 | { |
4b00a538 | 1493 | #ifdef __DJGPP__ |
13b1f8a7 VZ |
1494 | // VS: DJGPP is a strange mix of DOS and UNIX API and returns paths |
1495 | // with / deliminers. We don't like that. | |
1496 | for (wxChar *ch = buf; *ch; ch++) | |
1497 | { | |
1498 | if (*ch == wxT('/')) | |
1499 | *ch = wxT('\\'); | |
1500 | } | |
1501 | #endif // __DJGPP__ | |
1502 | ||
17234b26 MB |
1503 | // MBN: we hope that in the case the user is compiling a GTK+/Motif app, |
1504 | // he needs Unix as opposed to Win32 pathnames | |
1505 | #if defined( __CYGWIN__ ) && defined( __WINDOWS__ ) | |
3ffbc733 | 1506 | // another example of DOS/Unix mix (Cygwin) |
13b1f8a7 VZ |
1507 | wxString pathUnix = buf; |
1508 | cygwin_conv_to_full_win32_path(pathUnix, buf); | |
e02e8816 | 1509 | #endif // __CYGWIN__ |
13b1f8a7 | 1510 | } |
4b00a538 | 1511 | |
13b1f8a7 | 1512 | return buf; |
dbc38199 VS |
1513 | |
1514 | #if !wxUSE_UNICODE | |
247f8a77 | 1515 | #undef cbuf |
dbc38199 | 1516 | #endif |
c801d85f KB |
1517 | } |
1518 | ||
7af89395 VZ |
1519 | wxString wxGetCwd() |
1520 | { | |
eac2aeb0 | 1521 | wxString str; |
2fe0ef8a VZ |
1522 | |
1523 | // we can't create wxStringBuffer object inline: Sun CC generates buggy | |
1524 | // code in this case! | |
1525 | { | |
1526 | wxStringBuffer buf(str, _MAXPATHLEN); | |
1527 | wxGetWorkingDirectory(buf, _MAXPATHLEN); | |
1528 | } | |
eac2aeb0 VZ |
1529 | |
1530 | return str; | |
7af89395 VZ |
1531 | } |
1532 | ||
c801d85f KB |
1533 | bool wxSetWorkingDirectory(const wxString& d) |
1534 | { | |
f48fa475 | 1535 | #if defined(__UNIX__) || defined(__WXMAC__) || defined(__DOS__) |
e90c1d2a | 1536 | return (chdir(wxFNSTRINGCAST d.fn_str()) == 0); |
f6bcfd97 BP |
1537 | #elif defined(__WXPM__) |
1538 | return (::DosSetCurrentDir((PSZ)d.c_str()) == 0); | |
34138703 | 1539 | #elif defined(__WINDOWS__) |
c801d85f KB |
1540 | |
1541 | #ifdef __WIN32__ | |
1542 | return (bool)(SetCurrentDirectory(d) != 0); | |
1543 | #else | |
1544 | // Must change drive, too. | |
1545 | bool isDriveSpec = ((strlen(d) > 1) && (d[1] == ':')); | |
1546 | if (isDriveSpec) | |
1547 | { | |
50920146 | 1548 | wxChar firstChar = d[0]; |
c801d85f KB |
1549 | |
1550 | // To upper case | |
1551 | if (firstChar > 90) | |
1552 | firstChar = firstChar - 32; | |
1553 | ||
1554 | // To a drive number | |
1555 | unsigned int driveNo = firstChar - 64; | |
1556 | if (driveNo > 0) | |
1557 | { | |
1558 | unsigned int noDrives; | |
1559 | _dos_setdrive(driveNo, &noDrives); | |
1560 | } | |
1561 | } | |
1562 | bool success = (chdir(WXSTRINGCAST d) == 0); | |
1563 | ||
1564 | return success; | |
1565 | #endif | |
1566 | ||
1567 | #endif | |
1568 | } | |
1569 | ||
631f1bfe JS |
1570 | // Get the OS directory if appropriate (such as the Windows directory). |
1571 | // On non-Windows platform, probably just return the empty string. | |
1572 | wxString wxGetOSDirectory() | |
1573 | { | |
04ef50df | 1574 | #if defined(__WINDOWS__) && !defined(__WXMICROWIN__) |
50920146 | 1575 | wxChar buf[256]; |
631f1bfe JS |
1576 | GetWindowsDirectory(buf, 256); |
1577 | return wxString(buf); | |
1578 | #else | |
1579 | return wxEmptyString; | |
1580 | #endif | |
1581 | } | |
1582 | ||
a907da15 | 1583 | bool wxEndsWithPathSeparator(const wxChar *pszFileName) |
c801d85f | 1584 | { |
903b61cc VZ |
1585 | size_t len = wxStrlen(pszFileName); |
1586 | ||
1587 | return len && wxIsPathSeparator(pszFileName[len - 1]); | |
c801d85f KB |
1588 | } |
1589 | ||
1590 | // find a file in a list of directories, returns false if not found | |
50920146 | 1591 | bool wxFindFileInPath(wxString *pStr, const wxChar *pszPath, const wxChar *pszFile) |
c801d85f | 1592 | { |
a17e237f VZ |
1593 | // we assume that it's not empty |
1594 | wxCHECK_MSG( !wxIsEmpty(pszFile), FALSE, | |
f6bcfd97 | 1595 | _T("empty file name in wxFindFileInPath")); |
a17e237f VZ |
1596 | |
1597 | // skip path separator in the beginning of the file name if present | |
1598 | if ( wxIsPathSeparator(*pszFile) ) | |
1599 | pszFile++; | |
1600 | ||
1601 | // copy the path (strtok will modify it) | |
1602 | wxChar *szPath = new wxChar[wxStrlen(pszPath) + 1]; | |
1603 | wxStrcpy(szPath, pszPath); | |
1604 | ||
1605 | wxString strFile; | |
1606 | wxChar *pc, *save_ptr; | |
1607 | for ( pc = wxStrtok(szPath, wxPATH_SEP, &save_ptr); | |
1608 | pc != NULL; | |
1609 | pc = wxStrtok((wxChar *) NULL, wxPATH_SEP, &save_ptr) ) | |
1610 | { | |
1611 | // search for the file in this directory | |
1612 | strFile = pc; | |
1613 | if ( !wxEndsWithPathSeparator(pc) ) | |
1614 | strFile += wxFILE_SEP_PATH; | |
1615 | strFile += pszFile; | |
1616 | ||
1617 | if ( FileExists(strFile) ) { | |
1618 | *pStr = strFile; | |
1619 | break; | |
1620 | } | |
c801d85f | 1621 | } |
c801d85f | 1622 | |
a17e237f VZ |
1623 | // suppress warning about unused variable save_ptr when wxStrtok() is a |
1624 | // macro which throws away its third argument | |
1625 | save_ptr = pc; | |
1626 | ||
1627 | delete [] szPath; | |
c801d85f | 1628 | |
a17e237f | 1629 | return pc != NULL; // if true => we breaked from the loop |
c801d85f KB |
1630 | } |
1631 | ||
50920146 | 1632 | void WXDLLEXPORT wxSplitPath(const wxChar *pszFileName, |
3826db3e VZ |
1633 | wxString *pstrPath, |
1634 | wxString *pstrName, | |
1635 | wxString *pstrExt) | |
1636 | { | |
d37fd2fa | 1637 | // it can be empty, but it shouldn't be NULL |
223d09f6 | 1638 | wxCHECK_RET( pszFileName, wxT("NULL file name in wxSplitPath") ); |
3826db3e | 1639 | |
9e8d8607 | 1640 | wxFileName::SplitPath(pszFileName, pstrPath, pstrName, pstrExt); |
3826db3e | 1641 | } |
7f555861 | 1642 | |
a47ce4a7 VS |
1643 | time_t WXDLLEXPORT wxFileModificationTime(const wxString& filename) |
1644 | { | |
f6bcfd97 | 1645 | wxStructStat buf; |
92980e90 RR |
1646 | wxStat( filename, &buf); |
1647 | ||
a47ce4a7 VS |
1648 | return buf.st_mtime; |
1649 | } | |
1650 | ||
1651 | ||
7f555861 JS |
1652 | //------------------------------------------------------------------------ |
1653 | // wild character routines | |
1654 | //------------------------------------------------------------------------ | |
1655 | ||
1656 | bool wxIsWild( const wxString& pattern ) | |
1657 | { | |
1658 | wxString tmp = pattern; | |
50920146 | 1659 | wxChar *pat = WXSTRINGCAST(tmp); |
7f555861 | 1660 | while (*pat) { |
3f4a0c5b | 1661 | switch (*pat++) { |
223d09f6 | 1662 | case wxT('?'): case wxT('*'): case wxT('['): case wxT('{'): |
3f4a0c5b | 1663 | return TRUE; |
223d09f6 | 1664 | case wxT('\\'): |
3f4a0c5b VZ |
1665 | if (!*pat++) |
1666 | return FALSE; | |
1667 | } | |
7f555861 JS |
1668 | } |
1669 | return FALSE; | |
1670 | }; | |
1671 | ||
b112d152 | 1672 | bool wxMatchWild( const wxString& pat, const wxString& text, bool dot_special ) |
99cc00ed | 1673 | |
e21a44de | 1674 | #ifdef HAVE_FNMATCH |
dfcb1ae0 | 1675 | { |
50920146 | 1676 | // this probably won't work well for multibyte chars in Unicode mode? |
b112d152 | 1677 | if(dot_special) |
50920146 | 1678 | return fnmatch(pat.fn_str(), text.fn_str(), FNM_PERIOD) == 0; |
b112d152 | 1679 | else |
50920146 | 1680 | return fnmatch(pat.fn_str(), text.fn_str(), 0) == 0; |
dfcb1ae0 | 1681 | } |
e21a44de | 1682 | #else // !HAVE_FNMATCH |
dfcb1ae0 | 1683 | |
7be1f0d9 JS |
1684 | // #pragma error Broken implementation of wxMatchWild() -- needs fixing! |
1685 | ||
dfcb1ae0 KB |
1686 | /* |
1687 | * WARNING: this code is broken! | |
1688 | */ | |
7f555861 JS |
1689 | { |
1690 | wxString tmp1 = pat; | |
50920146 | 1691 | wxChar *pattern = WXSTRINGCAST(tmp1); |
7f555861 | 1692 | wxString tmp2 = text; |
50920146 OK |
1693 | wxChar *str = WXSTRINGCAST(tmp2); |
1694 | wxChar c; | |
1695 | wxChar *cp; | |
7f555861 JS |
1696 | bool done = FALSE, ret_code, ok; |
1697 | // Below is for vi fans | |
223d09f6 | 1698 | const wxChar OB = wxT('{'), CB = wxT('}'); |
7f555861 JS |
1699 | |
1700 | // dot_special means '.' only matches '.' | |
223d09f6 | 1701 | if (dot_special && *str == wxT('.') && *pattern != *str) |
3f4a0c5b | 1702 | return FALSE; |
7f555861 | 1703 | |
223d09f6 KB |
1704 | while ((*pattern != wxT('\0')) && (!done) |
1705 | && (((*str==wxT('\0'))&&((*pattern==OB)||(*pattern==wxT('*'))))||(*str!=wxT('\0')))) { | |
3f4a0c5b | 1706 | switch (*pattern) { |
223d09f6 | 1707 | case wxT('\\'): |
3f4a0c5b | 1708 | pattern++; |
223d09f6 | 1709 | if (*pattern != wxT('\0')) |
3f4a0c5b VZ |
1710 | pattern++; |
1711 | break; | |
223d09f6 | 1712 | case wxT('*'): |
3f4a0c5b VZ |
1713 | pattern++; |
1714 | ret_code = FALSE; | |
223d09f6 | 1715 | while ((*str!=wxT('\0')) |
33ac7e6f | 1716 | && ((ret_code=wxMatchWild(pattern, str++, FALSE)) == 0)) |
3f4a0c5b VZ |
1717 | /*loop*/; |
1718 | if (ret_code) { | |
223d09f6 | 1719 | while (*str != wxT('\0')) |
3f4a0c5b | 1720 | str++; |
223d09f6 | 1721 | while (*pattern != wxT('\0')) |
3f4a0c5b VZ |
1722 | pattern++; |
1723 | } | |
1724 | break; | |
223d09f6 | 1725 | case wxT('['): |
3f4a0c5b VZ |
1726 | pattern++; |
1727 | repeat: | |
223d09f6 | 1728 | if ((*pattern == wxT('\0')) || (*pattern == wxT(']'))) { |
3f4a0c5b VZ |
1729 | done = TRUE; |
1730 | break; | |
1731 | } | |
223d09f6 | 1732 | if (*pattern == wxT('\\')) { |
3f4a0c5b | 1733 | pattern++; |
223d09f6 | 1734 | if (*pattern == wxT('\0')) { |
3f4a0c5b VZ |
1735 | done = TRUE; |
1736 | break; | |
1737 | } | |
1738 | } | |
223d09f6 | 1739 | if (*(pattern + 1) == wxT('-')) { |
3f4a0c5b VZ |
1740 | c = *pattern; |
1741 | pattern += 2; | |
223d09f6 | 1742 | if (*pattern == wxT(']')) { |
3f4a0c5b VZ |
1743 | done = TRUE; |
1744 | break; | |
1745 | } | |
223d09f6 | 1746 | if (*pattern == wxT('\\')) { |
3f4a0c5b | 1747 | pattern++; |
223d09f6 | 1748 | if (*pattern == wxT('\0')) { |
3f4a0c5b VZ |
1749 | done = TRUE; |
1750 | break; | |
1751 | } | |
1752 | } | |
1753 | if ((*str < c) || (*str > *pattern)) { | |
1754 | pattern++; | |
1755 | goto repeat; | |
1756 | } | |
1757 | } else if (*pattern != *str) { | |
1758 | pattern++; | |
1759 | goto repeat; | |
1760 | } | |
1761 | pattern++; | |
223d09f6 KB |
1762 | while ((*pattern != wxT(']')) && (*pattern != wxT('\0'))) { |
1763 | if ((*pattern == wxT('\\')) && (*(pattern + 1) != wxT('\0'))) | |
3f4a0c5b VZ |
1764 | pattern++; |
1765 | pattern++; | |
1766 | } | |
223d09f6 | 1767 | if (*pattern != wxT('\0')) { |
3f4a0c5b VZ |
1768 | pattern++, str++; |
1769 | } | |
1770 | break; | |
223d09f6 | 1771 | case wxT('?'): |
3f4a0c5b VZ |
1772 | pattern++; |
1773 | str++; | |
1774 | break; | |
1775 | case OB: | |
1776 | pattern++; | |
223d09f6 | 1777 | while ((*pattern != CB) && (*pattern != wxT('\0'))) { |
3f4a0c5b VZ |
1778 | cp = str; |
1779 | ok = TRUE; | |
223d09f6 KB |
1780 | while (ok && (*cp != wxT('\0')) && (*pattern != wxT('\0')) |
1781 | && (*pattern != wxT(',')) && (*pattern != CB)) { | |
1782 | if (*pattern == wxT('\\')) | |
3f4a0c5b VZ |
1783 | pattern++; |
1784 | ok = (*pattern++ == *cp++); | |
1785 | } | |
223d09f6 | 1786 | if (*pattern == wxT('\0')) { |
3f4a0c5b VZ |
1787 | ok = FALSE; |
1788 | done = TRUE; | |
1789 | break; | |
1790 | } else if (ok) { | |
1791 | str = cp; | |
223d09f6 KB |
1792 | while ((*pattern != CB) && (*pattern != wxT('\0'))) { |
1793 | if (*++pattern == wxT('\\')) { | |
3f4a0c5b VZ |
1794 | if (*++pattern == CB) |
1795 | pattern++; | |
1796 | } | |
1797 | } | |
1798 | } else { | |
223d09f6 KB |
1799 | while (*pattern!=CB && *pattern!=wxT(',') && *pattern!=wxT('\0')) { |
1800 | if (*++pattern == wxT('\\')) { | |
1801 | if (*++pattern == CB || *pattern == wxT(',')) | |
3f4a0c5b VZ |
1802 | pattern++; |
1803 | } | |
1804 | } | |
1805 | } | |
223d09f6 | 1806 | if (*pattern != wxT('\0')) |
3f4a0c5b VZ |
1807 | pattern++; |
1808 | } | |
1809 | break; | |
1810 | default: | |
1811 | if (*str == *pattern) { | |
1812 | str++, pattern++; | |
1813 | } else { | |
1814 | done = TRUE; | |
1815 | } | |
1816 | } | |
7f555861 | 1817 | } |
223d09f6 | 1818 | while (*pattern == wxT('*')) |
3f4a0c5b | 1819 | pattern++; |
223d09f6 | 1820 | return ((*str == wxT('\0')) && (*pattern == wxT('\0'))); |
7f555861 | 1821 | }; |
fd3f686c | 1822 | |
e21a44de | 1823 | #endif // HAVE_FNMATCH/!HAVE_FNMATCH |
7f555861 | 1824 | |
3f4a0c5b | 1825 | #ifdef __VISUALC__ |
fd3f686c | 1826 | #pragma warning(default:4706) // assignment within conditional expression |
53c6e7cc | 1827 | #endif // VC++ |