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