compilation test for Unicode build

[wxWidgets.git] / src / common / filename.cpp

diff --git a/src/common/filename.cpp b/src/common/filename.cpp
index a746dd77b65b97fb90a7ee4d726b5ad3df392833..451effbc3c96c5dc52de539211f32f979eaeb1b0 100644 (file)
--- a/src/common/filename.cpp
+++ b/src/common/filename.cpp
@@ -47,7 +47,7 @@
                 Note that VMS uses different separators unlike Unix:
                  : always after the device. If the path does not contain : than
                    the default (the device of the current directory) is assumed.
                 Note that VMS uses different separators unlike Unix:
                  : always after the device. If the path does not contain : than
                    the default (the device of the current directory) is assumed.

-                 [ start of directory specyfication
+                 [ start of directory specification

                  . separator between directory and subdirectory
                  ] between directory and file
  */
                  . separator between directory and subdirectory
                  ] between directory and file
  */


@@ -60,10 +60,6 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-#pragma implementation "filename.h"
-#endif
-

 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 


@@ -87,6 +83,9 @@
 // For GetShort/LongPathName
 #ifdef __WIN32__
 #include "wx/msw/wrapwin.h"
 // For GetShort/LongPathName
 #ifdef __WIN32__
 #include "wx/msw/wrapwin.h"

+#if defined(__MINGW32__)
+#include "wx/msw/gccpriv.h"
+#endif

 #endif
 
 #ifdef __WXWINCE__
 #endif
 
 #ifdef __WXWINCE__


@@ -234,8 +233,8 @@ static void ConvertWxToFileTime(FILETIME *ft, const wxDateTime& dt)
 {
     SYSTEMTIME st;
     st.wDay = dt.GetDay();
 {
     SYSTEMTIME st;
     st.wDay = dt.GetDay();

-    st.wMonth = dt.GetMonth() + 1;
-    st.wYear = dt.GetYear();
+    st.wMonth = (WORD)(dt.GetMonth() + 1);
+    st.wYear = (WORD)dt.GetYear();

     st.wHour = dt.GetHour();
     st.wMinute = dt.GetMinute();
     st.wSecond = dt.GetSecond();
     st.wHour = dt.GetHour();
     st.wMinute = dt.GetMinute();
     st.wSecond = dt.GetSecond();


@@ -297,12 +296,14 @@ void wxFileName::Assign( const wxFileName &filepath )
     m_name = filepath.GetName();
     m_ext = filepath.GetExt();
     m_relative = filepath.m_relative;
     m_name = filepath.GetName();
     m_ext = filepath.GetExt();
     m_relative = filepath.m_relative;

+    m_hasExt = filepath.m_hasExt;

 }
 
 void wxFileName::Assign(const wxString& volume,
                         const wxString& path,
                         const wxString& name,
                         const wxString& ext,
 }
 
 void wxFileName::Assign(const wxString& volume,
                         const wxString& path,
                         const wxString& name,
                         const wxString& ext,

+                        bool hasExt,

                         wxPathFormat format )
 {
     SetPath( path, format );
                         wxPathFormat format )
 {
     SetPath( path, format );


@@ -310,86 +311,99 @@ void wxFileName::Assign(const wxString& volume,
     m_volume = volume;
     m_ext = ext;
     m_name = name;
     m_volume = volume;
     m_ext = ext;
     m_name = name;

+
+    m_hasExt = hasExt;

 }
 
 }
 

-void wxFileName::SetPath( const wxString &path, wxPathFormat format )
+void wxFileName::SetPath( const wxString& pathOrig, wxPathFormat format )

 {
     m_dirs.Clear();
 
 {
     m_dirs.Clear();
 

-    if ( !path.empty() )
+    if ( pathOrig.empty() )

     {
     {

-        wxPathFormat my_format = GetFormat( format );
-        wxString my_path = path;
+        // no path at all
+        m_relative = true;

 
 

-        // 1) Determine if the path is relative or absolute.
-        wxChar leadingChar = my_path[0u];
+        return;
+    }

 
 

-        switch (my_format)
-        {
-            case wxPATH_MAC:
-                m_relative = leadingChar == wxT(':');
-
-                // We then remove a leading ":". The reason is in our
-                // storage form for relative paths:
-                // ":dir:file.txt" actually means "./dir/file.txt" in
-                // DOS notation and should get stored as
-                // (relative) (dir) (file.txt)
-                // "::dir:file.txt" actually means "../dir/file.txt"
-                // stored as (relative) (..) (dir) (file.txt)
-                // This is important only for the Mac as an empty dir
-                // actually means <UP>, whereas under DOS, double
-                // slashes can be ignored: "\\\\" is the same as "\\".
-                if (m_relative)
-                    my_path.erase( 0, 1 );
-                break;
+    format = GetFormat( format );

 
 

-            case wxPATH_VMS:
-                // TODO: what is the relative path format here?
-                m_relative = false;
-                break;
+    // 0) deal with possible volume part first
+    wxString volume,
+             path;
+    SplitVolume(pathOrig, &volume, &path, format);
+    if ( !volume.empty() )
+    {
+        m_relative = false;

 
 

-            default:
-                wxFAIL_MSG( _T("Unknown path format") );
-                // !! Fall through !!
+        SetVolume(volume);
+    }

 
 

-            case wxPATH_UNIX:
-                // the paths of the form "~" or "~username" are absolute
-                m_relative = leadingChar != wxT('/') && leadingChar != _T('~');
-                break;
+    // 1) Determine if the path is relative or absolute.
+    wxChar leadingChar = path[0u];

 
 

-            case wxPATH_DOS:
-                m_relative = !IsPathSeparator(leadingChar, my_format);
-                break;
+    switch (format)
+    {
+        case wxPATH_MAC:
+            m_relative = leadingChar == wxT(':');
+
+            // We then remove a leading ":". The reason is in our
+            // storage form for relative paths:
+            // ":dir:file.txt" actually means "./dir/file.txt" in
+            // DOS notation and should get stored as
+            // (relative) (dir) (file.txt)
+            // "::dir:file.txt" actually means "../dir/file.txt"
+            // stored as (relative) (..) (dir) (file.txt)
+            // This is important only for the Mac as an empty dir
+            // actually means <UP>, whereas under DOS, double
+            // slashes can be ignored: "\\\\" is the same as "\\".
+            if (m_relative)
+                path.erase( 0, 1 );
+            break;

 
 

-        }
+        case wxPATH_VMS:
+            // TODO: what is the relative path format here?
+            m_relative = false;
+            break;

 
 

-        // 2) Break up the path into its members. If the original path
-        //    was just "/" or "\\", m_dirs will be empty. We know from
-        //    the m_relative field, if this means "nothing" or "root dir".
+        default:
+            wxFAIL_MSG( _T("Unknown path format") );
+            // !! Fall through !!

 
 

-        wxStringTokenizer tn( my_path, GetPathSeparators(my_format) );
+        case wxPATH_UNIX:
+            // the paths of the form "~" or "~username" are absolute
+            m_relative = leadingChar != wxT('/') && leadingChar != _T('~');
+            break;

 
 

-        while ( tn.HasMoreTokens() )
-        {
-            wxString token = tn.GetNextToken();
+        case wxPATH_DOS:
+            m_relative = !IsPathSeparator(leadingChar, format);
+            break;

 
 

-            // Remove empty token under DOS and Unix, interpret them
-            // as .. under Mac.
-            if (token.empty())
-            {
-                if (my_format == wxPATH_MAC)
-                    m_dirs.Add( wxT("..") );
-                // else ignore
-            }
-            else
-            {
-               m_dirs.Add( token );
-            }
-        }

     }
     }

-    else // no path at all
+
+    // 2) Break up the path into its members. If the original path
+    //    was just "/" or "\\", m_dirs will be empty. We know from
+    //    the m_relative field, if this means "nothing" or "root dir".
+
+    wxStringTokenizer tn( path, GetPathSeparators(format) );
+
+    while ( tn.HasMoreTokens() )

     {
     {

-        m_relative = true;
+        wxString token = tn.GetNextToken();
+
+        // Remove empty token under DOS and Unix, interpret them
+        // as .. under Mac.
+        if (token.empty())
+        {
+            if (format == wxPATH_MAC)
+                m_dirs.Add( wxT("..") );
+            // else ignore
+        }
+        else
+        {
+           m_dirs.Add( token );
+        }

     }
 }
 
     }
 }
 


@@ -397,9 +411,10 @@ void wxFileName::Assign(const wxString& fullpath,
                         wxPathFormat format)
 {
     wxString volume, path, name, ext;
                         wxPathFormat format)
 {
     wxString volume, path, name, ext;

-    SplitPath(fullpath, &volume, &path, &name, &ext, format);
+    bool hasExt;
+    SplitPath(fullpath, &volume, &path, &name, &ext, &hasExt, format);

 
 

-    Assign(volume, path, name, ext, format);
+    Assign(volume, path, name, ext, hasExt, format);

 }
 
 void wxFileName::Assign(const wxString& fullpathOrig,
 }
 
 void wxFileName::Assign(const wxString& fullpathOrig,


@@ -415,15 +430,16 @@ void wxFileName::Assign(const wxString& fullpathOrig,
     }
 
     wxString volume, path, name, ext;
     }
 
     wxString volume, path, name, ext;

+    bool hasExt;

 
     // do some consistency checks in debug mode: the name should be really just
     // the filename and the path should be really just a path
 #ifdef __WXDEBUG__
 
     // do some consistency checks in debug mode: the name should be really just
     // the filename and the path should be really just a path
 #ifdef __WXDEBUG__

-    wxString pathDummy, nameDummy, extDummy;
+    wxString volDummy, pathDummy, nameDummy, extDummy;

 
 

-    SplitPath(fullname, &pathDummy, &name, &ext, format);
+    SplitPath(fullname, &volDummy, &pathDummy, &name, &ext, &hasExt, format);

 
 

-    wxASSERT_MSG( pathDummy.empty(),
+    wxASSERT_MSG( volDummy.empty() && pathDummy.empty(),

                   _T("the file name shouldn't contain the path") );
 
     SplitPath(fullpath, &volume, &path, &nameDummy, &extDummy, format);
                   _T("the file name shouldn't contain the path") );
 
     SplitPath(fullpath, &volume, &path, &nameDummy, &extDummy, format);


@@ -432,16 +448,29 @@ void wxFileName::Assign(const wxString& fullpathOrig,
                   _T("the path shouldn't contain file name nor extension") );
 
 #else // !__WXDEBUG__
                   _T("the path shouldn't contain file name nor extension") );
 
 #else // !__WXDEBUG__

-    SplitPath(fullname, NULL /* no path */, &name, &ext, format);
+    SplitPath(fullname, NULL /* no volume */, NULL /* no path */,
+                        &name, &ext, &hasExt, format);

     SplitPath(fullpath, &volume, &path, NULL, NULL, format);
 #endif // __WXDEBUG__/!__WXDEBUG__
 
     SplitPath(fullpath, &volume, &path, NULL, NULL, format);
 #endif // __WXDEBUG__/!__WXDEBUG__
 

+    Assign(volume, path, name, ext, hasExt, format);
+}
+
+void wxFileName::Assign(const wxString& pathOrig,
+                        const wxString& name,
+                        const wxString& ext,
+                        wxPathFormat format)
+{
+    wxString volume,
+             path;
+    SplitVolume(pathOrig, &volume, &path, format);
+

     Assign(volume, path, name, ext, format);
 }
 
 void wxFileName::AssignDir(const wxString& dir, wxPathFormat format)
 {
     Assign(volume, path, name, ext, format);
 }
 
 void wxFileName::AssignDir(const wxString& dir, wxPathFormat format)
 {

-    Assign(dir, _T(""), format);
+    Assign(dir, wxEmptyString, format);

 }
 
 void wxFileName::Clear()
 }
 
 void wxFileName::Clear()


@@ -454,6 +483,9 @@ void wxFileName::Clear()
 
     // we don't have any absolute path for now
     m_relative = true;
 
     // we don't have any absolute path for now
     m_relative = true;

+
+    // nor any extension
+    m_hasExt = false;

 }
 
 /* static */
 }
 
 /* static */


@@ -547,6 +579,8 @@ wxString wxFileName::GetHomeDir()
     return ::wxGetHomeDir();
 }
 
     return ::wxGetHomeDir();
 }
 

+#if wxUSE_FILE
+

 void wxFileName::AssignTempFileName(const wxString& prefix, wxFile *fileTemp)
 {
     wxString tempname = CreateTempFileName(prefix, fileTemp);
 void wxFileName::AssignTempFileName(const wxString& prefix, wxFile *fileTemp)
 {
     wxString tempname = CreateTempFileName(prefix, fileTemp);


@@ -576,11 +610,11 @@ wxFileName::CreateTempFileName(const wxString& prefix, wxFile *fileTemp)
         // FIXME. Create \temp dir?
         dir = wxT("\\");
     }
         // FIXME. Create \temp dir?
         dir = wxT("\\");
     }

-    path = dir + wxT("\\") + prefix;
+    path = dir + wxT("\\") + name;

     int i = 1;
     int i = 1;

-    while (wxFileExists(path))
+    while (FileExists(path))

     {
     {

-        path = dir + wxT("\\") + prefix ;
+        path = dir + wxT("\\") + name ;

         path << i;
         i ++;
     }
         path << i;
         i ++;
     }


@@ -631,6 +665,8 @@ wxFileName::CreateTempFileName(const wxString& prefix, wxFile *fileTemp)
             // default
             #if defined(__DOS__) || defined(__OS2__)
                 dir = _T(".");
             // default
             #if defined(__DOS__) || defined(__OS2__)
                 dir = _T(".");

+            #elif defined(__WXMAC__)
+                dir = wxMacFindFolder(  (short) kOnSystemDisk, kTemporaryFolderType, kCreateFolder ) ;

             #else
                 dir = _T("/tmp");
             #endif
             #else
                 dir = _T("/tmp");
             #endif


@@ -666,7 +702,7 @@ wxFileName::CreateTempFileName(const wxString& prefix, wxFile *fileTemp)
     else // mkstemp() succeeded
     {
         path = wxConvFile.cMB2WX( (const char*) buf );
     else // mkstemp() succeeded
     {
         path = wxConvFile.cMB2WX( (const char*) buf );

-        
+

         // avoid leaking the fd
         if ( fileTemp )
         {
         // avoid leaking the fd
         if ( fileTemp )
         {


@@ -694,7 +730,7 @@ wxFileName::CreateTempFileName(const wxString& prefix, wxFile *fileTemp)
     }
 #else // !HAVE_MKTEMP (includes __DOS__)
     // generate the unique file name ourselves
     }
 #else // !HAVE_MKTEMP (includes __DOS__)
     // generate the unique file name ourselves

-    #if !defined(__DOS__) && (!defined(__MWERKS__) || defined(__DARWIN__) )
+    #if !defined(__DOS__) && !defined(__PALMOS__) && (!defined(__MWERKS__) || defined(__DARWIN__) )

     path << (unsigned int)getpid();
     #endif
 
     path << (unsigned int)getpid();
     #endif
 


@@ -705,7 +741,7 @@ wxFileName::CreateTempFileName(const wxString& prefix, wxFile *fileTemp)
     {
         // 3 hex digits is enough for numTries == 1000 < 4096
         pathTry = path + wxString::Format(_T("%.03x"), (unsigned int) n);
     {
         // 3 hex digits is enough for numTries == 1000 < 4096
         pathTry = path + wxString::Format(_T("%.03x"), (unsigned int) n);

-        if ( !wxFile::Exists(pathTry) )
+        if ( !FileExists(pathTry) )

         {
             break;
         }
         {
             break;
         }


@@ -756,6 +792,8 @@ wxFileName::CreateTempFileName(const wxString& prefix, wxFile *fileTemp)
     return path;
 }
 
     return path;
 }
 

+#endif // wxUSE_FILE
+

 // ----------------------------------------------------------------------------
 // directory operations
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // directory operations
 // ----------------------------------------------------------------------------


@@ -783,12 +821,12 @@ bool wxFileName::Mkdir( const wxString& dir, int perm, int flags )
         size_t count = dirs.GetCount();
         for ( size_t i = 0; i < count; i++ )
         {
         size_t count = dirs.GetCount();
         for ( size_t i = 0; i < count; i++ )
         {

-            if ( i > 0 || 
+            if ( i > 0 ||

 #if defined(__WXMAC__) && !defined(__DARWIN__)
 #if defined(__WXMAC__) && !defined(__DARWIN__)

-                       // relative pathnames are exactely the other way round under mac...
-               !filename.IsAbsolute() 
+            // relative pathnames are exactely the other way round under mac...
+                !filename.IsAbsolute()

 #else
 #else

-               filename.IsAbsolute() 
+                filename.IsAbsolute()

 #endif
             )
                 currPath += wxFILE_SEP_PATH;
 #endif
             )
                 currPath += wxFILE_SEP_PATH;


@@ -940,7 +978,7 @@ bool wxFileName::Normalize(int flags,
 
         m_dirs.Add(dir);
     }
 
         m_dirs.Add(dir);
     }

-    
+

 #if defined(__WIN32__) && !defined(__WXWINCE__) && wxUSE_OLE
     if ( (flags & wxPATH_NORM_SHORTCUT) )
     {
 #if defined(__WIN32__) && !defined(__WXWINCE__) && wxUSE_OLE
     if ( (flags & wxPATH_NORM_SHORTCUT) )
     {


@@ -1010,49 +1048,54 @@ bool wxFileName::GetShortcutTarget(const wxString& shortcutPath, wxString& targe
 {
     wxString path, file, ext;
     wxSplitPath(shortcutPath, & path, & file, & ext);
 {
     wxString path, file, ext;
     wxSplitPath(shortcutPath, & path, & file, & ext);

-    
-       HRESULT hres;   
-       IShellLink* psl;
-    bool success = FALSE;
+
+    HRESULT hres;
+    IShellLink* psl;
+    bool success = false;

 
     // Assume it's not a shortcut if it doesn't end with lnk
 
     // Assume it's not a shortcut if it doesn't end with lnk

-    if (ext.Lower() != wxT("lnk"))
-        return FALSE;
-    
-       // create a ShellLink object
-       hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
-                               IID_IShellLink, (LPVOID*) &psl);
-       
-       if (SUCCEEDED(hres))
-       {
-               IPersistFile* ppf;
-               hres = psl->QueryInterface( IID_IPersistFile, (LPVOID *) &ppf);
-               if (SUCCEEDED(hres))
-               {
-                       WCHAR wsz[MAX_PATH];
-
-                       MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, shortcutPath.mb_str(), -1, wsz,
-                MAX_PATH);
-                       
-                       hres = ppf->Load(wsz, 0);                       
-                       if (SUCCEEDED(hres))
-                       {
+    if (ext.CmpNoCase(wxT("lnk"))!=0)
+        return false;
+
+    // create a ShellLink object
+    hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
+                            IID_IShellLink, (LPVOID*) &psl);
+
+    if (SUCCEEDED(hres))
+    {
+        IPersistFile* ppf;
+        hres = psl->QueryInterface( IID_IPersistFile, (LPVOID *) &ppf);
+        if (SUCCEEDED(hres))
+        {
+            WCHAR wsz[MAX_PATH];
+
+            MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, shortcutPath.mb_str(), -1, wsz,
+                                MAX_PATH);
+
+            hres = ppf->Load(wsz, 0);
+            if (SUCCEEDED(hres))
+            {

                 wxChar buf[2048];
                 wxChar buf[2048];

-                               psl->GetPath(buf, 2048, NULL, SLGP_UNCPRIORITY);
-                               targetFilename = wxString(buf);
+                // Wrong prototype in early versions
+#if defined(__MINGW32__) && !wxCHECK_W32API_VERSION(2, 2)
+                psl->GetPath((CHAR*) buf, 2048, NULL, SLGP_UNCPRIORITY);
+#else
+                psl->GetPath(buf, 2048, NULL, SLGP_UNCPRIORITY);
+#endif
+                targetFilename = wxString(buf);

                 success = (shortcutPath != targetFilename);
 
                 success = (shortcutPath != targetFilename);
 

-                               psl->GetArguments(buf, 2048);
+                psl->GetArguments(buf, 2048);

                 wxString args(buf);
                 wxString args(buf);

-                if (!args.IsEmpty() && arguments)
+                if (!args.empty() && arguments)

                 {
                     *arguments = args;
                 {
                     *arguments = args;

-                }                
-                       }
-               }
-       }
-       psl->Release();
-       return success;
+                }
+            }
+        }
+    }
+    psl->Release();
+    return success;

 }
 #endif
 
 }
 #endif
 


@@ -1244,14 +1287,22 @@ wxString wxFileName::GetPathSeparators(wxPathFormat format)
     return seps;
 }
 
     return seps;
 }
 

+/* static */
+wxString wxFileName::GetPathTerminators(wxPathFormat format)
+{
+    format = GetFormat(format);
+
+    // under VMS the end of the path is ']', not the path separator used to
+    // separate the components
+    return format == wxPATH_VMS ? wxString(_T(']')) : GetPathSeparators(format);
+}
+

 /* static */
 bool wxFileName::IsPathSeparator(wxChar ch, wxPathFormat format)
 {
     // wxString::Find() doesn't work as expected with NUL - it will always find
 /* static */
 bool wxFileName::IsPathSeparator(wxChar ch, wxPathFormat format)
 {
     // wxString::Find() doesn't work as expected with NUL - it will always find

-    // it, so it is almost surely a bug if this function is called with NUL arg
-    wxASSERT_MSG( ch != _T('\0'), _T("shouldn't be called with NUL") );
-
-    return GetPathSeparators(format).Find(ch) != wxNOT_FOUND;
+    // it, so test for it separately
+    return ch != _T('\0') && GetPathSeparators(format).Find(ch) != wxNOT_FOUND;

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -1281,26 +1332,26 @@ bool wxFileName::IsPathSeparator(wxChar ch, wxPathFormat format)
     return true;
 }
 
     return true;
 }
 

-void wxFileName::AppendDir( const wxString &dir )
+void wxFileName::AppendDir( const wxString& dir )

 {
     if ( IsValidDirComponent(dir) )
         m_dirs.Add( dir );
 }
 
 {
     if ( IsValidDirComponent(dir) )
         m_dirs.Add( dir );
 }
 

-void wxFileName::PrependDir( const wxString &dir )
+void wxFileName::PrependDir( const wxString& dir )

 {
     InsertDir(0, dir);
 }
 
 {
     InsertDir(0, dir);
 }
 

-void wxFileName::InsertDir( int before, const wxString &dir )
+void wxFileName::InsertDir(size_t before, const wxString& dir)

 {
     if ( IsValidDirComponent(dir) )
 {
     if ( IsValidDirComponent(dir) )

-        m_dirs.Insert( dir, before );
+        m_dirs.Insert(dir, before);

 }
 
 }
 

-void wxFileName::RemoveDir( int pos )
+void wxFileName::RemoveDir(size_t pos)

 {
 {

-    m_dirs.RemoveAt( (size_t)pos );
+    m_dirs.RemoveAt(pos);

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -1309,13 +1360,14 @@ void wxFileName::RemoveDir( int pos )
 
 void wxFileName::SetFullName(const wxString& fullname)
 {
 
 void wxFileName::SetFullName(const wxString& fullname)
 {

-    SplitPath(fullname, NULL /* no path */, &m_name, &m_ext);
+    SplitPath(fullname, NULL /* no volume */, NULL /* no path */,
+                        &m_name, &m_ext, &m_hasExt);

 }
 
 wxString wxFileName::GetFullName() const
 {
     wxString fullname = m_name;
 }
 
 wxString wxFileName::GetFullName() const
 {
     wxString fullname = m_name;

-    if ( !m_ext.empty() )
+    if ( m_hasExt )

     {
         fullname << wxFILE_SEP_EXT << m_ext;
     }
     {
         fullname << wxFILE_SEP_EXT << m_ext;
     }


@@ -1399,7 +1451,7 @@ wxString wxFileName::GetPath( int flags, wxPathFormat format ) const
                 }
 
                 // convert back from ".." to nothing
                 }
 
                 // convert back from ".." to nothing

-                if ( m_dirs[i] != wxT("..") )
+                if ( !m_dirs[i].IsSameAs(wxT("..")) )

                      fullpath += m_dirs[i];
                 break;
 
                      fullpath += m_dirs[i];
                 break;
 


@@ -1416,7 +1468,7 @@ wxString wxFileName::GetPath( int flags, wxPathFormat format ) const
                 // TODO: What to do with ".." under VMS
 
                 // convert back from ".." to nothing
                 // TODO: What to do with ".." under VMS
 
                 // convert back from ".." to nothing

-                if ( m_dirs[i] != wxT("..") )
+                if ( !m_dirs[i].IsSameAs(wxT("..")) )

                     fullpath += m_dirs[i];
                 break;
         }
                     fullpath += m_dirs[i];
                 break;
         }


@@ -1448,27 +1500,26 @@ wxString wxFileName::GetFullPath( wxPathFormat format ) const
 // Return the short form of the path (returns identity on non-Windows platforms)
 wxString wxFileName::GetShortPath() const
 {
 // Return the short form of the path (returns identity on non-Windows platforms)
 wxString wxFileName::GetShortPath() const
 {

-#if defined(__WXMSW__) && defined(__WIN32__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)

     wxString path(GetFullPath());
     wxString path(GetFullPath());

-    wxString pathOut;
+
+#if defined(__WXMSW__) && defined(__WIN32__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)

     DWORD sz = ::GetShortPathName(path, NULL, 0);
     DWORD sz = ::GetShortPathName(path, NULL, 0);

-    bool ok = sz != 0;
-    if ( ok )
+    if ( sz != 0 )

     {
     {

-        ok = ::GetShortPathName
+        wxString pathOut;
+        if ( ::GetShortPathName

                (
                 path,
                 wxStringBuffer(pathOut, sz),
                 sz
                (
                 path,
                 wxStringBuffer(pathOut, sz),
                 sz

-               ) != 0;
+               ) != 0 )
+        {
+            return pathOut;
+        }

     }
     }

-    if (ok)
-        return pathOut;
+#endif // Windows

 
     return path;
 
     return path;

-#else
-    return GetFullPath();
-#endif

 }
 
 // Return the long form of the path (returns identity on non-Windows platforms)
 }
 
 // Return the long form of the path (returns identity on non-Windows platforms)


@@ -1478,116 +1529,115 @@ wxString wxFileName::GetLongPath() const
              path = GetFullPath();
 
 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
              path = GetFullPath();
 
 #if defined(__WIN32__) && !defined(__WXMICROWIN__)

-    bool success = false;

 
 #if wxUSE_DYNAMIC_LOADER
     typedef DWORD (WINAPI *GET_LONG_PATH_NAME)(const wxChar *, wxChar *, DWORD);
 
 
 #if wxUSE_DYNAMIC_LOADER
     typedef DWORD (WINAPI *GET_LONG_PATH_NAME)(const wxChar *, wxChar *, DWORD);
 

-    static bool s_triedToLoad = false;
-
-    if ( !s_triedToLoad )
+    // this is MT-safe as in the worst case we're going to resolve the function
+    // twice -- but as the result is the same in both threads, it's ok
+    static GET_LONG_PATH_NAME s_pfnGetLongPathName = NULL;
+    if ( !s_pfnGetLongPathName )

     {
     {

-        // suppress the errors about missing GetLongPathName[AW]
-        wxLogNull noLog;
+        static bool s_triedToLoad = false;

 
 

-        s_triedToLoad = true;
-        wxDynamicLibrary dllKernel(_T("kernel32"));
-        if ( dllKernel.IsLoaded() )
+        if ( !s_triedToLoad )

         {
         {

-            // may succeed or fail depending on the Windows version
-            static GET_LONG_PATH_NAME s_pfnGetLongPathName = NULL;
-#ifdef _UNICODE
-            s_pfnGetLongPathName = (GET_LONG_PATH_NAME) dllKernel.GetSymbol(_T("GetLongPathNameW"));
-#else
-            s_pfnGetLongPathName = (GET_LONG_PATH_NAME) dllKernel.GetSymbol(_T("GetLongPathNameA"));
-#endif
+            s_triedToLoad = true;

 
 

-            if ( s_pfnGetLongPathName )
-            {
-                DWORD dwSize = (*s_pfnGetLongPathName)(path, NULL, 0);
-                bool ok = dwSize > 0;
+            wxDynamicLibrary dllKernel(_T("kernel32"));

 
 

-                if ( ok )
-                {
-                    DWORD sz = (*s_pfnGetLongPathName)(path, NULL, 0);
-                    ok = sz != 0;
-                    if ( ok )
-                    {
-                        ok = (*s_pfnGetLongPathName)
-                                (
-                                path,
-                                wxStringBuffer(pathOut, sz),
-                                sz
-                                ) != 0;
-                        success = true;
-                    }
-                }
+            const wxChar* GetLongPathName = _T("GetLongPathName")
+#if wxUSE_UNICODE
+                              _T("W");
+#else // ANSI
+                              _T("A");
+#endif // Unicode/ANSI
+
+            if ( dllKernel.HasSymbol(GetLongPathName) )
+            {
+                s_pfnGetLongPathName = (GET_LONG_PATH_NAME)
+                    dllKernel.GetSymbol(GetLongPathName);

             }
             }

+
+            // note that kernel32.dll can be unloaded, it stays in memory
+            // anyhow as all Win32 programs link to it and so it's safe to call
+            // GetLongPathName() even after unloading it

         }
     }
 
         }
     }
 

-    if (success)
-        return pathOut;
+    if ( s_pfnGetLongPathName )
+    {
+        DWORD dwSize = (*s_pfnGetLongPathName)(path, NULL, 0);
+        if ( dwSize > 0 )
+        {
+            if ( (*s_pfnGetLongPathName)
+                 (
+                  path,
+                  wxStringBuffer(pathOut, dwSize),
+                  dwSize
+                 ) != 0 )
+            {
+                return pathOut;
+            }
+        }
+    }

 #endif // wxUSE_DYNAMIC_LOADER
 
 #endif // wxUSE_DYNAMIC_LOADER
 

-    if (!success)
-    {
-        // The OS didn't support GetLongPathName, or some other error.
-        // We need to call FindFirstFile on each component in turn.
+    // The OS didn't support GetLongPathName, or some other error.
+    // We need to call FindFirstFile on each component in turn.

 
 

-        WIN32_FIND_DATA findFileData;
-        HANDLE hFind;
+    WIN32_FIND_DATA findFileData;
+    HANDLE hFind;

 
 

-        if ( HasVolume() )
-            pathOut = GetVolume() +
-                      GetVolumeSeparator(wxPATH_DOS) +
-                      GetPathSeparator(wxPATH_DOS);
-        else
-            pathOut = wxEmptyString;
+    if ( HasVolume() )
+        pathOut = GetVolume() +
+                  GetVolumeSeparator(wxPATH_DOS) +
+                  GetPathSeparator(wxPATH_DOS);
+    else
+        pathOut = wxEmptyString;

 
 

-        wxArrayString dirs = GetDirs();
-        dirs.Add(GetFullName());
+    wxArrayString dirs = GetDirs();
+    dirs.Add(GetFullName());

 
 

-        wxString tmpPath;
+    wxString tmpPath;

 
 

-        size_t count = dirs.GetCount();
-        for ( size_t i = 0; i < count; i++ )
-        {
-            // We're using pathOut to collect the long-name path, but using a
-            // temporary for appending the last path component which may be
-            // short-name
-            tmpPath = pathOut + dirs[i];
+    size_t count = dirs.GetCount();
+    for ( size_t i = 0; i < count; i++ )
+    {
+        // We're using pathOut to collect the long-name path, but using a
+        // temporary for appending the last path component which may be
+        // short-name
+        tmpPath = pathOut + dirs[i];

 
 

-            if ( tmpPath.empty() )
-                continue;
+        if ( tmpPath.empty() )
+            continue;

 
 

-            // can't see this being necessary? MF
-            if ( tmpPath.Last() == GetVolumeSeparator(wxPATH_DOS) )
-            {
-                // Can't pass a drive and root dir to FindFirstFile,
-                // so continue to next dir
-                tmpPath += wxFILE_SEP_PATH;
-                pathOut = tmpPath;
-                continue;
-            }
+        // can't see this being necessary? MF
+        if ( tmpPath.Last() == GetVolumeSeparator(wxPATH_DOS) )
+        {
+            // Can't pass a drive and root dir to FindFirstFile,
+            // so continue to next dir
+            tmpPath += wxFILE_SEP_PATH;
+            pathOut = tmpPath;
+            continue;
+        }

 
 

-            hFind = ::FindFirstFile(tmpPath, &findFileData);
-            if (hFind == INVALID_HANDLE_VALUE)
-            {
-                // Error: most likely reason is that path doesn't exist, so
-                // append any unprocessed parts and return
-                for ( i += 1; i < count; i++ )
-                    tmpPath += wxFILE_SEP_PATH + dirs[i];
+        hFind = ::FindFirstFile(tmpPath, &findFileData);
+        if (hFind == INVALID_HANDLE_VALUE)
+        {
+            // Error: most likely reason is that path doesn't exist, so
+            // append any unprocessed parts and return
+            for ( i += 1; i < count; i++ )
+                tmpPath += wxFILE_SEP_PATH + dirs[i];

 
 

-                return tmpPath;
-            }
+            return tmpPath;
+        }

 
 

-            pathOut += findFileData.cFileName;
-            if ( (i < (count-1)) )
-                pathOut += wxFILE_SEP_PATH;
+        pathOut += findFileData.cFileName;
+        if ( (i < (count-1)) )
+            pathOut += wxFILE_SEP_PATH;

 
 

-            ::FindClose(hFind);
-        }
+        ::FindClose(hFind);

     }
 #else // !Win32
     pathOut = path;
     }
 #else // !Win32
     pathOut = path;


@@ -1618,22 +1668,16 @@ wxPathFormat wxFileName::GetFormat( wxPathFormat format )
 // ----------------------------------------------------------------------------
 
 /* static */
 // ----------------------------------------------------------------------------
 
 /* static */

-void wxFileName::SplitPath(const wxString& fullpathWithVolume,
-                           wxString *pstrVolume,
-                           wxString *pstrPath,
-                           wxString *pstrName,
-                           wxString *pstrExt,
-                           wxPathFormat format)
+void
+wxFileName::SplitVolume(const wxString& fullpathWithVolume,
+                        wxString *pstrVolume,
+                        wxString *pstrPath,
+                        wxPathFormat format)

 {
     format = GetFormat(format);
 
     wxString fullpath = fullpathWithVolume;
 
 {
     format = GetFormat(format);
 
     wxString fullpath = fullpathWithVolume;
 

-    // under VMS the end of the path is ']', not the path separator used to
-    // separate the components
-    wxString sepPath = format == wxPATH_VMS ? wxString(_T(']'))
-                                            : GetPathSeparators(format);
-

     // special Windows UNC paths hack: transform \\share\path into share:path
     if ( format == wxPATH_DOS )
     {
     // special Windows UNC paths hack: transform \\share\path into share:path
     if ( format == wxPATH_DOS )
     {


@@ -1643,7 +1687,8 @@ void wxFileName::SplitPath(const wxString& fullpathWithVolume,
         {
             fullpath.erase(0, 2);
 
         {
             fullpath.erase(0, 2);
 

-            size_t posFirstSlash = fullpath.find_first_of(sepPath);
+            size_t posFirstSlash =
+                fullpath.find_first_of(GetPathTerminators(format));

             if ( posFirstSlash != wxString::npos )
             {
                 fullpath[posFirstSlash] = wxFILE_SEP_DSK;
             if ( posFirstSlash != wxString::npos )
             {
                 fullpath[posFirstSlash] = wxFILE_SEP_DSK;


@@ -1672,21 +1717,38 @@ void wxFileName::SplitPath(const wxString& fullpathWithVolume,
         }
     }
 
         }
     }
 

+    if ( pstrPath )
+        *pstrPath = fullpath;
+}
+
+/* static */
+void wxFileName::SplitPath(const wxString& fullpathWithVolume,
+                           wxString *pstrVolume,
+                           wxString *pstrPath,
+                           wxString *pstrName,
+                           wxString *pstrExt,
+                           bool *hasExt,
+                           wxPathFormat format)
+{
+    format = GetFormat(format);
+
+    wxString fullpath;
+    SplitVolume(fullpathWithVolume, pstrVolume, &fullpath, format);
+

     // find the positions of the last dot and last path separator in the path
     size_t posLastDot = fullpath.find_last_of(wxFILE_SEP_EXT);
     // find the positions of the last dot and last path separator in the path
     size_t posLastDot = fullpath.find_last_of(wxFILE_SEP_EXT);

-    size_t posLastSlash = fullpath.find_last_of(sepPath);
+    size_t posLastSlash = fullpath.find_last_of(GetPathTerminators(format));

 
 

+    // check whether this dot occurs at the very beginning of a path component

     if ( (posLastDot != wxString::npos) &&
     if ( (posLastDot != wxString::npos) &&

-            ((format == wxPATH_UNIX) || (format == wxPATH_VMS)) )
+         (posLastDot == 0 ||
+            IsPathSeparator(fullpath[posLastDot - 1]) ||
+            (format == wxPATH_VMS && fullpath[posLastDot - 1] == _T(']'))) )

     {
     {

-        if ( (posLastDot == 0) ||
-             (fullpath[posLastDot - 1] == sepPath[0u] ) )
-        {
-            // under Unix and VMS, dot may be (and commonly is) the first
-            // character of the filename, don't treat the entire filename as
-            // extension in this case
-            posLastDot = wxString::npos;
-        }
+        // dot may be (and commonly -- at least under Unix -- is) the first
+        // character of the filename, don't treat the entire filename as
+        // extension in this case
+        posLastDot = wxString::npos;

     }
 
     // if we do have a dot and a slash, check that the dot is in the name part
     }
 
     // if we do have a dot and a slash, check that the dot is in the name part


@@ -1752,18 +1814,25 @@ void wxFileName::SplitPath(const wxString& fullpathWithVolume,
         *pstrName = fullpath.Mid(nStart, count);
     }
 
         *pstrName = fullpath.Mid(nStart, count);
     }
 

-    if ( pstrExt )
+    // finally deal with the extension here: we have an added complication that
+    // extension may be empty (but present) as in "foo." where trailing dot
+    // indicates the empty extension at the end -- and hence we must remember
+    // that we have it independently of pstrExt
+    if ( posLastDot == wxString::npos )

     {
     {

-        if ( posLastDot == wxString::npos )
-        {
-            // no extension
-            pstrExt->Empty();
-        }
-        else
-        {
-            // take everything after the dot
+        // no extension
+        if ( pstrExt )
+            pstrExt->clear();
+        if ( hasExt )
+            *hasExt = false;
+    }
+    else
+    {
+        // take everything after the dot
+        if ( pstrExt )

             *pstrExt = fullpath.Mid(posLastDot + 1);
             *pstrExt = fullpath.Mid(posLastDot + 1);

-        }
+        if ( hasExt )
+            *hasExt = true;

     }
 }
 
     }
 }
 


@@ -1823,6 +1892,8 @@ bool wxFileName::SetTimes(const wxDateTime *dtAccess,
         }
     }
 #elif defined(__UNIX_LIKE__) || (defined(__DOS__) && defined(__WATCOMC__))
         }
     }
 #elif defined(__UNIX_LIKE__) || (defined(__DOS__) && defined(__WATCOMC__))

+    wxUnusedVar(dtCreate);
+

     if ( !dtAccess && !dtMod )
     {
         // can't modify the creation time anyhow, don't try
     if ( !dtAccess && !dtMod )
     {
         // can't modify the creation time anyhow, don't try


@@ -1839,6 +1910,9 @@ bool wxFileName::SetTimes(const wxDateTime *dtAccess,
         return true;
     }
 #else // other platform
         return true;
     }
 #else // other platform

+    wxUnusedVar(dtAccess);
+    wxUnusedVar(dtMod);
+    wxUnusedVar(dtCreate);

 #endif // platforms
 
     wxLogSysError(_("Failed to modify file times for '%s'"),
 #endif // platforms
 
     wxLogSysError(_("Failed to modify file times for '%s'"),


@@ -1929,6 +2003,9 @@ bool wxFileName::GetTimes(wxDateTime *dtAccess,
         return true;
     }
 #else // other platform
         return true;
     }
 #else // other platform

+    wxUnusedVar(dtAccess);
+    wxUnusedVar(dtMod);
+    wxUnusedVar(dtCreate);

 #endif // platforms
 
     wxLogSysError(_("Failed to retrieve file times for '%s'"),
 #endif // platforms
 
     wxLogSysError(_("Failed to retrieve file times for '%s'"),


@@ -1948,7 +2025,7 @@ public :
   MacDefaultExtensionRecord()
   {
     m_ext[0] = 0 ;
   MacDefaultExtensionRecord()
   {
     m_ext[0] = 0 ;

-    m_type = m_creator = NULL ;
+    m_type = m_creator = 0 ;

   }
   MacDefaultExtensionRecord( const MacDefaultExtensionRecord& from )
   {
   }
   MacDefaultExtensionRecord( const MacDefaultExtensionRecord& from )
   {


@@ -1999,31 +2076,44 @@ static void MacEnsureDefaultExtensionsLoaded()
         gMacDefaultExtensionsInited = true ;
     }
 }
         gMacDefaultExtensionsInited = true ;
     }
 }

+

 bool wxFileName::MacSetTypeAndCreator( wxUint32 type , wxUint32 creator )
 {
 bool wxFileName::MacSetTypeAndCreator( wxUint32 type , wxUint32 creator )
 {

-  FInfo fndrInfo ;
-  FSSpec spec ;
-  wxMacFilename2FSSpec(GetFullPath(),&spec) ;
-  OSErr err = FSpGetFInfo( &spec , &fndrInfo ) ;
-  wxCHECK( err == noErr , false ) ;
+    FSRef fsRef ;
+    FSCatalogInfo catInfo;
+    FileInfo *finfo ;

 
 

-  fndrInfo.fdType = type ;
-  fndrInfo.fdCreator = creator ;
-  FSpSetFInfo( &spec , &fndrInfo ) ;
-  return true ;
+    if ( wxMacPathToFSRef( GetFullPath() , &fsRef ) == noErr )
+    {
+        if ( FSGetCatalogInfo (&fsRef, kFSCatInfoFinderInfo, &catInfo, NULL, NULL, NULL) == noErr )
+        {
+            finfo = (FileInfo*)&catInfo.finderInfo;
+            finfo->fileType = type ;
+            finfo->fileCreator = creator ;
+            FSSetCatalogInfo( &fsRef, kFSCatInfoFinderInfo, &catInfo ) ;
+            return true ;
+        }
+    }
+    return false ;

 }
 
 bool wxFileName::MacGetTypeAndCreator( wxUint32 *type , wxUint32 *creator )
 {
 }
 
 bool wxFileName::MacGetTypeAndCreator( wxUint32 *type , wxUint32 *creator )
 {

-  FInfo fndrInfo ;
-  FSSpec spec ;
-  wxMacFilename2FSSpec(GetFullPath(),&spec) ;
-  OSErr err = FSpGetFInfo( &spec , &fndrInfo ) ;
-  wxCHECK( err == noErr , false ) ;
+    FSRef fsRef ;
+    FSCatalogInfo catInfo;
+    FileInfo *finfo ;

 
 

-  *type = fndrInfo.fdType ;
-  *creator = fndrInfo.fdCreator ;
-  return true ;
+    if ( wxMacPathToFSRef( GetFullPath() , &fsRef ) == noErr )
+    {
+        if ( FSGetCatalogInfo (&fsRef, kFSCatInfoFinderInfo, &catInfo, NULL, NULL, NULL) == noErr )
+        {
+            finfo = (FileInfo*)&catInfo.finderInfo;
+            *type = finfo->fileType ;
+            *creator = finfo->fileCreator ;
+            return true ;
+        }
+    }
+    return false ;

 }
 
 bool wxFileName::MacSetDefaultTypeAndCreator()
 }
 
 bool wxFileName::MacSetDefaultTypeAndCreator()