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