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