]> git.saurik.com Git - wxWidgets.git/blob - src/common/filefn.cpp
projects / wxWidgets.git / blob
? search:


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