diff --git a/language/backgroundparser/parsejob.cpp b/language/backgroundparser/parsejob.cpp
index 4e02d12420..f060100811 100644
--- a/language/backgroundparser/parsejob.cpp
+++ b/language/backgroundparser/parsejob.cpp
@@ -1,521 +1,525 @@
 /*
 * This file is part of KDevelop
 *
 * Copyright 2006 Adam Treat <treat@kde.org>
 * Copyright 2006-2008 Hamish Rodda <rodda@kde.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Library General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
 
 #include "parsejob.h"
 
 #include <QFile>
 #include <QByteArray>
 #include <QMutex>
 #include <QMutexLocker>
 #include <QApplication>
 #include <QDebug>
 
 #include <KLocalizedString>
 #include <KFormat>
 #include <ktexteditor/movinginterface.h>
 
 #include "backgroundparser.h"
 #include "util/debug.h"
 #include "duchain/topducontext.h"
 
 #include "duchain/duchainlock.h"
 #include "duchain/duchain.h"
 #include "duchain/parsingenvironment.h"
 
 #include <util/foregroundlock.h>
+#include <util/kdevstringhandler.h>
 #include <interfaces/icore.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <codegen/coderepresentation.h>
 #include <duchain/declaration.h>
 #include <duchain/use.h>
 #include <interfaces/icodehighlighting.h>
 #include <duchain/problem.h>
 
 
 using namespace KTextEditor;
 
 static QMutex minimumFeaturesMutex;
 static QHash<KDevelop::IndexedString, QList<KDevelop::TopDUContext::Features> > staticMinimumFeatures;
 
 namespace KDevelop
 {
 
 class ParseJobPrivate
 {
 public:
 
     ParseJobPrivate(const IndexedString& url_, ILanguageSupport* languageSupport_) :
           url( url_ )
         , languageSupport( languageSupport_ )
         , abortRequested( 0 )
         , hasReadContents( false )
         , aborted( false )
         , features( TopDUContext::VisibleDeclarationsAndContexts )
         , parsePriority( 0 )
         , sequentialProcessingFlags( ParseJob::IgnoresSequentialProcessing )
     {
     }
 
     ~ParseJobPrivate()
     {
     }
 
     ReferencedTopDUContext duContext;
 
     IndexedString url;
     ILanguageSupport* languageSupport;
 
     ParseJob::Contents contents;
 
     QAtomicInt abortRequested;
 
     bool hasReadContents : 1;
     bool aborted : 1;
     TopDUContext::Features features;
     QList<QPointer<QObject> > notify;
     QPointer<DocumentChangeTracker> tracker;
     RevisionReference revision;
     RevisionReference previousRevision;
 
     int parsePriority;
     ParseJob::SequentialProcessingFlags sequentialProcessingFlags;
 };
 
 ParseJob::ParseJob( const IndexedString& url, KDevelop::ILanguageSupport* languageSupport )
         : ThreadWeaver::Sequence(),
         d(new ParseJobPrivate(url, languageSupport))
 {
 }
 
 ParseJob::~ParseJob()
 {
     typedef QPointer<QObject> QObjectPointer;
     foreach(const QObjectPointer &p, d->notify) {
         if(p) {
             QMetaObject::invokeMethod(p.data(), "updateReady", Qt::QueuedConnection, Q_ARG(KDevelop::IndexedString, d->url), Q_ARG(KDevelop::ReferencedTopDUContext, d->duContext));
         }
     }
 
     delete d;
 }
 
 ILanguageSupport* ParseJob::languageSupport() const
 {
     return d->languageSupport;
 }
 
 void ParseJob::setParsePriority(int priority)
 {
     d->parsePriority = priority;
 }
 
 int ParseJob::parsePriority() const
 {
     return d->parsePriority;
 }
 
 bool ParseJob::requiresSequentialProcessing() const
 {
     return d->sequentialProcessingFlags & RequiresSequentialProcessing;
 }
 
 bool ParseJob::respectsSequentialProcessing() const
 {
     return d->sequentialProcessingFlags & RespectsSequentialProcessing;
 }
 
 void ParseJob::setSequentialProcessingFlags(SequentialProcessingFlags flags)
 {
     d->sequentialProcessingFlags = flags;
 }
 
 IndexedString ParseJob::document() const
 {
     return d->url;
 }
 
 bool ParseJob::success() const
 {
     return !d->aborted;
 }
 
 void ParseJob::setMinimumFeatures(TopDUContext::Features features)
 {
     d->features = features;
 }
 
 bool ParseJob::hasStaticMinimumFeatures()
 {
     QMutexLocker lock(&minimumFeaturesMutex);
     return !::staticMinimumFeatures.isEmpty();
 }
 
 TopDUContext::Features ParseJob::staticMinimumFeatures(const IndexedString& url)
 {
     QMutexLocker lock(&minimumFeaturesMutex);
     TopDUContext::Features features = (TopDUContext::Features)0;
 
     if(::staticMinimumFeatures.contains(url))
         foreach(const TopDUContext::Features f, ::staticMinimumFeatures[url])
             features = (TopDUContext::Features)(features | f);
 
     return features;
 }
 
 TopDUContext::Features ParseJob::minimumFeatures() const
 {
     return (TopDUContext::Features)(d->features | staticMinimumFeatures(d->url));
 }
 
 void ParseJob::setDuChain(ReferencedTopDUContext duChain)
 {
     d->duContext = duChain;
 }
 
 ReferencedTopDUContext ParseJob::duChain() const
 {
     return d->duContext;
 }
 
 bool ParseJob::abortRequested() const
 {
     return d->abortRequested.load();
 }
 
 void ParseJob::requestAbort()
 {
     d->abortRequested = 1;
 }
 
 void ParseJob::abortJob()
 {
     d->aborted = true;
     setStatus(Status_Aborted);
 }
 
 void ParseJob::setNotifyWhenReady(const QList<QPointer< QObject > >& notify
 ) {
     d->notify = notify;
 }
 
 void ParseJob::setStaticMinimumFeatures(const IndexedString& url, TopDUContext::Features features) {
     QMutexLocker lock(&minimumFeaturesMutex);
     ::staticMinimumFeatures[url].append(features);
 }
 
 void ParseJob::unsetStaticMinimumFeatures(const IndexedString& url, TopDUContext::Features features) {
     QMutexLocker lock(&minimumFeaturesMutex);
     ::staticMinimumFeatures[url].removeOne(features);
     if(::staticMinimumFeatures[url].isEmpty())
       ::staticMinimumFeatures.remove(url);
 }
 
 KDevelop::ProblemPointer ParseJob::readContents()
 {
     Q_ASSERT(!d->hasReadContents);
     d->hasReadContents = true;
 
     QString localFile(document().toUrl().toLocalFile());
     QFileInfo fileInfo( localFile );
 
     QDateTime lastModified = fileInfo.lastModified();
 
     d->tracker = ICore::self()->languageController()->backgroundParser()->trackerForUrl(document());
 
     //Try using an artificial code-representation, which overrides everything else
     if(artificialCodeRepresentationExists(document())) {
         CodeRepresentation::Ptr repr = createCodeRepresentation(document());
         d->contents.contents = repr->text().toUtf8();
         qCDebug(LANGUAGE) << "took contents for " << document().str() << " from artificial code-representation";
         return KDevelop::ProblemPointer();
     }
 
     bool hadTracker = false;
     if(d->tracker)
     {
         ForegroundLock lock;
         if(DocumentChangeTracker* t = d->tracker.data())
         {
             // The file is open in an editor
             d->previousRevision = t->revisionAtLastReset();
 
             t->reset(); // Reset the tracker to the current revision
             Q_ASSERT(t->revisionAtLastReset());
 
             d->contents.contents = t->document()->text().toUtf8();
             d->contents.modification = KDevelop::ModificationRevision( lastModified, t->revisionAtLastReset()->revision() );
 
             d->revision = t->acquireRevision(d->contents.modification.revision);
             hadTracker = true;
         }
     }
     if (!hadTracker) {
         // We have to load the file from disk
 
         static const int maximumFileSize = 5 * 1024 * 1024; // 5 MB
         if (fileInfo.size() > maximumFileSize) {
             KFormat f;
 
             KDevelop::ProblemPointer p(new Problem());
             p->setSource(IProblem::Disk);
             p->setDescription(i18nc("%1: filename", "Skipped file that is too large: '%1'", localFile ));
             p->setExplanation(i18nc("%1: file size, %2: limit file size",
                                     "The file is %1 and exceeds the limit of %2.",
                                     f.formatByteSize(fileInfo.size()),
                                     f.formatByteSize(maximumFileSize)));
             p->setFinalLocation(DocumentRange(document(), KTextEditor::Range::invalid()));
             qCWarning(LANGUAGE) << p->description() << p->explanation();
             return p;
         }
         QFile file( localFile );
 
         if ( !file.open( QIODevice::ReadOnly ) )
         {
             KDevelop::ProblemPointer p(new Problem());
             p->setSource(IProblem::Disk);
             p->setDescription(i18n( "Could not open file '%1'", localFile ));
             switch (file.error()) {
               case QFile::ReadError:
                   p->setExplanation(i18n("File could not be read from disk."));
                   break;
               case QFile::OpenError:
                   p->setExplanation(i18n("File could not be opened."));
                   break;
               case QFile::PermissionsError:
                   p->setExplanation(i18n("File could not be read from disk due to permissions."));
                   break;
               default:
                   break;
             }
             p->setFinalLocation(DocumentRange(document(), KTextEditor::Range::invalid()));
 
             qCWarning(LANGUAGE) << "Could not open file" << document().str() << "(path" << localFile << ")" ;
 
             return p;
         }
 
         d->contents.contents = file.readAll(); ///@todo Convert from local encoding to utf-8 if they don't match
+
+        // This is consistent with KTextEditor::Document::text() as used for already-open files.
+        normalizeLineEndings(d->contents.contents);
         d->contents.modification = KDevelop::ModificationRevision(lastModified);
 
         file.close();
     }
 
     return KDevelop::ProblemPointer();
 }
 
 const KDevelop::ParseJob::Contents& ParseJob::contents() const
 {
     Q_ASSERT(d->hasReadContents);
     return d->contents;
 }
 
 struct MovingRangeTranslator : public DUChainVisitor
 {
     MovingRangeTranslator(qint64 _source, qint64 _target, MovingInterface* _moving) : source(_source), target(_target), moving(_moving) {
     }
 
     void visit(DUContext* context) override {
         translateRange(context);
         ///@todo Also map import-positions
         // Translate uses
         uint usesCount = context->usesCount();
         for(uint u = 0; u < usesCount; ++u)
         {
             RangeInRevision r = context->uses()[u].m_range;
             translateRange(r);
             context->changeUseRange(u, r);
         }
     }
 
     void visit(Declaration* declaration) override {
         translateRange(declaration);
     }
 
     void translateRange(DUChainBase* object)
     {
         RangeInRevision r = object->range();
         translateRange(r);
         object->setRange(r);
     }
 
     void translateRange(RangeInRevision& r)
     {
         // PHP and python use top contexts that start at (0, 0) end at INT_MAX, so make sure that doesn't overflow
         // or translate the start of the top context away from (0, 0)
         if ( r.start.line != 0 || r.start.column != 0 ) {
             moving->transformCursor(r.start.line, r.start.column, MovingCursor::MoveOnInsert, source, target);
         }
         if ( r.end.line != std::numeric_limits<int>::max() || r.end.column != std::numeric_limits<int>::max() ) {
             moving->transformCursor(r.end.line, r.end.column, MovingCursor::StayOnInsert, source, target);
         }
     }
 
     KTextEditor::Range range;
     qint64 source;
     qint64 target;
     MovingInterface* moving;
 };
 
 void ParseJob::translateDUChainToRevision(TopDUContext* context)
 {
     qint64 targetRevision = d->contents.modification.revision;
 
     if(targetRevision == -1)
     {
         qCDebug(LANGUAGE) << "invalid target revision" << targetRevision;
         return;
     }
 
     qint64 sourceRevision;
 
     {
         DUChainReadLocker duChainLock;
 
         Q_ASSERT(context->parsingEnvironmentFile());
 
         // Cannot map if there is no source revision
         sourceRevision = context->parsingEnvironmentFile()->modificationRevision().revision;
 
         if(sourceRevision == -1)
         {
             qCDebug(LANGUAGE) << "invalid source revision" << sourceRevision;
             return;
         }
     }
 
     if(sourceRevision > targetRevision)
     {
         qCDebug(LANGUAGE) << "for document" << document().str() << ": source revision is higher than target revision:" << sourceRevision << " > " << targetRevision;
         return;
     }
 
     ForegroundLock lock;
     if(DocumentChangeTracker* t = d->tracker.data())
     {
         if(!d->previousRevision)
         {
             qCDebug(LANGUAGE) << "not translating because there is no valid predecessor-revision";
             return;
         }
 
         if(sourceRevision != d->previousRevision->revision() || !d->previousRevision->valid())
         {
             qCDebug(LANGUAGE) << "not translating because the document revision does not match the tracker start revision (maybe the document was cleared)";
             return;
         }
 
         if(!t->holdingRevision(sourceRevision) || !t->holdingRevision(targetRevision))
         {
             qCDebug(LANGUAGE) << "lost one of the translation revisions, not doing the map";
             return;
         }
 
         // Perform translation
         MovingInterface* moving = t->documentMovingInterface();
 
         DUChainWriteLocker wLock;
 
         MovingRangeTranslator translator(sourceRevision, targetRevision, moving);
         context->visit(translator);
 
         QList< ProblemPointer > problems = context->problems();
         for(QList< ProblemPointer >::iterator problem = problems.begin(); problem != problems.end(); ++problem)
         {
             RangeInRevision r = (*problem)->range();
             translator.translateRange(r);
             (*problem)->setRange(r);
         }
 
         // Update the modification revision in the meta-data
         ModificationRevision modRev = context->parsingEnvironmentFile()->modificationRevision();
         modRev.revision = targetRevision;
         context->parsingEnvironmentFile()->setModificationRevision(modRev);
     }
 }
 
 bool ParseJob::isUpdateRequired(const IndexedString& languageString)
 {
     if (abortRequested()) {
         return false;
     }
 
     if (minimumFeatures() & TopDUContext::ForceUpdate) {
         return true;
     }
 
     DUChainReadLocker lock;
     if (abortRequested()) {
         return false;
     }
     foreach(const ParsingEnvironmentFilePointer &file, DUChain::self()->allEnvironmentFiles(document())) {
         if (file->language() != languageString) {
             continue;
         }
         if (!file->needsUpdate(environment()) && file->featuresSatisfied(minimumFeatures())) {
             qCDebug(LANGUAGE) << "Already up to date" << document().str();
             setDuChain(file->topContext());
             lock.unlock();
             highlightDUChain();
             return false;
         }
         break;
     }
     return !abortRequested();
 }
 
 const ParsingEnvironment* ParseJob::environment() const
 {
     return nullptr;
 }
 
 void ParseJob::highlightDUChain()
 {
     ENSURE_CHAIN_NOT_LOCKED
     if (!d->languageSupport->codeHighlighting() || !duChain() || abortRequested()) {
         // language doesn't support highlighting
         return;
     }
     if (!d->hasReadContents && !d->tracker) {
         d->tracker = ICore::self()->languageController()->backgroundParser()->trackerForUrl(document());
     }
     if (d->tracker) {
         d->languageSupport->codeHighlighting()->highlightDUChain(duChain());
     }
 }
 
 ControlFlowGraph* ParseJob::controlFlowGraph()
 {
     return nullptr;
 }
 
 DataAccessRepository* ParseJob::dataAccessInformation()
 {
     return nullptr;
 }
 
 bool ParseJob::hasTracker() const
 {
     return d->tracker;
 }
 
 }
 
diff --git a/util/kdevstringhandler.cpp b/util/kdevstringhandler.cpp
index fffa36b123..41462d3a56 100644
--- a/util/kdevstringhandler.cpp
+++ b/util/kdevstringhandler.cpp
@@ -1,231 +1,246 @@
 /*  This file is part of KDevelop
     Copyright 2009 Andreas Pakulat <apaku@gmx.de>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
     
     This file mostly code takes from Qt's QSettings class, the copyright 
     header from that file follows:
     
     ****************************************************************************
     **
     ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
     ** Contact: Nokia Corporation (qt-info@nokia.com)
     **
     ** This file is part of the QtCore module of the Qt Toolkit.
     **
     ** $QT_BEGIN_LICENSE:LGPL$
     ** Commercial Usage
     ** Licensees holding valid Qt Commercial licenses may use this file in
     ** accordance with the Qt Commercial License Agreement provided with the
     ** Software or, alternatively, in accordance with the terms contained in
     ** a written agreement between you and Nokia.
     **
     ** GNU Lesser General Public License Usage
     ** Alternatively, 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.0, included in the file LGPL_EXCEPTION.txt in this
     ** package.
     **
     ** GNU General Public License Usage
     ** Alternatively, this file may be used under the terms of the GNU
     ** General Public License version 3.0 as published by the Free Software
     ** Foundation and appearing in the file LICENSE.GPL included in the
     ** packaging of this file.  Please review the following information to
     ** ensure the GNU General Public License version 3.0 requirements will be
     ** met: http://www.gnu.org/copyleft/gpl.html.
     **
     ** If you are unsure which license is appropriate for your use, please
     ** contact the sales department at http://www.qtsoftware.com/contact.
     ** $QT_END_LICENSE$
     **
     ****************************************************************************
 */
 
 
 #include "kdevstringhandler.h"
 
 #include <QStringList>
 #include <QString>
+#include <QByteArray>
 #include <QChar>
 #include <QDataStream>
 #include <QVariant>
 #include <QRegExp>
 #include <QTextDocument>
 
 namespace KDevelop
 {
     QString joinWithEscaping( const QStringList& input, const QChar& joinchar, const QChar& escapechar )
     {
         QStringList tmp = input;
         return tmp.replaceInStrings( joinchar, QString( joinchar ) + QString( escapechar ) ).join( joinchar );
     }
     
     QStringList splitWithEscaping( const QString& input, const QChar& splitchar, const QChar& escapechar )
     {
         enum State { Normal, SeenEscape } state;
 
         state = Normal;
 
         QStringList result;
         QString currentstring;
         for( int i = 0; i < input.size(); i++ ) {
             switch( state ) {
                 case Normal:
                     if( input[i] == escapechar ) {
                         state = SeenEscape;
                     } else if( input[i] == splitchar ) {
                         result << currentstring;
                         currentstring.clear();
                     } else {
                         currentstring += input[i];
                     }
                     break;
                 case SeenEscape:
                     currentstring += input[i];
                     state = Normal;
                     break;
             }
         }
         if( !currentstring.isEmpty() ) {
             result << currentstring;
         }
         return result;
     }
     
     QVariant stringToQVariant(const QString& s)
     {
         // Taken from qsettings.cpp, stringToVariant()
         if (s.startsWith(QLatin1Char('@'))) {
             if (s.endsWith(QLatin1Char(')'))) {
                 if (s.startsWith(QLatin1String("@Variant("))) {
                     QByteArray a(s.toLatin1().mid(9));
                     QDataStream stream(&a, QIODevice::ReadOnly);
                     stream.setVersion(QDataStream::Qt_4_4);
                     QVariant result;
                     stream >> result;
                     return result;
                 }
             }
         }
         return QVariant();
         
     }
     
     QString qvariantToString(const QVariant& variant)
     {
         // Taken from qsettings.cpp, variantToString()
         QByteArray a;
         {
             QDataStream s(&a, QIODevice::WriteOnly);
             s.setVersion(QDataStream::Qt_4_4);
             s << variant;
         }
         
         QString result = QStringLiteral("@Variant(");
         result += QString::fromLatin1(a.constData(), a.size());
         result += QLatin1Char(')');
         return result;
         
     }
 
     QString htmlToPlainText(const QString& s, HtmlToPlainTextMode mode)
     {
         switch (mode) {
         case FastMode: {
             QString result(s);
             result.remove(QRegExp("<[^>]+>"));
             return result;
         }
         case CompleteMode: {
             QTextDocument doc;
             doc.setHtml(s);
             return doc.toPlainText();
         }
         }
         return QString(); // never reached
     }
 }
 
 QString KDevelop::stripAnsiSequences(const QString& str)
 {
     if (str.isEmpty()) {
         return QString(); // fast path
     }
 
     enum {
         PLAIN,
         ANSI_START,
         ANSI_CSI,
         ANSI_SEQUENCE,
         ANSI_WAITING_FOR_ST,
         ANSI_ST_STARTED
     } state = PLAIN;
 
     QString result;
     result.reserve(str.count());
 
     foreach (const QChar c, str) {
         const auto val = c.unicode();
         switch (state) {
         case PLAIN:
             if (val == 27) // 'ESC'
                 state = ANSI_START;
             else if (val == 155) // equivalent to 'ESC'-'['
                 state = ANSI_CSI;
             else
                 result.append(c);
             break;
         case ANSI_START:
             if (val == 91) // [
                 state = ANSI_CSI;
             else if (val == 80 || val == 93 || val == 94 || val == 95) // 'P', ']', '^' and '_'
                 state = ANSI_WAITING_FOR_ST;
             else if (val >= 64 && val <= 95)
                 state = PLAIN;
             else
                 state = ANSI_SEQUENCE;
             break;
         case ANSI_CSI:
             if (val >= 64 && val <= 126) // Anything between '@' and '~'
                 state = PLAIN;
             break;
         case ANSI_SEQUENCE:
             if (val >= 64 && val <= 95) // Anything between '@' and '_'
                 state = PLAIN;
             break;
         case ANSI_WAITING_FOR_ST:
             if (val == 7) // 'BEL'
                 state = PLAIN;
             else if (val == 27) // 'ESC'
                 state = ANSI_ST_STARTED;
             break;
         case ANSI_ST_STARTED:
             if (val == 92) // '\'
                 state = PLAIN;
             else
                 state = ANSI_WAITING_FOR_ST;
             break;
         }
     }
     return result;
 }
+
+void KDevelop::normalizeLineEndings(QByteArray& text)
+{
+    for (int i = 0, s = text.size(); i < s; ++i) {
+        if (text[i] != '\r') {
+            continue;
+        }
+        if (i + 1 < s && text[i + 1] == '\n') {
+            text.remove(i, 1);
+        } else {
+            text[i] = '\n';
+        }
+    }
+}
diff --git a/util/kdevstringhandler.h b/util/kdevstringhandler.h
index 3dcce4592c..7e0de20dab 100644
--- a/util/kdevstringhandler.h
+++ b/util/kdevstringhandler.h
@@ -1,71 +1,76 @@
 /*  This file is part of KDevelop
     Copyright 2009 Andreas Pakulat <apaku@gmx.de>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 */
 
 #ifndef KDEVPLATFORM_KDEVSTRINGHANDLER_H
 #define KDEVPLATFORM_KDEVSTRINGHANDLER_H
 
 #include "utilexport.h"
 
 class QString;
+class QByteArray;
 class QChar;
 class QStringList;
 class QVariant;
 
 namespace KDevelop
 {
     KDEVPLATFORMUTIL_EXPORT QStringList splitWithEscaping( const QString& input, const QChar& splitChar, const QChar& escapeChar );
     KDEVPLATFORMUTIL_EXPORT QString joinWithEscaping( const QStringList& input, const QChar& joinChar, const QChar& escapeChar );
     
     /**
     * convert the @p variant into a string which can then be stored
     * easily in a KConfig entry. This supports any QVariant type (including custom types)
     * for which there is a QDataStream operator defined
     * @returns a QString containing the data from the QVariant.
     */
     KDEVPLATFORMUTIL_EXPORT QString qvariantToString( const QVariant& variant );
     
     /**
     * convert the @p s into a QVariant, usually the string is read from KConfig.
     * This supports any QVariant type (including custom types)
     * for which there is a QDataStream operator defined
     * @returns a QVariant created from the bytearray
     */
     KDEVPLATFORMUTIL_EXPORT QVariant stringToQVariant( const QString& s );
 
     enum HtmlToPlainTextMode {
         FastMode,     /**< Fast (conversion via regular expression) */
         CompleteMode, /**< Slower, but with expected behavior (conversion via QTextDocument::toPlainText).
             This also replaces <br/> with newline chars, for example. */
     };
 
     /**
      * Strip HTML tags from string @p s
      *
      * @return String no longer containing any HTML tags
      */
     KDEVPLATFORMUTIL_EXPORT QString htmlToPlainText(const QString& s, HtmlToPlainTextMode mode = FastMode);
 
     /**
      * Strip ANSI sequences from string @p str
      */
     KDEVPLATFORMUTIL_EXPORT QString stripAnsiSequences(const QString& str);
 
+    /**
+     * Replace all occurrences of '\r' or '\r\n' in @p text with '\n'.
+     */
+    KDEVPLATFORMUTIL_EXPORT void normalizeLineEndings(QByteArray& text);
 }
 
 #endif // KDEVPLATFORM_KDEVSTRINGHANDLER_H
diff --git a/util/tests/test_stringhandler.cpp b/util/tests/test_stringhandler.cpp
index e7c791d6f5..dd409cd7ce 100644
--- a/util/tests/test_stringhandler.cpp
+++ b/util/tests/test_stringhandler.cpp
@@ -1,75 +1,103 @@
 /*
  * Copyright 2014 Kevin Funk <kfunk@kde.org>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of
  * the License or (at your option) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #include "test_stringhandler.h"
 
 #include "kdevstringhandler.h"
 
 #include <QtTest>
 
 QTEST_MAIN(TestStringHandler);
 
 using namespace KDevelop;
 
 Q_DECLARE_METATYPE(HtmlToPlainTextMode)
 
 void TestStringHandler::testHtmlToPlainText()
 {
     QFETCH(QString, html);
     QFETCH(HtmlToPlainTextMode, mode);
     QFETCH(QString, expectedPlainText);
 
     QString plainText = htmlToPlainText(html, mode);
     QCOMPARE(plainText, expectedPlainText);
 }
 
 void TestStringHandler::testHtmlToPlainText_data()
 {
     QTest::addColumn<QString>("html");
     QTest::addColumn<HtmlToPlainTextMode>("mode");
     QTest::addColumn<QString>("expectedPlainText");
 
     QTest::newRow("simple-fast")
         << "<p>bar() </p><dl><dt class=\"param-name-index-0\">a</dt><dd class=\"param-descr-index-0\"> foo</dd></dl>"
         << KDevelop::FastMode << "bar() a foo";
     QTest::newRow("simple-complete")
         << "<p>bar() </p><dl><dt class=\"param-name-index-0\">a</dt><dd class=\"param-descr-index-0\"> foo</dd></dl>"
         << KDevelop::CompleteMode << "bar() \na\nfoo";
 }
 
 void TestStringHandler::testStripAnsiSequences()
 {
     QFETCH(QString, input);
     QFETCH(QString, expectedOutput);
 
     const auto output = stripAnsiSequences(input);
     QCOMPARE(output, expectedOutput);
 }
 
 void TestStringHandler::testStripAnsiSequences_data()
 {
     QTest::addColumn<QString>("input");
     QTest::addColumn<QString>("expectedOutput");
 
     QTest::newRow("simple")
         << QStringLiteral("foo bar:")
         << "foo bar:";
-}
\ No newline at end of file
+}
+
+void TestStringHandler::testNormalizeLineEndings()
+{
+    QFETCH(QByteArray, text);
+    QFETCH(QByteArray, expectedOutput);
+
+    normalizeLineEndings(text);
+    QCOMPARE(text, expectedOutput);
+}
+
+void TestStringHandler::testNormalizeLineEndings_data()
+{
+    QTest::addColumn<QByteArray>("text");
+    QTest::addColumn<QByteArray>("expectedOutput");
+
+    QTest::newRow("trivial")
+        << QByteArray("foo\nbar\n")
+        << QByteArray("foo\nbar\n");
+    QTest::newRow("dos")
+        << QByteArray("foo\r\nbar\r\n")
+        << QByteArray("foo\nbar\n");
+    QTest::newRow("macos_classic")
+        << QByteArray("foo\rbar\r")
+        << QByteArray("foo\nbar\n");
+    QTest::newRow("mess")
+        << QByteArray("\r\n\n\r\r\r\n\r")
+        << QByteArray("\n\n\n\n\n\n");
+}
diff --git a/util/tests/test_stringhandler.h b/util/tests/test_stringhandler.h
index 4635fbf38a..24e9139058 100644
--- a/util/tests/test_stringhandler.h
+++ b/util/tests/test_stringhandler.h
@@ -1,39 +1,42 @@
 /*
  * Copyright 2014 Kevin Funk <kfunk@kde.org>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of
  * the License or (at your option) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef TESTSTRINGHANDLER_H
 #define TESTSTRINGHANDLER_H
 
 #include <QObject>
 
 class TestStringHandler : public QObject
 {
     Q_OBJECT
 
 private Q_SLOTS:
     void testHtmlToPlainText();
     void testHtmlToPlainText_data();
 
     void testStripAnsiSequences();
     void testStripAnsiSequences_data();
+
+    void testNormalizeLineEndings();
+    void testNormalizeLineEndings_data();
 };
 
 #endif // TESTSTRINGHANDLER_H