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>

28 files changed, 554 insertions, 1340 deletions

diff --git a/src/corelib/codecs/qtextcodec.cpp b/src/corelib/codecs/qtextcodec.cpp
index d4e5d44..c4266a0 100644
--- a/src/corelib/codecs/qtextcodec.cpp
+++ b/src/corelib/codecs/qtextcodec.cpp
@@ -233,9 +233,9 @@ QString QWindowsLocalCodec::convertToUnicode(const char *chars, int length, Conv
         return QString();
 
     const int wclen_auto = 4096;
-    WCHAR wc_auto[wclen_auto];
+    wchar_t wc_auto[wclen_auto];
     int wclen = wclen_auto;
-    WCHAR *wc = wc_auto;
+    wchar_t *wc = wc_auto;
     int len;
     QString sp;
     bool prepend = false;
@@ -275,7 +275,7 @@ QString QWindowsLocalCodec::convertToUnicode(const char *chars, int length, Conv
             } else {
                 wclen = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED,
                                     mb, mblen, 0, 0);
-                wc = new WCHAR[wclen];
+                wc = new wchar_t[wclen];
                 // and try again...
             }
         } else if (r == ERROR_NO_UNICODE_TRANSLATION) {
@@ -341,7 +341,7 @@ QString QWindowsLocalCodec::convertToUnicodeCharByChar(const char *chars, int le
     const char *next = 0;
     QString s;
     while((next = CharNextExA(CP_ACP, mb, 0)) != mb) {
-        WCHAR wc[2] ={0};
+        wchar_t wc[2] ={0};
         int charlength = next - mb;
         int len = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED|MB_ERR_INVALID_CHARS, mb, charlength, wc, 2);
         if (len>0) {
@@ -1042,16 +1042,10 @@ QList<int> QTextCodec::availableMibs()
     This might be needed for some applications that want to use their
     own mechanism for setting the locale.
 
-    Setting this codec is not supported on DOS based Windows.
-
     \sa codecForLocale()
 */
 void QTextCodec::setCodecForLocale(QTextCodec *c)
 {
-#ifdef Q_WS_WIN
-    if (QSysInfo::WindowsVersion& QSysInfo::WV_DOS_based)
-	return;
-#endif
     localeMapper = c;
     if (!localeMapper)
         setupLocaleMapper();
diff --git a/src/corelib/global/qglobal.cpp b/src/corelib/global/qglobal.cpp
index bb639fe..f7a97e1 100644
--- a/src/corelib/global/qglobal.cpp
+++ b/src/corelib/global/qglobal.cpp
@@ -915,7 +915,7 @@ QT_BEGIN_NAMESPACE
     \fn bool qt_winUnicode()
     \relates <QtGlobal>
 
-    Use QSysInfo::WindowsVersion and QSysInfo::WV_DOS_based instead.
+    This function always returns true.
 
     \sa QSysInfo
 */
@@ -1620,15 +1620,11 @@ QSysInfo::WinVersion QSysInfo::windowsVersion()
     if (winver)
         return winver;
     winver = QSysInfo::WV_NT;
-#ifndef Q_OS_WINCE
-    OSVERSIONINFOA osver;
-    osver.dwOSVersionInfoSize = sizeof(osver);
-    GetVersionExA(&osver);
-#else
-    DWORD qt_cever = 0;
     OSVERSIONINFOW osver;
     osver.dwOSVersionInfoSize = sizeof(osver);
     GetVersionEx(&osver);
+#ifdef Q_OS_WINCE
+    DWORD qt_cever = 0;
     qt_cever = osver.dwMajorVersion * 100;
     qt_cever += osver.dwMinorVersion * 10;
 #endif
@@ -1904,29 +1900,16 @@ QString qt_error_string(int errorCode)
         break;
     default: {
 #ifdef Q_OS_WIN
-        QT_WA({
-            unsigned short *string = 0;
-            FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
-                          NULL,
-                          errorCode,
-                          MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-                          (LPTSTR)&string,
-                          0,
-                          NULL);
-            ret = QString::fromUtf16(string);
-            LocalFree((HLOCAL)string);
-        }, {
-            char *string = 0;
-            FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
-                           NULL,
-                           errorCode,
-                           MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-                           (LPSTR)&string,
-                           0,
-                           NULL);
-            ret = QString::fromLocal8Bit(string);
-            LocalFree((HLOCAL)string);
-        });
+        wchar_t *string = 0;
+        FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
+                      NULL,
+                      errorCode,
+                      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+                      string,
+                      0,
+                      NULL);
+        ret = QString::fromWCharArray(string);
+        LocalFree((HLOCAL)string);
 
         if (ret.isEmpty() && errorCode == ERROR_MOD_NOT_FOUND)
             ret = QString::fromLatin1("The specified module could not be found.");
diff --git a/src/corelib/global/qglobal.h b/src/corelib/global/qglobal.h
index afc3f58..00a9466 100644
--- a/src/corelib/global/qglobal.h
+++ b/src/corelib/global/qglobal.h
@@ -147,7 +147,7 @@ namespace QT_NAMESPACE {}
      MSDOS    - MS-DOS and Windows
      OS2      - OS/2
      OS2EMX   - XFree86 on OS/2 (not PM)
-     WIN32    - Win32 (Windows 95/98/ME and Windows NT/2000/XP)
+     WIN32    - Win32 (Windows 2000/XP/Vista/7 and Windows Server 2003/2008)
      WINCE    - WinCE (Windows CE 5.0)
      CYGWIN   - Cygwin
      SOLARIS  - Sun Solaris
@@ -1416,7 +1416,7 @@ inline QT3_SUPPORT bool qSysInfo(int *wordSize, bool *bigEndian)
 
 #if defined(Q_WS_WIN) || defined(Q_OS_CYGWIN)
 #if defined(QT3_SUPPORT)
-inline QT3_SUPPORT bool qt_winUnicode() { return !(QSysInfo::WindowsVersion & QSysInfo::WV_DOS_based); }
+inline QT3_SUPPORT bool qt_winUnicode() { return true; }
 inline QT3_SUPPORT int qWinVersion() { return QSysInfo::WindowsVersion; }
 #endif
 
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;
diff --git a/src/corelib/kernel/qcoreapplication.cpp b/src/corelib/kernel/qcoreapplication.cpp
index e6a471c..f0a3fec 100644
--- a/src/corelib/kernel/qcoreapplication.cpp
+++ b/src/corelib/kernel/qcoreapplication.cpp
@@ -1742,18 +1742,10 @@ QString QCoreApplication::applicationFilePath()
         return d->cachedApplicationFilePath;
 
 #if defined( Q_WS_WIN )
-    QFileInfo filePath;
-    QT_WA({
-        wchar_t module_name[MAX_PATH+1];
-        GetModuleFileNameW(0, module_name, MAX_PATH);
-        module_name[MAX_PATH] = 0;
-        filePath = QString::fromUtf16((ushort *)module_name);
-    }, {
-        char module_name[MAX_PATH+1];
-        GetModuleFileNameA(0, module_name, MAX_PATH);
-        module_name[MAX_PATH] = 0;
-        filePath = QString::fromLocal8Bit(module_name);
-    });
+    wchar_t module_name[MAX_PATH];
+    GetModuleFileName(0, module_name, MAX_PATH);
+    module_name[MAX_PATH] = 0;
+    QFileInfo filePath = QString::fromWCharArray(module_name);
 
     d->cachedApplicationFilePath = filePath.filePath();
     return d->cachedApplicationFilePath;
@@ -1902,13 +1894,13 @@ QStringList QCoreApplication::arguments()
         return list;
     }
 #ifdef Q_OS_WIN
-    QString cmdline = QT_WA_INLINE(QString::fromUtf16((unsigned short *)GetCommandLineW()), QString::fromLocal8Bit(GetCommandLineA()));
+    QString cmdline = QString::fromWCharArray(GetCommandLine());
 
 #if defined(Q_OS_WINCE)
     wchar_t tempFilename[MAX_PATH+1];
-    if (GetModuleFileNameW(0, tempFilename, MAX_PATH)) {
+    if (GetModuleFileName(0, tempFilename, MAX_PATH)) {
         tempFilename[MAX_PATH] = 0;
-        cmdline.prepend(QLatin1Char('\"') + QString::fromUtf16((unsigned short *)tempFilename) + QLatin1String("\" "));
+        cmdline.prepend(QLatin1Char('\"') + QString::fromWCharArray(tempFilename) + QLatin1String("\" "));
     }
 #endif // Q_OS_WINCE
 
diff --git a/src/corelib/kernel/qcoreapplication_win.cpp b/src/corelib/kernel/qcoreapplication_win.cpp
index 7a35340..657abd1 100644
--- a/src/corelib/kernel/qcoreapplication_win.cpp
+++ b/src/corelib/kernel/qcoreapplication_win.cpp
@@ -45,14 +45,15 @@
 #include "qt_windows.h"
 #include "qvector.h"
 #include "qmutex.h"
+#include "qfileinfo.h"
 #include "qcorecmdlineargs_p.h"
 #include <private/qthread_p.h>
 #include <ctype.h>
 
 QT_BEGIN_NAMESPACE
 
-char         appFileName[MAX_PATH+1];                // application file name
-char         theAppName[MAX_PATH+1];                        // application name
+char         appFileName[MAX_PATH];                // application file name
+char         theAppName[MAX_PATH];                        // application name
 HINSTANCE appInst        = 0;                // handle to app instance
 HINSTANCE appPrevInst        = 0;                // handle to prev app instance
 int appCmdShow = 0;
@@ -73,48 +74,35 @@ Q_CORE_EXPORT int qWinAppCmdShow()                        // get main window sho
     return appCmdShow;
 }
 
+Q_CORE_EXPORT QString qAppFileName()                // get application file name
+{
+    wchar_t buffer[MAX_PATH];
+    GetModuleFileName(0, buffer, MAX_PATH);
+    return QString::fromWCharArray(buffer);
+}
 
 void set_winapp_name()
 {
     static bool already_set = false;
     if (!already_set) {
         already_set = true;
-#ifndef Q_OS_WINCE
-        GetModuleFileNameA(0, appFileName, sizeof(appFileName));
-        appFileName[sizeof(appFileName)-1] = 0;
-#else
-        QString afm;
-        afm.resize(sizeof(appFileName));
-        afm.resize(GetModuleFileName(0, (wchar_t *) (afm.unicode()), sizeof(appFileName)));
-        memcpy(appFileName, afm.toLatin1(), sizeof(appFileName));
-#endif
-        const char *p = strrchr(appFileName, '\\');        // skip path
-        if (p)
-            memcpy(theAppName, p+1, qstrlen(p));
-        int l = qstrlen(theAppName);
-        if ((l > 4) && !qstricmp(theAppName + l - 4, ".exe"))
-            theAppName[l-4] = '\0';                // drop .exe extension
 
-        if (appInst == 0) {
-            QT_WA({
-                appInst = GetModuleHandle(0);
-            }, {
-                appInst = GetModuleHandleA(0);
-            });
-        }
-    }
-}
+        QString moduleName = qAppFileName();
 
-Q_CORE_EXPORT QString qAppFileName()                // get application file name
-{
-    return QString::fromLatin1(appFileName);
+        QByteArray filePath = moduleName.toLocal8Bit();
+        QByteArray fileName = QFileInfo(moduleName).baseName().toLocal8Bit();
+
+        memcpy(appFileName, filePath.constData(), filePath.length());
+        memcpy(theAppName, fileName.constData(), fileName.length());
+
+        if (appInst == 0)
+            appInst = GetModuleHandle(0);
+    }
 }
 
 QString QCoreApplicationPrivate::appName() const
 {
-    if (!theAppName[0])
-        set_winapp_name();
-    return QString::fromLatin1(theAppName);
+    return QFileInfo(qAppFileName()).baseName();
 }
 
 class QWinMsgHandlerCriticalSection
@@ -145,15 +133,11 @@ Q_CORE_EXPORT void qWinMsgHandler(QtMsgType t, const char* str)
         str = "(null)";
 
     staticCriticalSection.lock();
-    QT_WA({
-        QString s(QString::fromLocal8Bit(str));
-        s += QLatin1Char('\n');
-        OutputDebugStringW((TCHAR*)s.utf16());
-    }, {
-        QByteArray s(str);
-        s += '\n';
-        OutputDebugStringA(s.data());
-    })
+
+    QString s(QString::fromLocal8Bit(str));
+    s += QLatin1Char('\n');
+    OutputDebugString((wchar_t*)s.utf16());
+
     staticCriticalSection.unlock();
 }
 
diff --git a/src/corelib/kernel/qcorecmdlineargs_p.h b/src/corelib/kernel/qcorecmdlineargs_p.h
index c0dd813..a012b4e 100644
--- a/src/corelib/kernel/qcorecmdlineargs_p.h
+++ b/src/corelib/kernel/qcorecmdlineargs_p.h
@@ -135,9 +135,9 @@ static inline QStringList qWinCmdArgs(QString cmdLine) // not const-ref: this mi
     QStringList args;
 
     int argc = 0;
-    QVector<ushort*> argv = qWinCmdLine<ushort>((ushort*)cmdLine.utf16(), cmdLine.length(), argc);
+    QVector<wchar_t*> argv = qWinCmdLine<wchar_t>((wchar_t *)cmdLine.utf16(), cmdLine.length(), argc);
     for (int a = 0; a < argc; ++a) {
-        args << QString::fromUtf16(argv[a]);
+        args << QString::fromWCharArray(argv[a]);
     }
 
     return args;
@@ -147,10 +147,7 @@ static inline QStringList qCmdLineArgs(int argc, char *argv[])
 {
     Q_UNUSED(argc)
     Q_UNUSED(argv)
-    QString cmdLine = QT_WA_INLINE(
-        QString::fromUtf16((unsigned short*)GetCommandLineW()),
-        QString::fromLocal8Bit(GetCommandLineA())
-    );
+    QString cmdLine = QString::fromWCharArray(GetCommandLine());
     return qWinCmdArgs(cmdLine);
 }
 
diff --git a/src/corelib/kernel/qeventdispatcher_win.cpp b/src/corelib/kernel/qeventdispatcher_win.cpp
index cb1549c..23e4fa9 100644
--- a/src/corelib/kernel/qeventdispatcher_win.cpp
+++ b/src/corelib/kernel/qeventdispatcher_win.cpp
@@ -355,8 +355,7 @@ QEventDispatcherWin32Private::QEventDispatcherWin32Private()
 {
     resolveTimerAPI();
 
-    wakeUpNotifier.setHandle(QT_WA_INLINE(CreateEventW(0, FALSE, FALSE, 0),
-                                          CreateEventA(0, FALSE, FALSE, 0)));
+    wakeUpNotifier.setHandle(CreateEvent(0, FALSE, FALSE, 0));
     if (!wakeUpNotifier.handle())
         qWarning("QEventDispatcher: Creating QEventDispatcherWin32Private wakeup event failed");
 }
@@ -367,13 +366,8 @@ QEventDispatcherWin32Private::~QEventDispatcherWin32Private()
     CloseHandle(wakeUpNotifier.handle());
     if (internalHwnd)
         DestroyWindow(internalHwnd);
-    QByteArray className = "QEventDispatcherWin32_Internal_Widget" + QByteArray::number(quintptr(qt_internal_proc));
-#if !defined(Q_OS_WINCE)
-    UnregisterClassA(className.constData(), qWinAppInst());
-#else
-    UnregisterClassW(reinterpret_cast<const wchar_t *> (QString::fromLatin1(className.constData()).utf16())
-                     , qWinAppInst());
-#endif
+    QString className = QLatin1String("QEventDispatcherWin32_Internal_Widget") + QString::number(quintptr(qt_internal_proc));
+    UnregisterClass((wchar_t*)className.utf16(), qWinAppInst());
 }
 
 void QEventDispatcherWin32Private::activateEventNotifier(QWinEventNotifier * wen)
@@ -382,18 +376,24 @@ void QEventDispatcherWin32Private::activateEventNotifier(QWinEventNotifier * wen
     QCoreApplication::sendEvent(wen, &event);
 }
 
-
+// ### Qt 5: remove
 Q_CORE_EXPORT bool winPeekMessage(MSG* msg, HWND hWnd, UINT wMsgFilterMin,
                      UINT wMsgFilterMax, UINT wRemoveMsg)
 {
-    QT_WA({ return PeekMessage(msg, hWnd, wMsgFilterMin, wMsgFilterMax, wRemoveMsg); } ,
-          { return PeekMessageA(msg, hWnd, wMsgFilterMin, wMsgFilterMax, wRemoveMsg); });
+    return PeekMessage(msg, hWnd, wMsgFilterMin, wMsgFilterMax, wRemoveMsg);
 }
 
+// ### Qt 5: remove
 Q_CORE_EXPORT bool winPostMessage(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
 {
-    QT_WA({ return PostMessage(hWnd, msg, wParam, lParam); } ,
-          { return PostMessageA(hWnd, msg, wParam, lParam); });
+    return PostMessage(hWnd, msg, wParam, lParam);
+}
+
+// ### Qt 5: remove
+Q_CORE_EXPORT bool winGetMessage(MSG* msg, HWND hWnd, UINT wMsgFilterMin,
+                     UINT wMsgFilterMax)
+{
+    return GetMessage(msg, hWnd, wMsgFilterMin, wMsgFilterMax);
 }
 
 // This function is called by a workerthread
@@ -443,10 +443,10 @@ LRESULT CALLBACK qt_internal_proc(HWND hwnd, UINT message, WPARAM wp, LPARAM lp)
 
     #ifdef GWLP_USERDATA
             QEventDispatcherWin32 *eventDispatcher =
-                (QEventDispatcherWin32 *) GetWindowLongPtrA(hwnd, GWLP_USERDATA);
+                (QEventDispatcherWin32 *) GetWindowLongPtr(hwnd, GWLP_USERDATA);
     #else
             QEventDispatcherWin32 *eventDispatcher =
-                (QEventDispatcherWin32 *) GetWindowLongA(hwnd, GWL_USERDATA);
+                (QEventDispatcherWin32 *) GetWindowLong(hwnd, GWL_USERDATA);
     #endif
             if (eventDispatcher) {
                 QEventDispatcherWin32Private *d = eventDispatcher->d_func();
@@ -494,54 +494,35 @@ LRESULT CALLBACK qt_internal_proc(HWND hwnd, UINT message, WPARAM wp, LPARAM lp)
 
 static HWND qt_create_internal_window(const QEventDispatcherWin32 *eventDispatcher)
 {
-    HINSTANCE hi = qWinAppInst();
-#if defined(Q_OS_WINCE)
+    // make sure that multiple Qt's can coexist in the same process
+    QString className = QLatin1Strign("QEventDispatcherWin32_Internal_Widget") + QString::number(quintptr(qt_internal_proc));
+
     WNDCLASS wc;
-#else
-    WNDCLASSA wc;
-#endif
     wc.style = 0;
     wc.lpfnWndProc = qt_internal_proc;
     wc.cbClsExtra = 0;
     wc.cbWndExtra = 0;
-    wc.hInstance = hi;
+    wc.hInstance = qWinAppInst();
     wc.hIcon = 0;
     wc.hCursor = 0;
     wc.hbrBackground = 0;
     wc.lpszMenuName = NULL;
+    wc.lpszClassName = reinterpret_cast<const wchar_t *> (className.utf16());
 
-    // make sure that multiple Qt's can coexist in the same process
-    QByteArray className = "QEventDispatcherWin32_Internal_Widget" + QByteArray::number(quintptr(qt_internal_proc));
-#if defined(Q_OS_WINCE)
-    QString tmp = QString::fromLatin1(className.data());
-    wc.lpszClassName = reinterpret_cast<const wchar_t *> (tmp.utf16());
     RegisterClass(&wc);
     HWND wnd = CreateWindow(wc.lpszClassName,  // classname
-                             wc.lpszClassName,  // window name
-                             0,                 // style
-                             0, 0, 0, 0,        // geometry
-                             0,                 // parent
-                             0,                 // menu handle
-                             hi,                // application
-                             0);                // windows creation data.
-#else
-    wc.lpszClassName = className.constData();
-    RegisterClassA(&wc);
-    HWND wnd = CreateWindowA(wc.lpszClassName,  // classname
-                             wc.lpszClassName,  // window name
-                             0,                 // style
-                             0, 0, 0, 0,        // geometry
-                             0,                 // parent
-                             0,                 // menu handle
-                             hi,                // application
-                             0);                // windows creation data.
-#endif
-
+                            wc.lpszClassName,  // window name
+                            0,                 // style
+                            0, 0, 0, 0,        // geometry
+                            0,                 // parent
+                            0,                 // menu handle
+                            qWinAppInst(),     // application
+                            0);                // windows creation data.
 
 #ifdef GWLP_USERDATA
-    SetWindowLongPtrA(wnd, GWLP_USERDATA, (LONG_PTR)eventDispatcher);
+    SetWindowLongPtr(wnd, GWLP_USERDATA, (LONG_PTR)eventDispatcher);
 #else
-    SetWindowLongA(wnd, GWL_USERDATA, (LONG)eventDispatcher);
+    SetWindowLong(wnd, GWL_USERDATA, (LONG)eventDispatcher);
 #endif
 
     if (!wnd) {
@@ -690,7 +671,7 @@ bool QEventDispatcherWin32::processEvents(QEventLoop::ProcessEventsFlags flags)
                 haveMessage = true;
                 msg = d->queuedSocketEvents.takeFirst();
             } else {
-                haveMessage = winPeekMessage(&msg, 0, 0, 0, PM_REMOVE);
+                haveMessage = PeekMessage(&msg, 0, 0, 0, PM_REMOVE);
                 if (haveMessage && (flags & QEventLoop::ExcludeUserInputEvents)
                     && ((msg.message >= WM_KEYFIRST
                          && msg.message <= WM_KEYLAST)
@@ -738,11 +719,7 @@ bool QEventDispatcherWin32::processEvents(QEventLoop::ProcessEventsFlags flags)
 
                 if (!filterEvent(&msg)) {
                     TranslateMessage(&msg);
-                    QT_WA({
-                        DispatchMessage(&msg);
-                    } , {
-                        DispatchMessageA(&msg);
-                    });
+                    DispatchMessage(&msg);
                 }
             } else if (waitRet >= WAIT_OBJECT_0 && waitRet < WAIT_OBJECT_0 + nCount) {
                 d->activateEventNotifier(d->winEventNotifierList.at(waitRet - WAIT_OBJECT_0));
@@ -781,7 +758,7 @@ bool QEventDispatcherWin32::processEvents(QEventLoop::ProcessEventsFlags flags)
 bool QEventDispatcherWin32::hasPendingEvents()
 {
     MSG msg;
-    return qGlobalPostedEventsCount() || winPeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE);
+    return qGlobalPostedEventsCount() || PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE);
 }
 
 void QEventDispatcherWin32::registerSocketNotifier(QSocketNotifier *notifier)
diff --git a/src/corelib/kernel/qfunctions_wince.cpp b/src/corelib/kernel/qfunctions_wince.cpp
index 2c47adb..5680ad5 100644
--- a/src/corelib/kernel/qfunctions_wince.cpp
+++ b/src/corelib/kernel/qfunctions_wince.cpp
@@ -108,7 +108,7 @@ int qt_wince__getdrive( void )
     return 1;
 }
 
-int qt_wince__waccess( const WCHAR *path, int pmode )
+int qt_wince__waccess( const wchar_t *path, int pmode )
 {
     DWORD res = GetFileAttributes( path );
     if ( 0xFFFFFFFF == res )
@@ -118,7 +118,7 @@ int qt_wince__waccess( const WCHAR *path, int pmode )
         return -1;
 
     if ( (pmode & X_OK) && !(res & FILE_ATTRIBUTE_DIRECTORY) ) {
-        QString file = QString::fromUtf16(reinterpret_cast<const ushort *> (path));
+        QString file = QString::fromWCharArray(path);
         if ( !(file.endsWith(QString::fromLatin1(".exe")) ||
            file.endsWith(QString::fromLatin1(".com"))) )
         return -1;
@@ -130,12 +130,12 @@ int qt_wince__waccess( const WCHAR *path, int pmode )
 int qt_wince_open( const char *filename, int oflag, int pmode )
 {
     QString fn( QString::fromLatin1(filename) );
-    return _wopen( (WCHAR*)fn.utf16(), oflag, pmode );
+    return _wopen( (wchar_t*)fn.utf16(), oflag, pmode );
 }
 
-int qt_wince__wopen( const WCHAR *filename, int oflag, int /*pmode*/ )
+int qt_wince__wopen( const wchar_t *filename, int oflag, int /*pmode*/ )
 {
-    WCHAR *flag;
+    wchar_t *flag;
 
     if ( oflag & _O_APPEND ) {
         if ( oflag & _O_WRONLY ) {
@@ -290,7 +290,7 @@ bool qt_wince__chmod(const char *file, int mode)
     return _wchmod( reinterpret_cast<const wchar_t *> (QString::fromLatin1(file).utf16()), mode);
 }
 
-bool qt_wince__wchmod(const WCHAR *file, int mode)
+bool qt_wince__wchmod(const wchar_t *file, int mode)
 {
     // ### Does not work properly, what about just adding one property?
     if(mode&_S_IWRITE) {
diff --git a/src/corelib/kernel/qfunctions_wince.h b/src/corelib/kernel/qfunctions_wince.h
index 307e17b..41cb641 100644
--- a/src/corelib/kernel/qfunctions_wince.h
+++ b/src/corelib/kernel/qfunctions_wince.h
@@ -175,8 +175,8 @@ typedef int mode_t;
 extern int errno;
 
 int     qt_wince__getdrive( void );
-int     qt_wince__waccess( const WCHAR *path, int pmode );
-int     qt_wince__wopen( const WCHAR *filename, int oflag, int pmode );
+int     qt_wince__waccess( const wchar_t *path, int pmode );
+int     qt_wince__wopen( const wchar_t *filename, int oflag, int pmode );
 long    qt_wince__lseek( int handle, long offset, int origin );
 int     qt_wince__read( int handle, void *buffer, unsigned int count );
 int     qt_wince__write( int handle, const void *buffer, unsigned int count );
@@ -204,7 +204,7 @@ int qt_wince_SetErrorMode(int);
 #endif
 
 bool qt_wince__chmod(const char *file, int mode);
-bool qt_wince__wchmod(const WCHAR *file, int mode);
+bool qt_wince__wchmod(const wchar_t *file, int mode);
 
 #pragma warning(disable: 4273)
 HANDLE qt_wince_CreateFileA(LPCSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES, DWORD, DWORD, HANDLE);
diff --git a/src/corelib/kernel/qsharedmemory_win.cpp b/src/corelib/kernel/qsharedmemory_win.cpp
index d963a6d..c88149a 100644
--- a/src/corelib/kernel/qsharedmemory_win.cpp
+++ b/src/corelib/kernel/qsharedmemory_win.cpp
@@ -106,16 +106,11 @@ HANDLE QSharedMemoryPrivate::handle()
             return false;
         }
 #ifndef Q_OS_WINCE
-    QT_WA({
-            hand = OpenFileMappingW(FILE_MAP_ALL_ACCESS, false, (TCHAR*)safeKey.utf16());
-        }, {
-            hand = OpenFileMappingA(FILE_MAP_ALL_ACCESS, false, safeKey.toLocal8Bit().constData());
-        });
+        hand = OpenFileMapping(FILE_MAP_ALL_ACCESS, false, (wchar_t*)safeKey.utf16());
 #else
         // This works for opening a mapping too, but always opens it with read/write access in
         // attach as it seems.
-        hand = CreateFileMappingW(INVALID_HANDLE_VALUE,
-               0, PAGE_READWRITE, 0, 0, (TCHAR*)safeKey.utf16());
+        hand = CreateFileMapping(INVALID_HANDLE_VALUE, 0, PAGE_READWRITE, 0, 0, (wchar_t*)safeKey.utf16());
 #endif
         if (!hand) {
             setErrorString(function);
@@ -148,13 +143,7 @@ bool QSharedMemoryPrivate::create(int size)
     }
 
     // Create the file mapping.
-    QT_WA( {
-        hand = CreateFileMappingW(INVALID_HANDLE_VALUE,
-               0, PAGE_READWRITE, 0, size, (TCHAR*)safeKey.utf16());
-    }, {
-        hand = CreateFileMappingA(INVALID_HANDLE_VALUE,
-               0, PAGE_READWRITE, 0, size, safeKey.toLocal8Bit().constData());
-    } );
+    hand = CreateFileMapping(INVALID_HANDLE_VALUE, 0, PAGE_READWRITE, 0, size, (wchar_t*)safeKey.utf16());
     setErrorString(function);
 
     // hand is valid when it already exists unlike unix so explicitly check
diff --git a/src/corelib/kernel/qsystemsemaphore_win.cpp b/src/corelib/kernel/qsystemsemaphore_win.cpp
index 4e03ddf..1102258 100644
--- a/src/corelib/kernel/qsystemsemaphore_win.cpp
+++ b/src/corelib/kernel/qsystemsemaphore_win.cpp
@@ -87,11 +87,7 @@ HANDLE QSystemSemaphorePrivate::handle(QSystemSemaphore::AccessMode)
     // Create it if it doesn't already exists.
     if (semaphore == 0) {
         QString safeName = makeKeyFileName();
-        QT_WA({
-            semaphore = CreateSemaphoreW(0, initialValue, MAXLONG, (TCHAR*)safeName.utf16());
-        }, {
-            semaphore = CreateSemaphoreA(0, initialValue, MAXLONG, safeName.toLocal8Bit().constData());
-        });
+        semaphore = CreateSemaphore(0, initialValue, MAXLONG, (wchar_t*)safeName.utf16());
         if (semaphore == NULL)
             setErrorString(QLatin1String("QSystemSemaphore::handle"));
     }
diff --git a/src/corelib/kernel/qtimer.cpp b/src/corelib/kernel/qtimer.cpp
index d2a0b3a..2ee9d26 100644
--- a/src/corelib/kernel/qtimer.cpp
+++ b/src/corelib/kernel/qtimer.cpp
@@ -103,9 +103,8 @@ QT_BEGIN_NAMESPACE
 
     Note that QTimer's accuracy depends on the underlying operating
     system and hardware. Most platforms support an accuracy of
-    1 millisecond, but Windows 98 supports only 55. If Qt is
-    unable to deliver the requested number of timer clicks, it will
-    silently discard some.
+    1 millisecond. If Qt is unable to deliver the requested number of
+    timer clicks, it will silently discard some.
 
     An alternative to using QTimer is to call QObject::startTimer()
     for your object and reimplement the QObject::timerEvent() event
diff --git a/src/corelib/plugin/qlibrary.cpp b/src/corelib/plugin/qlibrary.cpp
index 4d465dc..8f364ba 100644
--- a/src/corelib/plugin/qlibrary.cpp
+++ b/src/corelib/plugin/qlibrary.cpp
@@ -623,11 +623,7 @@ bool QLibraryPrivate::isPlugin(QSettings *settings)
 #endif
             if (!pHnd) {
 #ifdef Q_OS_WIN
-                QT_WA({
-                    hTempModule = ::LoadLibraryExW((wchar_t*)QDir::toNativeSeparators(fileName).utf16(), 0, DONT_RESOLVE_DLL_REFERENCES);
-                } , {
-                    temporary_load = load_sys();
-                });
+                hTempModule = ::LoadLibraryEx((wchar_t*)QDir::toNativeSeparators(fileName).utf16(), 0, DONT_RESOLVE_DLL_REFERENCES);
 #else
                 temporary_load =  load_sys();
 #endif
@@ -641,7 +637,7 @@ bool QLibraryPrivate::isPlugin(QSettings *settings)
             QtPluginQueryVerificationDataFunction qtPluginQueryVerificationDataFunction = hTempModule
                 ? (QtPluginQueryVerificationDataFunction)
 #ifdef Q_OS_WINCE
-                    ::GetProcAddressW(hTempModule, L"qt_plugin_query_verification_data")
+                    ::GetProcAddress(hTempModule, L"qt_plugin_query_verification_data")
 #else
                     ::GetProcAddress(hTempModule, "qt_plugin_query_verification_data")
 #endif
diff --git a/src/corelib/plugin/qlibrary_win.cpp b/src/corelib/plugin/qlibrary_win.cpp
index 43eeafa..847c0d2 100644
--- a/src/corelib/plugin/qlibrary_win.cpp
+++ b/src/corelib/plugin/qlibrary_win.cpp
@@ -67,30 +67,18 @@ bool QLibraryPrivate::load_sys()
 
     //avoid 'Bad Image' message box
     UINT oldmode = SetErrorMode(SEM_FAILCRITICALERRORS|SEM_NOOPENFILEERRORBOX);
-    QT_WA({
-        pHnd = LoadLibraryW((TCHAR*)QDir::toNativeSeparators(attempt).utf16());
-    } , {
-        pHnd = LoadLibraryA(QFile::encodeName(QDir::toNativeSeparators(attempt)).data());
-    });
-    
+    pHnd = LoadLibrary((wchar_t*)QDir::toNativeSeparators(attempt).utf16());
+
     if (pluginState != IsAPlugin) {
 #if defined(Q_OS_WINCE)
         if (!pHnd && ::GetLastError() == ERROR_MOD_NOT_FOUND) {
             QString secondAttempt = fileName;
-            QT_WA({
-                pHnd = LoadLibraryW((TCHAR*)QDir::toNativeSeparators(secondAttempt).utf16());
-            } , {
-                pHnd = LoadLibraryA(QFile::encodeName(QDir::toNativeSeparators(secondAttempt)).data());
-            });
+            pHnd = LoadLibrary((wchar_t*)QDir::toNativeSeparators(secondAttempt).utf16());
         }
 #endif
         if (!pHnd && ::GetLastError() == ERROR_MOD_NOT_FOUND) {
             attempt += QLatin1String(".dll");
-            QT_WA({
-                pHnd = LoadLibraryW((TCHAR*)QDir::toNativeSeparators(attempt).utf16());
-            } , {
-                pHnd = LoadLibraryA(QFile::encodeName(QDir::toNativeSeparators(attempt)).data());
-            });
+            pHnd = LoadLibrary((wchar_t*)QDir::toNativeSeparators(attempt).utf16());
         }
     }
 
@@ -100,15 +88,11 @@ bool QLibraryPrivate::load_sys()
     }
     if (pHnd) {
         errorString.clear();
-        QT_WA({
-            TCHAR buffer[MAX_PATH + 1];
-            ::GetModuleFileNameW(pHnd, buffer, MAX_PATH);
-            attempt = QString::fromUtf16(reinterpret_cast<const ushort *>(&buffer));
-        }, {
-            char buffer[MAX_PATH + 1];
-            ::GetModuleFileNameA(pHnd, buffer, MAX_PATH);
-            attempt = QString::fromLocal8Bit(buffer);
-        });
+
+        wchar_t buffer[MAX_PATH];
+        ::GetModuleFileName(pHnd, buffer, MAX_PATH);
+        attempt = QString::fromWCharArray(buffer);
+
         const QDir dir =  QFileInfo(fileName).dir();
         const QString realfilename = attempt.mid(attempt.lastIndexOf(QLatin1Char('\\')) + 1);
         if (dir.path() == QLatin1String("."))
diff --git a/src/corelib/thread/qmutex_win.cpp b/src/corelib/thread/qmutex_win.cpp
index f2022a5..1d247fc 100644
--- a/src/corelib/thread/qmutex_win.cpp
+++ b/src/corelib/thread/qmutex_win.cpp
@@ -50,19 +50,7 @@ QT_BEGIN_NAMESPACE
 QMutexPrivate::QMutexPrivate(QMutex::RecursionMode mode)
     : recursive(mode == QMutex::Recursive), contenders(0), lastSpinCount(0), owner(0), count(0)
 {
-    if (QSysInfo::WindowsVersion == 0) {
-        // mutex was created before initializing WindowsVersion. this
-        // can happen when creating the resource file engine handler,
-        // for example. try again with just the A version
-#ifdef Q_OS_WINCE
-        event = CreateEventW(0, FALSE, FALSE, 0);
-#else
-        event = CreateEventA(0, FALSE, FALSE, 0);
-#endif
-    } else {
-        event = QT_WA_INLINE(CreateEventW(0, FALSE, FALSE, 0),
-                             CreateEventA(0, FALSE, FALSE, 0));
-    }
+    event = CreateEvent(0, FALSE, FALSE, 0);
     if (!event)
         qWarning("QMutexPrivate::QMutexPrivate: Cannot create event");
 }
diff --git a/src/corelib/thread/qthread_win.cpp b/src/corelib/thread/qthread_win.cpp
index b5bdba3..6c24784 100644
--- a/src/corelib/thread/qthread_win.cpp
+++ b/src/corelib/thread/qthread_win.cpp
@@ -163,8 +163,7 @@ void qt_watch_adopted_thread(const HANDLE adoptedThreadHandle, QThread *qthread)
     // Start watcher thread if it is not already running.
     if (qt_adopted_thread_watcher_handle == 0) {
         if (qt_adopted_thread_wakeup == 0) {
-            qt_adopted_thread_wakeup = QT_WA_INLINE(CreateEventW(0, false, false, 0),
-                                                    CreateEventA(0, false, false, 0));
+            qt_adopted_thread_wakeup = CreateEvent(0, false, false, 0);
             qt_adopted_thread_handles.prepend(qt_adopted_thread_wakeup);
         }
 
@@ -364,11 +363,10 @@ int QThread::idealThreadCount()
 void QThread::yieldCurrentThread()
 {
 #ifndef Q_OS_WINCE
-    if (QSysInfo::WindowsVersion & QSysInfo::WV_NT_based)
-        SwitchToThread();
-    else
+    SwitchToThread();
+#else
+    ::Sleep(0);
 #endif
-        ::Sleep(0);
 }
 
 void QThread::sleep(unsigned long secs)
@@ -419,17 +417,11 @@ void QThread::start(Priority priority)
         return;
     }
 
-    // Since Win 9x will have problems if the priority is idle or time critical
-    // we have to use the closest one instead
     int prio;
     d->priority = priority;
     switch (d->priority) {
     case IdlePriority:
-        if (QSysInfo::WindowsVersion & QSysInfo::WV_DOS_based) {
-            prio = THREAD_PRIORITY_LOWEST;
-        } else {
-            prio = THREAD_PRIORITY_IDLE;
-        }
+        prio = THREAD_PRIORITY_IDLE;
         break;
 
     case LowestPriority:
@@ -453,11 +445,7 @@ void QThread::start(Priority priority)
         break;
 
     case TimeCriticalPriority:
-        if (QSysInfo::WindowsVersion & QSysInfo::WV_DOS_based) {
-            prio = THREAD_PRIORITY_HIGHEST;
-        } else {
-            prio = THREAD_PRIORITY_TIME_CRITICAL;
-        }
+        prio = THREAD_PRIORITY_TIME_CRITICAL;
         break;
 
     case InheritPriority:
@@ -563,17 +551,11 @@ void QThread::setPriority(Priority priority)
 
     // copied from start() with a few modifications:
 
-    // Since Win 9x will have problems if the priority is idle or time critical
-    // we have to use the closest one instead
     int prio;
     d->priority = priority;
     switch (d->priority) {
     case IdlePriority:
-        if (QSysInfo::WindowsVersion & QSysInfo::WV_DOS_based) {
-            prio = THREAD_PRIORITY_LOWEST;
-        } else {
-            prio = THREAD_PRIORITY_IDLE;
-        }
+        prio = THREAD_PRIORITY_IDLE;
         break;
 
     case LowestPriority:
@@ -597,11 +579,7 @@ void QThread::setPriority(Priority priority)
         break;
 
     case TimeCriticalPriority:
-        if (QSysInfo::WindowsVersion & QSysInfo::WV_DOS_based) {
-            prio = THREAD_PRIORITY_HIGHEST;
-        } else {
-            prio = THREAD_PRIORITY_TIME_CRITICAL;
-        }
+        prio = THREAD_PRIORITY_TIME_CRITICAL;
         break;
 
     case InheritPriority:
diff --git a/src/corelib/thread/qwaitcondition_win.cpp b/src/corelib/thread/qwaitcondition_win.cpp
index 9129fb6..b0146d2 100644
--- a/src/corelib/thread/qwaitcondition_win.cpp
+++ b/src/corelib/thread/qwaitcondition_win.cpp
@@ -64,11 +64,7 @@ class QWaitConditionEvent
 public:
     inline QWaitConditionEvent() : priority(0), wokenUp(false)
     {
-        QT_WA ({
-            event = CreateEvent(NULL, TRUE, FALSE, NULL);
-        }, {
-            event = CreateEventA(NULL, TRUE, FALSE, NULL);
-        });
+        event = CreateEvent(NULL, TRUE, FALSE, NULL);
     }
     inline ~QWaitConditionEvent() { CloseHandle(event); }
     int priority;
diff --git a/src/corelib/tools/qdatetime.cpp b/src/corelib/tools/qdatetime.cpp
index 6674717..42f4304 100644
--- a/src/corelib/tools/qdatetime.cpp
+++ b/src/corelib/tools/qdatetime.cpp
@@ -2503,16 +2503,9 @@ QString QDateTime::toString(Qt::DateFormat f) const
         buf += QLatin1Char(' ');
         buf += QString::number(d->date.day());
 #else
-        QString winstr;
-        QT_WA({
-            TCHAR out[255];
-            GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_ILDATE, out, 255);
-            winstr = QString::fromUtf16((ushort*)out);
-        } , {
-            char out[255];
-            GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_ILDATE, (char*)&out, 255);
-            winstr = QString::fromLocal8Bit(out);
-        });
+        wchar_t out[255];
+        GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_ILDATE, out, 255);
+        QString winstr = QString::fromWCharArray(out);
         switch (winstr.toInt()) {
         case 1:
             buf = d->date.shortDayName(d->date.dayOfWeek());
diff --git a/src/corelib/tools/qlocale.cpp b/src/corelib/tools/qlocale.cpp
index 8c1a0ff..fef1931 100644
--- a/src/corelib/tools/qlocale.cpp
+++ b/src/corelib/tools/qlocale.cpp
@@ -386,15 +386,8 @@ static QString winIso3116CtryName(LCID id = LOCALE_USER_DEFAULT);
 
 static QString getWinLocaleInfo(LCTYPE type)
 {
-    int cnt = 0;
-
     LCID id = GetUserDefaultLCID();
-
-    QT_WA({
-        cnt = GetLocaleInfoW(id, type, 0, 0)*2;
-    } , {
-        cnt = GetLocaleInfoA(id, type, 0, 0);
-    });
+    int cnt = GetLocaleInfo(id, type, 0, 0) * 2;
 
     if (cnt == 0) {
         qWarning("QLocale: empty windows locale info (%d)", (int)type);
@@ -403,27 +396,14 @@ static QString getWinLocaleInfo(LCTYPE type)
 
     QByteArray buff(cnt, 0);
 
-    QT_WA({
-        cnt = GetLocaleInfoW(id, type,
-                                reinterpret_cast<wchar_t*>(buff.data()),
-                                buff.size()/2);
-    } , {
-        cnt = GetLocaleInfoA(id, type,
-                                buff.data(), buff.size());
-    });
+    cnt = GetLocaleInfo(id, type, reinterpret_cast<wchar_t*>(buff.data()), buff.size() / 2);
 
     if (cnt == 0) {
         qWarning("QLocale: empty windows locale info (%d)", (int)type);
         return QString();
     }
 
-    QString result;
-    QT_WA({
-        result = QString::fromUtf16(reinterpret_cast<ushort*>(buff.data()));
-    } , {
-        result = QString::fromLocal8Bit(buff.data());
-    });
-    return result;
+    return QString::fromWCharArray(reinterpret_cast<const wchar_t *>(buff.data()));
 }
 
 QByteArray getWinLocaleName(LCID id = LOCALE_USER_DEFAULT)
@@ -445,20 +425,19 @@ QByteArray getWinLocaleName(LCID id = LOCALE_USER_DEFAULT)
         }
     }
 
-    if (QSysInfo::WindowsVersion == QSysInfo::WV_95
-        || (QSysInfo::WindowsVersion & QSysInfo::WV_CE_based)) {
-        result = winLangCodeToIsoName(id != LOCALE_USER_DEFAULT ? id : GetUserDefaultLCID());
-    } else {
-        if (id == LOCALE_USER_DEFAULT)
-            id = GetUserDefaultLCID();
-        QString resultuage = winIso639LangName(id);
-        QString country = winIso3116CtryName(id);
-        result = resultuage.toLatin1();
-        if (!country.isEmpty()) {
-            result += '_';
-            result += country.toLatin1();
-        }
+#if defined(Q_OS_WINCE)
+    result = winLangCodeToIsoName(id != LOCALE_USER_DEFAULT ? id : GetUserDefaultLCID());
+#else
+    if (id == LOCALE_USER_DEFAULT)
+        id = GetUserDefaultLCID();
+    QString resultuage = winIso639LangName(id);
+    QString country = winIso3116CtryName(id);
+    result = resultuage.toLatin1();
+    if (!country.isEmpty()) {
+        result += '_';
+        result += country.toLatin1();
     }
+#endif
 
     return result;
 }
@@ -544,15 +523,9 @@ static QString winDateToString(const QDate &date, DWORD flags)
 
     LCID id = GetUserDefaultLCID();
 
-    QT_WA({
-        TCHAR buf[255];
-        if (GetDateFormatW(id, flags, &st, 0, buf, 255))
-            return QString::fromUtf16((ushort*)buf);
-    } , {
-        char buf[255];
-        if (GetDateFormatA(id, flags, &st, 0, (char*)&buf, 255))
-            return QString::fromLocal8Bit(buf);
-    });
+    wchar_t buf[255];
+    if (GetDateFormat(id, flags, &st, 0, buf, 255))
+        return QString::fromWCharArray(buf);
 
     return QString();
 }
@@ -569,15 +542,9 @@ static QString winTimeToString(const QTime &time)
     DWORD flags = 0;
     LCID id = GetUserDefaultLCID();
 
-    QT_WA({
-        TCHAR buf[255];
-        if (GetTimeFormatW(id, flags, &st, 0, buf, 255))
-            return QString::fromUtf16((ushort*)buf);
-    } , {
-        char buf[255];
-        if (GetTimeFormatA(id, flags, &st, 0, (char*)&buf, 255))
-            return QString::fromLocal8Bit(buf);
-    });
+    wchar_t buf[255];
+    if (GetTimeFormat(id, flags, &st, 0, buf, 255))
+        return QString::fromWCharArray(buf);
 
     return QString();
 }
@@ -626,12 +593,10 @@ static QString winMonthName(int month, bool short_format)
 static QLocale::MeasurementSystem winSystemMeasurementSystem()
 {
     LCID id = GetUserDefaultLCID();
-    TCHAR output[2];
+    wchar_t output[2];
 
     if (GetLocaleInfo(id, LOCALE_IMEASURE, output, 2)) {
-        QString iMeasure = QT_WA_INLINE(
-                QString::fromUtf16(reinterpret_cast<ushort*>(output)),
-                QString::fromLocal8Bit(reinterpret_cast<char*>(output)));
+        QString iMeasure = QString::fromWCharArray(output);
         if (iMeasure == QLatin1String("1")) {
             return QLocale::ImperialSystem;
         }
@@ -643,12 +608,10 @@ static QLocale::MeasurementSystem winSystemMeasurementSystem()
 static QString winSystemAMText()
 {
     LCID id = GetUserDefaultLCID();
-    TCHAR output[15]; // maximum length including  terminating zero character for Win2003+
+    wchar_t output[15]; // maximum length including  terminating zero character for Win2003+
 
     if (GetLocaleInfo(id, LOCALE_S1159, output, 15)) {
-        return QT_WA_INLINE(
-                QString::fromUtf16(reinterpret_cast<ushort*>(output)),
-                QString::fromLocal8Bit(reinterpret_cast<char*>(output)));
+        return QString::fromWCharArray(output);
     }
 
     return QString();
@@ -657,12 +620,10 @@ static QString winSystemAMText()
 static QString winSystemPMText()
 {
     LCID id = GetUserDefaultLCID();
-    TCHAR output[15]; // maximum length including  terminating zero character for Win2003+
+    wchar_t output[15]; // maximum length including  terminating zero character for Win2003+
 
     if (GetLocaleInfo(id, LOCALE_S2359, output, 15)) {
-        return QT_WA_INLINE(
-                QString::fromUtf16(reinterpret_cast<ushort*>(output)),
-                QString::fromLocal8Bit(reinterpret_cast<char*>(output)));
+        return QString::fromWCharArray(output);
     }
 
     return QString();
@@ -766,9 +727,6 @@ QVariant QSystemLocale::query(QueryType type, QVariant in = QVariant()) const
     return QVariant();
 }
 
-/* Win95 doesn't have a function to return the ISO lang/country name of the user's locale.
-   Instead it can return a "Windows code". This maps windows codes to ISO country names. */
-
 struct WindowsToISOListElt {
     ushort windows_code;
     char iso_name[6];
@@ -924,15 +882,9 @@ static QString winIso639LangName(LCID id)
     // Windows returns the wrong ISO639 for some languages, we need to detect them here using
     // the language code
     QString lang_code;
-    QT_WA({
-        TCHAR out[256];
-        if (GetLocaleInfoW(id, LOCALE_ILANGUAGE, out, 255))
-            lang_code = QString::fromUtf16((ushort*)out);
-    } , {
-        char out[256];
-        if (GetLocaleInfoA(id, LOCALE_ILANGUAGE, out, 255))
-            lang_code = QString::fromLocal8Bit(out);
-    });
+    wchar_t out[256];
+    if (GetLocaleInfo(id, LOCALE_ILANGUAGE, out, 255))
+        lang_code = QString::fromWCharArray(out);
 
     if (!lang_code.isEmpty()) {
         const char *endptr;
@@ -954,15 +906,8 @@ static QString winIso639LangName(LCID id)
         return result;
 
     // not one of the problematic languages - do the usual lookup
-    QT_WA({
-        TCHAR out[256];
-        if (GetLocaleInfoW(id, LOCALE_SISO639LANGNAME , out, 255))
-            result = QString::fromUtf16((ushort*)out);
-    } , {
-        char out[256];
-        if (GetLocaleInfoA(id, LOCALE_SISO639LANGNAME, out, 255))
-            result = QString::fromLocal8Bit(out);
-    });
+    if (GetLocaleInfo(id, LOCALE_SISO639LANGNAME , out, 255))
+        result = QString::fromWCharArray(out);
 
     return result;
 }
@@ -971,15 +916,9 @@ static QString winIso3116CtryName(LCID id)
 {
     QString result;
 
-    QT_WA({
-        TCHAR out[256];
-        if (GetLocaleInfoW(id, LOCALE_SISO3166CTRYNAME, out, 255))
-            result = QString::fromUtf16((ushort*)out);
-    } , {
-        char out[256];
-        if (GetLocaleInfoA(id, LOCALE_SISO3166CTRYNAME, out, 255))
-            result = QString::fromLocal8Bit(out);
-    });
+    wchar_t out[256];
+    if (GetLocaleInfo(id, LOCALE_SISO3166CTRYNAME, out, 255))
+        result = QString::fromWCharArray(out);
 
     return result;
 }
@@ -2689,7 +2628,7 @@ static QString timeZone()
     DWORD res = GetTimeZoneInformation(&info);
     if (res == TIME_ZONE_ID_UNKNOWN)
         return QString();
-    return QString::fromUtf16(reinterpret_cast<const ushort *> (info.StandardName));
+    return QString::fromWCharArray(info.StandardName);
 #elif defined(Q_OS_WIN)
     _tzset();
 # if defined(_MSC_VER) && _MSC_VER >= 1400
diff --git a/src/corelib/tools/qstring.cpp b/src/corelib/tools/qstring.cpp
index 71482f5..b160b90 100644
--- a/src/corelib/tools/qstring.cpp
+++ b/src/corelib/tools/qstring.cpp
@@ -3714,13 +3714,13 @@ QByteArray qt_winQString2MB(const QChar *ch, int uclen)
     BOOL used_def;
     QByteArray mb(4096, 0);
     int len;
-    while (!(len=WideCharToMultiByte(CP_ACP, 0, (const WCHAR*)ch, uclen,
+    while (!(len=WideCharToMultiByte(CP_ACP, 0, (const wchar_t*)ch, uclen,
                 mb.data(), mb.size()-1, 0, &used_def)))
     {
         int r = GetLastError();
         if (r == ERROR_INSUFFICIENT_BUFFER) {
             mb.resize(1+WideCharToMultiByte(CP_ACP, 0,
-                                (const WCHAR*)ch, uclen,
+                                (const wchar_t*)ch, uclen,
                                 0, 0, 0, &used_def));
                 // and try again...
         } else {
@@ -3741,9 +3741,9 @@ QString qt_winMB2QString(const char *mb, int mblen)
     if (!mb || !mblen)
         return QString();
     const int wclen_auto = 4096;
-    WCHAR wc_auto[wclen_auto];
+    wchar_t wc_auto[wclen_auto];
     int wclen = wclen_auto;
-    WCHAR *wc = wc_auto;
+    wchar_t *wc = wc_auto;
     int len;
     while (!(len=MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED,
                 mb, mblen, wc, wclen)))
@@ -3756,7 +3756,7 @@ QString qt_winMB2QString(const char *mb, int mblen)
             } else {
                 wclen = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED,
                                     mb, mblen, 0, 0);
-                wc = new WCHAR[wclen];
+                wc = new wchar_t[wclen];
                 // and try again...
             }
         } else {
@@ -3799,11 +3799,6 @@ QString QString::fromLocal8Bit(const char *str, int size)
         return QString();
     if (size == 0 || (!*str && size < 0))
         return QLatin1String("");
-#if defined(Q_OS_WIN32)
-    if(QSysInfo::WindowsVersion & QSysInfo::WV_DOS_based) {
-        return qt_winMB2QString(str, size);
-    }
-#endif
 #if !defined(QT_NO_TEXTCODEC)
     if (size < 0)
         size = qstrlen(str);
@@ -4697,16 +4692,7 @@ int QString::localeAwareCompare_helper(const QChar *data1, int length1,
         return ucstrcmp(data1, length1, data2, length2);
 
 #if defined(Q_OS_WIN32) || defined(Q_OS_WINCE)
-    int res;
-    QT_WA({
-        const TCHAR* s1 = (TCHAR*)data1;
-        const TCHAR* s2 = (TCHAR*)data2;
-        res = CompareStringW(GetUserDefaultLCID(), 0, s1, length1, s2, length2);
-    } , {
-        QByteArray s1 = toLocal8Bit_helper(data1, length1);
-        QByteArray s2 = toLocal8Bit_helper(data2, length2);
-        res = CompareStringA(GetUserDefaultLCID(), 0, s1.data(), s1.length(), s2.data(), s2.length());
-    });
+    int res = CompareString(GetUserDefaultLCID(), 0, (wchar_t*)data1, length1, (wchar_t*)data2, length2);
 
     switch (res) {
     case CSTR_LESS_THAN: