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 #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
  30 #include <ctype.h>
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #if !defined(__WATCOMC__)
  35 #if !(defined(_MSC_VER) && (_MSC_VER > 800))
  36 #include <errno.h>
  37 #endif
  38 #endif
  39 #include <time.h>
  40 #include <sys/types.h>
  41 #include <sys/stat.h>
  42
  43 #ifdef __UNIX__
  44 #include <unistd.h>
  45 #include <dirent.h>
  46 #endif
  47
  48 #ifdef __WINDOWS__
  49 #ifndef __GNUWIN32__
  50 #include <direct.h>
  51 #include <dos.h>
  52 #endif
  53 #endif
  54
  55 #ifdef __GNUWIN32__
  56 #include <sys/unistd.h>
  57 // #include <sys/stat.h>
  58
  59 #ifndef __MINGW32__
  60 #include <std.h>
  61 #endif
  62
  63 #define stricmp strcasecmp
  64 #endif
  65
  66 #ifdef __BORLANDC__ // Please someone tell me which version of Borland needs
  67                     // this (3.1 I believe) and how to test for it.
  68                     // If this works for Borland 4.0 as well, then no worries.
  69 #include <dir.h>
  70 #endif
  71
  72 #ifdef __WINDOWS__
  73 #include "windows.h"
  74 #endif
  75
  76 #define _MAXPATHLEN 500
  77
  78 #if !USE_SHARED_LIBRARY
  79 IMPLEMENT_DYNAMIC_CLASS(wxPathList, wxStringList)
  80 #endif
  81
  82 extern char *wxBuffer;
  83
  84 void wxPathList::Add (const wxString& path)
  85 {
  86   wxStringList::Add ((char *)(const char *)path);
  87 }
  88
  89 // Add paths e.g. from the PATH environment variable
  90 void wxPathList::AddEnvList (const wxString& envVariable)
  91 {
  92   static const char PATH_TOKS[] =
  93 #ifdef __WINDOWS__
  94         " ;"; // Don't seperate with colon in DOS (used for drive)
  95 #else
  96         " :;";
  97 #endif
  98
  99   char *val = getenv (WXSTRINGCAST envVariable);
 100   if (val && *val)
 101     {
 102       char *s = copystring (val);
 103       char *token = strtok (s, PATH_TOKS);
 104
 105       if (token)
 106         {
 107           Add (copystring (token));
 108           while (token)
 109             {
 110               if ((token = strtok (NULL, PATH_TOKS)) != NULL)
 111                 Add (wxString(token));
 112             }
 113         }
 114       delete[]s;
 115     }
 116 }
 117
 118 // Given a full filename (with path), ensure that that file can
 119 // be accessed again USING FILENAME ONLY by adding the path
 120 // to the list if not already there.
 121 void wxPathList::EnsureFileAccessible (const wxString& path)
 122 {
 123   wxString path1(path);
 124   char *path_only = wxPathOnly (WXSTRINGCAST path1);
 125   if (path_only)
 126   {
 127       if (!Member (wxString(path_only)))
 128             Add (wxString(path_only));
 129   }
 130 }
 131
 132 bool wxPathList::Member (const wxString& path)
 133 {
 134   for (wxNode * node = First (); node != NULL; node = node->Next ())
 135   {
 136       wxString path2((char *) node->Data ());
 137       if (
 138 #if defined(__WINDOWS__) || defined(__VMS__)
 139       // Case INDEPENDENT
 140           path.CompareTo (path2, wxString::ignoreCase) == 0
 141 #else
 142       // Case sensitive File System
 143           path.CompareTo (path2) == 0
 144 #endif
 145         )
 146         return TRUE;
 147   }
 148   return FALSE;
 149 }
 150
 151 wxString wxPathList::FindValidPath (const wxString& file)
 152 {
 153   if (wxFileExists (wxExpandPath(wxBuffer, file)))
 154     return wxString(wxBuffer);
 155
 156   char buf[_MAXPATHLEN];
 157   strcpy(buf, wxBuffer);
 158
 159   char *filename = IsAbsolutePath (buf) ? wxFileNameFromPath (buf) : (char *)buf;
 160
 161   for (wxNode * node = First (); node; node = node->Next ())
 162     {
 163       char *path = (char *) node->Data ();
 164       strcpy (wxBuffer, path);
 165       char ch = wxBuffer[strlen(wxBuffer)-1];
 166       if (ch != '\\' && ch != '/')
 167         strcat (wxBuffer, "/");
 168       strcat (wxBuffer, filename);
 169 #ifdef __WINDOWS__
 170       Unix2DosFilename (wxBuffer);
 171 #endif
 172       if (wxFileExists (wxBuffer))
 173       {
 174         return wxString(wxBuffer);      // Found!
 175       }
 176     }                           // for()
 177
 178   return wxString("");                  // Not found
 179 }
 180
 181 wxString wxPathList::FindAbsoluteValidPath (const wxString& file)
 182 {
 183   wxString f = FindValidPath(file);
 184   if (wxIsAbsolutePath(f))
 185     return f;
 186   else
 187   {
 188     char buf[500];
 189     wxGetWorkingDirectory(buf, 499);
 190     int len = (int)strlen(buf);
 191     char lastCh = 0;
 192     if (len > 0)
 193       lastCh = buf[len-1];
 194     if (lastCh != '/' && lastCh != '\\')
 195     {
 196 #ifdef __WINDOWS__
 197       strcat(buf, "\\");
 198 #else
 199       strcat(buf, "/");
 200 #endif
 201     }
 202     strcat(buf, (const char *)f);
 203     strcpy(wxBuffer, buf);
 204     return wxString(wxBuffer);
 205   }
 206 }
 207
 208 bool
 209 wxFileExists (const wxString& filename)
 210 {
 211   struct stat stbuf;
 212
 213   if (filename && stat ((char *)(const char *)filename, &stbuf) == 0)
 214     return TRUE;
 215   return FALSE;
 216 }
 217
 218 /* Vadim's alternative implementation
 219
 220 // does the file exist?
 221 bool wxFileExists(const char *pszFileName)
 222 {
 223   struct stat st;
 224   return !access(pszFileName, 0) &&
 225          !stat(pszFileName, &st) &&
 226          (st.st_mode & S_IFREG);
 227 }
 228 */
 229
 230 bool
 231 wxIsAbsolutePath (const wxString& filename)
 232 {
 233   if (filename != "")
 234     {
 235       if (filename[0] == '/'
 236 #ifdef __VMS__
 237       || (filename[0] == '[' && filename[1] != '.')
 238 #endif
 239 #ifdef __WINDOWS__
 240       /* MSDOS */
 241       || filename[0] == '\\' || (isalpha (filename[0]) && filename[1] == ':')
 242 #endif
 243         )
 244         return TRUE;
 245     }
 246   return FALSE;
 247 }
 248
 249 /*
 250  * Strip off any extension (dot something) from end of file,
 251  * IF one exists. Inserts zero into buffer.
 252  *
 253  */
 254
 255 void wxStripExtension(char *buffer)
 256 {
 257   int len = strlen(buffer);
 258   int i = len-1;
 259   while (i > 0)
 260   {
 261     if (buffer[i] == '.')
 262     {
 263       buffer[i] = 0;
 264       break;
 265     }
 266     i --;
 267   }
 268 }
 269
 270 // Destructive removal of /./ and /../ stuff
 271 char *wxRealPath (char *path)
 272 {
 273 #ifdef __WINDOWS__
 274   static const char SEP = '\\';
 275   Unix2DosFilename(path);
 276 #else
 277   static const char SEP = '/';
 278 #endif
 279   if (path[0] && path[1]) {
 280     /* MATTHEW: special case "/./x" */
 281     char *p;
 282     if (path[2] == SEP && path[1] == '.')
 283       p = &path[0];
 284     else
 285       p = &path[2];
 286     for (; *p; p++)
 287       {
 288         if (*p == SEP)
 289           {
 290             if (p[1] == '.' && p[2] == '.' && (p[3] == SEP || p[3] == '\0'))
 291               {
 292                 char *q;
 293                 for (q = p - 1; q >= path && *q != SEP; q--);
 294                 if (q[0] == SEP && (q[1] != '.' || q[2] != '.' || q[3] != SEP)
 295                     && (q - 1 <= path || q[-1] != SEP))
 296                   {
 297                     strcpy (q, p + 3);
 298                     if (path[0] == '\0')
 299                       {
 300                         path[0] = SEP;
 301                         path[1] = '\0';
 302                       }
 303 #ifdef __WINDOWS__
 304                     /* Check that path[2] is NULL! */
 305                     else if (path[1] == ':' && !path[2])
 306                       {
 307                         path[2] = SEP;
 308                         path[3] = '\0';
 309                       }
 310 #endif
 311                     p = q - 1;
 312                   }
 313               }
 314             else if (p[1] == '.' && (p[2] == SEP || p[2] == '\0'))
 315               strcpy (p, p + 2);
 316           }
 317       }
 318   }
 319   return path;
 320 }
 321
 322 // Must be destroyed
 323 char *wxCopyAbsolutePath(const wxString& filename)
 324 {
 325   if (filename == "")
 326     return NULL;
 327
 328   if (! IsAbsolutePath(wxExpandPath(wxBuffer, filename))) {
 329     char    buf[_MAXPATHLEN];
 330     buf[0] = '\0';
 331     wxGetWorkingDirectory(buf, sizeof(buf)/sizeof(char));
 332     char ch = buf[strlen(buf) - 1];
 333 #ifdef __WINDOWS__
 334     if (ch != '\\' && ch != '/')
 335         strcat(buf, "\\");
 336 #else
 337     if (ch != '/')
 338         strcat(buf, "/");
 339 #endif
 340     strcat(buf, wxBuffer);
 341     return copystring( wxRealPath(buf) );
 342   }
 343   return copystring( wxBuffer );
 344 }
 345
 346 /*-
 347  Handles:
 348    ~/ => home dir
 349    ~user/ => user's home dir
 350    If the environment variable a = "foo" and b = "bar" then:
 351    Unix:
 352         $a      =>      foo
 353         $a$b    =>      foobar
 354         $a.c    =>      foo.c
 355         xxx$a   =>      xxxfoo
 356         ${a}!   =>      foo!
 357         $(b)!   =>      bar!
 358         \$a     =>      \$a
 359    MSDOS:
 360         $a      ==>     $a
 361         $(a)    ==>     foo
 362         $(a)$b  ==>     foo$b
 363         $(a)$(b)==>     foobar
 364         test.$$ ==>     test.$$
 365  */
 366
 367 /* input name in name, pathname output to buf. */
 368
 369 char *wxExpandPath(char *buf, const char *name)
 370 {
 371     register char  *d, *s, *nm;
 372     char            lnm[_MAXPATHLEN];
 373     int                         q;
 374
 375     // Some compilers don't like this line.
 376 //    const char      trimchars[] = "\n \t";
 377
 378     char      trimchars[4];
 379     trimchars[0] = '\n';
 380     trimchars[1] = ' ';
 381     trimchars[2] = '\t';
 382     trimchars[3] = 0;
 383
 384 #ifdef __WINDOWS__
 385      const char     SEP = '\\';
 386 #else
 387      const char     SEP = '/';
 388 #endif
 389     buf[0] = '\0';
 390     if (name == NULL || *name == '\0')
 391         return buf;
 392     nm = copystring(name); // Make a scratch copy
 393     char *nm_tmp = nm;
 394
 395     /* Skip leading whitespace and cr */
 396     while (strchr((char *)trimchars, *nm) != NULL)
 397         nm++;
 398     /* And strip off trailing whitespace and cr */
 399     s = nm + (q = strlen(nm)) - 1;
 400     while (q-- && strchr((char *)trimchars, *s) != NULL)
 401         *s = '\0';
 402
 403     s = nm;
 404     d = lnm;
 405 #ifdef __WINDOWS__
 406     q = FALSE;
 407 #else
 408     q = nm[0] == '\\' && nm[1] == '~';
 409 #endif
 410
 411     /* Expand inline environment variables */
 412     while ((*d++ = *s)) {
 413 #ifndef __WINDOWS__
 414         if (*s == '\\') {
 415             if ((*(d - 1) = *++s)) {
 416                 s++;
 417                 continue;
 418             } else
 419                 break;
 420         } else
 421 #endif
 422 #ifdef __WINDOWS__
 423         if (*s++ == '$' && (*s == '{' || *s == ')'))
 424 #else
 425         if (*s++ == '$')
 426 #endif
 427         {
 428             register char  *start = d;
 429             register        braces = (*s == '{' || *s == '(');
 430             register char  *value;
 431             while ((*d++ = *s))
 432                 if (braces ? (*s == '}' || *s == ')') : !(isalnum(*s) || *s == '_') )
 433                     break;
 434                 else
 435                     s++;
 436             *--d = 0;
 437             value = getenv(braces ? start + 1 : start);
 438             if (value) {
 439                 for ((d = start - 1); (*d++ = *value++););
 440                 d--;
 441                 if (braces && *s)
 442                     s++;
 443             }
 444         }
 445     }
 446
 447     /* Expand ~ and ~user */
 448     nm = lnm;
 449     s = "";
 450     if (nm[0] == '~' && !q)
 451     {
 452         /* prefix ~ */
 453         if (nm[1] == SEP || nm[1] == 0)
 454         {       /* ~/filename */
 455             if ((s = wxGetUserHome("")) != NULL) {
 456                 if (*++nm)
 457                     nm++;
 458             }
 459         } else
 460         {               /* ~user/filename */
 461             register char  *nnm;
 462             register char  *home;
 463             for (s = nm; *s && *s != SEP; s++);
 464             int was_sep; /* MATTHEW: Was there a separator, or NULL? */
 465             was_sep = (*s == SEP);
 466             nnm = *s ? s + 1 : s;
 467             *s = 0;
 468             if ((home = wxGetUserHome(wxString(nm + 1))) == NULL) {
 469                if (was_sep) /* replace only if it was there: */
 470                   *s = SEP;
 471                 s = "";
 472             } else {
 473                 nm = nnm;
 474                 s = home;
 475             }
 476         }
 477     }
 478
 479     d = buf;
 480     if (s && *s) { /* MATTHEW: s could be NULL if user '~' didn't exist */
 481         /* Copy home dir */
 482         while ('\0' != (*d++ = *s++))
 483           /* loop */;
 484         // Handle root home
 485         if (d - 1 > buf && *(d - 2) != SEP)
 486           *(d - 1) = SEP;
 487     }
 488     s = nm;
 489     while ((*d++ = *s++));
 490
 491     delete[] nm_tmp; // clean up alloc
 492     /* Now clean up the buffer */
 493     return wxRealPath(buf);
 494 }
 495
 496
 497 /* Contract Paths to be build upon an environment variable
 498    component:
 499
 500    example: "/usr/openwin/lib", OPENWINHOME --> ${OPENWINHOME}/lib
 501
 502    The call wxExpandPath can convert these back!
 503  */
 504 char *
 505 wxContractPath (const wxString& filename, const wxString& envname, const wxString& user)
 506 {
 507   static char dest[_MAXPATHLEN];
 508
 509   if (filename == "")
 510     return NULL;
 511
 512   strcpy (dest, WXSTRINGCAST filename);
 513 #ifdef __WINDOWS__
 514   Unix2DosFilename(dest);
 515 #endif
 516
 517   // Handle environment
 518   char *val = NULL;
 519   char *tcp = NULL;
 520   if (envname != NULL && (val = getenv (WXSTRINGCAST envname)) != NULL &&
 521      (tcp = strstr (dest, val)) != NULL)
 522     {
 523         strcpy (wxBuffer, tcp + strlen (val));
 524         *tcp++ = '$';
 525         *tcp++ = '{';
 526         strcpy (tcp, WXSTRINGCAST envname);
 527         strcat (tcp, "}");
 528         strcat (tcp, wxBuffer);
 529     }
 530
 531   // Handle User's home (ignore root homes!)
 532   size_t len = 0;
 533   if ((val = wxGetUserHome (user)) != NULL &&
 534       (len = strlen(val)) > 2 &&
 535       strncmp(dest, val, len) == 0)
 536     {
 537       strcpy(wxBuffer, "~");
 538       if (user && *user)
 539         strcat(wxBuffer, user);
 540 #ifdef __WINDOWS__
 541 //      strcat(wxBuffer, "\\");
 542 #else
 543 //      strcat(wxBuffer, "/");
 544 #endif
 545       strcat(wxBuffer, dest + len);
 546       strcpy (dest, wxBuffer);
 547     }
 548
 549   return dest;
 550 }
 551
 552 // Return just the filename, not the path
 553 // (basename)
 554 char *wxFileNameFromPath (char *path)
 555 {
 556   if (path)
 557     {
 558       register char *tcp;
 559
 560       tcp = path + strlen (path);
 561       while (--tcp >= path)
 562         {
 563           if (*tcp == '/' || *tcp == '\\'
 564 #ifdef __VMS__
 565      || *tcp == ':' || *tcp == ']')
 566 #else
 567      )
 568 #endif
 569             return tcp + 1;
 570         }                       /* while */
 571 #ifdef __WINDOWS__
 572       if (isalpha (*path) && *(path + 1) == ':')
 573         return path + 2;
 574 #endif
 575     }
 576   return path;
 577 }
 578
 579 wxString wxFileNameFromPath (const wxString& path1)
 580 {
 581   if (path1 != "")
 582   {
 583
 584       char *path = WXSTRINGCAST path1 ;
 585       register char *tcp;
 586
 587       tcp = path + strlen (path);
 588       while (--tcp >= path)
 589           {
 590             if (*tcp == '/' || *tcp == '\\'
 591 #ifdef __VMS__
 592         || *tcp == ':' || *tcp == ']')
 593 #else
 594         )
 595 #endif
 596                 return wxString(tcp + 1);
 597             }                   /* while */
 598 #ifdef __WINDOWS__
 599       if (isalpha (*path) && *(path + 1) == ':')
 600             return wxString(path + 2);
 601 #endif
 602     }
 603   return wxString("");
 604 }
 605
 606 // Return just the directory, or NULL if no directory
 607 char *
 608 wxPathOnly (char *path)
 609 {
 610   if (path && *path)
 611     {
 612       static char buf[_MAXPATHLEN];
 613
 614       // Local copy
 615       strcpy (buf, path);
 616
 617       int l = strlen(path);
 618       bool done = FALSE;
 619
 620       int i = l - 1;
 621
 622       // Search backward for a backward or forward slash
 623       while (!done && i > -1)
 624       {
 625         // ] is for VMS
 626         if (path[i] == '/' || path[i] == '\\' || path[i] == ']')
 627         {
 628           done = TRUE;
 629 #ifdef __VMS__
 630           buf[i+1] = 0;
 631 #else
 632           buf[i] = 0;
 633 #endif
 634
 635           return buf;
 636         }
 637         else i --;
 638       }
 639
 640 #ifdef __WINDOWS__
 641       // Try Drive specifier
 642       if (isalpha (buf[0]) && buf[1] == ':')
 643         {
 644           // A:junk --> A:. (since A:.\junk Not A:\junk)
 645           buf[2] = '.';
 646           buf[3] = '\0';
 647           return buf;
 648         }
 649 #endif
 650     }
 651
 652   return NULL;
 653 }
 654
 655 // Return just the directory, or NULL if no directory
 656 wxString wxPathOnly (const wxString& path)
 657 {
 658   if (path != "")
 659     {
 660       char buf[_MAXPATHLEN];
 661
 662       // Local copy
 663       strcpy (buf, WXSTRINGCAST path);
 664
 665       int l = path.Length();
 666       bool done = FALSE;
 667
 668       int i = l - 1;
 669
 670       // Search backward for a backward or forward slash
 671       while (!done && i > -1)
 672       {
 673         // ] is for VMS
 674         if (path[i] == '/' || path[i] == '\\' || path[i] == ']')
 675         {
 676           done = TRUE;
 677 #ifdef __VMS__
 678           buf[i+1] = 0;
 679 #else
 680           buf[i] = 0;
 681 #endif
 682
 683           return wxString(buf);
 684         }
 685         else i --;
 686       }
 687
 688 #ifdef __WINDOWS__
 689       // Try Drive specifier
 690       if (isalpha (buf[0]) && buf[1] == ':')
 691         {
 692           // A:junk --> A:. (since A:.\junk Not A:\junk)
 693           buf[2] = '.';
 694           buf[3] = '\0';
 695           return wxString(buf);
 696         }
 697 #endif
 698     }
 699
 700   return wxString("");
 701 }
 702
 703 // Utility for converting delimiters in DOS filenames to UNIX style
 704 // and back again - or we get nasty problems with delimiters.
 705 // Also, convert to lower case, since case is significant in UNIX.
 706
 707 void
 708 wxDos2UnixFilename (char *s)
 709 {
 710   if (s)
 711     while (*s)
 712       {
 713         if (*s == '\\')
 714           *s = '/';
 715 #ifdef __WINDOWS__
 716         else
 717           *s = wxToLower (*s);  // Case INDEPENDENT
 718 #endif
 719         s++;
 720       }
 721 }
 722
 723 void
 724 wxUnix2DosFilename (char *s)
 725 {
 726 // Yes, I really mean this to happen under DOS only! JACS
 727 #ifdef __WINDOWS__
 728   if (s)
 729     while (*s)
 730       {
 731         if (*s == '/')
 732           *s = '\\';
 733         s++;
 734       }
 735 #endif
 736 }
 737
 738 // Concatenate two files to form third
 739 bool
 740 wxConcatFiles (const wxString& file1, const wxString& file2, const wxString& file3)
 741 {
 742   char *outfile = wxGetTempFileName("cat");
 743
 744   FILE *fp1 = NULL;
 745   FILE *fp2 = NULL;
 746   FILE *fp3 = NULL;
 747   // Open the inputs and outputs
 748   if ((fp1 = fopen (WXSTRINGCAST file1, "rb")) == NULL ||
 749       (fp2 = fopen (WXSTRINGCAST file2, "rb")) == NULL ||
 750       (fp3 = fopen (outfile, "wb")) == NULL)
 751     {
 752       if (fp1)
 753         fclose (fp1);
 754       if (fp2)
 755         fclose (fp2);
 756       if (fp3)
 757         fclose (fp3);
 758       return FALSE;
 759     }
 760
 761   int ch;
 762   while ((ch = getc (fp1)) != EOF)
 763     (void) putc (ch, fp3);
 764   fclose (fp1);
 765
 766   while ((ch = getc (fp2)) != EOF)
 767     (void) putc (ch, fp3);
 768   fclose (fp2);
 769
 770   fclose (fp3);
 771   bool result = wxRenameFile(outfile, file3);
 772   delete[] outfile;
 773   return result;
 774 }
 775
 776 // Copy files
 777 bool
 778 wxCopyFile (const wxString& file1, const wxString& file2)
 779 {
 780   FILE *fd1;
 781   FILE *fd2;
 782   int ch;
 783
 784   if ((fd1 = fopen (WXSTRINGCAST file1, "rb")) == NULL)
 785     return FALSE;
 786   if ((fd2 = fopen (WXSTRINGCAST file2, "wb")) == NULL)
 787     {
 788       fclose (fd1);
 789       return FALSE;
 790     }
 791
 792   while ((ch = getc (fd1)) != EOF)
 793     (void) putc (ch, fd2);
 794
 795   fclose (fd1);
 796   fclose (fd2);
 797   return TRUE;
 798 }
 799
 800 bool
 801 wxRenameFile (const wxString& file1, const wxString& file2)
 802 {
 803   // Normal system call
 804   if (0 == rename (WXSTRINGCAST file1, WXSTRINGCAST file2))
 805     return TRUE;
 806   // Try to copy
 807   if (wxCopyFile(file1, file2)) {
 808     wxRemoveFile(file1);
 809     return TRUE;
 810   }
 811   // Give up
 812   return FALSE;
 813 }
 814
 815 bool wxRemoveFile(const wxString& file)
 816 {
 817 #if defined(_MSC_VER) || defined(__BORLANDC__)
 818   int flag = remove(WXSTRINGCAST file);
 819 #else
 820   int flag = unlink(WXSTRINGCAST file);
 821 #endif
 822   return (flag == 0) ;
 823 }
 824
 825 bool wxMkdir(const wxString& dir)
 826 {
 827 #ifdef __VMS__
 828         return FALSE;
 829 #elif (defined(__GNUWIN32__) && !defined(__MINGW32__)) || !defined(__WINDOWS__)
 830   return (mkdir (WXSTRINGCAST dir, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) == 0);
 831 #else
 832   return (mkdir(WXSTRINGCAST dir) == 0);
 833 #endif
 834 }
 835
 836 bool wxRmdir(const wxString& dir, int WXUNUSED(flags))
 837 {
 838 #ifdef __VMS__
 839   return FALSE;
 840 #else
 841   return (rmdir(WXSTRINGCAST dir) == 0);
 842 #endif
 843 }
 844
 845 #if 0
 846 bool wxDirExists(const wxString& dir)
 847 {
 848 #ifdef __VMS__
 849   return FALSE;
 850 #elif !defined(__WINDOWS__)
 851   struct stat sbuf;
 852   return (stat(dir, &sbuf) != -1) && S_ISDIR(sbuf.st_mode) ? TRUE : FALSE;
 853 #else
 854
 855   /* MATTHEW: [6] Always use same code for Win32, call FindClose */
 856 #if defined(__WIN32__)
 857   WIN32_FIND_DATA fileInfo;
 858 #else
 859 #ifdef __BORLANDC__
 860   struct ffblk fileInfo;
 861 #else
 862   struct find_t fileInfo;
 863 #endif
 864 #endif
 865
 866 #if defined(__WIN32__)
 867         HANDLE h = FindFirstFile((LPTSTR) WXSTRINGCAST dir,(LPWIN32_FIND_DATA)&fileInfo);
 868
 869         if (h==INVALID_HANDLE_VALUE)
 870          return FALSE;
 871         else {
 872          FindClose(h);
 873          return ((fileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY);
 874         }
 875 #else
 876   // In Borland findfirst has a different argument
 877   // ordering from _dos_findfirst. But _dos_findfirst
 878   // _should_ be ok in both MS and Borland... why not?
 879 #ifdef __BORLANDC__
 880   return ((findfirst(WXSTRINGCAST dir, &fileInfo, _A_SUBDIR) == 0  && (fileInfo.ff_attrib & _A_SUBDIR) != 0));
 881 #else
 882   return (((_dos_findfirst(WXSTRINGCAST dir, _A_SUBDIR, &fileInfo) == 0) && (fileInfo.attrib & _A_SUBDIR)) != 0);
 883 #endif
 884 #endif
 885
 886 #endif
 887 }
 888
 889 #endif
 890
 891 // does the path exists? (may have or not '/' or '\\' at the end)
 892 bool wxPathExists(const char *pszPathName)
 893 {
 894   // Windows API returns -1 from stat for "c:\dir\" if "c:\dir" exists
 895   // OTOH, we should change "d:" to "d:\" and leave "\" as is.
 896   wxString strPath(pszPathName);
 897   if ( wxEndsWithPathSeparator(pszPathName) && pszPathName[1] != '\0' )
 898     strPath.Last() = '\0';
 899
 900   struct stat st;
 901   return stat(strPath, &st) == 0 && (st.st_mode & S_IFDIR);
 902 }
 903
 904 // Get a temporary filename, opening and closing the file.
 905 char *wxGetTempFileName(const wxString& prefix, char *buf)
 906 {
 907 #ifdef __WINDOWS__
 908
 909 #ifndef __WIN32__
 910   char tmp[144];
 911   ::GetTempFileName(0, WXSTRINGCAST prefix, 0, tmp);
 912 #else
 913   char tmp[MAX_PATH];
 914   char tmpPath[MAX_PATH];
 915   ::GetTempPath(MAX_PATH, tmpPath);
 916   ::GetTempFileName(tmpPath, WXSTRINGCAST prefix, 0, tmp);
 917 #endif
 918   if (buf) strcpy(buf, tmp);
 919   else buf = copystring(tmp);
 920   return buf;
 921
 922 #else
 923   static short last_temp = 0;   // cache last to speed things a bit
 924   // At most 1000 temp files to a process! We use a ring count.
 925   char tmp[100];
 926
 927   for (short suffix = last_temp + 1; suffix != last_temp; ++suffix %= 1000)
 928     {
 929       sprintf (tmp, "/tmp/%s%d.%03x", WXSTRINGCAST prefix, (int) getpid (), (int) suffix);
 930       if (!wxFileExists( tmp ))
 931         {
 932           // Touch the file to create it (reserve name)
 933           FILE *fd = fopen (tmp, "w");
 934           if (fd)
 935             fclose (fd);
 936           last_temp = suffix;
 937           if (buf)
 938             strcpy( buf, tmp);
 939           else
 940             buf = copystring( tmp );
 941           return buf;
 942         }
 943     }
 944   cerr << "wxWindows: error finding temporary file name.\n";
 945   if (buf) buf[0] = 0;
 946   return NULL;
 947 #endif
 948 }
 949
 950 // Get first file name matching given wild card.
 951
 952 #ifdef __UNIX__
 953
 954 // Get first file name matching given wild card.
 955 // Flags are reserved for future use.
 956
 957 #ifndef __VMS__
 958 static DIR *wxDirStream = NULL;
 959 static char *wxFileSpec = NULL;
 960 static int wxFindFileFlags = 0;
 961 #endif
 962
 963 char *wxFindFirstFile(const char *spec, int flags)
 964 {
 965 #ifndef __VMS__
 966   if (wxDirStream)
 967     closedir(wxDirStream); // edz 941103: better housekeping
 968
 969   wxFindFileFlags = flags;
 970
 971   if (wxFileSpec)
 972     delete[] wxFileSpec;
 973   wxFileSpec = copystring(spec);
 974
 975   // Find path only so we can concatenate
 976   // found file onto path
 977   char *p = wxPathOnly(wxFileSpec);
 978
 979   /* MATTHEW: special case: path is really "/" */
 980   if (p && !*p && *wxFileSpec == '/')
 981     p = "/";
 982   /* MATTHEW: p is NULL => Local directory */
 983   if (!p)
 984     p = ".";
 985
 986   if ((wxDirStream=opendir(p))==NULL)
 987     return NULL;
 988
 989  /* MATTHEW: [5] wxFindNextFile can do the rest of the work */
 990   return wxFindNextFile();
 991 #endif
 992  // ifndef __VMS__
 993   return NULL;
 994 }
 995
 996 char *wxFindNextFile(void)
 997 {
 998 #ifndef __VMS__
 999   static char buf[400];
1000
1001   /* MATTHEW: [2] Don't crash if we read too many times */
1002   if (!wxDirStream)
1003     return NULL;
1004
1005   // Find path only so we can concatenate
1006   // found file onto path
1007   char *p = wxPathOnly(wxFileSpec);
1008   char *n = wxFileNameFromPath(wxFileSpec);
1009
1010   /* MATTHEW: special case: path is really "/" */
1011   if (p && !*p && *wxFileSpec == '/')
1012     p = "/";
1013
1014   // Do the reading
1015   struct dirent *nextDir;
1016   for (nextDir = readdir(wxDirStream); nextDir != NULL; nextDir = readdir(wxDirStream))
1017   {
1018
1019     /* MATTHEW: [5] Only return "." and ".." when they match, and only return
1020        directories when flags & wxDIR */
1021     if (wxMatchWild(n, nextDir->d_name)) {
1022       bool isdir;
1023
1024       buf[0] = 0;
1025       if (p && *p) {
1026         strcpy(buf, p);
1027         if (strcmp(p, "/") != 0)
1028           strcat(buf, "/");
1029       }
1030       strcat(buf, nextDir->d_name);
1031
1032       if ((strcmp(nextDir->d_name, ".") == 0) ||
1033           (strcmp(nextDir->d_name, "..") == 0)) {
1034         if (wxFindFileFlags && !(wxFindFileFlags & wxDIR))
1035           continue;
1036         isdir = TRUE;
1037       } else
1038         isdir = wxDirExists(buf);
1039
1040       if (!wxFindFileFlags
1041           || ((wxFindFileFlags & wxDIR) && isdir)
1042           || ((wxFindFileFlags & wxFILE) && !isdir))
1043         return buf;
1044     }
1045   }
1046   closedir(wxDirStream);
1047   wxDirStream = NULL;
1048 #endif
1049  // ifndef __VMS__
1050
1051   return NULL;
1052 }
1053
1054 #elif defined(__WINDOWS__)
1055
1056 #ifdef __WIN32__
1057 HANDLE wxFileStrucHandle = INVALID_HANDLE_VALUE;
1058 WIN32_FIND_DATA wxFileStruc;
1059 #else
1060 #ifdef __BORLANDC__
1061 static struct ffblk wxFileStruc;
1062 #else
1063 static struct _find_t wxFileStruc;
1064 #endif
1065 #endif
1066 static wxString wxFileSpec = "";
1067 static int wxFindFileFlags;
1068
1069 char *wxFindFirstFile(const wxString& spec, int flags)
1070 {
1071   wxFileSpec = spec;
1072   wxFindFileFlags = flags; /* MATTHEW: [5] Remember flags */
1073
1074   // Find path only so we can concatenate
1075   // found file onto path
1076   wxString path1(wxFileSpec);
1077   char *p = wxPathOnly(WXSTRINGCAST path1);
1078   if (p && (strlen(p) > 0))
1079          strcpy(wxBuffer, p);
1080   else
1081          wxBuffer[0] = 0;
1082
1083 #ifdef __WIN32__
1084   if (wxFileStrucHandle != INVALID_HANDLE_VALUE)
1085          FindClose(wxFileStrucHandle);
1086
1087   wxFileStrucHandle = ::FindFirstFile(WXSTRINGCAST spec, &wxFileStruc);
1088
1089   if (wxFileStrucHandle == INVALID_HANDLE_VALUE)
1090          return NULL;
1091
1092   bool isdir = !!(wxFileStruc.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
1093
1094   if (isdir && !(flags & wxDIR))
1095          return wxFindNextFile();
1096   else if (!isdir && flags && !(flags & wxFILE))
1097          return wxFindNextFile();
1098
1099   if (wxBuffer[0] != 0)
1100          strcat(wxBuffer, "\\");
1101   strcat(wxBuffer, wxFileStruc.cFileName);
1102   return wxBuffer;
1103 #else
1104
1105   int flag = _A_NORMAL;
1106   if (flags & wxDIR) /* MATTHEW: [5] Use & */
1107     flag = _A_SUBDIR;
1108
1109 #ifdef __BORLANDC__
1110   if (findfirst(WXSTRINGCAST spec, &wxFileStruc, flag) == 0)
1111 #else
1112   if (_dos_findfirst(WXSTRINGCAST spec, flag, &wxFileStruc) == 0)
1113 #endif
1114   {
1115     /* MATTHEW: [5] Check directory flag */
1116     char attrib;
1117
1118 #ifdef __BORLANDC__
1119     attrib = wxFileStruc.ff_attrib;
1120 #else
1121     attrib = wxFileStruc.attrib;
1122 #endif
1123
1124     if (attrib & _A_SUBDIR) {
1125       if (!(wxFindFileFlags & wxDIR))
1126         return wxFindNextFile();
1127     } else if (wxFindFileFlags && !(wxFindFileFlags & wxFILE))
1128                 return wxFindNextFile();
1129
1130          if (wxBuffer[0] != 0)
1131                 strcat(wxBuffer, "\\");
1132
1133 #ifdef __BORLANDC__
1134          strcat(wxBuffer, wxFileStruc.ff_name);
1135 #else
1136          strcat(wxBuffer, wxFileStruc.name);
1137 #endif
1138          return wxBuffer;
1139   }
1140   else
1141     return NULL;
1142 #endif // __WIN32__
1143 }
1144
1145 char *wxFindNextFile(void)
1146 {
1147   // Find path only so we can concatenate
1148   // found file onto path
1149   wxString p2(wxFileSpec);
1150   char *p = wxPathOnly(WXSTRINGCAST p2);
1151   if (p && (strlen(p) > 0))
1152          strcpy(wxBuffer, p);
1153   else
1154          wxBuffer[0] = 0;
1155
1156  try_again:
1157
1158 #ifdef __WIN32__
1159   if (wxFileStrucHandle == INVALID_HANDLE_VALUE)
1160          return NULL;
1161
1162   bool success = (FindNextFile(wxFileStrucHandle, &wxFileStruc) != 0);
1163   if (!success) {
1164                 FindClose(wxFileStrucHandle);
1165       wxFileStrucHandle = INVALID_HANDLE_VALUE;
1166                 return NULL;
1167   }
1168
1169   bool isdir = !!(wxFileStruc.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
1170
1171   if (isdir && !(wxFindFileFlags & wxDIR))
1172     goto try_again;
1173   else if (!isdir && wxFindFileFlags && !(wxFindFileFlags & wxFILE))
1174          goto try_again;
1175
1176   if (wxBuffer[0] != 0)
1177     strcat(wxBuffer, "\\");
1178   strcat(wxBuffer, wxFileStruc.cFileName);
1179   return wxBuffer;
1180 #else
1181
1182 #ifdef __BORLANDC__
1183   if (findnext(&wxFileStruc) == 0)
1184 #else
1185   if (_dos_findnext(&wxFileStruc) == 0)
1186 #endif
1187   {
1188     /* MATTHEW: [5] Check directory flag */
1189     char attrib;
1190
1191 #ifdef __BORLANDC__
1192     attrib = wxFileStruc.ff_attrib;
1193 #else
1194     attrib = wxFileStruc.attrib;
1195 #endif
1196
1197     if (attrib & _A_SUBDIR) {
1198       if (!(wxFindFileFlags & wxDIR))
1199         goto try_again;
1200     } else if (wxFindFileFlags && !(wxFindFileFlags & wxFILE))
1201       goto try_again;
1202
1203
1204          if (wxBuffer[0] != 0)
1205       strcat(wxBuffer, "\\");
1206 #ifdef __BORLANDC__
1207          strcat(wxBuffer, wxFileStruc.ff_name);
1208 #else
1209          strcat(wxBuffer, wxFileStruc.name);
1210 #endif
1211          return wxBuffer;
1212   }
1213   else
1214     return NULL;
1215 #endif
1216 }
1217
1218 #endif
1219  // __WINDOWS__
1220
1221 // Get current working directory.
1222 // If buf is NULL, allocates space using new, else
1223 // copies into buf.
1224 char *wxGetWorkingDirectory(char *buf, int sz)
1225 {
1226   if (!buf)
1227     buf = new char[sz+1];
1228 #ifdef _MSC_VER
1229   if (_getcwd(buf, sz) == NULL) {
1230 #else
1231   if (getcwd(buf, sz) == NULL) {
1232 #endif
1233     buf[0] = '.';
1234     buf[1] = '\0';
1235   }
1236   return buf;
1237 }
1238
1239 bool wxSetWorkingDirectory(const wxString& d)
1240 {
1241 #ifdef __UNIX__
1242   return (chdir(d) == 0);
1243 #elif defined(__WINDOWS__)
1244
1245 #ifdef __WIN32__
1246   return (bool)(SetCurrentDirectory(d) != 0);
1247 #else
1248   // Must change drive, too.
1249   bool isDriveSpec = ((strlen(d) > 1) && (d[1] == ':'));
1250   if (isDriveSpec)
1251   {
1252     char firstChar = d[0];
1253
1254     // To upper case
1255     if (firstChar > 90)
1256       firstChar = firstChar - 32;
1257
1258     // To a drive number
1259     unsigned int driveNo = firstChar - 64;
1260     if (driveNo > 0)
1261     {
1262        unsigned int noDrives;
1263        _dos_setdrive(driveNo, &noDrives);
1264     }
1265   }
1266   bool success = (chdir(WXSTRINGCAST d) == 0);
1267
1268   return success;
1269 #endif
1270
1271 #endif
1272 }
1273
1274 bool wxEndsWithPathSeparator(const char *pszFileName)
1275 {
1276   size_t len = Strlen(pszFileName);
1277   if ( len == 0 )
1278     return FALSE;
1279   else
1280     return wxIsPathSeparator(pszFileName[len - 1]);
1281 }
1282
1283 // find a file in a list of directories, returns false if not found
1284 bool wxFindFileInPath(wxString *pStr, const char *pszPath, const char *pszFile)
1285 {
1286   // we assume that it's not empty
1287   wxCHECK_RET( Strlen(pszFile) != 0, FALSE);
1288
1289   // skip path separator in the beginning of the file name if present
1290   if ( wxIsPathSeparator(*pszFile) )
1291     pszFile++;
1292
1293   // copy the path (strtok will modify it)
1294   char *szPath = new char[strlen(pszPath) + 1];
1295   strcpy(szPath, pszPath);
1296
1297   wxString strFile;
1298   char *pc;
1299   for ( pc = strtok(szPath, PATH_SEP); pc; pc = strtok(NULL, PATH_SEP) ) {
1300     // search for the file in this directory
1301     strFile = pc;
1302     if ( !wxEndsWithPathSeparator(pc) )
1303       strFile += FILE_SEP_PATH;
1304     strFile += pszFile;
1305
1306     if ( FileExists(strFile) ) {
1307       *pStr = strFile;
1308       break;
1309     }
1310   }
1311
1312   delete [] szPath;
1313
1314   return pc != NULL;  // if true => we breaked from the loop
1315 }
1316