Fix the support for WinCE.

Change-Id: Id08dab3128b9ff943c68b442e8cadf14caaee204
Reviewed-by: hjk <qthjk@ovi.com>

12 files changed, 1069 insertions, 210 deletions

diff --git a/src/plugins/projectexplorer/abstractmsvctoolchain.cpp b/src/plugins/projectexplorer/abstractmsvctoolchain.cpp
new file mode 100644
index 0000000000..94b17e65cf
--- /dev/null
+++ b/src/plugins/projectexplorer/abstractmsvctoolchain.cpp
@@ -0,0 +1,269 @@
+/**************************************************************************
+**
+** This file is part of Qt Creator
+**
+** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
+**
+** Contact: Nokia Corporation (info@qt.nokia.com)
+**
+**
+** GNU Lesser General Public License Usage
+**
+** This file may be used under the terms of the GNU Lesser General Public
+** License version 2.1 as published by the Free Software Foundation and
+** appearing in the file LICENSE.LGPL included in the packaging of this file.
+** Please review the following information to ensure the GNU Lesser General
+** Public License version 2.1 requirements will be met:
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** Other Usage
+**
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at info@qt.nokia.com.
+**
+**************************************************************************/
+
+#include "abstractmsvctoolchain.h"
+
+#include "msvcparser.h"
+
+#include <projectexplorer/projectexplorer.h>
+#include <projectexplorer/projectexplorersettings.h>
+
+
+#include <utils/fileutils.h>
+#include <utils/qtcprocess.h>
+#include <utils/synchronousprocess.h>
+
+#include <QFileInfo>
+#include <QDir>
+#include <QTemporaryFile>
+
+enum { debug = 0 };
+
+namespace ProjectExplorer {
+namespace Internal {
+
+
+AbstractMsvcToolChain::AbstractMsvcToolChain(const QString &id,
+                                             bool autodetect,
+                                             const Abi &abi,
+                                             const QString& vcvarsBat) :
+    ToolChain(id, autodetect),
+    m_lastEnvironment(Utils::Environment::systemEnvironment()),
+    m_abi(abi),
+    m_vcvarsBat(vcvarsBat)
+{
+    Q_ASSERT(abi.os() == Abi::WindowsOS);
+    Q_ASSERT(abi.binaryFormat() == Abi::PEFormat);
+    Q_ASSERT(abi.osFlavor() != Abi::WindowsMSysFlavor);
+    Q_ASSERT(!m_vcvarsBat.isEmpty());
+}
+
+AbstractMsvcToolChain::AbstractMsvcToolChain(const QString &id, bool autodetect) :
+    ToolChain(id, autodetect),
+    m_lastEnvironment(Utils::Environment::systemEnvironment())
+{
+
+}
+
+Abi AbstractMsvcToolChain::targetAbi() const
+{
+    return m_abi;
+}
+
+bool AbstractMsvcToolChain::isValid() const
+{
+    return !m_vcvarsBat.isEmpty();
+}
+
+QByteArray AbstractMsvcToolChain::predefinedMacros() const
+{
+    if (m_predefinedMacros.isEmpty()) {
+        Utils::Environment env(m_lastEnvironment);
+        addToEnvironment(env);
+        m_predefinedMacros = msvcPredefinedMacros(env);
+    }
+    return m_predefinedMacros;
+}
+
+QList<HeaderPath> AbstractMsvcToolChain::systemHeaderPaths() const
+{
+    if (m_headerPaths.isEmpty()) {
+        Utils::Environment env(m_lastEnvironment);
+        addToEnvironment(env);
+        foreach (const QString &path, env.value("INCLUDE").split(QLatin1Char(';')))
+            m_headerPaths.append(HeaderPath(path, HeaderPath::GlobalHeaderPath));
+    }
+    return m_headerPaths;
+}
+
+void AbstractMsvcToolChain::addToEnvironment(Utils::Environment &env) const
+{
+    // We cache the full environment (incoming + modifications by setup script).
+    if (!m_resultEnvironment.size() || env != m_lastEnvironment) {
+        if (debug)
+            qDebug() << "addToEnvironment: " << displayName();
+        m_lastEnvironment = env;
+        m_resultEnvironment = readEnvironmentSetting(env);
+    }
+    env = m_resultEnvironment;
+}
+
+
+QString AbstractMsvcToolChain::makeCommand() const
+{
+    if (ProjectExplorerPlugin::instance()->projectExplorerSettings().useJom) {
+        // We want jom! Try to find it.
+        const QString jom = QLatin1String("jom.exe");
+        const QFileInfo installedJom = QFileInfo(QCoreApplication::applicationDirPath()
+                                                 + QLatin1Char('/') + jom);
+        if (installedJom.isFile() && installedJom.isExecutable()) {
+            return installedJom.absoluteFilePath();
+        } else {
+            return jom;
+        }
+    }
+    return QLatin1String("nmake.exe");
+}
+
+void AbstractMsvcToolChain::setDebuggerCommand(const QString &d)
+{
+    if (m_debuggerCommand == d)
+        return;
+    m_debuggerCommand = d;
+    updateId();
+    toolChainUpdated();
+}
+
+QString AbstractMsvcToolChain::debuggerCommand() const
+{
+    return m_debuggerCommand;
+}
+
+
+IOutputParser *AbstractMsvcToolChain::outputParser() const
+{
+    return new MsvcParser;
+}
+
+bool AbstractMsvcToolChain::canClone() const
+{
+    return true;
+}
+
+QByteArray AbstractMsvcToolChain::msvcPredefinedMacros(const Utils::Environment& env) const
+{
+    QByteArray predefinedMacros = "#define __MSVCRT__\n"
+            "#define __w64\n"
+            "#define __int64 long long\n"
+            "#define __int32 long\n"
+            "#define __int16 short\n"
+            "#define __int8 char\n"
+            "#define __ptr32\n"
+            "#define __ptr64\n";
+
+    return predefinedMacros;
+}
+
+
+bool AbstractMsvcToolChain::generateEnvironmentSettings(Utils::Environment &env,
+                                                        const QString& batchFile,
+                                                        const QString& batchArgs,
+                                                        QMap<QString, QString>& envPairs) const
+{
+    // Create a temporary file name for the output. Use a temporary file here
+    // as I don't know another way to do this in Qt...
+    // Note, can't just use a QTemporaryFile all the way through as it remains open
+    // internally so it can't be streamed to later.
+    QString tempOutFile;
+    QTemporaryFile* pVarsTempFile = new QTemporaryFile(QDir::tempPath() + "/XXXXXX.txt");
+    pVarsTempFile->setAutoRemove(false);
+    pVarsTempFile->open();
+    pVarsTempFile->close();
+    tempOutFile = pVarsTempFile->fileName();
+    delete pVarsTempFile;
+
+    // Create a batch file to create and save the env settings
+    Utils::TempFileSaver saver(QDir::tempPath() + "/XXXXXX.bat");
+
+    QByteArray call = "call ";
+    call += Utils::QtcProcess::quoteArg(batchFile).toLocal8Bit() + "\r\n";
+    if (!batchArgs.isEmpty()) {
+        call += ' ';
+        call += batchArgs.toLocal8Bit();
+    }
+    call += "\r\n";
+
+    saver.write(call);
+    const QByteArray redirect = "set > " + Utils::QtcProcess::quoteArg(
+                                    QDir::toNativeSeparators(tempOutFile)).toLocal8Bit() + "\r\n";
+    saver.write(redirect);
+    if (!saver.finalize()) {
+        qWarning("%s: %s", Q_FUNC_INFO, qPrintable(saver.errorString()));
+        return false;
+    }
+
+    Utils::QtcProcess run;
+    // As of WinSDK 7.1, there is logic preventing the path from being set
+    // correctly if "ORIGINALPATH" is already set. That can cause problems
+    // if Creator is launched within a session set up by setenv.cmd.
+    env.unset(QLatin1String("ORIGINALPATH"));
+    run.setEnvironment(env);
+    const QString cmdPath = QString::fromLocal8Bit(qgetenv("COMSPEC"));
+    // Windows SDK setup scripts require command line switches for environment expansion.
+    QString cmdArguments = QLatin1String(" /E:ON /V:ON /c \"");
+    cmdArguments += QDir::toNativeSeparators(saver.fileName());
+    cmdArguments += QLatin1Char('"');
+    run.setCommand(cmdPath, cmdArguments);
+    if (debug)
+        qDebug() << "readEnvironmentSetting: " << call << cmdPath << cmdArguments
+                 << " Env: " << env.size();
+    run.start();
+
+    if (!run.waitForStarted()) {
+        qWarning("%s: Unable to run '%s': %s", Q_FUNC_INFO, qPrintable(m_vcvarsBat),
+                 qPrintable(run.errorString()));
+        return false;
+    }
+    if (!run.waitForFinished()) {
+        qWarning("%s: Timeout running '%s'", Q_FUNC_INFO, qPrintable(m_vcvarsBat));
+        Utils::SynchronousProcess::stopProcess(run);
+        return false;
+    }
+
+    //
+    // Now parse the file to get the environment settings
+    QFile varsFile(tempOutFile);
+    if (!varsFile.open(QIODevice::ReadOnly))
+        return false;
+
+    QRegExp regexp(QLatin1String("(\\w*)=(.*)"));
+    while (!varsFile.atEnd()) {
+        const QString line = QString::fromLocal8Bit(varsFile.readLine()).trimmed();
+        if (regexp.exactMatch(line)) {
+            const QString varName = regexp.cap(1);
+            const QString varValue = regexp.cap(2);
+
+            if (!varValue.isEmpty())
+                envPairs.insert(varName, varValue);
+        }
+    }
+
+    // Tidy up and remove the file
+    varsFile.close();
+    varsFile.remove();
+
+    return true;
+}
+
+} // namespace Internal
+} // namespace ProjectExplorer
+
diff --git a/src/plugins/projectexplorer/abstractmsvctoolchain.h b/src/plugins/projectexplorer/abstractmsvctoolchain.h
new file mode 100644
index 0000000000..1c346a13a6
--- /dev/null
+++ b/src/plugins/projectexplorer/abstractmsvctoolchain.h
@@ -0,0 +1,90 @@
+/**************************************************************************
+**
+** This file is part of Qt Creator
+**
+** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
+**
+** Contact: Nokia Corporation (info@qt.nokia.com)
+**
+**
+** GNU Lesser General Public License Usage
+**
+** This file may be used under the terms of the GNU Lesser General Public
+** License version 2.1 as published by the Free Software Foundation and
+** appearing in the file LICENSE.LGPL included in the packaging of this file.
+** Please review the following information to ensure the GNU Lesser General
+** Public License version 2.1 requirements will be met:
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** Other Usage
+**
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at info@qt.nokia.com.
+**
+**************************************************************************/
+
+#ifndef ABSTRACTMSVCTOOLCHAIN_H
+#define ABSTRACTMSVCTOOLCHAIN_H
+
+#include "toolchain.h"
+#include "abi.h"
+
+#include <utils/environment.h>
+
+namespace ProjectExplorer {
+namespace Internal {
+
+class AbstractMsvcToolChain : public ToolChain
+{
+public:
+    AbstractMsvcToolChain(const QString &id, bool autodetect, const Abi &abi, const QString& vcvarsBat);
+    AbstractMsvcToolChain(const QString &id, bool autodetect);
+
+    Abi targetAbi() const;
+
+    bool isValid() const;
+    QByteArray predefinedMacros() const;
+
+    QList<HeaderPath> systemHeaderPaths() const;
+
+    void addToEnvironment(Utils::Environment &env) const;
+    QString makeCommand() const;
+    void setDebuggerCommand(const QString &d);
+
+    QString debuggerCommand() const;
+    IOutputParser *outputParser() const;
+
+    bool canClone() const;
+
+    QString varsBat() const { return m_vcvarsBat; }
+protected:
+    virtual Utils::Environment readEnvironmentSetting(Utils::Environment& env) const = 0;
+    virtual QByteArray msvcPredefinedMacros(const Utils::Environment& env) const;
+    virtual void updateId() = 0;
+
+    bool generateEnvironmentSettings(Utils::Environment &env,
+                                     const QString& batchFile,
+                                     const QString& batchArgs,
+                                     QMap<QString, QString>& envPairs) const;
+
+    QString m_debuggerCommand;
+    mutable QByteArray m_predefinedMacros;
+    mutable Utils::Environment m_lastEnvironment;   // Last checked 'incoming' environment.
+    mutable Utils::Environment m_resultEnvironment; // Resulting environment for VC
+    mutable QList<HeaderPath> m_headerPaths;
+    Abi m_abi;
+
+   QString m_vcvarsBat;
+};
+
+} // namespace Internal
+} // namespace ProjectExplorer
+
+#endif // ABSTRACTMSVCTOOLCHAIN_H
diff --git a/src/plugins/projectexplorer/msvctoolchain.cpp b/src/plugins/projectexplorer/msvctoolchain.cpp
index 9baa888e22..d7577b6a06 100644
--- a/src/plugins/projectexplorer/msvctoolchain.cpp
+++ b/src/plugins/projectexplorer/msvctoolchain.cpp
@@ -40,18 +40,14 @@
 #include <projectexplorer/projectexplorersettings.h>
 
 #include <utils/fileutils.h>
-#include <utils/qtcprocess.h>
-#include <utils/qtcassert.h>
 #include <utils/synchronousprocess.h>
 #include <utils/winutils.h>
+#include <utils/qtcassert.h>
 
-#include <QtCore/QCoreApplication>
 #include <QtCore/QDir>
-#include <QtCore/QFileInfo>
+#include <QtCore/QProcess>
 #include <QtCore/QSettings>
 #include <QtCore/QUrl>
-#include <QtCore/QTemporaryFile>
-#include <QtGui/QLabel>
 #include <QtGui/QFormLayout>
 #include <QtGui/QDesktopServices>
 
@@ -170,16 +166,9 @@ static QByteArray msvcCompilationFile()
 }
 
 // Run MSVC 'cl' compiler to obtain #defines.
-static QByteArray msvcPredefinedMacros(const Utils::Environment &env)
+QByteArray MsvcToolChain::msvcPredefinedMacros(const Utils::Environment &env) const
 {
-    QByteArray predefinedMacros = "#define __MSVCRT__\n"
-                      "#define __w64\n"
-                      "#define __int64 long long\n"
-                      "#define __int32 long\n"
-                      "#define __int16 short\n"
-                      "#define __int8 char\n"
-                      "#define __ptr32\n"
-                      "#define __ptr64\n";
+    QByteArray predefinedMacros = AbstractMsvcToolChain::msvcPredefinedMacros(env);
 
     Utils::TempFileSaver saver(QDir::tempPath()+"/envtestXXXXXX.cpp");
     saver.write(msvcCompilationFile());
@@ -258,77 +247,24 @@ static QString winExpandDelayedEnvReferences(QString in, const Utils::Environmen
     return in;
 }
 
-static Utils::Environment msvcReadEnvironmentSetting(const QString &varsBat,
-                                                     const QString &args,
-                                                     Utils::Environment env)
+Utils::Environment MsvcToolChain::readEnvironmentSetting(Utils::Environment& env) const
 {
-    // Run the setup script and extract the variables
     Utils::Environment result = env;
-    if (!QFileInfo(varsBat).exists())
+    if (!QFileInfo(m_vcvarsBat).exists())
         return result;
 
-    const QString tempOutputFileName = QDir::tempPath() + QLatin1String("\\qtcreator-msvc-environment.txt");
-    Utils::TempFileSaver saver(QDir::tempPath() + "\\XXXXXX.bat");
-    QByteArray call = "call ";
-    call += Utils::QtcProcess::quoteArg(varsBat).toLocal8Bit();
-    if (!args.isEmpty()) {
-        call += ' ';
-        call += args.toLocal8Bit();
-    }
-    call += "\r\n";
-    saver.write(call);
-    const QByteArray redirect = "set > " + Utils::QtcProcess::quoteArg(
-                QDir::toNativeSeparators(tempOutputFileName)).toLocal8Bit() + "\r\n";
-    saver.write(redirect);
-    if (!saver.finalize()) {
-        qWarning("%s: %s", Q_FUNC_INFO, qPrintable(saver.errorString()));
+    QMap<QString, QString> envPairs;
+    if (!generateEnvironmentSettings(env, m_vcvarsBat, m_varsBatArg, envPairs))
         return result;
-    }
-
-    Utils::QtcProcess run;
-    // As of WinSDK 7.1, there is logic preventing the path from being set
-    // correctly if "ORIGINALPATH" is already set. That can cause problems
-    // if Creator is launched within a session set up by setenv.cmd.
-    env.unset(QLatin1String("ORIGINALPATH"));
-    run.setEnvironment(env);
-    const QString cmdPath = QString::fromLocal8Bit(qgetenv("COMSPEC"));
-    // Windows SDK setup scripts require command line switches for environment expansion.
-    QString cmdArguments = QLatin1String(" /E:ON /V:ON /c \"");
-    cmdArguments += QDir::toNativeSeparators(saver.fileName());
-    cmdArguments += QLatin1Char('"');
-    run.setCommand(cmdPath, cmdArguments);
-    if (debug)
-        qDebug() << "msvcReadEnvironmentSetting: " << call << cmdPath << cmdArguments
-                 << " Env: " << env.size();
-    run.start();
 
-    if (!run.waitForStarted()) {
-        qWarning("%s: Unable to run '%s': %s", Q_FUNC_INFO, qPrintable(varsBat),
-            qPrintable(run.errorString()));
-        return result;
-    }
-    if (!run.waitForFinished()) {
-        qWarning("%s: Timeout running '%s'", Q_FUNC_INFO, qPrintable(varsBat));
-        Utils::SynchronousProcess::stopProcess(run);
-        return result;
+    // Now loop through and process them
+    QMap<QString,QString>::const_iterator envIter;
+    for (envIter = envPairs.begin(); envIter!=envPairs.end(); ++envIter) {
+        const QString expandedValue = winExpandDelayedEnvReferences(envIter.value(), env);
+        if (!expandedValue.isEmpty())
+            result.set(envIter.key(), expandedValue);
     }
 
-    QFile varsFile(tempOutputFileName);
-    if (!varsFile.open(QIODevice::ReadOnly|QIODevice::Text))
-        return result;
-
-    QRegExp regexp(QLatin1String("(\\w*)=(.*)"));
-    while (!varsFile.atEnd()) {
-        const QString line = QString::fromLocal8Bit(varsFile.readLine()).trimmed();
-        if (regexp.exactMatch(line)) {
-            const QString varName = regexp.cap(1);
-            const QString expandedValue = winExpandDelayedEnvReferences(regexp.cap(2), env);
-            if (!expandedValue.isEmpty())
-                result.set(varName, expandedValue);
-        }
-    }
-    varsFile.close();
-    varsFile.remove();
     if (debug) {
         const QStringList newVars = result.toStringList();
         const QStringList oldVars = env.toStringList();
@@ -347,26 +283,17 @@ static Utils::Environment msvcReadEnvironmentSetting(const QString &varsBat,
 
 MsvcToolChain::MsvcToolChain(const QString &name, const Abi &abi,
                              const QString &varsBat, const QString &varsBatArg, bool autodetect) :
-    ToolChain(QLatin1String(Constants::MSVC_TOOLCHAIN_ID), autodetect),
-    m_varsBat(varsBat),
-    m_varsBatArg(varsBatArg),
-    m_lastEnvironment(Utils::Environment::systemEnvironment()),
-    m_abi(abi)
+    AbstractMsvcToolChain(QLatin1String(Constants::MSVC_TOOLCHAIN_ID), autodetect, abi, varsBat),
+    m_varsBatArg(varsBatArg)
 {
     Q_ASSERT(!name.isEmpty());
-    Q_ASSERT(!m_varsBat.isEmpty());
-    Q_ASSERT(QFileInfo(m_varsBat).exists());
-    Q_ASSERT(abi.os() == Abi::WindowsOS);
-    Q_ASSERT(abi.binaryFormat() == Abi::PEFormat);
-    Q_ASSERT(abi.osFlavor() != Abi::WindowsMSysFlavor);
 
     updateId();
     setDisplayName(name);
 }
 
 MsvcToolChain::MsvcToolChain() :
-    ToolChain(QLatin1String(Constants::MSVC_TOOLCHAIN_ID), false),
-    m_lastEnvironment(Utils::Environment::systemEnvironment())
+    AbstractMsvcToolChain(QLatin1String(Constants::MSVC_TOOLCHAIN_ID), false)
 {
 }
 
@@ -384,7 +311,7 @@ void MsvcToolChain::updateId()
     const QChar colon = QLatin1Char(':');
     QString id = QLatin1String(Constants::MSVC_TOOLCHAIN_ID);
     id += colon;
-    id += m_varsBat;
+    id += m_vcvarsBat;
     id += colon;
     id += m_varsBatArg;
     id += colon;
@@ -397,49 +324,6 @@ QString MsvcToolChain::typeName() const
     return MsvcToolChainFactory::tr("MSVC");
 }
 
-Abi MsvcToolChain::targetAbi() const
-{
-    return m_abi;
-}
-
-bool MsvcToolChain::isValid() const
-{
-    return !m_varsBat.isEmpty();
-}
-
-QByteArray MsvcToolChain::predefinedMacros() const
-{
-    if (m_predefinedMacros.isEmpty()) {
-        Utils::Environment env(m_lastEnvironment);
-        addToEnvironment(env);
-        m_predefinedMacros = msvcPredefinedMacros(env);
-    }
-    return m_predefinedMacros;
-}
-
-QList<HeaderPath> MsvcToolChain::systemHeaderPaths() const
-{
-    if (m_headerPaths.isEmpty()) {
-        Utils::Environment env(m_lastEnvironment);
-        addToEnvironment(env);
-        foreach (const QString &path, env.value("INCLUDE").split(QLatin1Char(';')))
-            m_headerPaths.append(HeaderPath(path, HeaderPath::GlobalHeaderPath));
-    }
-    return m_headerPaths;
-}
-
-void MsvcToolChain::addToEnvironment(Utils::Environment &env) const
-{
-    // We cache the full environment (incoming + modifications by setup script).
-    if (!m_resultEnvironment.size() || env != m_lastEnvironment) {
-        if (debug)
-            qDebug() << "addToEnvironment: " << displayName();
-        m_lastEnvironment = env;
-        m_resultEnvironment = msvcReadEnvironmentSetting(m_varsBat, m_varsBatArg, env);
-    }
-    env = m_resultEnvironment;
-}
-
 QString MsvcToolChain::mkspec() const
 {
     if (m_abi.osFlavor() == Abi::WindowsMsvc2005Flavor)
@@ -451,42 +335,12 @@ QString MsvcToolChain::mkspec() const
     return QString();
 }
 
-QString MsvcToolChain::makeCommand() const
-{
-    if (ProjectExplorerPlugin::instance()->projectExplorerSettings().useJom) {
-        // We want jom! Try to find it.
-        const QString jom = QLatin1String("jom.exe");
-        const QFileInfo installedJom = QFileInfo(QCoreApplication::applicationDirPath()
-                                                 + QLatin1Char('/') + jom);
-        if (installedJom.isFile() && installedJom.isExecutable()) {
-            return installedJom.absoluteFilePath();
-        } else {
-            return jom;
-        }
-    }
-    return QLatin1String("nmake.exe");
-}
-
-void MsvcToolChain::setDebuggerCommand(const QString &d)
-{
-    if (m_debuggerCommand == d)
-        return;
-    m_debuggerCommand = d;
-    updateId();
-    toolChainUpdated();
-}
-
-QString MsvcToolChain::debuggerCommand() const
-{
-    return m_debuggerCommand;
-}
-
 QVariantMap MsvcToolChain::toMap() const
 {
     QVariantMap data = ToolChain::toMap();
     if (!m_debuggerCommand.isEmpty())
         data.insert(QLatin1String(debuggerCommandKeyC), m_debuggerCommand);
-    data.insert(QLatin1String(varsBatKeyC), m_varsBat);
+    data.insert(QLatin1String(varsBatKeyC), m_vcvarsBat);
     if (!m_varsBatArg.isEmpty())
         data.insert(QLatin1String(varsBatArgKeyC), m_varsBatArg);
     data.insert(QLatin1String(supportedAbiKeyC), m_abi.toString());
@@ -497,30 +351,22 @@ bool MsvcToolChain::fromMap(const QVariantMap &data)
 {
     if (!ToolChain::fromMap(data))
         return false;
-    m_varsBat = data.value(QLatin1String(varsBatKeyC)).toString();
+    m_vcvarsBat = data.value(QLatin1String(varsBatKeyC)).toString();
     m_varsBatArg = data.value(QLatin1String(varsBatArgKeyC)).toString();
     m_debuggerCommand = data.value(QLatin1String(debuggerCommandKeyC)).toString();
     const QString abiString = data.value(QLatin1String(supportedAbiKeyC)).toString();
     m_abi = Abi(abiString);
     updateId();
-    return !m_varsBat.isEmpty() && m_abi.isValid();
-}
 
-IOutputParser *MsvcToolChain::outputParser() const
-{
-    return new MsvcParser;
+    return !m_vcvarsBat.isEmpty() && m_abi.isValid();
 }
 
+
 ToolChainConfigWidget *MsvcToolChain::configurationWidget()
 {
     return new MsvcToolChainConfigWidget(this);
 }
 
-bool MsvcToolChain::canClone() const
-{
-    return true;
-}
-
 ToolChain *MsvcToolChain::clone() const
 {
     return new MsvcToolChain(*this);
@@ -762,6 +608,7 @@ QList<ToolChain *> MsvcToolChainFactory::autoDetect()
         foreach (ToolChain *tc, results)
             static_cast<MsvcToolChain *>(tc)->setDebuggerCommand(tc->targetAbi().wordWidth() == 32 ? cdbDebugger.first : cdbDebugger.second);
     }
+
     return results;
 }
 
diff --git a/src/plugins/projectexplorer/msvctoolchain.h b/src/plugins/projectexplorer/msvctoolchain.h
index 937154a9d9..fde8e1bb46 100644
--- a/src/plugins/projectexplorer/msvctoolchain.h
+++ b/src/plugins/projectexplorer/msvctoolchain.h
@@ -33,7 +33,7 @@
 #ifndef MSVCTOOLCHAIN_H
 #define MSVCTOOLCHAIN_H
 
-#include "toolchain.h"
+#include "abstractmsvctoolchain.h"
 #include "abi.h"
 #include "toolchainconfigwidget.h"
 
@@ -48,7 +48,7 @@ namespace Internal {
 // MsvcToolChain
 // --------------------------------------------------------------------------
 
-class MsvcToolChain : public ToolChain
+class MsvcToolChain : public AbstractMsvcToolChain
 {
 public:
     enum Type { WindowsSDK, VS };
@@ -60,44 +60,29 @@ public:
     static MsvcToolChain *readFromMap(const QVariantMap &data);
 
     QString typeName() const;
-    Abi targetAbi() const;
 
-    bool isValid() const;
-
-    QByteArray predefinedMacros() const;
-    QList<HeaderPath> systemHeaderPaths() const;
-    void addToEnvironment(Utils::Environment &env) const;
     QString mkspec() const;
-    QString makeCommand() const;
-    void setDebuggerCommand(const QString &d);
-    virtual QString debuggerCommand() const;
-    IOutputParser *outputParser() const;
 
-    virtual QVariantMap toMap() const;
-    virtual bool fromMap(const QVariantMap &data);
+    QVariantMap toMap() const;
+    bool fromMap(const QVariantMap &data);
 
     ToolChainConfigWidget *configurationWidget();
 
-    bool canClone() const;
     ToolChain *clone() const;
 
-    QString varsBat() const { return m_varsBat; }
     QString varsBatArg() const { return m_varsBatArg; }
 
     static QPair<QString, QString> autoDetectCdbDebugger();
 
+protected:
+    Utils::Environment readEnvironmentSetting(Utils::Environment& env) const;
+    QByteArray msvcPredefinedMacros(const Utils::Environment &env) const;
+
 private:
     MsvcToolChain();
     void updateId();
 
-    QString m_varsBat; // Script to setup environment
     QString m_varsBatArg; // Argument
-    QString m_debuggerCommand;
-    mutable QByteArray m_predefinedMacros;
-    mutable Utils::Environment m_lastEnvironment;   // Last checked 'incoming' environment.
-    mutable Utils::Environment m_resultEnvironment; // Resulting environment for VC
-    mutable QList<HeaderPath> m_headerPaths;
-    Abi m_abi;
 };
 
 // --------------------------------------------------------------------------
diff --git a/src/plugins/projectexplorer/projectexplorer.cpp b/src/plugins/projectexplorer/projectexplorer.cpp
index cf380ace6a..6cbed896af 100644
--- a/src/plugins/projectexplorer/projectexplorer.cpp
+++ b/src/plugins/projectexplorer/projectexplorer.cpp
@@ -85,6 +85,7 @@
 #ifdef Q_OS_WIN
 #    include "windebuginterface.h"
 #    include "msvctoolchain.h"
+#    include "wincetoolchain.h"
 #endif
 
 #include <extensionsystem/pluginspec.h>
@@ -318,6 +319,7 @@ bool ProjectExplorerPlugin::initialize(const QStringList &arguments, QString *er
 
     addAutoReleasedObject(new Internal::MingwToolChainFactory);
     addAutoReleasedObject(new Internal::MsvcToolChainFactory);
+    addAutoReleasedObject(new Internal::WinCEToolChainFactory);
 #else
     addAutoReleasedObject(new Internal::GccToolChainFactory);
     addAutoReleasedObject(new Internal::LinuxIccToolChainFactory);
diff --git a/src/plugins/projectexplorer/projectexplorer.pro b/src/plugins/projectexplorer/projectexplorer.pro
index dd5f9abf2b..b526d840fd 100644
--- a/src/plugins/projectexplorer/projectexplorer.pro
+++ b/src/plugins/projectexplorer/projectexplorer.pro
@@ -213,11 +213,15 @@ win32 {
     SOURCES += \
         windebuginterface.cpp \
         msvcparser.cpp \
-        msvctoolchain.cpp
+        msvctoolchain.cpp \
+        abstractmsvctoolchain.cpp \
+        wincetoolchain.cpp
     HEADERS += \
         windebuginterface.h \
         msvcparser.h \
-        msvctoolchain.h
+        msvctoolchain.h \
+        abstractmsvctoolchain.h \
+        wincetoolchain.h
 } else {
     macx:LIBS += -framework Carbon
 }
diff --git a/src/plugins/projectexplorer/projectexplorerconstants.h b/src/plugins/projectexplorer/projectexplorerconstants.h
index 8111e3fd24..a43c8756c4 100644
--- a/src/plugins/projectexplorer/projectexplorerconstants.h
+++ b/src/plugins/projectexplorer/projectexplorerconstants.h
@@ -215,6 +215,7 @@ const char GCC_TOOLCHAIN_ID[] = "ProjectExplorer.ToolChain.Gcc";
 const char LINUXICC_TOOLCHAIN_ID[] = "ProjectExplorer.ToolChain.LinuxIcc";
 const char MINGW_TOOLCHAIN_ID[] = "ProjectExplorer.ToolChain.Mingw";
 const char MSVC_TOOLCHAIN_ID[] = "ProjectExplorer.ToolChain.Msvc";
+const char WINCE_TOOLCHAIN_ID[] = "ProjectExplorer.ToolChain.WinCE";
 
 // Run Configuration defaults:
 const int QML_DEFAULT_DEBUG_SERVER_PORT = 3768;
diff --git a/src/plugins/projectexplorer/wincetoolchain.cpp b/src/plugins/projectexplorer/wincetoolchain.cpp
new file mode 100644
index 0000000000..d3913524cf
--- /dev/null
+++ b/src/plugins/projectexplorer/wincetoolchain.cpp
@@ -0,0 +1,488 @@
+/**************************************************************************
+**
+** This file is part of Qt Creator
+**
+** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
+**
+** Contact: Nokia Corporation (info@qt.nokia.com)
+**
+**
+** GNU Lesser General Public License Usage
+**
+** This file may be used under the terms of the GNU Lesser General Public
+** License version 2.1 as published by the Free Software Foundation and
+** appearing in the file LICENSE.LGPL included in the packaging of this file.
+** Please review the following information to ensure the GNU Lesser General
+** Public License version 2.1 requirements will be met:
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** Other Usage
+**
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at info@qt.nokia.com.
+**
+**************************************************************************/
+
+#include "wincetoolchain.h"
+
+#include "msvcparser.h"
+#include "projectexplorerconstants.h"
+#include "headerpath.h"
+
+#include <projectexplorer/projectexplorer.h>
+#include <projectexplorer/projectexplorersettings.h>
+#include <utils/qtcassert.h>
+
+#include <QtCore/QDir>
+#include <QtCore/QFileInfo>
+#include <QtCore/QSettings>
+
+#include <QtGui/QFormLayout>
+#include <QtGui/QLabel>
+
+#include <QXmlStreamReader>
+
+#define KEY_ROOT "ProjectExplorer.WinCEToolChain."
+static const char debuggerCommandKeyC[] = KEY_ROOT"Debugger";
+static const char msvcVerKeyC[] = KEY_ROOT"MSVCVer";
+static const char ceVerKeyC[] = KEY_ROOT"CEVer";
+static const char binPathKeyC[] = KEY_ROOT"BinPath";
+static const char includePathKeyC[] = KEY_ROOT"IncludePath";
+static const char libPathKeyC[] = KEY_ROOT"LibPath";
+static const char supportedAbiKeyC[] = KEY_ROOT"SupportedAbi";
+static const char vcVarsKeyC[] = KEY_ROOT"VCVars";
+
+enum { debug = 0 };
+
+namespace ProjectExplorer {
+namespace Internal {
+
+// --------------------------------------------------------------------------
+// Helpers:
+// --------------------------------------------------------------------------
+
+// Just decodes from the integer version to the string used in Qt mkspecs
+static QString findMsvcVer(int version)
+{
+    if (10 == version)
+        return QLatin1String("msvc2010");
+    else if (9 == version)
+        return QLatin1String("msvc2008");;
+
+    return QLatin1String("msvc2005");
+}
+
+
+// Windows: Expand the delayed evaluation references returned by the
+// SDK setup scripts: "PATH=$(Path);foo". Some values might expand
+// to empty and should not be added
+static QString winExpandDelayedEnvReferences(QString in, const Utils::Environment &env)
+{
+    const QString firstDelimit = QLatin1String("$(");
+    const QChar secondDelimit = QLatin1Char(')');
+    for (int pos = 0; pos < in.size(); ) {
+        // Replace "$(REF)" by its value in process environment
+        pos = in.indexOf(firstDelimit, pos);
+        if (pos == -1)
+            break;
+        const int replaceStart = pos + firstDelimit.size();
+        const int nextPos = in.indexOf(secondDelimit, replaceStart);
+        if (nextPos == -1)
+            break;
+        const QString var = in.mid(replaceStart, nextPos - replaceStart);
+        QString replacement = env.value(var.toUpper());
+        if (replacement.isEmpty()) {
+            qWarning() << "No replacement for var: " << var;
+            pos = nextPos;
+        }
+        else {
+            // Not sure about this, but we need to account for the case where
+            // the end of the replacement doesn't have the directory seperator and
+            // neither does the start of the insert. This solution assumes:
+            //  1) Having \\ in a path is valid (it is on WinXP)
+            //  2) We're only replacing in paths. This will cause problems if there's
+            //     a replace of a string
+            if (!replacement.endsWith('\\'))
+                replacement += '\\';
+
+            in.replace(pos, nextPos + 1 - pos, replacement);
+            pos += replacement.size();
+        }
+    }
+    return in;
+}
+
+// This is pretty much the same as the ReadEnvironmentSetting in the msvctoolchain.cpp, but
+// this takes account of the library, binary and include paths to replace the vcvars versions
+// with the ones for this toolchain.
+Utils::Environment WinCEToolChain::readEnvironmentSetting(Utils::Environment& env) const
+{
+    Utils::Environment result = env;
+    if (!QFileInfo(m_vcvarsBat).exists())
+        return result;
+
+    // Get the env pairs
+    QMap<QString, QString> envPairs;
+
+    if (!generateEnvironmentSettings(env, m_vcvarsBat, QString(), envPairs))
+        return result;
+
+    QMap<QString,QString>::const_iterator envPairIter;
+    for (envPairIter = envPairs.begin(); envPairIter!=envPairs.end(); ++envPairIter) {
+        // Replace the env values with those from the WinCE SDK
+        QString varValue = envPairIter.value();
+        if ("PATH" == envPairIter.key())
+            varValue = m_binPath + ";" + varValue;
+        else if ("INCLUDE" == envPairIter.key())
+            varValue = m_includePath;
+        else if ("LIB" == envPairIter.key())
+            varValue = m_libPath;
+
+        if (!varValue.isEmpty())
+            result.set(envPairIter.key(), varValue);
+    }
+
+
+    // Now loop round and do the delayed expansion
+    Utils::Environment::const_iterator envIter = result.constBegin();
+    while (envIter != result.constEnd()) {
+        const QString key = result.key(envIter);
+        const QString unexpandedValue = result.value(envIter);
+
+        const QString expandedValue = winExpandDelayedEnvReferences(unexpandedValue, result);
+
+        result.set(key, expandedValue);
+
+        ++envIter;
+    }
+
+    if (debug) {
+        const QStringList newVars = result.toStringList();
+        const QStringList oldVars = env.toStringList();
+        QDebug nsp = qDebug().nospace();
+        foreach (const QString &n, newVars) {
+            if (!oldVars.contains(n))
+                nsp << n << '\n';
+        }
+    }
+    return result;
+}
+
+// Used to parse an SDK entry in the config file and extract information about this SDK
+static bool parseSDK(QXmlStreamReader& theReader,
+                     Abi::Architecture& sdkArch,
+                     QString& sdkName,
+                     QString& ceVer,
+                     QString& binPath,
+                     QString& includePath,
+                     QString& libPath)
+{
+    sdkArch = Abi::UnknownArchitecture;
+    sdkName = "";
+
+    // Loop through until either the end of the file or until is gets to the next
+    // end element.
+    while (!theReader.atEnd()) {
+        theReader.readNext();
+
+        if (theReader.isEndElement()) {
+            // Got to the end element so return...
+            if (theReader.name() == "Platform")
+                return (sdkArch!=Abi::UnknownArchitecture && !sdkName.isEmpty());
+        } else if (theReader.isStartElement()) {
+            const QStringRef elemName = theReader.name();
+            if (elemName == "PlatformName") {
+                sdkName = theReader.readElementText();
+            } else if (elemName == "Directories") {
+                // Populate the paths from this element. Note: we remove the
+                // $(PATH) from the binPath as this will be pre-pended in code
+                binPath = theReader.attributes().value("Path").toString();
+                binPath.remove("$(PATH)");
+                includePath = theReader.attributes().value("Include").toString();
+                libPath = theReader.attributes().value("Library").toString();
+            } else if (elemName == "OSMajorVersion") {
+                // Qt only supports CE5 and higher so drop out here if this version is
+                // invalid
+                ceVer = theReader.readElementText();
+                if (ceVer.toInt() < 5) {
+                    qDebug() << "Ignoring SDK as Qt only support CE 5 and higher.";
+                    return false;
+                }
+            } else if (elemName == "Macro") {
+                // Pull out the architecture from the macro values.
+                if (theReader.attributes().value("Name") == "ARCHFAM") {
+                    const QStringRef archFam = theReader.attributes().value("Value");
+
+                    if (archFam == "ARM")
+                        sdkArch = Abi::ArmArchitecture;
+                    else if (archFam == "x86")
+                        sdkArch = Abi::X86Architecture;
+                    else if (archFam == "MIPS")
+                        sdkArch = Abi::MipsArchitecture;
+                }
+            }
+        }
+    }
+
+    // If we've got to here then the end of the file has been reached before the
+    // end of element tag, so return error.
+    return false;
+}
+
+// --------------------------------------------------------------------------
+// WinCEToolChain
+// --------------------------------------------------------------------------
+
+WinCEToolChain::WinCEToolChain(const QString &name,
+                               const Abi &abi,
+                               const QString &vcvarsBat,
+                               const QString &msvcVer,
+                               const QString &ceVer,
+                               const QString &binPath,
+                               const QString &includePath,
+                               const QString &libPath,
+                               bool autodetect) :
+    AbstractMsvcToolChain(QLatin1String(Constants::WINCE_TOOLCHAIN_ID), autodetect, abi, vcvarsBat),
+    m_msvcVer(msvcVer),
+    m_ceVer(ceVer),
+    m_binPath(binPath),
+    m_includePath(includePath),
+    m_libPath(libPath)
+{
+    Q_ASSERT(!name.isEmpty());
+    Q_ASSERT(!m_binPath.isEmpty());
+    Q_ASSERT(!m_includePath.isEmpty());
+    Q_ASSERT(!m_libPath.isEmpty());
+
+    updateId();
+    setDisplayName(name);
+}
+
+WinCEToolChain::WinCEToolChain() :
+    AbstractMsvcToolChain(QLatin1String(Constants::WINCE_TOOLCHAIN_ID), false)
+{
+}
+
+WinCEToolChain *WinCEToolChain::readFromMap(const QVariantMap &data)
+{
+    WinCEToolChain *tc = new WinCEToolChain;
+    if (tc->fromMap(data))
+        return tc;
+    delete tc;
+    return 0;
+}
+
+void WinCEToolChain::updateId()
+{
+    const QChar colon = QLatin1Char(':');
+    QString id = QLatin1String(Constants::WINCE_TOOLCHAIN_ID);
+    id += colon;
+    id += m_msvcVer;
+    id += colon;
+    id += m_binPath;
+    id += colon;
+    id += m_includePath;
+    id += colon;
+    id += m_libPath;
+    id += colon;
+    id += m_debuggerCommand;
+    setId(id);
+}
+
+QString WinCEToolChain::typeName() const
+{
+    return WinCEToolChainFactory::tr("WinCE");
+}
+
+QString WinCEToolChain::mkspec() const
+{
+    const QChar specSeperator('-');
+
+    QString specString = QLatin1String("wince");
+
+    specString += m_ceVer;
+    specString += specSeperator;
+    specString += Abi::toString(m_abi.architecture());
+    specString += specSeperator;
+    specString += m_msvcVer;
+
+    return specString;
+}
+
+
+QString WinCEToolChain::ceVer() const
+{
+    return m_ceVer;
+}
+
+
+QVariantMap WinCEToolChain::toMap() const
+{
+    QVariantMap data = ToolChain::toMap();
+    if (!m_debuggerCommand.isEmpty())
+        data.insert(QLatin1String(debuggerCommandKeyC), m_debuggerCommand);
+
+    data.insert(QLatin1String(msvcVerKeyC), m_msvcVer);
+    data.insert(QLatin1String(ceVerKeyC), m_ceVer);
+    data.insert(QLatin1String(binPathKeyC), m_binPath);
+    data.insert(QLatin1String(includePathKeyC), m_includePath);
+    data.insert(QLatin1String(libPathKeyC), m_libPath);
+    data.insert(QLatin1String(vcVarsKeyC), m_vcvarsBat);
+
+    data.insert(QLatin1String(supportedAbiKeyC), m_abi.toString());
+    return data;
+}
+
+bool WinCEToolChain::fromMap(const QVariantMap &data)
+{
+    if (!ToolChain::fromMap(data))
+        return false;
+
+    m_msvcVer = data.value(QLatin1String(msvcVerKeyC)).toString();
+    m_ceVer = data.value(QLatin1String(ceVerKeyC)).toString();
+    m_binPath = data.value(QLatin1String(binPathKeyC)).toString();
+    m_includePath = data.value(QLatin1String(includePathKeyC)).toString();
+    m_libPath = data.value(QLatin1String(libPathKeyC)).toString();
+    m_vcvarsBat = data.value(QLatin1String(vcVarsKeyC)).toString();
+
+    m_debuggerCommand = data.value(QLatin1String(debuggerCommandKeyC)).toString();
+    const QString abiString = data.value(QLatin1String(supportedAbiKeyC)).toString();
+    m_abi = Abi(abiString);
+    updateId();
+
+    return isValid();
+}
+
+ToolChainConfigWidget *WinCEToolChain::configurationWidget()
+{
+    return new WinCEToolChainConfigWidget(this);
+}
+
+ToolChain *WinCEToolChain::clone() const
+{
+    return new WinCEToolChain(*this);
+}
+
+
+
+// --------------------------------------------------------------------------
+// WinCEToolChainFactory
+// --------------------------------------------------------------------------
+
+QString WinCEToolChainFactory::displayName() const
+{
+    return tr("WinCE");
+}
+
+QString WinCEToolChainFactory::id() const
+{
+    return QLatin1String(Constants::WINCE_TOOLCHAIN_ID);
+}
+
+
+QList<ToolChain *> WinCEToolChainFactory::autoDetect()
+{
+    QList<ToolChain *> results;
+
+    // 1) Installed WinCEs
+    const QSettings vsRegistry(
+#ifdef Q_OS_WIN64
+                QLatin1String("HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\Microsoft\\VisualStudio\\SxS\\VC7"),
+#else
+                QLatin1String("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\SxS\\VC7"),
+#endif
+                QSettings::NativeFormat);
+
+    foreach (const QString &vsName, vsRegistry.allKeys()) {
+        // Scan for version major.minor
+        const int dotPos = vsName.indexOf(QLatin1Char('.'));
+        if (dotPos == -1)
+            continue;
+
+        const QString path = QDir::fromNativeSeparators(vsRegistry.value(vsName).toString());
+        const int version = vsName.left(dotPos).toInt();
+
+        // Check existence of various install scripts
+        const QString vcvars32bat = path + QLatin1String("bin/vcvars32.bat");
+        QFile cePlatforms(path + "vcpackages/WCE.VCPlatform.config");
+
+        if (cePlatforms.exists()) {
+            const QString msvcVer = findMsvcVer(version);
+            cePlatforms.open(QIODevice::ReadOnly);
+            QXmlStreamReader platformReader(&cePlatforms);
+
+            // Rip through the config file getting all of the installed platforms.
+            while (!platformReader.atEnd()) {
+                platformReader.readNext();
+                if (platformReader.isStartElement()) {
+                    if (platformReader.name() == "Platform") {
+                        Abi::Architecture theArch;
+                        QString thePlat;
+                        QString binPath;
+                        QString includePath;
+                        QString libPath;
+                        QString ceVer;
+
+                        if (parseSDK(platformReader, theArch, thePlat, ceVer, binPath, includePath, libPath)) {
+                            WinCEToolChain *pChain = new WinCEToolChain(thePlat,
+                                                                        Abi(theArch, Abi::WindowsOS, Abi::WindowsCEFlavor, Abi::PEFormat, 32),
+                                                                        vcvars32bat,
+                                                                        msvcVer,
+                                                                        ceVer,
+                                                                        binPath,
+                                                                        includePath,
+                                                                        libPath,
+                                                                        true);
+                            results.append(pChain);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    return results;
+}
+
+
+QString WinCEToolChain::autoDetectCdbDebugger(QStringList *checkedDirectories /* = 0 */)
+{
+    return QString();
+}
+
+bool WinCEToolChainFactory::canRestore(const QVariantMap &data)
+{
+    return idFromMap(data).startsWith(QLatin1String(Constants::WINCE_TOOLCHAIN_ID) + QLatin1Char(':'));
+}
+
+ToolChain *WinCEToolChainFactory::restore(const QVariantMap &data)
+{
+    return WinCEToolChain::readFromMap(data);
+}
+
+// --------------------------------------------------------------------------
+// WinCEToolChainConfigWidget
+// --------------------------------------------------------------------------
+
+WinCEToolChainConfigWidget::WinCEToolChainConfigWidget(ToolChain *tc) :
+    ToolChainConfigWidget(tc)
+{
+    WinCEToolChain *toolChain = static_cast<WinCEToolChain *>(tc);
+    QTC_ASSERT(tc, return);
+
+    QFormLayout *formLayout = new QFormLayout(this);
+    formLayout->addRow(tr("SDK:"), new QLabel(toolChain->displayName()));
+    formLayout->addRow(tr("WinCE Version:"), new QLabel(toolChain->ceVer()));
+    formLayout->addRow(tr("ABI:"), new QLabel(toolChain->targetAbi().toString()));
+    addErrorLabel(formLayout);
+}
+
+} // namespace Internal
+} // namespace ProjectExplorer
diff --git a/src/plugins/projectexplorer/wincetoolchain.h b/src/plugins/projectexplorer/wincetoolchain.h
new file mode 100644
index 0000000000..2bc28932ac
--- /dev/null
+++ b/src/plugins/projectexplorer/wincetoolchain.h
@@ -0,0 +1,139 @@
+/**************************************************************************
+**
+** This file is part of Qt Creator
+**
+** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
+**
+** Contact: Nokia Corporation (info@qt.nokia.com)
+**
+**
+** GNU Lesser General Public License Usage
+**
+** This file may be used under the terms of the GNU Lesser General Public
+** License version 2.1 as published by the Free Software Foundation and
+** appearing in the file LICENSE.LGPL included in the packaging of this file.
+** Please review the following information to ensure the GNU Lesser General
+** Public License version 2.1 requirements will be met:
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** Other Usage
+**
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at info@qt.nokia.com.
+**
+**************************************************************************/
+
+#ifndef WINCETOOLCHAIN_H
+#define WINCETOOLCHAIN_H
+
+#include "abstractmsvctoolchain.h"
+#include "abi.h"
+#include "toolchainconfigwidget.h"
+
+#include <utils/environment.h>
+
+#include <QtGui/QLabel>
+
+namespace ProjectExplorer {
+namespace Internal {
+
+// --------------------------------------------------------------------------
+// WinCEToolChain
+// --------------------------------------------------------------------------
+
+class WinCEToolChain : public AbstractMsvcToolChain
+{
+public:
+
+    WinCEToolChain(const QString &name,
+                   const Abi &abi,
+                   const QString &vcvarsBat,
+                   const QString &msvcVer,
+                   const QString &ceVer,
+                   const QString &binPath,
+                   const QString &includePath,
+                   const QString &libPath,
+                   bool autodetect = false);
+
+    static WinCEToolChain *readFromMap(const QVariantMap &data);
+
+    QString typeName() const;
+
+    QString mkspec() const;
+
+    QString ceVer() const;
+
+    QVariantMap toMap() const;
+    bool fromMap(const QVariantMap &data);
+
+    ToolChainConfigWidget *configurationWidget();
+
+    ToolChain *clone() const;
+
+    static QString autoDetectCdbDebugger(QStringList *checkedDirectories = 0);
+
+protected:
+    Utils::Environment readEnvironmentSetting(Utils::Environment& env) const;
+
+private:
+    WinCEToolChain();
+    void updateId();
+
+    QString m_msvcVer;
+    QString m_ceVer;
+    QString m_binPath;
+    QString m_includePath;
+    QString m_libPath;
+};
+
+// --------------------------------------------------------------------------
+// WinCEToolChainConfigWidget
+// --------------------------------------------------------------------------
+class WinCEToolChainConfigWidget : public ToolChainConfigWidget
+{
+    Q_OBJECT
+
+public:
+    WinCEToolChainConfigWidget(ToolChain *);
+
+    void apply() {}
+    void discard() { }
+    bool isDirty() const {return false;}
+
+};
+
+// --------------------------------------------------------------------------
+// WinCEToolChainFactory
+// --------------------------------------------------------------------------
+
+class WinCEToolChainFactory : public ToolChainFactory
+{
+    Q_OBJECT
+
+public:
+    QString displayName() const;
+    QString id() const;
+
+    QList<ToolChain *> autoDetect();
+
+    bool canRestore(const QVariantMap &data);
+    ToolChain *restore(const QVariantMap &data);
+
+    ToolChainConfigWidget *configurationWidget(ToolChain *);
+
+private:
+    QList<ToolChain *> detectCEToolKits(const QString& msvcPath, const QString& vcvarsbat);
+};
+
+
+} // namespace Internal
+} // namespace ProjectExplorer
+
+#endif // MSVCTOOLCHAIN_H
diff --git a/src/plugins/qt4projectmanager/winceqtversion.cpp b/src/plugins/qt4projectmanager/winceqtversion.cpp
index 44c8986e4d..d0c99bb920 100644
--- a/src/plugins/qt4projectmanager/winceqtversion.cpp
+++ b/src/plugins/qt4projectmanager/winceqtversion.cpp
@@ -39,20 +39,22 @@ using namespace Qt4ProjectManager;
 using namespace Qt4ProjectManager::Internal;
 
 WinCeQtVersion::WinCeQtVersion()
-    : QtSupport::BaseQtVersion()
+    : QtSupport::BaseQtVersion(),
+      m_archType(ProjectExplorer::Abi::ArmArchitecture)
 {
-
 }
 
-WinCeQtVersion::WinCeQtVersion(const QString &path, bool isAutodetected, const QString &autodetectionSource)
-    : QtSupport::BaseQtVersion(path, isAutodetected, autodetectionSource)
+WinCeQtVersion::WinCeQtVersion(const QString &path, const QString& archType, bool isAutodetected, const QString &autodetectionSource)
+    : QtSupport::BaseQtVersion(path, isAutodetected, autodetectionSource), m_archType(ProjectExplorer::Abi::ArmArchitecture)
 {
-
+    if (0 == archType.compare("x86", Qt::CaseInsensitive))
+        m_archType = ProjectExplorer::Abi::X86Architecture;
+    else if (0 == archType.compare("mipsii", Qt::CaseInsensitive))
+        m_archType = ProjectExplorer::Abi::MipsArchitecture;
 }
 
 WinCeQtVersion::~WinCeQtVersion()
 {
-
 }
 
 WinCeQtVersion *WinCeQtVersion::clone() const
@@ -68,7 +70,7 @@ QString WinCeQtVersion::type() const
 QList<ProjectExplorer::Abi> WinCeQtVersion::detectQtAbis() const
 {
     return QList<ProjectExplorer::Abi>()
-            << ProjectExplorer::Abi(ProjectExplorer::Abi::ArmArchitecture,
+            << ProjectExplorer::Abi(m_archType,
                                     ProjectExplorer::Abi::WindowsOS,
                                     ProjectExplorer::Abi::WindowsCEFlavor,
                                     ProjectExplorer::Abi::PEFormat,
@@ -89,3 +91,29 @@ QString WinCeQtVersion::description() const
 {
     return QCoreApplication::translate("QtVersion", "Qt for WinCE", "Qt Version is meant for WinCE");
 }
+
+void WinCeQtVersion::fromMap(const QVariantMap &map)
+{
+    BaseQtVersion::fromMap(map);
+
+    // Default to an ARM architecture, then use the makespec to see what
+    // the architecture is. This assumes that a WinCE makespec will be
+    // named <Description>-<Architecture>-<Compiler> with no other '-' characters.
+    m_archType = ProjectExplorer::Abi::ArmArchitecture;
+
+    const QStringList splitSpec = mkspec().split("-");
+    if (splitSpec.length() == 3) {
+        const QString archString = splitSpec.value(1);
+        if (archString.contains("x86", Qt::CaseInsensitive))
+            m_archType = ProjectExplorer::Abi::X86Architecture;
+        else if (archString.contains("mips", Qt::CaseInsensitive))
+            m_archType = ProjectExplorer::Abi::MipsArchitecture;
+    }
+}
+
+QVariantMap WinCeQtVersion::toMap() const
+{
+    QVariantMap result = BaseQtVersion::toMap();
+
+    return result;
+}
diff --git a/src/plugins/qt4projectmanager/winceqtversion.h b/src/plugins/qt4projectmanager/winceqtversion.h
index b94b8c3398..03d2ff8385 100644
--- a/src/plugins/qt4projectmanager/winceqtversion.h
+++ b/src/plugins/qt4projectmanager/winceqtversion.h
@@ -42,7 +42,7 @@ class WinCeQtVersion : public QtSupport::BaseQtVersion
 {
 public:
     WinCeQtVersion();
-    WinCeQtVersion(const QString &path, bool isAutodetected = false, const QString &autodetectionSource = QString());
+    WinCeQtVersion(const QString &path, const QString& archType, bool isAutodetected = false, const QString &autodetectionSource = QString());
     ~WinCeQtVersion();
     WinCeQtVersion *clone() const;
 
@@ -54,6 +54,12 @@ public:
     QSet<QString> supportedTargetIds() const;
 
     QString description() const;
+
+    virtual QVariantMap toMap() const;
+    virtual void fromMap(const QVariantMap &data);
+
+private:
+    ProjectExplorer::Abi::Architecture m_archType;
 };
 
 }
diff --git a/src/plugins/qt4projectmanager/winceqtversionfactory.cpp b/src/plugins/qt4projectmanager/winceqtversionfactory.cpp
index f6d9dbea5f..26a42fd549 100644
--- a/src/plugins/qt4projectmanager/winceqtversionfactory.cpp
+++ b/src/plugins/qt4projectmanager/winceqtversionfactory.cpp
@@ -79,7 +79,7 @@ QtSupport::BaseQtVersion *WinCeQtVersionFactory::create(const QString &qmakePath
     QString ce_arch = evaluator->value("CE_ARCH");
 
     if (!ce_sdk.isEmpty() && !ce_arch.isEmpty())
-        return new WinCeQtVersion(qmakePath, isAutoDetected, autoDetectionSource);
+        return new WinCeQtVersion(qmakePath, ce_arch, isAutoDetected, autoDetectionSource);
 
     return 0;
 }