src/corelib: Remove QT_WA and non-Unicode code paths, dropping Win9x and NT support

Also: QString::fromUtf16() -> QString::fromWCharArray()
      WCHAR & TCHAR -> wchar_t
      LPTSTR/LPCTSTR -> LPWSTR/LPCWSTR
      Documentation update

Merge-request: 604
Reviewed-by: Marius Storm-Olsen <marius@trolltech.com>

8 files changed, 386 insertions, 943 deletions

diff --git a/src/corelib/io/qfileinfo.cpp b/src/corelib/io/qfileinfo.cpp
index 4c1c21a..c50bb51 100644
--- a/src/corelib/io/qfileinfo.cpp
+++ b/src/corelib/io/qfileinfo.cpp
@@ -117,11 +117,7 @@ bool QFileInfoPrivate::hasAccess(Access access) const
     if (access == ExecuteAccess)
         return getFileFlags(QAbstractFileEngine::ExeUserPerm);
 
-    QT_WA( {
-        return ::_waccess((TCHAR *)QFSFileEnginePrivate::longFileName(data->fileName).utf16(), mode) == 0;
-    } , {
-        return QT_ACCESS(QFSFileEnginePrivate::win95Name(data->fileName), mode) == 0;
-    } );
+    return ::_waccess((wchar_t*)QFSFileEnginePrivate::longFileName(data->fileName).utf16(), mode) == 0;
 #endif
     return false;
 }
diff --git a/src/corelib/io/qfilesystemwatcher_win.cpp b/src/corelib/io/qfilesystemwatcher_win.cpp
index 9a3aeae..c15b1d2 100644
--- a/src/corelib/io/qfilesystemwatcher_win.cpp
+++ b/src/corelib/io/qfilesystemwatcher_win.cpp
@@ -56,9 +56,7 @@ QT_BEGIN_NAMESPACE
 QWindowsFileSystemWatcherEngine::QWindowsFileSystemWatcherEngine()
     : msg(0)
 {
-    HANDLE h = QT_WA_INLINE(CreateEventW(0, false, false, 0),
-                                CreateEventA(0, false, false, 0));
-    if (h != INVALID_HANDLE_VALUE) {
+    if (HANDLE h = CreateEvent(0, false, false, 0)) {
         handles.reserve(MAXIMUM_WAIT_OBJECTS);
         handles.append(h);
     }
@@ -216,13 +214,7 @@ QStringList QWindowsFileSystemWatcherEngine::addPaths(const QStringList &paths,
             const QString effectiveAbsolutePath =
                 isDir ? (absolutePath + QLatin1Char('/')) : absolutePath;
 
-            QT_WA({
-                    handle.handle = FindFirstChangeNotificationW((TCHAR *) QDir::toNativeSeparators(effectiveAbsolutePath).utf16(),
-                                                      false, flags);
-            },{
-                    handle.handle = FindFirstChangeNotificationA(QDir::toNativeSeparators(effectiveAbsolutePath).toLocal8Bit(),
-                                                      false, flags);
-            })
+            handle.handle = FindFirstChangeNotification((wchar_t*) QDir::toNativeSeparators(effectiveAbsolutePath).utf16(), false, flags);
             handle.flags = flags;
             if (handle.handle == INVALID_HANDLE_VALUE)
                 continue;
diff --git a/src/corelib/io/qfsfileengine_iterator_win.cpp b/src/corelib/io/qfsfileengine_iterator_win.cpp
index 2336542..dd4ddf3 100644
--- a/src/corelib/io/qfsfileengine_iterator_win.cpp
+++ b/src/corelib/io/qfsfileengine_iterator_win.cpp
@@ -79,11 +79,7 @@ void QFSFileEngineIteratorPlatformSpecificData::saveCurrentFileName()
         it->currentEntry = uncShares.at(uncShareIndex - 1);
     } else {
         // Local directory
-        QT_WA({
-            it->currentEntry = QString::fromUtf16((unsigned short *)findData.cFileName);
-        } , {
-            it->currentEntry = QString::fromLocal8Bit((const char *)findData.cFileName);
-        });
+        it->currentEntry = QString::fromWCharArray(findData.cFileName);
     }
 }
 
@@ -97,17 +93,10 @@ void QFSFileEngineIterator::advance()
     if (platform->uncFallback) {
         ++platform->uncShareIndex;
     } else if (platform->findFileHandle != INVALID_HANDLE_VALUE) {
-        QT_WA({
-            if (!FindNextFile(platform->findFileHandle, &platform->findData)) {
-                platform->done = true;        
-                FindClose(platform->findFileHandle);
-            }
-        } , {
-            if (!FindNextFileA(platform->findFileHandle, (WIN32_FIND_DATAA *)&platform->findData)) {
-                platform->done = true;
-                FindClose(platform->findFileHandle);
-            }
-        });
+        if (!FindNextFile(platform->findFileHandle, &platform->findData)) {
+            platform->done = true;
+            FindClose(platform->findFileHandle);
+        }
     }
 }
 
@@ -141,15 +130,8 @@ bool QFSFileEngineIterator::hasNext() const
             path.append(QLatin1Char('/'));
         path.append(QLatin1String("*.*"));
 
-        QT_WA({
-            QString fileName = QFSFileEnginePrivate::longFileName(path);
-            platform->findFileHandle = FindFirstFileW((TCHAR *)fileName.utf16(),
-                                                      &platform->findData);
-        }, {
-            // Cast is safe, since char is at end of WIN32_FIND_DATA
-            platform->findFileHandle = FindFirstFileA(QFSFileEnginePrivate::win95Name(path),
-                                                      (WIN32_FIND_DATAA*)&platform->findData);
-        });
+        QString fileName = QFSFileEnginePrivate::longFileName(path);
+        platform->findFileHandle = FindFirstFile((const wchar_t *)fileName.utf16(), &platform->findData);
 
         if (platform->findFileHandle == INVALID_HANDLE_VALUE) {
             if (path.startsWith(QLatin1String("//"))) {
diff --git a/src/corelib/io/qfsfileengine_p.h b/src/corelib/io/qfsfileengine_p.h
index 5aef229..864599f 100644
--- a/src/corelib/io/qfsfileengine_p.h
+++ b/src/corelib/io/qfsfileengine_p.h
@@ -72,7 +72,6 @@ class QFSFileEnginePrivate : public QAbstractFileEnginePrivate
 
 public:
 #ifdef Q_WS_WIN
-    static QByteArray win95Name(const QString &path);
     static QString longFileName(const QString &path);
 #endif
     static QString canonicalized(const QString &path);
@@ -151,8 +150,7 @@ public:
 
 #if defined(Q_OS_WIN32) || defined(Q_OS_WINCE)
     static void resolveLibs();
-    static bool resolveUNCLibs_NT();
-    static bool resolveUNCLibs_9x();
+    static bool resolveUNCLibs();
     static bool uncListSharesOnServer(const QString &server, QStringList *list);
 #endif
 
diff --git a/src/corelib/io/qfsfileengine_win.cpp b/src/corelib/io/qfsfileengine_win.cpp
index eef39e4..ee49853 100644
--- a/src/corelib/io/qfsfileengine_win.cpp
+++ b/src/corelib/io/qfsfileengine_win.cpp
@@ -152,66 +152,64 @@ void QFSFileEnginePrivate::resolveLibs()
 
         triedResolve = true;
 #if !defined(Q_OS_WINCE)
-        if(QSysInfo::WindowsVersion & QSysInfo::WV_NT_based) {
-            HINSTANCE advapiHnd = LoadLibraryW(L"advapi32");
-            if (advapiHnd) {
-                ptrGetNamedSecurityInfoW = (PtrGetNamedSecurityInfoW)GetProcAddress(advapiHnd, "GetNamedSecurityInfoW");
-                ptrLookupAccountSidW = (PtrLookupAccountSidW)GetProcAddress(advapiHnd, "LookupAccountSidW");
-                ptrAllocateAndInitializeSid = (PtrAllocateAndInitializeSid)GetProcAddress(advapiHnd, "AllocateAndInitializeSid");
-                ptrBuildTrusteeWithSidW = (PtrBuildTrusteeWithSidW)GetProcAddress(advapiHnd, "BuildTrusteeWithSidW");
-                ptrBuildTrusteeWithNameW = (PtrBuildTrusteeWithNameW)GetProcAddress(advapiHnd, "BuildTrusteeWithNameW");
-                ptrGetEffectiveRightsFromAclW = (PtrGetEffectiveRightsFromAclW)GetProcAddress(advapiHnd, "GetEffectiveRightsFromAclW");
-                ptrFreeSid = (PtrFreeSid)GetProcAddress(advapiHnd, "FreeSid");
-            }
-            if (ptrBuildTrusteeWithNameW) {
-                HINSTANCE versionHnd = LoadLibraryW(L"version");
-                if (versionHnd) {
-                    typedef DWORD (WINAPI *PtrGetFileVersionInfoSizeW)(LPWSTR lptstrFilename,LPDWORD lpdwHandle);
-                    PtrGetFileVersionInfoSizeW ptrGetFileVersionInfoSizeW = (PtrGetFileVersionInfoSizeW)GetProcAddress(versionHnd, "GetFileVersionInfoSizeW");
-                    typedef BOOL (WINAPI *PtrGetFileVersionInfoW)(LPWSTR lptstrFilename,DWORD dwHandle,DWORD dwLen,LPVOID lpData);
-                    PtrGetFileVersionInfoW ptrGetFileVersionInfoW = (PtrGetFileVersionInfoW)GetProcAddress(versionHnd, "GetFileVersionInfoW");
-                    typedef BOOL (WINAPI *PtrVerQueryValueW)(const LPVOID pBlock,LPWSTR lpSubBlock,LPVOID *lplpBuffer,PUINT puLen);
-                    PtrVerQueryValueW ptrVerQueryValueW = (PtrVerQueryValueW)GetProcAddress(versionHnd, "VerQueryValueW");
-                    if(ptrGetFileVersionInfoSizeW && ptrGetFileVersionInfoW && ptrVerQueryValueW) {
-                        DWORD fakeHandle;
-                        DWORD versionSize = ptrGetFileVersionInfoSizeW(L"secur32.dll", &fakeHandle);
-                        if(versionSize) {
-                            LPVOID versionData;
-                            versionData = malloc(versionSize);
-                            if(ptrGetFileVersionInfoW(L"secur32.dll", 0, versionSize, versionData)) {
-                                UINT puLen;
-                                VS_FIXEDFILEINFO *pLocalInfo;
-                                if(ptrVerQueryValueW(versionData, L"\\", (void**)&pLocalInfo, &puLen)) {
-                                    WORD wVer1, wVer2, wVer3, wVer4;
-                                    wVer1 = HIWORD(pLocalInfo->dwFileVersionMS);
-                                    wVer2 = LOWORD(pLocalInfo->dwFileVersionMS);
-                                    wVer3 = HIWORD(pLocalInfo->dwFileVersionLS);
-                                    wVer4 = LOWORD(pLocalInfo->dwFileVersionLS);
-                                    // It will not work with secur32.dll version 5.0.2195.2862
-                                    if(!(wVer1 == 5 && wVer2 == 0 && wVer3 == 2195 && (wVer4 == 2862 || wVer4 == 4587))) {
-                                        HINSTANCE userHnd = LoadLibraryW(L"secur32");
-                                        if (userHnd) {
-                                            typedef BOOL (WINAPI *PtrGetUserNameExW)(EXTENDED_NAME_FORMAT nameFormat, ushort* lpBuffer, LPDWORD nSize);
-                                            PtrGetUserNameExW ptrGetUserNameExW = (PtrGetUserNameExW)GetProcAddress(userHnd, "GetUserNameExW");
-                                            if(ptrGetUserNameExW) {
-                                                static TCHAR buffer[258];
-                                                DWORD bufferSize = 257;
-                                                ptrGetUserNameExW(NameSamCompatible, (ushort*)buffer, &bufferSize);
-                                                ptrBuildTrusteeWithNameW(&currentUserTrusteeW, (ushort*)buffer);
-                                            }
-                                            FreeLibrary(userHnd);
+        HINSTANCE advapiHnd = LoadLibraryW(L"advapi32");
+        if (advapiHnd) {
+            ptrGetNamedSecurityInfoW = (PtrGetNamedSecurityInfoW)GetProcAddress(advapiHnd, "GetNamedSecurityInfoW");
+            ptrLookupAccountSidW = (PtrLookupAccountSidW)GetProcAddress(advapiHnd, "LookupAccountSidW");
+            ptrAllocateAndInitializeSid = (PtrAllocateAndInitializeSid)GetProcAddress(advapiHnd, "AllocateAndInitializeSid");
+            ptrBuildTrusteeWithSidW = (PtrBuildTrusteeWithSidW)GetProcAddress(advapiHnd, "BuildTrusteeWithSidW");
+            ptrBuildTrusteeWithNameW = (PtrBuildTrusteeWithNameW)GetProcAddress(advapiHnd, "BuildTrusteeWithNameW");
+            ptrGetEffectiveRightsFromAclW = (PtrGetEffectiveRightsFromAclW)GetProcAddress(advapiHnd, "GetEffectiveRightsFromAclW");
+            ptrFreeSid = (PtrFreeSid)GetProcAddress(advapiHnd, "FreeSid");
+        }
+        if (ptrBuildTrusteeWithNameW) {
+            HINSTANCE versionHnd = LoadLibraryW(L"version");
+            if (versionHnd) {
+                typedef DWORD (WINAPI *PtrGetFileVersionInfoSizeW)(LPWSTR lptstrFilename,LPDWORD lpdwHandle);
+                PtrGetFileVersionInfoSizeW ptrGetFileVersionInfoSizeW = (PtrGetFileVersionInfoSizeW)GetProcAddress(versionHnd, "GetFileVersionInfoSizeW");
+                typedef BOOL (WINAPI *PtrGetFileVersionInfoW)(LPWSTR lptstrFilename,DWORD dwHandle,DWORD dwLen,LPVOID lpData);
+                PtrGetFileVersionInfoW ptrGetFileVersionInfoW = (PtrGetFileVersionInfoW)GetProcAddress(versionHnd, "GetFileVersionInfoW");
+                typedef BOOL (WINAPI *PtrVerQueryValueW)(const LPVOID pBlock,LPWSTR lpSubBlock,LPVOID *lplpBuffer,PUINT puLen);
+                PtrVerQueryValueW ptrVerQueryValueW = (PtrVerQueryValueW)GetProcAddress(versionHnd, "VerQueryValueW");
+                if(ptrGetFileVersionInfoSizeW && ptrGetFileVersionInfoW && ptrVerQueryValueW) {
+                    DWORD fakeHandle;
+                    DWORD versionSize = ptrGetFileVersionInfoSizeW(L"secur32.dll", &fakeHandle);
+                    if(versionSize) {
+                        LPVOID versionData;
+                        versionData = malloc(versionSize);
+                        if(ptrGetFileVersionInfoW(L"secur32.dll", 0, versionSize, versionData)) {
+                            UINT puLen;
+                            VS_FIXEDFILEINFO *pLocalInfo;
+                            if(ptrVerQueryValueW(versionData, L"\\", (void**)&pLocalInfo, &puLen)) {
+                                WORD wVer1, wVer2, wVer3, wVer4;
+                                wVer1 = HIWORD(pLocalInfo->dwFileVersionMS);
+                                wVer2 = LOWORD(pLocalInfo->dwFileVersionMS);
+                                wVer3 = HIWORD(pLocalInfo->dwFileVersionLS);
+                                wVer4 = LOWORD(pLocalInfo->dwFileVersionLS);
+                                // It will not work with secur32.dll version 5.0.2195.2862
+                                if(!(wVer1 == 5 && wVer2 == 0 && wVer3 == 2195 && (wVer4 == 2862 || wVer4 == 4587))) {
+                                    HINSTANCE userHnd = LoadLibraryW(L"secur32");
+                                    if (userHnd) {
+                                        typedef BOOL (WINAPI *PtrGetUserNameExW)(EXTENDED_NAME_FORMAT nameFormat, ushort* lpBuffer, LPDWORD nSize);
+                                        PtrGetUserNameExW ptrGetUserNameExW = (PtrGetUserNameExW)GetProcAddress(userHnd, "GetUserNameExW");
+                                        if(ptrGetUserNameExW) {
+                                            static wchar_t buffer[258];
+                                            DWORD bufferSize = 257;
+                                            ptrGetUserNameExW(NameSamCompatible, (ushort*)buffer, &bufferSize);
+                                            ptrBuildTrusteeWithNameW(&currentUserTrusteeW, (ushort*)buffer);
                                         }
+                                        FreeLibrary(userHnd);
                                     }
                                 }
                             }
-                            free(versionData);
                         }
+                        free(versionData);
                     }
-                    FreeLibrary(versionHnd);
                 }
+                FreeLibrary(versionHnd);
             }
             ptrOpenProcessToken = (PtrOpenProcessToken)GetProcAddress(advapiHnd, "OpenProcessToken");
-	        HINSTANCE userenvHnd = LoadLibraryW(L"userenv");
+                HINSTANCE userenvHnd = LoadLibraryW(L"userenv");
             if (userenvHnd) {
                 ptrGetUserProfileDirectoryW = (PtrGetUserProfileDirectoryW)GetProcAddress(userenvHnd, "GetUserProfileDirectoryW");
             }
@@ -225,120 +223,60 @@ void QFSFileEnginePrivate::resolveLibs()
 #endif // QT_NO_LIBRARY
 
 // UNC functions NT
-typedef DWORD (WINAPI *PtrNetShareEnum_NT)(LPWSTR, DWORD, LPBYTE*, DWORD, LPDWORD, LPDWORD, LPDWORD);
-static PtrNetShareEnum_NT ptrNetShareEnum_NT = 0;
-typedef DWORD (WINAPI *PtrNetApiBufferFree_NT)(LPVOID);
-static PtrNetApiBufferFree_NT ptrNetApiBufferFree_NT = 0;
-typedef struct _SHARE_INFO_1_NT {
+typedef DWORD (WINAPI *PtrNetShareEnum)(LPWSTR, DWORD, LPBYTE*, DWORD, LPDWORD, LPDWORD, LPDWORD);
+static PtrNetShareEnum ptrNetShareEnum = 0;
+typedef DWORD (WINAPI *PtrNetApiBufferFree)(LPVOID);
+static PtrNetApiBufferFree ptrNetApiBufferFree = 0;
+typedef struct _SHARE_INFO_1 {
     LPWSTR shi1_netname;
     DWORD shi1_type;
     LPWSTR shi1_remark;
-} SHARE_INFO_1_NT;
+} SHARE_INFO_1;
 
 
-bool QFSFileEnginePrivate::resolveUNCLibs_NT()
+bool QFSFileEnginePrivate::resolveUNCLibs()
 {
     static bool triedResolve = false;
     if (!triedResolve) {
 #ifndef QT_NO_THREAD
         QMutexLocker locker(QMutexPool::globalInstanceGet(&triedResolve));
         if (triedResolve) {
-            return ptrNetShareEnum_NT && ptrNetApiBufferFree_NT;
+            return ptrNetShareEnum && ptrNetApiBufferFree;
         }
 #endif
         triedResolve = true;
 #if !defined(Q_OS_WINCE)
         HINSTANCE hLib = LoadLibraryW(L"Netapi32");
         if (hLib) {
-            ptrNetShareEnum_NT = (PtrNetShareEnum_NT)GetProcAddress(hLib, "NetShareEnum");
-            if (ptrNetShareEnum_NT)
-                ptrNetApiBufferFree_NT = (PtrNetApiBufferFree_NT)GetProcAddress(hLib, "NetApiBufferFree");
-        }
-#endif
-    }
-    return ptrNetShareEnum_NT && ptrNetApiBufferFree_NT;
-}
-
-// UNC functions 9x
-typedef DWORD (WINAPI *PtrNetShareEnum_9x)(const char FAR *, short, char FAR *, unsigned short, unsigned short FAR *, unsigned short FAR *);
-static PtrNetShareEnum_9x ptrNetShareEnum_9x = 0;
-#ifdef LM20_NNLEN
-# define LM20_NNLEN_9x LM20_NNLEN
-#else
-# define LM20_NNLEN_9x 12
-#endif
-typedef struct _SHARE_INFO_1_9x {
-  char shi1_netname[LM20_NNLEN_9x+1];
-  char shi1_pad1;
-  unsigned short shi1_type;
-  char FAR* shi1_remark;
-} SHARE_INFO_1_9x;
-
-bool QFSFileEnginePrivate::resolveUNCLibs_9x()
-{
-    static bool triedResolve = false;
-    if (!triedResolve) {
-#ifndef QT_NO_THREAD
-        QMutexLocker locker(QMutexPool::globalInstanceGet(&triedResolve));
-        if (triedResolve) {
-            return ptrNetShareEnum_9x;
+            ptrNetShareEnum = (PtrNetShareEnum)GetProcAddress(hLib, "NetShareEnum");
+            if (ptrNetShareEnum)
+                ptrNetApiBufferFree = (PtrNetApiBufferFree)GetProcAddress(hLib, "NetApiBufferFree");
         }
 #endif
-        triedResolve = true;
-#if !defined(Q_OS_WINCE)
-        HINSTANCE hLib = LoadLibraryA("Svrapi");
-        if (hLib)
-            ptrNetShareEnum_9x = (PtrNetShareEnum_9x)GetProcAddress(hLib, "NetShareEnum");
-#endif
     }
-    return ptrNetShareEnum_9x;
+    return ptrNetShareEnum && ptrNetApiBufferFree;
 }
 
 bool QFSFileEnginePrivate::uncListSharesOnServer(const QString &server, QStringList *list)
 {
-    if (resolveUNCLibs_NT()) {
-        SHARE_INFO_1_NT *BufPtr, *p;
+    if (resolveUNCLibs()) {
+        SHARE_INFO_1 *BufPtr, *p;
         DWORD res;
         DWORD er=0,tr=0,resume=0, i;
         do {
-            res = ptrNetShareEnum_NT((wchar_t*)server.utf16(), 1, (LPBYTE *)&BufPtr, DWORD(-1), &er, &tr, &resume);
+            res = ptrNetShareEnum((wchar_t*)server.utf16(), 1, (LPBYTE *)&BufPtr, DWORD(-1), &er, &tr, &resume);
             if (res == ERROR_SUCCESS || res == ERROR_MORE_DATA) {
                 p=BufPtr;
                 for (i = 1; i <= er; ++i) {
                     if (list && p->shi1_type == 0)
-                        list->append(QString::fromUtf16((unsigned short *)p->shi1_netname));
+                        list->append(QString::fromWCharArray(p->shi1_netname));
                     p++;
                 }
             }
-            ptrNetApiBufferFree_NT(BufPtr);
+            ptrNetApiBufferFree(BufPtr);
         } while (res==ERROR_MORE_DATA);
         return res == ERROR_SUCCESS;
 
-    } else if (resolveUNCLibs_9x()) {
-        SHARE_INFO_1_9x *pBuf = 0;
-        short cbBuffer;
-        unsigned short nEntriesRead = 0;
-        unsigned short nTotalEntries = 0;
-        short numBuffs = 20;
-        DWORD nStatus = 0;
-        do {
-            cbBuffer = numBuffs * sizeof(SHARE_INFO_1_9x);
-            pBuf = (SHARE_INFO_1_9x *)malloc(cbBuffer);
-            if (pBuf) {
-                nStatus = ptrNetShareEnum_9x(server.toLocal8Bit().constData(), 1, (char FAR *)pBuf, cbBuffer, &nEntriesRead, &nTotalEntries);
-                if ((nStatus == ERROR_SUCCESS)) {
-                    for (int i = 0; i < nEntriesRead; ++i) {
-                        if (list && pBuf[i].shi1_type == 0)
-                            list->append(QString::fromLocal8Bit(pBuf[i].shi1_netname));
-                    }
-                    free(pBuf);
-                    break;
-                }
-                free(pBuf);
-                numBuffs *=2;
-            }
-        } while (nStatus == ERROR_MORE_DATA);
-        return nStatus == ERROR_SUCCESS;
     }
     return false;
 }
@@ -399,39 +337,19 @@ static bool uncShareExists(const QString &server)
     return false;
 }
 
-#if !defined(Q_OS_WINCE)
-// If you change this function, remember to also change the UNICODE version
-static QString nativeAbsoluteFilePathA(const QString &path)
-{
-    QString ret;
-    QVarLengthArray<char, MAX_PATH> buf(MAX_PATH);
-    char *fileName = 0;
-    QByteArray ba = path.toLocal8Bit();
-    DWORD retLen = GetFullPathNameA(ba.constData(), buf.size(), buf.data(), &fileName);
-    if (retLen > (DWORD)buf.size()) {
-        buf.resize(retLen);
-        retLen = GetFullPathNameA(ba.constData(), buf.size(), buf.data(), &fileName);
-    }
-    if (retLen != 0)
-        ret = QString::fromLocal8Bit(buf.data(), retLen);
-    return ret;
-}
-#endif
-
-// If you change this function, remember to also change the NON-UNICODE version
-static QString nativeAbsoluteFilePathW(const QString &path)
+static QString nativeAbsoluteFilePathCore(const QString &path)
 {
     QString ret;
 #if !defined(Q_OS_WINCE)
     QVarLengthArray<wchar_t, MAX_PATH> buf(MAX_PATH);
     wchar_t *fileName = 0;
-    DWORD retLen = GetFullPathNameW((wchar_t*)path.utf16(), buf.size(), buf.data(), &fileName);
+    DWORD retLen = GetFullPathName((wchar_t*)path.utf16(), buf.size(), buf.data(), &fileName);
     if (retLen > (DWORD)buf.size()) {
         buf.resize(retLen);
-        retLen = GetFullPathNameW((wchar_t*)path.utf16(), buf.size(), buf.data(), &fileName);
+        retLen = GetFullPathName((wchar_t*)path.utf16(), buf.size(), buf.data(), &fileName);
     }
     if (retLen != 0)
-        ret = QString::fromUtf16((unsigned short *)buf.data(), retLen);
+        ret = QString::fromWCharArray(buf.data(), retLen);
 #else
     if (path.startsWith(QLatin1Char('/')) || path.startsWith(QLatin1Char('\\')))
         ret = QDir::toNativeSeparators(path);
@@ -443,7 +361,7 @@ static QString nativeAbsoluteFilePathW(const QString &path)
 
 static QString nativeAbsoluteFilePath(const QString &path)
 {
-    QString absPath = QT_WA_INLINE(nativeAbsoluteFilePathW(path), nativeAbsoluteFilePathA(path));
+    QString absPath = nativeAbsoluteFilePathCore(path);
     // This is really ugly, but GetFullPathName strips off whitespace at the end.
     // If you for instance write ". " in the lineedit of QFileDialog,
     // (which is an invalid filename) this function will strip the space off and viola,
@@ -461,26 +379,6 @@ static QString nativeAbsoluteFilePath(const QString &path)
     return absPath;
 }
 
-QByteArray QFSFileEnginePrivate::win95Name(const QString &path)
-{
-    QString ret(path);
-    if(path.length() > 1 && path[0] == QLatin1Char('/') && path[1] == QLatin1Char('/')) {
-        // Win95 cannot handle slash-slash needs slosh-slosh.
-        ret[0] = QLatin1Char('\\');
-        ret[1] = QLatin1Char('\\');
-        int n = ret.indexOf(QLatin1Char('/'));
-        if(n >= 0)
-            ret[n] = QLatin1Char('\\');
-    } else if(path.length() > 3 && path[2] == QLatin1Char('/') && path[3] == QLatin1Char('/')) {
-        ret[2] = QLatin1Char('\\');
-        ret.remove(3, 1);
-        int n = ret.indexOf(QLatin1Char('/'));
-        if(n >= 0)
-            ret[n] = QLatin1Char('\\');
-    }
-    return ret.toLocal8Bit();
-}
-
 /*!
     \internal
 */
@@ -507,13 +405,8 @@ QString QFSFileEnginePrivate::longFileName(const QString &path)
 */
 void QFSFileEnginePrivate::nativeInitFileName()
 {
-    QT_WA({
-        QString path = longFileName(QDir::toNativeSeparators(fixIfRelativeUncPath(filePath)));
-        nativeFilePath = QByteArray((const char *)path.utf16(), path.size() * 2 + 1);
-    }, {
-        QString path = fixIfRelativeUncPath(filePath);
-        nativeFilePath = win95Name(path).replace('/', '\\');
-    });
+		QString path = longFileName(QDir::toNativeSeparators(fixIfRelativeUncPath(filePath)));
+		nativeFilePath = QByteArray((const char *)path.utf16(), path.size() * 2 + 1);
 }
 
 /*
@@ -539,23 +432,13 @@ bool QFSFileEnginePrivate::nativeOpen(QIODevice::OpenMode openMode)
                          ? OPEN_ALWAYS : OPEN_EXISTING;
 
     // Create the file handle.
-    QT_WA({
-        fileHandle = CreateFileW((TCHAR *)nativeFilePath.constData(),
-                                 accessRights,
-                                 shareMode,
-                                 &securityAtts,
-                                 creationDisp,
-                                 FILE_ATTRIBUTE_NORMAL,
-                                 NULL);
-    }, {
-        fileHandle = CreateFileA(nativeFilePath.constData(),
-                                 accessRights,
-                                 shareMode,
-                                 &securityAtts,
-                                 creationDisp,
-                                 FILE_ATTRIBUTE_NORMAL,
-                                 NULL);
-    });
+    fileHandle = CreateFile((const wchar_t*)nativeFilePath.constData(),
+                            accessRights,
+                            shareMode,
+                            &securityAtts,
+                            creationDisp,
+                            FILE_ATTRIBUTE_NORMAL,
+                            NULL);
 
     // Bail out on error.
     if (fileHandle == INVALID_HANDLE_VALUE) {
@@ -641,15 +524,9 @@ qint64 QFSFileEnginePrivate::nativeSize() const
     // Not-open mode, where the file name is known: We'll check the
     // file system directly.
     if (openMode == QIODevice::NotOpen && !nativeFilePath.isEmpty()) {
-        bool ok = false;
         WIN32_FILE_ATTRIBUTE_DATA attribData;
-        QT_WA({
-            ok = ::GetFileAttributesExW((TCHAR *)nativeFilePath.constData(),
-                                        GetFileExInfoStandard, &attribData);
-        } , {
-            ok = ::GetFileAttributesExA(nativeFilePath.constData(),
+        bool ok = ::GetFileAttributesEx((const wchar_t*)nativeFilePath.constData(),
                                         GetFileExInfoStandard, &attribData);
-        });
         if (ok) {
             qint64 size = attribData.nFileSizeHigh;
             size <<= 32;
@@ -949,35 +826,21 @@ bool QFSFileEnginePrivate::nativeIsSequential() const
 bool QFSFileEngine::remove()
 {
     Q_D(QFSFileEngine);
-    QT_WA({
-        return ::DeleteFileW((TCHAR*)QFSFileEnginePrivate::longFileName(d->filePath).utf16()) != 0;
-    } , {
-        return ::DeleteFileA(QFSFileEnginePrivate::win95Name(d->filePath)) != 0;
-    });
+    return ::DeleteFile((wchar_t*)QFSFileEnginePrivate::longFileName(d->filePath).utf16()) != 0;
 }
 
 bool QFSFileEngine::copy(const QString &copyName)
 {
     Q_D(QFSFileEngine);
-    QT_WA({
-        return ::CopyFileW((TCHAR*)QFSFileEnginePrivate::longFileName(d->filePath).utf16(),
-                           (TCHAR*)QFSFileEnginePrivate::longFileName(copyName).utf16(), true) != 0;
-    } , {
-        return ::CopyFileA(QFSFileEnginePrivate::win95Name(d->filePath),
-                           QFSFileEnginePrivate::win95Name(copyName), true) != 0;
-    });
+    return ::CopyFile((wchar_t*)QFSFileEnginePrivate::longFileName(d->filePath).utf16(),
+                      (wchar_t*)QFSFileEnginePrivate::longFileName(copyName).utf16(), true) != 0;
 }
 
 bool QFSFileEngine::rename(const QString &newName)
 {
     Q_D(QFSFileEngine);
-    QT_WA({
-        return ::MoveFileW((TCHAR*)QFSFileEnginePrivate::longFileName(d->filePath).utf16(),
-                           (TCHAR*)QFSFileEnginePrivate::longFileName(newName).utf16()) != 0;
-    } , {
-        return ::MoveFileA(QFSFileEnginePrivate::win95Name(d->filePath),
-                           QFSFileEnginePrivate::win95Name(newName)) != 0;
-    });
+    return ::MoveFile((wchar_t*)QFSFileEnginePrivate::longFileName(d->filePath).utf16(),
+                      (wchar_t*)QFSFileEnginePrivate::longFileName(newName).utf16()) != 0;
 }
 
 static inline bool mkDir(const QString &path)
@@ -1001,20 +864,12 @@ static inline bool mkDir(const QString &path)
     if (platformId == 1 && QFSFileEnginePrivate::longFileName(path).size() > 256)
         return false;
 #endif
-    QT_WA({
-        return ::CreateDirectoryW((TCHAR*)QFSFileEnginePrivate::longFileName(path).utf16(), 0);
-    } , {
-        return ::CreateDirectoryA(QFSFileEnginePrivate::win95Name(QFileInfo(path).absoluteFilePath()), 0);
-    });
+    return ::CreateDirectory((wchar_t*)QFSFileEnginePrivate::longFileName(path).utf16(), 0);
 }
 
 static inline bool rmDir(const QString &path)
 {
-    QT_WA({
-        return ::RemoveDirectoryW((TCHAR*)QFSFileEnginePrivate::longFileName(path).utf16());
-    } , {
-        return ::RemoveDirectoryA(QFSFileEnginePrivate::win95Name(QFileInfo(path).absoluteFilePath()));
-    });
+    return ::RemoveDirectory((wchar_t*)QFSFileEnginePrivate::longFileName(path).utf16());
 }
 
 static inline bool isDirPath(const QString &dirPath, bool *existed)
@@ -1023,12 +878,7 @@ static inline bool isDirPath(const QString &dirPath, bool *existed)
     if (path.length() == 2 &&path.at(1) == QLatin1Char(':'))
         path += QLatin1Char('\\');
 
-    DWORD fileAttrib = INVALID_FILE_ATTRIBUTES;
-    QT_WA({
-        fileAttrib = ::GetFileAttributesW((TCHAR*)QFSFileEnginePrivate::longFileName(path).utf16());
-    } , {
-        fileAttrib = ::GetFileAttributesA(QFSFileEnginePrivate::win95Name(QFileInfo(path).absoluteFilePath()));
-    });
+    DWORD fileAttrib = ::GetFileAttributes((wchar_t*)QFSFileEnginePrivate::longFileName(path).utf16());
 
     if (existed)
         *existed = fileAttrib != INVALID_FILE_ATTRIBUTES;
@@ -1110,16 +960,10 @@ bool QFSFileEngine::setCurrentPath(const QString &path)
         return false;
 
 #if !defined(Q_OS_WINCE)
-    int r;
-    QT_WA({
-        r = ::SetCurrentDirectoryW((WCHAR*)path.utf16());
-    } , {
-        r = ::SetCurrentDirectoryA(QFSFileEnginePrivate::win95Name(path));
-    });
-    return r != 0;
+    return ::SetCurrentDirectory((wchar_t*)path.utf16()) != 0;
 #else
-	qfsPrivateCurrentDir = QFSFileEnginePrivate::longFileName(path);
-	return true;
+        qfsPrivateCurrentDir = QFSFileEnginePrivate::longFileName(path);
+        return true;
 #endif
 }
 
@@ -1132,48 +976,34 @@ QString QFSFileEngine::currentPath(const QString &fileName)
         fileName.at(0).isLetter() && fileName.at(1) == QLatin1Char(':')) {
         int drv = fileName.toUpper().at(0).toLatin1() - 'A' + 1;
         if (_getdrive() != drv) {
-            QT_WA({
-                TCHAR buf[PATH_MAX];
-                ::_wgetdcwd(drv, buf, PATH_MAX);
-                ret.setUtf16((ushort*)buf, uint(::wcslen(buf)));
-            }, {
-                char buf[PATH_MAX];
-                ::_getdcwd(drv, buf, PATH_MAX);
-                ret = QString::fromLatin1(buf);
-            });
+            wchar_t buf[PATH_MAX];
+            ::_wgetdcwd(drv, buf, PATH_MAX);
+            ret = QString::fromWCharArray(buf);
         }
     }
     if (ret.isEmpty()) {
         //just the pwd
-        QT_WA({
-            DWORD size = 0;
-            WCHAR currentName[PATH_MAX];
-            size = ::GetCurrentDirectoryW(PATH_MAX, currentName);
-            if (size !=0) {
-                if (size > PATH_MAX) {
-                    WCHAR * newCurrentName = new WCHAR[size];
-                    if (::GetCurrentDirectoryW(PATH_MAX, newCurrentName) != 0)
-                        ret = QString::fromUtf16((ushort*)newCurrentName);
-                    delete [] newCurrentName;
-                } else {
-                    ret = QString::fromUtf16((ushort*)currentName);
-                }
+        DWORD size = 0;
+        wchar_t currentName[PATH_MAX];
+        size = ::GetCurrentDirectory(PATH_MAX, currentName);
+        if (size != 0) {
+            if (size > PATH_MAX) {
+                wchar_t *newCurrentName = new wchar_t[size];
+                if (::GetCurrentDirectory(PATH_MAX, newCurrentName) != 0)
+                    ret = QString::fromWCharArray(newCurrentName);
+                delete [] newCurrentName;
+            } else {
+                ret = QString::fromWCharArray(currentName);
             }
-        } , {
-            DWORD size = 0;
-            char currentName[PATH_MAX];
-            size = ::GetCurrentDirectoryA(PATH_MAX, currentName);
-            if (size !=0)
-                ret = QString::fromLocal8Bit(currentName);
-        });
+        }
     }
     if (ret.length() >= 2 && ret[1] == QLatin1Char(':'))
         ret[0] = ret.at(0).toUpper(); // Force uppercase drive letters.
     return QDir::fromNativeSeparators(ret);
 #else
-	Q_UNUSED(fileName);
-	if (qfsPrivateCurrentDir.isEmpty())
-		qfsPrivateCurrentDir = QCoreApplication::applicationDirPath();
+        Q_UNUSED(fileName);
+        if (qfsPrivateCurrentDir.isEmpty())
+                qfsPrivateCurrentDir = QCoreApplication::applicationDirPath();
 
     return QDir::fromNativeSeparators(qfsPrivateCurrentDir);
 #endif
@@ -1183,35 +1013,27 @@ QString QFSFileEngine::homePath()
 {
     QString ret;
 #if !defined(QT_NO_LIBRARY)
-    QT_WA (
-    {
-        QFSFileEnginePrivate::resolveLibs();
-		if (ptrOpenProcessToken && ptrGetUserProfileDirectoryW) {
-			HANDLE hnd = ::GetCurrentProcess();
-			HANDLE token = 0;
-			BOOL ok = ::ptrOpenProcessToken(hnd, TOKEN_QUERY, &token);
-			if (ok) {
-				DWORD dwBufferSize = 0;
-				// First call, to determine size of the strings (with '\0').
-				ok = ::ptrGetUserProfileDirectoryW(token, NULL, &dwBufferSize);
-				if (!ok && dwBufferSize != 0) {		// We got the required buffer size
-					wchar_t *userDirectory = new wchar_t[dwBufferSize];
-					// Second call, now we can fill the allocated buffer.
-					ok = ::ptrGetUserProfileDirectoryW(token, userDirectory, &dwBufferSize);
-					if (ok)
-						ret = QString::fromUtf16((ushort*)userDirectory);
-
-					delete [] userDirectory;
-				}
-				::CloseHandle(token);
-			}
-		}
-    }
-    ,
-    {
-        // GetUserProfileDirectory is only available from NT 4.0,
-		// so fall through for Win98 and friends version.
-    })
+    QFSFileEnginePrivate::resolveLibs();
+    if (ptrOpenProcessToken && ptrGetUserProfileDirectoryW) {
+        HANDLE hnd = ::GetCurrentProcess();
+        HANDLE token = 0;
+        BOOL ok = ::ptrOpenProcessToken(hnd, TOKEN_QUERY, &token);
+        if (ok) {
+            DWORD dwBufferSize = 0;
+            // First call, to determine size of the strings (with '\0').
+            ok = ::ptrGetUserProfileDirectoryW(token, NULL, &dwBufferSize);
+            if (!ok && dwBufferSize != 0) {        // We got the required buffer size
+                wchar_t *userDirectory = new wchar_t[dwBufferSize];
+                // Second call, now we can fill the allocated buffer.
+                ok = ::ptrGetUserProfileDirectoryW(token, userDirectory, &dwBufferSize);
+                if (ok)
+                    ret = QString::fromWCharArray(userDirectory);
+
+                delete [] userDirectory;
+            }
+            ::CloseHandle(token);
+        }
+                }
 #endif
     if(ret.isEmpty() || !QFile::exists(ret)) {
         ret = QString::fromLocal8Bit(qgetenv("USERPROFILE").constData());
@@ -1251,17 +1073,10 @@ QString QFSFileEngine::rootPath()
 
 QString QFSFileEngine::tempPath()
 {
-    QString ret;
-    int success;
-    QT_WA({
-        wchar_t tempPath[MAX_PATH];
-        success = GetTempPathW(MAX_PATH, tempPath);
-        ret = QString::fromUtf16((ushort*)tempPath);
-    } , {
-        char tempPath[MAX_PATH];
-        success = GetTempPathA(MAX_PATH, tempPath);
-        ret = QString::fromLocal8Bit(tempPath);
-    });
+    wchar_t tempPath[MAX_PATH];
+    int success = GetTempPath(MAX_PATH, tempPath);
+    QString ret = QString::fromWCharArray(tempPath);
+
     if (ret.isEmpty() || !success) {
 #if !defined(Q_OS_WINCE)
         ret = QString::fromLatin1("c:/tmp");
@@ -1285,7 +1100,7 @@ QFileInfoList QFSFileEngine::drives()
 #elif defined(Q_OS_OS2EMX)
     quint32 driveBits, cur;
     if(DosQueryCurrentDisk(&cur,&driveBits) != NO_ERROR)
-	exit(1);
+        exit(1);
     driveBits &= 0x3ffffff;
 #endif
     char driveName[] = "A:/";
@@ -1327,18 +1142,14 @@ bool QFSFileEnginePrivate::doStat() const
                 }
             }
 #else
-            DWORD tmpAttributes = GetFileAttributesW((TCHAR*)QFSFileEnginePrivate::longFileName(fname).utf16());
+            DWORD tmpAttributes = GetFileAttributes((wchar_t*)QFSFileEnginePrivate::longFileName(fname).utf16());
             if (tmpAttributes != -1) {
                 fileAttrib = tmpAttributes;
                 could_stat = true;
             }
 #endif
         } else {
-            QT_WA({
-                fileAttrib = GetFileAttributesW((TCHAR*)QFSFileEnginePrivate::longFileName(fname).utf16());
-            } , {
-                fileAttrib = GetFileAttributesA(QFSFileEnginePrivate::win95Name(QFileInfo(fname).absoluteFilePath()));
-            });
+            fileAttrib = GetFileAttributes((wchar_t*)QFSFileEnginePrivate::longFileName(fname).utf16());
             could_stat = fileAttrib != INVALID_FILE_ATTRIBUTES;
             if (!could_stat) {
 #if !defined(Q_OS_WINCE)
@@ -1398,74 +1209,39 @@ static QString readLink(const QString &link)
 #if !defined(Q_OS_WINCE)
 #if !defined(QT_NO_LIBRARY)
     QString ret;
-    QT_WA({
-        bool neededCoInit = false;
-        IShellLink *psl;                            // pointer to IShellLink i/f
-        HRESULT hres;
-        WIN32_FIND_DATA wfd;
-        TCHAR szGotPath[MAX_PATH];
-        // Get pointer to the IShellLink interface.
-        hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
-                                    IID_IShellLink, (LPVOID *)&psl);
 
-        if(hres == CO_E_NOTINITIALIZED) { // COM was not initialized
-            neededCoInit = true;
-            CoInitialize(NULL);
-            hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
-                                        IID_IShellLink, (LPVOID *)&psl);
-        }
-        if(SUCCEEDED(hres)) {    // Get pointer to the IPersistFile interface.
-            IPersistFile *ppf;
-            hres = psl->QueryInterface(IID_IPersistFile, (LPVOID *)&ppf);
-            if(SUCCEEDED(hres))  {
-                hres = ppf->Load((LPOLESTR)link.utf16(), STGM_READ);
-                //The original path of the link is retrieved. If the file/folder
-                //was moved, the return value still have the old path.
-                if(SUCCEEDED(hres)) {
-                    if (psl->GetPath(szGotPath, MAX_PATH, &wfd, SLGP_UNCPRIORITY) == NOERROR)
-                        ret = QString::fromUtf16((ushort*)szGotPath);
-                }
-                ppf->Release();
-            }
-            psl->Release();
-        }
-        if(neededCoInit)
-            CoUninitialize();
-    } , {
-	    bool neededCoInit = false;
-        IShellLinkA *psl;                            // pointer to IShellLink i/f
-        HRESULT hres;
-        WIN32_FIND_DATAA wfd;
-        char szGotPath[MAX_PATH];
-        // Get pointer to the IShellLink interface.
+    bool neededCoInit = false;
+    IShellLink *psl;                            // pointer to IShellLink i/f
+    WIN32_FIND_DATA wfd;
+    wchar_t szGotPath[MAX_PATH];
 
-        hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
-                                    IID_IShellLinkA, (LPVOID *)&psl);
+    // Get pointer to the IShellLink interface.
+    HRESULT hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (LPVOID *)&psl);
 
-        if(hres == CO_E_NOTINITIALIZED) { // COM was not initialized
-            neededCoInit = true;
-            CoInitialize(NULL);
-            hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
-                                        IID_IShellLinkA, (LPVOID *)&psl);
-        }
-        if(SUCCEEDED(hres)) {    // Get pointer to the IPersistFile interface.
-            IPersistFile *ppf;
-            hres = psl->QueryInterface(IID_IPersistFile, (LPVOID *)&ppf);
-            if(SUCCEEDED(hres))  {
-                hres = ppf->Load((LPOLESTR)QFileInfo(link).absoluteFilePath().utf16(), STGM_READ);
-                //The original path of the link is retrieved. If the file/folder
-                //was moved, the return value still have the old path.
-                 if(SUCCEEDED(hres)) {
-                    if (psl->GetPath((char*)szGotPath, MAX_PATH, &wfd, SLGP_UNCPRIORITY) == NOERROR)
-                        ret = QString::fromLocal8Bit(szGotPath);
-                }
-                ppf->Release();
+    if (hres == CO_E_NOTINITIALIZED) { // COM was not initialized
+        neededCoInit = true;
+        CoInitialize(NULL);
+        hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
+                                    IID_IShellLink, (LPVOID *)&psl);
+    }
+    if (SUCCEEDED(hres)) {    // Get pointer to the IPersistFile interface.
+        IPersistFile *ppf;
+        hres = psl->QueryInterface(IID_IPersistFile, (LPVOID *)&ppf);
+        if(SUCCEEDED(hres))  {
+            hres = ppf->Load((LPOLESTR)link.utf16(), STGM_READ);
+            //The original path of the link is retrieved. If the file/folder
+            //was moved, the return value still have the old path.
+            if(SUCCEEDED(hres)) {
+                if (psl->GetPath(szGotPath, MAX_PATH, &wfd, SLGP_UNCPRIORITY) == NOERROR)
+                    ret = QString::fromWCharArray(szGotPath);
             }
-            psl->Release();
+            ppf->Release();
         }
-        if(neededCoInit)
-            CoUninitialize();
-    });
+        psl->Release();
+    }
+    if (neededCoInit)
+        CoUninitialize();
+
     return ret;
 #else
     Q_UNUSED(link);
@@ -1475,7 +1251,7 @@ static QString readLink(const QString &link)
     wchar_t target[MAX_PATH];
     QString result;
     if (SHGetShortcutTarget((wchar_t*)QFileInfo(link).absoluteFilePath().replace(QLatin1Char('/'),QLatin1Char('\\')).utf16(), target, MAX_PATH)) {
-        result = QString::fromUtf16(reinterpret_cast<const ushort *> (target));
+        result = QString::fromWCharArray(target);
         if (result.startsWith(QLatin1Char('"')))
             result.remove(0,1);
         if (result.endsWith(QLatin1Char('"')))
@@ -1502,76 +1278,37 @@ bool QFSFileEngine::link(const QString &newName)
     QString linkName = newName;
     //### assume that they add .lnk
 
-    QT_WA({
-        HRESULT hres;
-        IShellLink *psl;
-        bool neededCoInit = false;
+    IShellLink *psl;
+    bool neededCoInit = false;
 
-        hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (void **)&psl);
-        if(hres == CO_E_NOTINITIALIZED) { // COM was not initialized
-                neededCoInit = true;
-                CoInitialize(NULL);
-                hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (void **)&psl);
-        }
-        if (SUCCEEDED(hres)) {
-            hres = psl->SetPath((wchar_t *)fileName(AbsoluteName).replace(QLatin1Char('/'), QLatin1Char('\\')).utf16());
-            if (SUCCEEDED(hres)) {
-                hres = psl->SetWorkingDirectory((wchar_t *)fileName(AbsolutePathName).replace(QLatin1Char('/'), QLatin1Char('\\')).utf16());
-                if (SUCCEEDED(hres)) {
-                    IPersistFile *ppf;
-                    hres = psl->QueryInterface(IID_IPersistFile, (void **)&ppf);
-                    if (SUCCEEDED(hres)) {
-                        hres = ppf->Save((TCHAR*)linkName.utf16(), TRUE);
-                        if (SUCCEEDED(hres))
-                             ret = true;
-                        ppf->Release();
-                    }
-                }
-            }
-            psl->Release();
-        }
-        if(neededCoInit)
-                CoUninitialize();
-    } , {
-        // the SetPath() call _sometimes_ changes the current path and when it does it sometimes
-        // does not let us change it back unless we call currentPath() many times.
-        QString cwd = currentPath();
-        HRESULT hres;
-        IShellLinkA *psl;
-        bool neededCoInit = false;
+    HRESULT hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (void **)&psl);
 
+    if (hres == CO_E_NOTINITIALIZED) { // COM was not initialized
+        neededCoInit = true;
+        CoInitialize(NULL);
         hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (void **)&psl);
-        if(hres == CO_E_NOTINITIALIZED) { // COM was not initialized
-            neededCoInit = true;
-            CoInitialize(NULL);
-            hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (void **)&psl);
-        }
+    }
+
+    if (SUCCEEDED(hres)) {
+        hres = psl->SetPath((wchar_t *)fileName(AbsoluteName).replace(QLatin1Char('/'), QLatin1Char('\\')).utf16());
         if (SUCCEEDED(hres)) {
-            currentPath();
-            hres = psl->SetPath((char *)QString::fromLocal8Bit(QFSFileEnginePrivate::win95Name(fileName(AbsoluteName))).utf16());
-            currentPath();
+            hres = psl->SetWorkingDirectory((wchar_t *)fileName(AbsolutePathName).replace(QLatin1Char('/'), QLatin1Char('\\')).utf16());
             if (SUCCEEDED(hres)) {
-                hres = psl->SetWorkingDirectory((char *)QString::fromLocal8Bit(QFSFileEnginePrivate::win95Name(fileName(AbsolutePathName))).utf16());
-                currentPath();
+                IPersistFile *ppf;
+                hres = psl->QueryInterface(IID_IPersistFile, (void **)&ppf);
                 if (SUCCEEDED(hres)) {
-                    IPersistFile *ppf;
-                    hres = psl->QueryInterface(IID_IPersistFile, (void **)&ppf);
-                    if (SUCCEEDED(hres)) {
-                        currentPath();
-                        hres = ppf->Save((LPCOLESTR)linkName.utf16(), TRUE);
-                        currentPath();
-                        if (SUCCEEDED(hres))
-                            ret = true;
-                        ppf->Release();
-                    }
+                    hres = ppf->Save((wchar_t*)linkName.utf16(), TRUE);
+                    if (SUCCEEDED(hres))
+                         ret = true;
+                    ppf->Release();
                 }
-                psl->Release();
             }
         }
-        if(neededCoInit)
+        psl->Release();
+    }
+    if(neededCoInit)
             CoUninitialize();
-        setCurrentPath(cwd);
-    });
+
     return ret;
 #else
     Q_UNUSED(newName);
@@ -1598,9 +1335,9 @@ QAbstractFileEngine::FileFlags QFSFileEnginePrivate::getPermissions() const
 
 #if !defined(QT_NO_LIBRARY)
     if((qt_ntfs_permission_lookup > 0) && ((QSysInfo::WindowsVersion&QSysInfo::WV_NT_based) > QSysInfo::WV_NT)) {
-	PSID pOwner = 0;
-	PSID pGroup = 0;
-	PACL pDacl;
+        PSID pOwner = 0;
+        PSID pGroup = 0;
+        PACL pDacl;
         PSECURITY_DESCRIPTOR pSD;
         ACCESS_MASK access_mask;
 
@@ -1610,42 +1347,42 @@ QAbstractFileEngine::FileFlags QFSFileEnginePrivate::getPermissions() const
 
             QString fname = filePath.endsWith(QLatin1String(".lnk")) ? readLink(filePath) : filePath;
             DWORD res = ptrGetNamedSecurityInfoW((wchar_t*)fname.utf16(), SE_FILE_OBJECT,
-						 OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
-						 &pOwner, &pGroup, &pDacl, 0, &pSD);
+                                                 OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
+                                                 &pOwner, &pGroup, &pDacl, 0, &pSD);
 
             if(res == ERROR_SUCCESS) {
                 TRUSTEE_W trustee;
                 { //user
                     if(ptrGetEffectiveRightsFromAclW(pDacl, &currentUserTrusteeW, &access_mask) != ERROR_SUCCESS)
                         access_mask = (ACCESS_MASK)-1;
-		    if(access_mask & ReadMask)
-			ret |= QAbstractFileEngine::ReadUserPerm;
-		    if(access_mask & WriteMask)
-			ret |= QAbstractFileEngine::WriteUserPerm;
-		    if(access_mask & ExecMask)
-			ret |= QAbstractFileEngine::ExeUserPerm;
+                    if(access_mask & ReadMask)
+                        ret |= QAbstractFileEngine::ReadUserPerm;
+                    if(access_mask & WriteMask)
+                        ret |= QAbstractFileEngine::WriteUserPerm;
+                    if(access_mask & ExecMask)
+                        ret |= QAbstractFileEngine::ExeUserPerm;
                 }
                 { //owner
                     ptrBuildTrusteeWithSidW(&trustee, pOwner);
                     if(ptrGetEffectiveRightsFromAclW(pDacl, &trustee, &access_mask) != ERROR_SUCCESS)
                         access_mask = (ACCESS_MASK)-1;
-		    if(access_mask & ReadMask)
-			ret |= QAbstractFileEngine::ReadOwnerPerm;
-		    if(access_mask & WriteMask)
-			ret |= QAbstractFileEngine::WriteOwnerPerm;
-		    if(access_mask & ExecMask)
-			ret |= QAbstractFileEngine::ExeOwnerPerm;
+                    if(access_mask & ReadMask)
+                        ret |= QAbstractFileEngine::ReadOwnerPerm;
+                    if(access_mask & WriteMask)
+                        ret |= QAbstractFileEngine::WriteOwnerPerm;
+                    if(access_mask & ExecMask)
+                        ret |= QAbstractFileEngine::ExeOwnerPerm;
                 }
                 { //group
                     ptrBuildTrusteeWithSidW(&trustee, pGroup);
                     if(ptrGetEffectiveRightsFromAclW(pDacl, &trustee, &access_mask) != ERROR_SUCCESS)
                         access_mask = (ACCESS_MASK)-1;
-		    if(access_mask & ReadMask)
-			ret |= QAbstractFileEngine::ReadGroupPerm;
-		    if(access_mask & WriteMask)
-			ret |= QAbstractFileEngine::WriteGroupPerm;
-		    if(access_mask & ExecMask)
-			ret |= QAbstractFileEngine::ExeGroupPerm;
+                    if(access_mask & ReadMask)
+                        ret |= QAbstractFileEngine::ReadGroupPerm;
+                    if(access_mask & WriteMask)
+                        ret |= QAbstractFileEngine::WriteGroupPerm;
+                    if(access_mask & ExecMask)
+                        ret |= QAbstractFileEngine::ExeGroupPerm;
                 }
                 { //other (world)
                     // Create SID for Everyone (World)
@@ -1655,12 +1392,12 @@ QAbstractFileEngine::FileFlags QFSFileEnginePrivate::getPermissions() const
                         ptrBuildTrusteeWithSidW(&trustee, pWorld);
                         if(ptrGetEffectiveRightsFromAclW(pDacl, &trustee, &access_mask) != ERROR_SUCCESS)
                             access_mask = (ACCESS_MASK)-1; // ###
-			if(access_mask & ReadMask)
-			    ret |= QAbstractFileEngine::ReadOtherPerm;
-			if(access_mask & WriteMask)
-			    ret |= QAbstractFileEngine::WriteOtherPerm;
-			if(access_mask & ExecMask)
-			    ret |= QAbstractFileEngine::ExeOtherPerm;
+                        if(access_mask & ReadMask)
+                            ret |= QAbstractFileEngine::ReadOtherPerm;
+                        if(access_mask & WriteMask)
+                            ret |= QAbstractFileEngine::WriteOtherPerm;
+                        if(access_mask & ExecMask)
+                            ret |= QAbstractFileEngine::ExeOtherPerm;
                     }
                     ptrFreeSid(pWorld);
                 }
@@ -1670,13 +1407,13 @@ QAbstractFileEngine::FileFlags QFSFileEnginePrivate::getPermissions() const
     } else
 #endif
            {
-	//### what to do with permissions if we don't use ntfs or are not on a NT system
-	// for now just add all permissions and what about exe missions ??
-	// also qt_ntfs_permission_lookup is now not set by defualt ... should it ?
-    	ret |= QAbstractFileEngine::ReadOtherPerm | QAbstractFileEngine::ReadGroupPerm
-	    | QAbstractFileEngine::ReadOwnerPerm | QAbstractFileEngine::ReadUserPerm
-	    | QAbstractFileEngine::WriteUserPerm | QAbstractFileEngine::WriteOwnerPerm
-	    | QAbstractFileEngine::WriteGroupPerm | QAbstractFileEngine::WriteOtherPerm;
+        //### what to do with permissions if we don't use NTFS
+        // for now just add all permissions and what about exe missions ??
+        // also qt_ntfs_permission_lookup is now not set by defualt ... should it ?
+            ret |= QAbstractFileEngine::ReadOtherPerm | QAbstractFileEngine::ReadGroupPerm
+            | QAbstractFileEngine::ReadOwnerPerm | QAbstractFileEngine::ReadUserPerm
+            | QAbstractFileEngine::WriteUserPerm | QAbstractFileEngine::WriteOwnerPerm
+            | QAbstractFileEngine::WriteGroupPerm | QAbstractFileEngine::WriteOtherPerm;
     }
 
     if (doStat()) {
@@ -1911,13 +1648,9 @@ bool QFSFileEngine::setPermissions(uint perms)
         return false;
 
 #if !defined(Q_OS_WINCE)
-   QT_WA({
-        ret = ::_wchmod((TCHAR*)d->filePath.utf16(), mode) == 0;
-   } , {
-        ret = ::_chmod(d->filePath.toLocal8Bit(), mode) == 0;
-   });
+    ret = ::_wchmod((wchar_t*)d->filePath.utf16(), mode) == 0;
 #else
-    ret = ::_wchmod((TCHAR*)d->longFileName(d->filePath).utf16(), mode);
+    ret = ::_wchmod((wchar_t*)d->longFileName(d->filePath).utf16(), mode);
 #endif
    return ret;
 }
@@ -1960,34 +1693,33 @@ bool QFSFileEngine::setSize(qint64 size)
 static inline QDateTime fileTimeToQDateTime(const FILETIME *time)
 {
     QDateTime ret;
-    if (QSysInfo::WindowsVersion & QSysInfo::WV_DOS_based || QSysInfo::WindowsVersion & QSysInfo::WV_CE_based) {
-        // SystemTimeToTzSpecificLocalTime is not available on Win98/ME so we have to pull it off ourselves.
-        SYSTEMTIME systime;
-        FILETIME ftime;
-        systime.wYear = 1970;
-        systime.wMonth = 1;
-        systime.wDay = 1;
-        systime.wHour = 0;
-        systime.wMinute = 0;
-        systime.wSecond = 0;
-        systime.wMilliseconds = 0;
-        systime.wDayOfWeek = 4;
-        SystemTimeToFileTime(&systime, &ftime);
-        unsigned __int64 acttime = (unsigned __int64)time->dwHighDateTime << 32 | time->dwLowDateTime;
-        FileTimeToSystemTime(time, &systime);
-        unsigned __int64 time1970 = (unsigned __int64)ftime.dwHighDateTime << 32 | ftime.dwLowDateTime;
-        unsigned __int64 difftime = acttime - time1970;
-        difftime /= 10000000;
-        ret.setTime_t((unsigned int)difftime);
-    } else {
-#ifndef Q_OS_WINCE
-        SYSTEMTIME sTime, lTime;
-        FileTimeToSystemTime(time, &sTime);
-        SystemTimeToTzSpecificLocalTime(0, &sTime, &lTime);
-        ret.setDate(QDate(lTime.wYear, lTime.wMonth, lTime.wDay));
-        ret.setTime(QTime(lTime.wHour, lTime.wMinute, lTime.wSecond, lTime.wMilliseconds));
+
+#if defined(Q_OS_WINCE)
+    SYSTEMTIME systime;
+    FILETIME ftime;
+    systime.wYear = 1970;
+    systime.wMonth = 1;
+    systime.wDay = 1;
+    systime.wHour = 0;
+    systime.wMinute = 0;
+    systime.wSecond = 0;
+    systime.wMilliseconds = 0;
+    systime.wDayOfWeek = 4;
+    SystemTimeToFileTime(&systime, &ftime);
+    unsigned __int64 acttime = (unsigned __int64)time->dwHighDateTime << 32 | time->dwLowDateTime;
+    FileTimeToSystemTime(time, &systime);
+    unsigned __int64 time1970 = (unsigned __int64)ftime.dwHighDateTime << 32 | ftime.dwLowDateTime;
+    unsigned __int64 difftime = acttime - time1970;
+    difftime /= 10000000;
+    ret.setTime_t((unsigned int)difftime);
+#else
+    SYSTEMTIME sTime, lTime;
+    FileTimeToSystemTime(time, &sTime);
+    SystemTimeToTzSpecificLocalTime(0, &sTime, &lTime);
+    ret.setDate(QDate(lTime.wYear, lTime.wMonth, lTime.wDay));
+    ret.setTime(QTime(lTime.wHour, lTime.wMinute, lTime.wSecond, lTime.wMilliseconds));
 #endif
-    }
+
     return ret;
 }
 
@@ -2011,13 +1743,8 @@ QDateTime QFSFileEngine::fileTime(FileTime time) const
         }
 #endif
     } else {
-        bool ok = false;
         WIN32_FILE_ATTRIBUTE_DATA attribData;
-        QT_WA({
-            ok = ::GetFileAttributesExW((TCHAR*)QFSFileEnginePrivate::longFileName(d->filePath).utf16(), GetFileExInfoStandard, &attribData);
-        } , {
-            ok = ::GetFileAttributesExA(QFSFileEnginePrivate::win95Name(QFileInfo(d->filePath).absoluteFilePath()), GetFileExInfoStandard, &attribData);
-        });
+        bool ok = ::GetFileAttributesEx((wchar_t*)QFSFileEnginePrivate::longFileName(d->filePath).utf16(), GetFileExInfoStandard, &attribData);
         if (ok) {
             if(time == CreationTime)
                 ret = fileTimeToQDateTime(&attribData.ftCreationTime);
@@ -2037,11 +1764,11 @@ uchar *QFSFileEnginePrivate::map(qint64 offset, qint64 size,
     Q_UNUSED(flags);
     if (openMode == QFile::NotOpen) {
         q->setError(QFile::PermissionsError, qt_error_string());
-	return 0;
+        return 0;
     }
     if (offset == 0 && size == 0) {
         q->setError(QFile::UnspecifiedError, qt_error_string());
-	return 0;
+        return 0;
     }
 
 
@@ -2054,7 +1781,7 @@ uchar *QFSFileEnginePrivate::map(qint64 offset, qint64 size,
     #ifdef Q_USE_DEPRECATED_MAP_API
     nativeClose();
     if (fileMapHandle == INVALID_HANDLE_VALUE) {
-        fileMapHandle = CreateFileForMappingW((TCHAR *)nativeFilePath.constData(),
+        fileMapHandle = CreateFileForMapping((const wchar_t*)nativeFilePath.constData(),
                 GENERIC_READ | (openMode & QIODevice::WriteOnly ? GENERIC_WRITE : 0),
                 0,
                 NULL,
@@ -2069,21 +1796,14 @@ uchar *QFSFileEnginePrivate::map(qint64 offset, qint64 size,
 #endif
 
     // first create the file mapping handle
-    HANDLE mapHandle = 0;
     DWORD protection = (openMode & QIODevice::WriteOnly) ? PAGE_READWRITE : PAGE_READONLY;
-    QT_WA({
-    mapHandle = ::CreateFileMappingW(handle, 0, protection,
-             0, 0, 0);
-    },{
-    mapHandle = ::CreateFileMappingA(handle, 0, protection,
-             0, 0, 0);
-    });
+    HANDLE mapHandle = ::CreateFileMapping(handle, 0, protection, 0, 0, 0);
     if (mapHandle == NULL) {
         q->setError(QFile::PermissionsError, qt_error_string());
 #ifdef Q_USE_DEPRECATED_MAP_API
         mapHandleClose();
 #endif
-	return 0;
+        return 0;
     }
 
     // setup args to map
@@ -2112,7 +1832,7 @@ uchar *QFSFileEnginePrivate::map(qint64 offset, qint64 size,
     switch(GetLastError()) {
     case ERROR_ACCESS_DENIED:
         q->setError(QFile::PermissionsError, qt_error_string());
-	break;
+        break;
     case ERROR_INVALID_PARAMETER:
         // size are out of bounds
     default:
diff --git a/src/corelib/io/qprocess_win.cpp b/src/corelib/io/qprocess_win.cpp
index d028df1..eae17b4 100644
--- a/src/corelib/io/qprocess_win.cpp
+++ b/src/corelib/io/qprocess_win.cpp
@@ -54,7 +54,7 @@
 #include <private/qthread_p.h>
 #include <qdebug.h>
 
-#include "private/qfsfileengine_p.h" // for longFileName and win95FileName
+#include "private/qfsfileengine_p.h" // for longFileName
 
 
 #ifndef QT_NO_PROCESS
@@ -122,25 +122,15 @@ bool QProcessPrivate::createChannel(Channel &channel)
         if (&channel == &stdinChannel) {
             // try to open in read-only mode
             channel.pipe[1] = INVALID_Q_PIPE;
-            QT_WA({
-                channel.pipe[0] =
-                    CreateFileW((TCHAR*)QFSFileEnginePrivate::longFileName(channel.file).utf16(),
-                                GENERIC_READ,
-                                FILE_SHARE_READ | FILE_SHARE_WRITE,
-                                &secAtt,
-                                OPEN_EXISTING,
-                                FILE_ATTRIBUTE_NORMAL,
-                                NULL);
-            }, {
-                channel.pipe[0] =
-                    CreateFileA(QFSFileEnginePrivate::win95Name(channel.file),
-                                GENERIC_READ,
-                                FILE_SHARE_READ | FILE_SHARE_WRITE,
-                                &secAtt,
-                                OPEN_EXISTING,
-                                FILE_ATTRIBUTE_NORMAL,
-                                NULL);
-            });
+            channel.pipe[0] =
+                CreateFile((const wchar_t*)QFSFileEnginePrivate::longFileName(channel.file).utf16(),
+                           GENERIC_READ,
+                           FILE_SHARE_READ | FILE_SHARE_WRITE,
+                           &secAtt,
+                           OPEN_EXISTING,
+                           FILE_ATTRIBUTE_NORMAL,
+                           NULL);
+
             if (channel.pipe[0] != INVALID_Q_PIPE)
                 return true;
 
@@ -148,31 +138,15 @@ bool QProcessPrivate::createChannel(Channel &channel)
         } else {
             // open in write mode
             channel.pipe[0] = INVALID_Q_PIPE;
-            DWORD creation;
-            if (channel.append)
-                creation = OPEN_ALWAYS;
-            else
-                creation = CREATE_ALWAYS;
-
-            QT_WA({
-                channel.pipe[1] =
-                    CreateFileW((TCHAR*)QFSFileEnginePrivate::longFileName(channel.file).utf16(),
-                                GENERIC_WRITE,
-                                FILE_SHARE_READ | FILE_SHARE_WRITE,
-                                &secAtt,
-                                creation,
-                                FILE_ATTRIBUTE_NORMAL,
-                                NULL);
-            }, {
-                channel.pipe[1] =
-                    CreateFileA(QFSFileEnginePrivate::win95Name(channel.file),
-                                GENERIC_WRITE,
-                                FILE_SHARE_READ | FILE_SHARE_WRITE,
-                                &secAtt,
-                                creation,
-                                FILE_ATTRIBUTE_NORMAL,
-                                NULL);
-            });
+            channel.pipe[1] =
+                CreateFile((const wchar_t *)QFSFileEnginePrivate::longFileName(channel.file).utf16(),
+                           GENERIC_WRITE,
+                           FILE_SHARE_READ | FILE_SHARE_WRITE,
+                           &secAtt,
+                           channel.append ? OPEN_ALWAYS : CREATE_ALWAYS,
+                           FILE_ATTRIBUTE_NORMAL,
+                           NULL);
+
             if (channel.pipe[1] != INVALID_Q_PIPE) {
                 if (channel.append) {
                     SetFilePointer(channel.pipe[1], 0, NULL, FILE_END);
@@ -327,56 +301,37 @@ static QByteArray qt_create_environment(const QHash<QString, QString> *environme
         int pos = 0;
         QHash<QString, QString>::ConstIterator it = copy.constBegin(),
                                               end = copy.constEnd();
-#ifdef UNICODE
-        if (!(QSysInfo::WindowsVersion & QSysInfo::WV_DOS_based)) {
-            static const TCHAR equal = L'=';
-            static const TCHAR nul = L'\0';
-
-            for ( ; it != end; ++it) {
-                uint tmpSize = sizeof(TCHAR) * (it.key().length() + it.value().length() + 2);
-                // ignore empty strings
-                if (tmpSize == sizeof(TCHAR)*2)
-                    continue;
-                envlist.resize(envlist.size() + tmpSize);
-
-                tmpSize = it.key().length() * sizeof(TCHAR);
-                memcpy(envlist.data()+pos, it.key().utf16(), tmpSize);
-                pos += tmpSize;
-
-                memcpy(envlist.data()+pos, &equal, sizeof(TCHAR));
-                pos += sizeof(TCHAR);
-
-                tmpSize = it.value().length() * sizeof(TCHAR);
-                memcpy(envlist.data()+pos, it.value().utf16(), tmpSize);
-                pos += tmpSize;
-
-                memcpy(envlist.data()+pos, &nul, sizeof(TCHAR));
-                pos += sizeof(TCHAR);
-            }
-            // add the 2 terminating 0 (actually 4, just to be on the safe side)
-            envlist.resize( envlist.size()+4 );
-            envlist[pos++] = 0;
-            envlist[pos++] = 0;
-            envlist[pos++] = 0;
-            envlist[pos++] = 0;
-        } else
-#endif // UNICODE
-        {
-            for ( ; it != end; it++) {
-                QByteArray tmp = it.key().toLocal8Bit();
-                tmp.append('=');
-                tmp.append(it.value().toLocal8Bit());
-
-                uint tmpSize = tmp.length() + 1;
-                envlist.resize(envlist.size() + tmpSize);
-                memcpy(envlist.data()+pos, tmp.data(), tmpSize);
-                pos += tmpSize;
-            }
-            // add the terminating 0 (actually 2, just to be on the safe side)
-            envlist.resize(envlist.size()+2);
-            envlist[pos++] = 0;
-            envlist[pos++] = 0;
+
+        static const wchar_t equal = L'=';
+        static const wchar_t nul = L'\0';
+
+        for ( ; it != end; ++it) {
+            uint tmpSize = sizeof(wchar_t) * (it.key().length() + it.value().length() + 2);
+            // ignore empty strings
+            if (tmpSize == sizeof(wchar_t) * 2)
+                continue;
+            envlist.resize(envlist.size() + tmpSize);
+
+            tmpSize = it.key().length() * sizeof(wchar_t);
+            memcpy(envlist.data()+pos, it.key().utf16(), tmpSize);
+            pos += tmpSize;
+
+            memcpy(envlist.data()+pos, &equal, sizeof(wchar_t));
+            pos += sizeof(wchar_t);
+
+            tmpSize = it.value().length() * sizeof(wchar_t);
+            memcpy(envlist.data()+pos, it.value().utf16(), tmpSize);
+            pos += tmpSize;
+
+            memcpy(envlist.data()+pos, &nul, sizeof(wchar_t));
+            pos += sizeof(wchar_t);
         }
+        // add the 2 terminating 0 (actually 4, just to be on the safe side)
+        envlist.resize( envlist.size()+4 );
+        envlist[pos++] = 0;
+        envlist[pos++] = 0;
+        envlist[pos++] = 0;
+        envlist[pos++] = 0;
     }
     return envlist;
 }
@@ -417,58 +372,33 @@ void QProcessPrivate::startProcess()
     qDebug("   pass environment : %s", environment.isEmpty() ? "no" : "yes");
 #endif
 
-    DWORD dwCreationFlags = 0;
-    if (!(QSysInfo::WindowsVersion & QSysInfo::WV_DOS_based))
-        dwCreationFlags |= CREATE_NO_WINDOW;
+    DWORD dwCreationFlags = CREATE_NO_WINDOW;
 
-#ifdef UNICODE
-    if (!(QSysInfo::WindowsVersion & QSysInfo::WV_DOS_based)) {
 #if defined(Q_OS_WINCE)
         QString fullPathProgram = program;
         if (!QDir::isAbsolutePath(fullPathProgram))
             fullPathProgram = QFileInfo(fullPathProgram).absoluteFilePath();
         fullPathProgram.replace(QLatin1Char('/'), QLatin1Char('\\'));
-        success = CreateProcessW((WCHAR*)fullPathProgram.utf16(),
-                                 (WCHAR*)args.utf16(),
-                                 0, 0, false, 0, 0, 0, 0, pid);
+        success = CreateProcess((wchar_t*)fullPathProgram.utf16(),
+                                (wchar_t*)args.utf16(),
+                                0, 0, false, 0, 0, 0, 0, pid);
 #else
         dwCreationFlags |= CREATE_UNICODE_ENVIRONMENT;
         STARTUPINFOW startupInfo = { sizeof( STARTUPINFO ), 0, 0, 0,
 	                                 (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT,
-                                         (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT,
-                                         0, 0, 0,
-                                         STARTF_USESTDHANDLES,
-                                         0, 0, 0,
-                                         stdinChannel.pipe[0], stdoutChannel.pipe[1], stderrChannel.pipe[1]
+                                   (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT,
+                                   0, 0, 0,
+                                   STARTF_USESTDHANDLES,
+                                   0, 0, 0,
+                                   stdinChannel.pipe[0], stdoutChannel.pipe[1], stderrChannel.pipe[1]
         };
-        success = CreateProcessW(0, (WCHAR*)args.utf16(),
-                                 0, 0, TRUE, dwCreationFlags,
-                                 environment ? envlist.data() : 0,
-                                 workingDirectory.isEmpty() ? 0
-                                    : (WCHAR*)QDir::toNativeSeparators(workingDirectory).utf16(),
-                                 &startupInfo, pid);
-#endif
-    } else
-#endif // UNICODE
-    {
-#ifndef Q_OS_WINCE
-	    STARTUPINFOA startupInfo = { sizeof( STARTUPINFOA ), 0, 0, 0,
-                                         (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT,
-                                         (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT,
-                                         0, 0, 0,
-                                         STARTF_USESTDHANDLES,
-                                         0, 0, 0,
-                                         stdinChannel.pipe[0], stdoutChannel.pipe[1], stderrChannel.pipe[1]
-	    };
-
-	    success = CreateProcessA(0, args.toLocal8Bit().data(),
-                                     0, 0, TRUE, dwCreationFlags, environment ? envlist.data() : 0,
-                                     workingDirectory.isEmpty() ? 0
-                                        : QDir::toNativeSeparators(workingDirectory).toLocal8Bit().data(),
-                                     &startupInfo, pid);
-#endif // Q_OS_WINCE
-    }
-#ifndef Q_OS_WINCE
+        success = CreateProcess(0, (wchar_t*)args.utf16(),
+                                0, 0, TRUE, dwCreationFlags,
+                                environment ? envlist.data() : 0,
+                                workingDirectory.isEmpty() ? 0
+                                    : (wchar_t*)QDir::toNativeSeparators(workingDirectory).utf16(),
+                                &startupInfo, pid);
+
     if (stdinChannel.pipe[0] != INVALID_Q_PIPE) {
         CloseHandle(stdinChannel.pipe[0]);
         stdinChannel.pipe[0] = INVALID_Q_PIPE;
@@ -508,7 +438,7 @@ void QProcessPrivate::startProcess()
     }
 
     // give the process a chance to start ...
-    Sleep(SLEEPMIN*2);
+    Sleep(SLEEPMIN * 2);
     _q_startupNotification();
 }
 
@@ -882,42 +812,25 @@ bool QProcessPrivate::startDetached(const QString &program, const QStringList &a
 
     PROCESS_INFORMATION pinfo;
 
-#ifdef UNICODE
-    if (!(QSysInfo::WindowsVersion & QSysInfo::WV_DOS_based)) {
 #if defined(Q_OS_WINCE)
         QString fullPathProgram = program;
         if (!QDir::isAbsolutePath(fullPathProgram))
             fullPathProgram.prepend(QDir::currentPath().append(QLatin1Char('/')));
         fullPathProgram.replace(QLatin1Char('/'), QLatin1Char('\\'));
-        success = CreateProcessW((WCHAR*)fullPathProgram.utf16(),
-                                 (WCHAR*)args.utf16(),
-                                 0, 0, false, CREATE_NEW_CONSOLE, 0, 0, 0, &pinfo);
+        success = CreateProcess((wchar_t*)fullPathProgram.utf16(),
+                                (wchar_t*)args.utf16(),
+                                0, 0, false, CREATE_NEW_CONSOLE, 0, 0, 0, &pinfo);
 #else
         STARTUPINFOW startupInfo = { sizeof( STARTUPINFO ), 0, 0, 0,
                                      (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT,
                                      (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT,
                                      0, 0, 0, 0, 0, 0, 0, 0, 0, 0
                                    };
-        success = CreateProcessW(0, (WCHAR*)args.utf16(),
-                                 0, 0, FALSE, CREATE_UNICODE_ENVIRONMENT | CREATE_NEW_CONSOLE, 0, 
-                                 workingDir.isEmpty() ? (const WCHAR *)0 : (const WCHAR *)workingDir.utf16(),
-                                 &startupInfo, &pinfo);
-#endif
-    } else
-#endif // UNICODE
-    {
-#ifndef Q_OS_WINCE
-       STARTUPINFOA startupInfo = { sizeof( STARTUPINFOA ), 0, 0, 0,
-                                     (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT,
-                                     (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT,
-                                     0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-                                  };
-       success = CreateProcessA(0, args.toLocal8Bit().data(),
-                                0, 0, FALSE, CREATE_NEW_CONSOLE, 0,
-                                workingDir.isEmpty() ? (LPCSTR)0 : workingDir.toLocal8Bit().constData(),
+        success = CreateProcess(0, (wchar_t*)args.utf16(),
+                                0, 0, FALSE, CREATE_UNICODE_ENVIRONMENT | CREATE_NEW_CONSOLE, 0,
+                                workingDir.isEmpty() ? 0 : (wchar_t*)workingDir.utf16(),
                                 &startupInfo, &pinfo);
 #endif // Q_OS_WINCE
-    }
 
     if (success) {
         CloseHandle(pinfo.hThread);
diff --git a/src/corelib/io/qsettings.cpp b/src/corelib/io/qsettings.cpp
index 3f8dc36f..7de5030 100644
--- a/src/corelib/io/qsettings.cpp
+++ b/src/corelib/io/qsettings.cpp
@@ -1037,33 +1037,16 @@ static QString windowsConfigPath(int type)
     // This only happens when bootstrapping qmake.
 #ifndef Q_OS_WINCE
     QLibrary library(QLatin1String("shell32"));
-    QT_WA( {
-        typedef BOOL (WINAPI*GetSpecialFolderPath)(HWND, LPTSTR, int, BOOL);
-        GetSpecialFolderPath SHGetSpecialFolderPath = (GetSpecialFolderPath)library.resolve("SHGetSpecialFolderPathW");
-        if (SHGetSpecialFolderPath) {
-            TCHAR path[MAX_PATH];
-            SHGetSpecialFolderPath(0, path, type, FALSE);
-            result = QString::fromUtf16((ushort*)path);
-        }
-    } , {
-        typedef BOOL (WINAPI*GetSpecialFolderPath)(HWND, char*, int, BOOL);
-        GetSpecialFolderPath SHGetSpecialFolderPath = (GetSpecialFolderPath)library.resolve("SHGetSpecialFolderPathA");
-        if (SHGetSpecialFolderPath) {
-            char path[MAX_PATH];
-            SHGetSpecialFolderPath(0, path, type, FALSE);
-            result = QString::fromLocal8Bit(path);
-        }
-    } );
 #else
     QLibrary library(QLatin1String("coredll"));
-    typedef BOOL (WINAPI*GetSpecialFolderPath)(HWND, LPTSTR, int, BOOL);
-    GetSpecialFolderPath SHGetSpecialFolderPath = (GetSpecialFolderPath)library.resolve("SHGetSpecialFolderPath");
+#endif // Q_OS_WINCE
+    typedef BOOL (WINAPI*GetSpecialFolderPath)(HWND, LPWSTR, int, BOOL);
+    GetSpecialFolderPath SHGetSpecialFolderPath = (GetSpecialFolderPath)library.resolve("SHGetSpecialFolderPathW");
     if (SHGetSpecialFolderPath) {
         wchar_t path[MAX_PATH];
         SHGetSpecialFolderPath(0, path, type, FALSE);
-        result = QString::fromUtf16((ushort*)path);
+        result = QString::fromWCharArray(path);
     }
-#endif // Q_OS_WINCE
 
 #endif // QT_NO_QOBJECT
 
@@ -1459,11 +1442,7 @@ void QConfFileSettingsPrivate::syncConfFile(int confFileNo)
             QString writeSemName = QLatin1String("QSettingsWriteSem ");
             writeSemName.append(file.fileName());
 
-            QT_WA( {
-                writeSemaphore = CreateSemaphoreW(0, 1, 1, reinterpret_cast<const wchar_t *>(writeSemName.utf16()));
-            } , {
-                writeSemaphore = CreateSemaphoreA(0, 1, 1, writeSemName.toLocal8Bit());
-            } );
+            writeSemaphore = CreateSemaphore(0, 1, 1, reinterpret_cast<const wchar_t *>(writeSemName.utf16()));
 
             if (writeSemaphore) {
                 WaitForSingleObject(writeSemaphore, INFINITE);
@@ -1479,11 +1458,7 @@ void QConfFileSettingsPrivate::syncConfFile(int confFileNo)
         QString readSemName(QLatin1String("QSettingsReadSem "));
         readSemName.append(file.fileName());
 
-        QT_WA( {
-            readSemaphore = CreateSemaphoreW(0, FileLockSemMax, FileLockSemMax, reinterpret_cast<const wchar_t *>(readSemName.utf16()));
-        } , {
-            readSemaphore = CreateSemaphoreA(0, FileLockSemMax, FileLockSemMax, readSemName.toLocal8Bit());
-        } );
+        readSemaphore = CreateSemaphore(0, FileLockSemMax, FileLockSemMax, reinterpret_cast<const wchar_t *>(readSemName.utf16()));
 
         if (readSemaphore) {
             for (int i = 0; i < numReadLocks; ++i)
diff --git a/src/corelib/io/qsettings_win.cpp b/src/corelib/io/qsettings_win.cpp
index 0cbcc10..1e1509d 100644
--- a/src/corelib/io/qsettings_win.cpp
+++ b/src/corelib/io/qsettings_win.cpp
@@ -130,24 +130,13 @@ static void mergeKeySets(NameSet *dest, const QStringList &src)
 
 static QString errorCodeToString(DWORD errorCode)
 {
-    QString result;
-	QT_WA({
-		wchar_t *data = 0;
-		FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
-			0, errorCode, 0,
-			data, 0, 0);
-		result = QString::fromUtf16(reinterpret_cast<const ushort *> (data));
-		if (data != 0)
-			LocalFree(data);
-	},	{
-		char *data = 0;
-		FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
-			0, errorCode, 0,
-			(char *)&data, 0, 0);
-		result = QString::fromLocal8Bit(data);
-		if (data != 0)
-			LocalFree(data);
-	})
+    wchar_t *data = 0;
+    FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, 0, errorCode, 0, data, 0, 0);
+    QString result = QString::fromWCharArray(data);
+
+    if (data != 0)
+        LocalFree(data);
+
     if (result.endsWith(QLatin1Char('\n')))
         result.truncate(result.length() - 1);
 
@@ -158,15 +147,8 @@ static QString errorCodeToString(DWORD errorCode)
 static HKEY openKey(HKEY parentHandle, REGSAM perms, const QString &rSubKey)
 {
     HKEY resultHandle = 0;
-
-    LONG res;
-    QT_WA( {
-        res = RegOpenKeyExW(parentHandle, reinterpret_cast<const wchar_t *>(rSubKey.utf16()),
-                            0, perms, &resultHandle);
-    } , {
-        res = RegOpenKeyExA(parentHandle, rSubKey.toLocal8Bit(),
+    LONG res = RegOpenKeyEx(parentHandle, reinterpret_cast<const wchar_t *>(rSubKey.utf16()),
                             0, perms, &resultHandle);
-    } );
 
     if (res == ERROR_SUCCESS)
         return resultHandle;
@@ -183,14 +165,8 @@ static HKEY createOrOpenKey(HKEY parentHandle, REGSAM perms, const QString &rSub
         return resultHandle;
 
     // try to create it
-    LONG res;
-    QT_WA( {
-        res = RegCreateKeyExW(parentHandle, reinterpret_cast<const wchar_t *>(rSubKey.utf16()), 0, 0,
-                              REG_OPTION_NON_VOLATILE, perms, 0, &resultHandle, 0);
-    } , {
-        res = RegCreateKeyExA(parentHandle, rSubKey.toLocal8Bit(), 0, 0,
+    LONG res = RegCreateKeyEx(parentHandle, reinterpret_cast<const wchar_t *>(rSubKey.utf16()), 0, 0,
                               REG_OPTION_NON_VOLATILE, perms, 0, &resultHandle, 0);
-    } );
 
     if (res == ERROR_SUCCESS)
         return resultHandle;
@@ -225,20 +201,14 @@ static HKEY createOrOpenKey(HKEY parentHandle, const QString &rSubKey, bool *rea
 static QStringList childKeysOrGroups(HKEY parentHandle, QSettingsPrivate::ChildSpec spec)
 {
     QStringList result;
-    LONG res;
     DWORD numKeys;
     DWORD maxKeySize;
     DWORD numSubgroups;
     DWORD maxSubgroupSize;
 
     // Find the number of keys and subgroups, as well as the max of their lengths.
-    QT_WA( {
-        res = RegQueryInfoKeyW(parentHandle, 0, 0, 0, &numSubgroups, &maxSubgroupSize, 0,
+    LONG res = RegQueryInfoKey(parentHandle, 0, 0, 0, &numSubgroups, &maxSubgroupSize, 0,
                                &numKeys, &maxKeySize, 0, 0, 0);
-    }, {
-        res = RegQueryInfoKeyA(parentHandle, 0, 0, 0, &numSubgroups, &maxSubgroupSize, 0,
-                               &numKeys, &maxKeySize, 0, 0, 0);
-    } );
 
     if (res != ERROR_SUCCESS) {
         qWarning("QSettings: RegQueryInfoKey() failed: %s", errorCodeToString(res).toLatin1().data());
@@ -258,36 +228,21 @@ static QStringList childKeysOrGroups(HKEY parentHandle, QSettingsPrivate::ChildS
         m = maxSubgroupSize;
     }
 
-    /* Windows NT/2000/XP: The size does not include the terminating null character.
-       Windows Me/98/95: The size includes the terminating null character. */
+    /* The size does not include the terminating null character. */
     ++m;
 
     // Get the list
-    QByteArray buff(m*sizeof(ushort), 0);
+    QByteArray buff(m * sizeof(wchar_t), 0);
     for (int i = 0; i < n; ++i) {
         QString item;
-        QT_WA( {
-            DWORD l = buff.size() / sizeof(ushort);
-            if (spec == QSettingsPrivate::ChildKeys) {
-                res = RegEnumValueW(parentHandle, i,
-                                    reinterpret_cast<wchar_t *>(buff.data()),
-                                    &l, 0, 0, 0, 0);
-            } else {
-                res = RegEnumKeyExW(parentHandle, i,
-                                    reinterpret_cast<wchar_t *>(buff.data()),
-                                    &l, 0, 0, 0, 0);
-            }
-            if (res == ERROR_SUCCESS)
-                item = QString::fromUtf16(reinterpret_cast<ushort*>(buff.data()), l);
-        }, {
-            DWORD l = buff.size();
-            if (spec == QSettingsPrivate::ChildKeys)
-                res = RegEnumValueA(parentHandle, i, buff.data(), &l, 0, 0, 0, 0);
-            else
-                res = RegEnumKeyExA(parentHandle, i, buff.data(), &l, 0, 0, 0, 0);
-            if (res == ERROR_SUCCESS)
-                item = QString::fromLocal8Bit(buff.data(), l);
-        } );
+        DWORD l = buff.size() / sizeof(wchar_t);
+        if (spec == QSettingsPrivate::ChildKeys) {
+            res = RegEnumValue(parentHandle, i, reinterpret_cast<wchar_t *>(buff.data()), &l, 0, 0, 0, 0);
+        } else {
+            res = RegEnumKeyEx(parentHandle, i, reinterpret_cast<wchar_t *>(buff.data()), &l, 0, 0, 0, 0);
+        }
+        if (res == ERROR_SUCCESS)
+            item = QString::fromWCharArray((const wchar_t *)buff.constData(), l);
 
         if (res != ERROR_SUCCESS) {
             qWarning("QSettings: RegEnumValue failed: %s", errorCodeToString(res).toLatin1().data());
@@ -342,12 +297,7 @@ static void deleteChildGroups(HKEY parentHandle)
         RegCloseKey(childGroupHandle);
 
         // delete group itself
-        LONG res;
-        QT_WA( {
-            res = RegDeleteKeyW(parentHandle, reinterpret_cast<const wchar_t *>(group.utf16()));
-        }, {
-            res = RegDeleteKeyA(parentHandle, group.toLocal8Bit());
-        } );
+        LONG res = RegDeleteKey(parentHandle, reinterpret_cast<const wchar_t *>(group.utf16()));
         if (res != ERROR_SUCCESS) {
             qWarning("QSettings: RegDeleteKey failed on subkey \"%s\": %s",
                       group.toLatin1().data(), errorCodeToString(res).toLatin1().data());
@@ -519,12 +469,7 @@ bool QWinSettingsPrivate::readKey(HKEY parentHandle, const QString &rSubKey, QVa
     // get the size and type of the value
     DWORD dataType;
     DWORD dataSize;
-    LONG res;
-    QT_WA( {
-        res = RegQueryValueExW(handle, reinterpret_cast<const wchar_t *>(rSubkeyName.utf16()), 0, &dataType, 0, &dataSize);
-    }, {
-        res = RegQueryValueExA(handle, rSubkeyName.toLocal8Bit(), 0, &dataType, 0, &dataSize);
-    } );
+    LONG res = RegQueryValueEx(handle, reinterpret_cast<const wchar_t *>(rSubkeyName.utf16()), 0, &dataType, 0, &dataSize);
     if (res != ERROR_SUCCESS) {
         RegCloseKey(handle);
         return false;
@@ -532,13 +477,8 @@ bool QWinSettingsPrivate::readKey(HKEY parentHandle, const QString &rSubKey, QVa
 
     // get the value
     QByteArray data(dataSize, 0);
-    QT_WA( {
-        res = RegQueryValueExW(handle, reinterpret_cast<const wchar_t *>(rSubkeyName.utf16()), 0, 0,
-                               reinterpret_cast<unsigned char*>(data.data()), &dataSize);
-    }, {
-        res = RegQueryValueExA(handle, rSubkeyName.toLocal8Bit(), 0, 0,
-                               reinterpret_cast<unsigned char*>(data.data()), &dataSize);
-    } );
+    res = RegQueryValueEx(handle, reinterpret_cast<const wchar_t *>(rSubkeyName.utf16()), 0, 0,
+                           reinterpret_cast<unsigned char*>(data.data()), &dataSize);
     if (res != ERROR_SUCCESS) {
         RegCloseKey(handle);
         return false;
@@ -549,11 +489,7 @@ bool QWinSettingsPrivate::readKey(HKEY parentHandle, const QString &rSubKey, QVa
         case REG_SZ: {
             QString s;
             if (dataSize) {
-                QT_WA( {
-                    s = QString::fromUtf16(((const ushort*)data.constData()));
-                }, {
-                    s = QString::fromLocal8Bit(data.constData());
-                } );
+                s = QString::fromWCharArray(((const wchar_t *)data.constData()));
             }
             if (value != 0)
                 *value = stringToVariant(s);
@@ -565,12 +501,7 @@ bool QWinSettingsPrivate::readKey(HKEY parentHandle, const QString &rSubKey, QVa
             if (dataSize) {
                 int i = 0;
                 for (;;) {
-                    QString s;
-                    QT_WA( {
-                        s = QString::fromUtf16((const ushort*)data.constData() + i);
-                    }, {
-                        s = QString::fromLocal8Bit(data.constData() + i);
-                    } );
+                    QString s = QString::fromWCharArray((const wchar_t *)data.constData() + i);
                     i += s.length() + 1;
 
                     if (s.isEmpty())
@@ -587,11 +518,7 @@ bool QWinSettingsPrivate::readKey(HKEY parentHandle, const QString &rSubKey, QVa
         case REG_BINARY: {
             QString s;
             if (dataSize) {
-                QT_WA( {
-                    s = QString::fromUtf16((const ushort*)data.constData(), data.size()/2);
-                }, {
-                    s = QString::fromLocal8Bit(data.constData(), data.size());
-                } );
+                s = QString::fromWCharArray((const wchar_t *)data.constData(), data.size() / 2);
             }
             if (value != 0)
                 *value = stringToVariant(s);
@@ -635,13 +562,8 @@ QWinSettingsPrivate::~QWinSettingsPrivate()
 #if defined(Q_OS_WINCE)
         remove(regList.at(0).key()); 
 #else
-        DWORD res;
         QString emptyKey;
-        QT_WA( {
-            res = RegDeleteKeyW(writeHandle(), reinterpret_cast<const wchar_t *>(emptyKey.utf16()));
-        }, {
-            res = RegDeleteKeyA(writeHandle(), emptyKey.toLocal8Bit());
-        } );
+        DWORD res = RegDeleteKey(writeHandle(), reinterpret_cast<const wchar_t *>(emptyKey.utf16()));
         if (res != ERROR_SUCCESS) {
             qWarning("QSettings: Failed to delete key \"%s\": %s",
                     regList.at(0).key().toLatin1().data(), errorCodeToString(res).toLatin1().data());
@@ -666,11 +588,7 @@ void QWinSettingsPrivate::remove(const QString &uKey)
     LONG res;
     HKEY handle = openKey(writeHandle(), registryPermissions, keyPath(rKey));
     if (handle != 0) {
-        QT_WA( {
-            res = RegDeleteValueW(handle, reinterpret_cast<const wchar_t *>(keyName(rKey).utf16()));
-        }, {
-            res = RegDeleteValueA(handle, keyName(rKey).toLocal8Bit());
-        } );
+        res = RegDeleteValue(handle, reinterpret_cast<const wchar_t *>(keyName(rKey).utf16()));
         RegCloseKey(handle);
     }
 
@@ -685,12 +603,7 @@ void QWinSettingsPrivate::remove(const QString &uKey)
             for (int i = 0; i < childKeys.size(); ++i) {
                 QString group = childKeys.at(i);
 
-                LONG res;
-                QT_WA( {
-                    res = RegDeleteValueW(handle, reinterpret_cast<const wchar_t *>(group.utf16()));
-                }, {
-                    res = RegDeleteValueA(handle, group.toLocal8Bit());
-                } );
+                LONG res = RegDeleteValue(handle, reinterpret_cast<const wchar_t *>(group.utf16()));
                 if (res != ERROR_SUCCESS) {
                     qWarning("QSettings: RegDeleteValue failed on subkey \"%s\": %s",
                               group.toLatin1().data(), errorCodeToString(res).toLatin1().data());
@@ -701,11 +614,7 @@ void QWinSettingsPrivate::remove(const QString &uKey)
             // For WinCE always Close the handle first.
             RegCloseKey(handle);
 #endif
-            QT_WA( {
-                res = RegDeleteKeyW(writeHandle(), reinterpret_cast<const wchar_t *>(rKey.utf16()));
-            }, {
-                res = RegDeleteKeyA(writeHandle(), rKey.toLocal8Bit());
-            } );
+            res = RegDeleteKey(writeHandle(), reinterpret_cast<const wchar_t *>(rKey.utf16()));
 
             if (res != ERROR_SUCCESS) {
                 qWarning("QSettings: RegDeleteKey failed on key \"%s\": %s",
@@ -761,27 +670,15 @@ void QWinSettingsPrivate::set(const QString &uKey, const QVariant &value)
 
             if (type == REG_BINARY) {
                 QString s = variantToString(value);
-                QT_WA( {
-                    regValueBuff = QByteArray((const char*)s.utf16(), s.length()*2);
-                }, {
-                    regValueBuff = QByteArray((const char*)s.toLocal8Bit(), s.length());
-                } );
+                regValueBuff = QByteArray((const char*)s.utf16(), s.length() * 2);
             } else {
                 QStringList::const_iterator it = l.constBegin();
                 for (; it != l.constEnd(); ++it) {
                     const QString &s = *it;
-                    QT_WA( {
-                        regValueBuff += QByteArray((const char*)s.utf16(), (s.length() + 1)*2);
-                    }, {
-                        regValueBuff += QByteArray((const char*)s.toLocal8Bit(), s.length() + 1);
-                    } );
+                    regValueBuff += QByteArray((const char*)s.utf16(), (s.length() + 1) * 2);
                 }
-                QT_WA( {
-                    regValueBuff.append((char)0);
-                    regValueBuff.append((char)0);
-                }, {
-                    regValueBuff.append((char)0);
-                } );
+                regValueBuff.append((char)0);
+                regValueBuff.append((char)0);
             }
             break;
         }
@@ -794,21 +691,6 @@ void QWinSettingsPrivate::set(const QString &uKey, const QVariant &value)
         }
 
         case QVariant::ByteArray:
-            // On Win95/98/Me QString::toLocal8Bit() fails to handle chars > 0x7F. So we don't go through variantToString() at all.
-            if (QSysInfo::WindowsVersion & QSysInfo::WV_DOS_based) {
-                QByteArray ba = value.toByteArray();
-                regValueBuff = "@ByteArray(";
-                regValueBuff += ba;
-                regValueBuff += ')';
-                if (ba.contains('\0')) {
-                    type = REG_BINARY;
-                } else {
-                    type = REG_SZ;
-                    regValueBuff += '\0';
-                }
-                    
-                break;
-            }
             // fallthrough intended
 
         default: {
@@ -817,33 +699,18 @@ void QWinSettingsPrivate::set(const QString &uKey, const QVariant &value)
             QString s = variantToString(value);
             type = stringContainsNullChar(s) ? REG_BINARY : REG_SZ;
             if (type == REG_BINARY) {
-                QT_WA( {
-                    regValueBuff = QByteArray((const char*)s.utf16(), s.length()*2);
-                }, {
-                    regValueBuff = QByteArray((const char*)s.toLocal8Bit(), s.length());
-                } );
+                regValueBuff = QByteArray((const char*)s.utf16(), s.length() * 2);
             } else {
-                QT_WA( {
-                    regValueBuff = QByteArray((const char*)s.utf16(), (s.length() + 1)*2);
-                }, {
-                    regValueBuff = QByteArray((const char*)s.toLocal8Bit(), s.length() + 1);
-                } );
+                regValueBuff = QByteArray((const char*)s.utf16(), (s.length() + 1) * 2);
             }
             break;
         }
     }
 
     // set the value
-    LONG res;
-    QT_WA( {
-        res = RegSetValueExW(handle, reinterpret_cast<const wchar_t *>(keyName(rKey).utf16()), 0, type,
-                             reinterpret_cast<const unsigned char*>(regValueBuff.constData()),
-                             regValueBuff.size());
-    }, {
-        res = RegSetValueExA(handle, keyName(rKey).toLocal8Bit(), 0, type,
+    LONG res = RegSetValueEx(handle, reinterpret_cast<const wchar_t *>(keyName(rKey).utf16()), 0, type,
                              reinterpret_cast<const unsigned char*>(regValueBuff.constData()),
                              regValueBuff.size());
-    } );
 
     if (res == ERROR_SUCCESS) {
         deleteWriteHandleOnExit = false;