File indexing completed on 2024-04-28 05:41:36

 /*
     This file is part of KCachegrind.
 
     SPDX-FileCopyrightText: 2011-2016 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
 
     SPDX-License-Identifier: GPL-2.0-only
 */
 
 /*
  * Source View
  */
 
 #include "sourceview.h"
 
 #include <QDebug>
 #include <QDir>
 #include <QFile>
 #include <QFileInfo>
 #include <QAction>
 #include <QMenu>
 #include <QScrollBar>
 #include <QHeaderView>
 #include <QKeyEvent>
 
 #include "globalconfig.h"
 #include "sourceitem.h"
 
 
 
 //
 // SourceView
 //
 
 
 SourceView::SourceView(TraceItemView* parentView,
                        QWidget* parent)
     : QTreeWidget(parent), TraceItemView(parentView)
 {
     _inSelectionUpdate = false;
 
     _arrowLevels = 0;
 
     setColumnCount(5);
     setRootIsDecorated(false);
     setAllColumnsShowFocus(true);
     setUniformRowHeights(true);
     // collapsing call/jump lines by double-click is confusing
     setExpandsOnDoubleClick(false);
 
     QStringList headerLabels;
     headerLabels << tr( "#" )
                  << tr( "Cost" )
                  << tr( "Cost 2" )
                  << QString()
                  <<  tr( "Source");
     setHeaderLabels(headerLabels);
 
     // sorting will be enabled after refresh()
     sortByColumn(0, Qt::AscendingOrder);
     header()->setSortIndicatorShown(false);
     this->setItemDelegate(new SourceItemDelegate(this));
     this->setWhatsThis( whatsThis());
 
     connect( this,
              &QTreeWidget::currentItemChanged,
              this, &SourceView::selectedSlot);
 
     setContextMenuPolicy(Qt::CustomContextMenu);
     connect( this,
              &QWidget::customContextMenuRequested,
              this, &SourceView::context);
 
     connect(this,
             &QTreeWidget::itemDoubleClicked,
             this, &SourceView::activatedSlot);
 
     connect(header(), &QHeaderView::sectionClicked,
             this, &SourceView::headerClicked);
 }
 
 QString SourceView::whatsThis() const
 {
     return tr( "<b>Annotated Source</b>"
                "<p>The annotated source list shows the "
                "source lines of the current selected function "
                "together with (self) cost spent while executing the "
                "code of this source line. If there was a call "
                "in a source line, lines with details on the "
                "call happening are inserted into the source: "
                "the cost spent inside of the call, the "
                "number of calls happening, and the call destination.</p>"
                "<p>Select a inserted call information line to "
                "make the destination function current.</p>");
 }
 
 void SourceView::context(const QPoint & p)
 {
     int c = columnAt(p.x());
     QTreeWidgetItem* i = itemAt(p);
     QMenu popup;
 
     TraceLineCall* lc = i ? ((SourceItem*) i)->lineCall() : nullptr;
     TraceLineJump* lj = i ? ((SourceItem*) i)->lineJump() : nullptr;
     TraceFunction* f = lc ? lc->call()->called() : nullptr;
     TraceLine* line = lj ? lj->lineTo() : nullptr;
 
     QAction* activateFunctionAction = nullptr;
     QAction* activateLineAction = nullptr;
     if (f) {
         QString menuText = tr("Go to '%1'").arg(GlobalConfig::shortenSymbol(f->prettyName()));
         activateFunctionAction = popup.addAction(menuText);
         popup.addSeparator();
     }
     else if (line) {
         QString menuText = tr("Go to Line %1").arg(line->name());
         activateLineAction = popup.addAction(menuText);
         popup.addSeparator();
     }
 
     if ((c == 1) || (c == 2)) {
         addEventTypeMenu(&popup);
         popup.addSeparator();
     }
     addGoMenu(&popup);
 
     QAction* a = popup.exec(mapToGlobal(p + QPoint(0,header()->height())));
     if (a == activateFunctionAction)
         TraceItemView::activated(f);
     else if (a == activateLineAction)
         TraceItemView::activated(line);
 }
 
 
 void SourceView::selectedSlot(QTreeWidgetItem *i, QTreeWidgetItem *)
 {
     if (!i) return;
     // programatically selected items are not signalled
     if (_inSelectionUpdate) return;
 
     TraceLineCall* lc = ((SourceItem*) i)->lineCall();
     TraceLineJump* lj = ((SourceItem*) i)->lineJump();
 
     if (!lc && !lj) {
         TraceLine* l = ((SourceItem*) i)->line();
         if (l) {
             _selectedItem = l;
             selected(l);
         }
         return;
     }
 
     TraceFunction* f = lc ? lc->call()->called() : nullptr;
     if (f) {
         _selectedItem = f;
         selected(f);
     }
     else {
         TraceLine* line = lj ? lj->lineTo() : nullptr;
         if (line) {
             _selectedItem = line;
             selected(line);
         }
     }
 }
 
 void SourceView::activatedSlot(QTreeWidgetItem* i, int)
 {
     if (!i) return;
 
     TraceLineCall* lc = ((SourceItem*) i)->lineCall();
     TraceLineJump* lj = ((SourceItem*) i)->lineJump();
 
     if (!lc && !lj) {
         TraceLine* l = ((SourceItem*) i)->line();
         if (l) TraceItemView::activated(l);
         return;
     }
 
     TraceFunction* f = lc ? lc->call()->called() : nullptr;
     if (f) TraceItemView::activated(f);
     else {
         TraceLine* line = lj ? lj->lineTo() : nullptr;
         if (line) TraceItemView::activated(line);
     }
 }
 
 void SourceView::keyPressEvent(QKeyEvent* event)
 {
     QTreeWidgetItem *item = currentItem();
     if (item && ((event->key() == Qt::Key_Return) ||
                  (event->key() == Qt::Key_Space)))
     {
         activatedSlot(item, 0);
     }
     QTreeView::keyPressEvent(event);
 }
 
 CostItem* SourceView::canShow(CostItem* i)
 {
     ProfileContext::Type t = i ? i->type() : ProfileContext::InvalidType;
 
     switch(t) {
     case ProfileContext::Function:
     case ProfileContext::Instr:
     case ProfileContext::Line:
         return i;
 
     default:
         break;
     }
 
     return nullptr;
 }
 
 void SourceView::doUpdate(int changeType, bool)
 {
     // Special case ?
     if (changeType == selectedItemChanged) {
 
         if (!_selectedItem) {
             clearSelection();
             return;
         }
 
         TraceLine* sLine = nullptr;
         if (_selectedItem->type() == ProfileContext::Line)
             sLine = (TraceLine*) _selectedItem;
         if (_selectedItem->type() == ProfileContext::Instr)
             sLine = ((TraceInstr*)_selectedItem)->line();
         if ((_selectedItem->type() != ProfileContext::Function) && (sLine == nullptr))
             return;
 
         QList<QTreeWidgetItem*> items = selectedItems();
         SourceItem* si = (items.count() > 0) ? (SourceItem*)items[0] : nullptr;
         if (si) {
             if (sLine && (si->line() == sLine)) return;
             if (si->lineCall() &&
                 (si->lineCall()->call()->called() == _selectedItem)) return;
         }
 
         QTreeWidgetItem *item, *item2;
         for (int i=0; i<topLevelItemCount(); i++) {
             item = topLevelItem(i);
             si = (SourceItem*)item;
             if (sLine && (si->line() == sLine)) {
                 scrollToItem(item);
                 _inSelectionUpdate = true;
                 setCurrentItem(item);
                 _inSelectionUpdate = false;
                 break;
             }
             bool foundCall = false;
             for (int j=0; j<item->childCount(); j++) {
                 item2 = item->child(j);
                 si = (SourceItem*)item2;
                 if (!si->lineCall()) continue;
                 if (si->lineCall()->call()->called() == _selectedItem) {
                     scrollToItem(item2);
                     _inSelectionUpdate = true;
                     setCurrentItem(item2);
                     _inSelectionUpdate = false;
                     foundCall = true;
                     break;
                 }
             }
             if (foundCall) break;
         }
         return;
     }
 
     if (changeType == groupTypeChanged) {
         // update group colors for call lines
         QTreeWidgetItem *item, *item2;
         for (int i=0; i<topLevelItemCount(); i++) {
             item = topLevelItem(i);
             for (int j=0; i<item->childCount(); i++) {
                 item2 = item->child(j);
                 ((SourceItem*)item2)->updateGroup();
             }
         }
         return;
     }
 
     // On eventTypeChanged, we can not just change the costs shown in
     // already existing items, as costs of 0 should make the line to not
     // be shown at all. So we do a full refresh.
 
     refresh();
 }
 
 void SourceView::refresh()
 {
     int originalPosition = verticalScrollBar()->value();
     clear();
     setColumnWidth(0, 20);
     setColumnWidth(1, 50);
     setColumnHidden(2, (_eventType2 == nullptr));
     setColumnWidth(2, 50);
     // arrows, defaults to invisible
     setColumnHidden(3, true);
     if (_eventType)
         headerItem()->setText(1, _eventType->name());
     if (_eventType2)
         headerItem()->setText(2, _eventType2->name());
 
     _arrowLevels = 0;
     if (!_data || !_activeItem) {
         return;
     }
 
     ProfileContext::Type t = _activeItem->type();
     TraceFunction* f = nullptr;
     if (t == ProfileContext::Function) f = (TraceFunction*) _activeItem;
     if (t == ProfileContext::Instr) {
         f = ((TraceInstr*)_activeItem)->function();
         if (!_selectedItem)
             _selectedItem = ((TraceInstr*)_activeItem)->line();
     }
     if (t == ProfileContext::Line) {
         f = ((TraceLine*)_activeItem)->functionSource()->function();
         if (!_selectedItem) _selectedItem = _activeItem;
     }
 
     if (!f) return;
 
     TraceFunctionSource* mainSF = f->sourceFile();
 
     // skip first source if there is no debug info and there are more sources
     // (this is for a bug in GCC 2.95.x giving unknown source for prologs)
     if (mainSF &&
         (mainSF->firstLineno() == 0) &&
         (mainSF->lastLineno() == 0) &&
         (f->sourceFiles().count()>1) ) {
         // skip
     }
     else
         fillSourceFile(mainSF, 0);
 
     int fileno = 0;
     foreach(TraceFunctionSource* sf, f->sourceFiles()) {
         fileno++;
         if (sf != mainSF)
             fillSourceFile(sf, fileno);
     }
 
     if (!_eventType2) {
 #if QT_VERSION >= 0x050000
         header()->setSectionResizeMode(2, QHeaderView::Interactive);
 #else
         header()->setResizeMode(2, QHeaderView::Interactive);
 #endif
     }
     // reset to the original position - this is useful when the view
     // is refreshed just because we change between relative/absolute
     // FIXME: this overrides scrolling to selected item
     verticalScrollBar()->setValue(originalPosition);
 }
 
 
 /* Helper for fillSourceList:
  * search recursive for a file, starting from a base dir
  * If found, returns true and <dir> is set to the file path.
  */
 static bool searchFileRecursive(QString& dir, const QString& name)
 {
     // we leave this in...
     qDebug("Checking %s/%s", qPrintable(dir), qPrintable(name));
 
     if (QFile::exists(dir + '/' + name)) return true;
 
     // check in subdirectories
     QDir d(dir);
     d.setFilter( QDir::Dirs | QDir::NoSymLinks );
     d.setSorting( QDir::Unsorted );
     QStringList subdirs = d.entryList();
     QStringList::const_iterator it =subdirs.constBegin();
     for(; it != subdirs.constEnd(); ++it ) {
         if (*it == QLatin1Char('.') || *it == QLatin1String("..") || *it == QLatin1String("CVS")) continue;
 
         dir = d.filePath(*it);
         if (searchFileRecursive(dir, name)) return true;
     }
     return false;
 }
 
 /* Search for a source file in different places.
  * If found, returns true and <dir> is set to the file path.
  */
 bool SourceView::searchFile(QString& dir,
                             TraceFunctionSource* sf)
 {
     QString name = sf->file()->shortName();
 
     if (QDir::isAbsolutePath(dir)) {
         if (QFile::exists(dir + '/' + name)) return true;
     }
     else {
         /* Directory is relative. Check
      * - relative to cwd
      * - relative to path of data file
      */
         QString base = QDir::currentPath() + '/' + dir;
         if (QFile::exists(base + '/' + name)) {
             dir = base;
             return true;
         }
 
         TracePart* firstPart = _data->parts().first();
         if (firstPart) {
             QFileInfo partFile(firstPart->name());
             if (QFileInfo(partFile.absolutePath(), name).exists()) {
                 dir = partFile.absolutePath();
                 return true;
             }
         }
     }
 
     QStringList list = GlobalConfig::sourceDirs(_data,
                                                 sf->function()->object());
     QStringList::const_iterator it;
     for ( it = list.constBegin(); it != list.constEnd(); ++it ) {
         dir = *it;
         if (searchFileRecursive(dir, name)) return true;
     }
 
     return false;
 }
 
 
 void SourceView::updateJumpArray(uint lineno, SourceItem* si,
                                  bool ignoreFrom, bool ignoreTo)
 {
     uint lowLineno, highLineno;
     int iEnd = -1, iStart = -1;
 
     if (0) qDebug("updateJumpArray(line %d, jump to %s)",
                   lineno,
                   si->lineJump()
                   ? qPrintable(si->lineJump()->lineTo()->name()) : "?" );
 
     while(_lowListIter != _lowList.end()) {
         TraceLineJump* lj= *_lowListIter;
         lowLineno = lj->lineFrom()->lineno();
         if (lj->lineTo()->lineno() < lowLineno)
             lowLineno = lj->lineTo()->lineno();
 
         if (lowLineno > lineno) break;
 
         if (ignoreFrom && (lowLineno < lj->lineTo()->lineno())) break;
         if (ignoreTo && (lowLineno < lj->lineFrom()->lineno())) break;
 
         if (si->lineJump() && (lj != si->lineJump())) break;
 
         int asize = (int)_jump.size();
 #if 0
         for(iStart=0;iStart<asize;iStart++)
             if (_jump[iStart] &&
                 (_jump[iStart]->lineTo() == lj->lineTo())) break;
 #else
         iStart = asize;
 #endif
 
         if (iStart == asize) {
             for(iStart=0; iStart<asize; ++iStart)
                 if (_jump[iStart] == nullptr) break;
 
             if (iStart== asize) {
                 asize++;
                 _jump.resize(asize);
                 if (asize > _arrowLevels) _arrowLevels = asize;
             }
 
             if (0) qDebug(" start %d (%s to %s)",
                           iStart,
                           qPrintable(lj->lineFrom()->name()),
                           qPrintable(lj->lineTo()->name()));
 
             _jump[iStart] = lj;
         }
         _lowListIter++;
     }
 
     si->setJumpArray(_jump);
 
     while(_highListIter != _highList.end()) {
         TraceLineJump* lj= *_highListIter;
         highLineno = lj->lineFrom()->lineno();
         if (lj->lineTo()->lineno() > highLineno) {
             highLineno = lj->lineTo()->lineno();
             if (ignoreTo) break;
         }
         else if (ignoreFrom) break;
 
         if (highLineno > lineno) break;
 
         for(iEnd=0; iEnd< (int)_jump.size(); ++iEnd)
             if (_jump[iEnd] == lj) break;
         if (iEnd == (int)_jump.size()) {
             qDebug("LineView: no jump start for end at %x ?", highLineno);
             iEnd = -1;
         }
 
         if (0 && (iEnd>=0))
             qDebug(" end %d (%s to %s)",
                    iEnd,
                    qPrintable(_jump[iEnd]->lineFrom()->name()),
                    qPrintable(_jump[iEnd]->lineTo()->name()));
 
         if (0 && lj) qDebug("next end: %s to %s",
                             qPrintable(lj->lineFrom()->name()),
                             qPrintable(lj->lineTo()->name()));
 
         _highListIter++;
 
         if (highLineno > lineno)
             break;
         else {
             if (iEnd>=0) _jump[iEnd] = nullptr;
             iEnd = -1;
         }
     }
     if (iEnd>=0) _jump[iEnd] = nullptr;
 }
 
 
 // compare functions for jump arrow drawing
 
 void getJumpLines(const TraceLineJump* jump, uint& low, uint& high)
 {
     low  = jump->lineFrom()->lineno();
     high = jump->lineTo()->lineno();
 
     if (low > high) {
         uint t = low;
         low = high;
         high = t;
     }
 }
 
 // sort jumps according to lower line number
 bool lineJumpLowLessThan(const TraceLineJump* jump1,
                          const TraceLineJump* jump2)
 {
     uint line1Low, line1High, line2Low, line2High;
 
     getJumpLines(jump1, line1Low, line1High);
     getJumpLines(jump2, line2Low, line2High);
 
     if (line1Low != line2Low) return (line1Low < line2Low);
     // jump ends come before jump starts
     bool low1IsEnd = (line1Low == jump1->lineTo()->lineno());
     bool low2IsEnd = (line2Low == jump2->lineTo()->lineno());
     if (low1IsEnd && !low2IsEnd) return true;
     if (low2IsEnd && !low1IsEnd) return false;
     // both the low line of jump 1 and 2 are end or start
     return (line1High < line2High);
 }
 
 // sort jumps according to higher line number
 bool lineJumpHighLessThan(const TraceLineJump* jump1,
                           const TraceLineJump* jump2)
 {
     uint line1Low, line1High, line2Low, line2High;
 
     getJumpLines(jump1, line1Low, line1High);
     getJumpLines(jump2, line2Low, line2High);
 
     if (line1High != line2High) return (line1High < line2High);
     // jump ends come before jump starts
     bool high1IsEnd = (line1High == jump1->lineTo()->lineno());
     bool high2IsEnd = (line2High == jump2->lineTo()->lineno());
     if (high1IsEnd && !high2IsEnd) return true;
     if (high2IsEnd && !high1IsEnd) return false;
     // both the high line of jump 1 and 2 are end or start
     return (line1Low < line2Low);
 }
 
 /* If sourceList is empty we set the source file name into the header,
  * else this code is of a inlined function, and we add "inlined from..."
  */
 void SourceView::fillSourceFile(TraceFunctionSource* sf, int fileno)
 {
     if (!sf) return;
 
     if (0) qDebug("Selected Item %s",
                   _selectedItem ? qPrintable(_selectedItem->name()) : "(none)");
 
     TraceLineMap::Iterator lineIt, lineItEnd;
     int nextCostLineno = 0, lastCostLineno = 0;
 
     bool validSourceFile = (!sf->file()->name().isEmpty());
 
     TraceLine* sLine = nullptr;
     if (_selectedItem) {
         if (_selectedItem->type() == ProfileContext::Line)
             sLine = (TraceLine*) _selectedItem;
         if (_selectedItem->type() == ProfileContext::Instr)
             sLine = ((TraceInstr*)_selectedItem)->line();
     }
 
     if (validSourceFile) {
         TraceLineMap* lineMap = sf->lineMap();
         if (lineMap) {
             lineIt    = lineMap->begin();
             lineItEnd = lineMap->end();
             // get first line with cost of selected type
             while(lineIt != lineItEnd) {
                 if (&(*lineIt) == sLine) break;
                 if ((*lineIt).hasCost(_eventType)) break;
                 if (_eventType2 && (*lineIt).hasCost(_eventType2)) break;
                 ++lineIt;
             }
 
             nextCostLineno     = (lineIt == lineItEnd) ? 0 : (*lineIt).lineno();
             if (nextCostLineno<0) {
                 qDebug() << "SourceView::fillSourceFile: Negative line number "
                          << nextCostLineno;
                 qDebug() << "  Function '" << sf->function()->name() << "'";
                 qDebug() << "  File '" << sf->file()->name() << "'";
                 nextCostLineno = 0;
             }
 
         }
 
         if (nextCostLineno == 0) {
             new SourceItem(this, this, fileno, 1, false,
                            tr("There is no cost of current selected type associated"));
             new SourceItem(this, this, fileno, 2, false,
                            tr("with any source line of this function in file"));
             new SourceItem(this, this, fileno, 3, false,
                            QStringLiteral("    '%1'").arg(sf->file()->prettyName()));
             new SourceItem(this, this, fileno, 4, false,
                            tr("Thus, no annotated source can be shown."));
             return;
         }
     }
 
     QString filename = sf->file()->shortName();
     QString dir = sf->file()->directory();
     if (!dir.isEmpty())
         filename = dir + '/' + filename;
 
     if (nextCostLineno>0) {
         // we have debug info... search for source file
         if (searchFile(dir, sf)) {
             filename = dir + '/' + sf->file()->shortName();
             // no need to search again
             sf->file()->setDirectory(dir);
         }
         else
             nextCostLineno = 0;
     }
 
     // do it here, because the source directory could have been set before
     if (topLevelItemCount()==0) {
         if (validSourceFile && (nextCostLineno != 0))
             new SourceItem(this, this, fileno, 0, true,
                            tr("--- From '%1' ---").arg(filename));
     }
     else {
         new SourceItem(this, this, fileno, 0, true,
                        validSourceFile ?
                            tr("--- Inlined from '%1' ---").arg(filename) :
                            tr("--- Inlined from unknown source ---"));
     }
 
     if (nextCostLineno == 0) {
         new SourceItem(this, this, fileno, 1, false,
                        tr("There is no source available for the following function:"));
         new SourceItem(this, this, fileno, 2, false,
                        QStringLiteral("    '%1'").arg(sf->function()->prettyName()));
         if (sf->file()->name().isEmpty()) {
             new SourceItem(this, this, fileno, 3, false,
                            tr("This is because no debug information is present."));
             new SourceItem(this, this, fileno, 4, false,
                            tr("Recompile source and redo the profile run."));
             if (sf->function()->object()) {
                 new SourceItem(this, this, fileno, 5, false,
                                tr("The function is located in this ELF object:"));
                 new SourceItem(this, this, fileno, 6, false,
                                QStringLiteral("    '%1'")
                                .arg(sf->function()->object()->prettyName()));
             }
         }
         else {
             new SourceItem(this, this, fileno, 3, false,
                            tr("This is because its source file cannot be found:"));
             new SourceItem(this, this, fileno, 4, false,
                            QStringLiteral("    '%1'").arg(sf->file()->name()));
             new SourceItem(this, this, fileno, 5, false,
                            tr("Add the folder of this file to the source folder list."));
             new SourceItem(this, this, fileno, 6, false,
                            tr("The list can be found in the configuration dialog."));
         }
         return;
     }
 
     // initialisation for arrow drawing
     // create sorted list of jumps (for jump arrows)
     TraceLineMap::Iterator it = lineIt, nextIt;
     _lowList.clear();
     _highList.clear();
     while(1) {
 
         nextIt = it;
         ++nextIt;
         while(nextIt != lineItEnd) {
             if (&(*nextIt) == sLine) break;
             if ((*nextIt).hasCost(_eventType)) break;
             if (_eventType2 && (*nextIt).hasCost(_eventType2)) break;
             ++nextIt;
         }
 
         TraceLineJumpList jlist = (*it).lineJumps();
         foreach(TraceLineJump* lj, jlist) {
             if (lj->executedCount()==0) continue;
             // skip jumps to next source line with cost
             //if (lj->lineTo() == &(*nextIt)) continue;
 
             _lowList.append(lj);
             _highList.append(lj);
         }
         it = nextIt;
         if (it == lineItEnd) break;
     }
     std::sort(_lowList.begin(), _lowList.end(), lineJumpLowLessThan);
     std::sort(_highList.begin(), _highList.end(), lineJumpHighLessThan);
     _lowListIter = _lowList.begin(); // iterators to list start
     _highListIter = _highList.begin();
     _jump.resize(0);
 
     char buf[160];
     bool inside = false, skipLineWritten = true;
     int readBytes;
     int fileLineno = 0;
     SubCost most = 0;
 
     QList<QTreeWidgetItem*> items;
     TraceLine* currLine;
     SourceItem *si, *si2, *item = nullptr, *first = nullptr, *selected = nullptr;
     QFile file(filename);
     bool fileEndReached = false;
     if (!file.open(QIODevice::ReadOnly)) return;
     while (1) {
         readBytes=file.readLine(buf, sizeof( buf ));
         if (readBytes<=0) {
             // for nice empty 4 lines after function with EOF
             buf[0] = 0;
             if (readBytes<0) fileEndReached = true;
         }
 
         if ((readBytes >0) && (buf[readBytes-1] != '\n')) {
             /* Something was read but not ending in newline. I.e.
          * - buffer was not big enough: discard rest of line, add "..."
          * - this is last line of file, not ending in newline
          * NB: checking for '\n' is enough for all systems.
          */
             int r;
             char buf2[32];
             bool somethingRead = false;
             while(1) {
                 r = file.readLine(buf2, sizeof(buf2));
                 if ((r<=0) || (buf2[r-1] == '\n')) break;
                 somethingRead = true;
             }
             if (somethingRead) {
                 // add dots as sign that we truncated the line
                 Q_ASSERT(readBytes>3);
                 buf[readBytes-1] = buf[readBytes-2] = buf[readBytes-3] = '.';
             }
         }
         else if ((readBytes>0) && (buf[readBytes-1] == '\n'))
             buf[readBytes-1] = 0;
 
 
         // keep fileLineno inside [lastCostLineno;nextCostLineno]
         fileLineno++;
         if (fileLineno == nextCostLineno) {
             currLine = &(*lineIt);
 
             // get next line with cost of selected type
             ++lineIt;
             while(lineIt != lineItEnd) {
                 if (&(*lineIt) == sLine) break;
                 if ((*lineIt).hasCost(_eventType)) break;
                 if (_eventType2 && (*lineIt).hasCost(_eventType2)) break;
                 ++lineIt;
             }
 
             lastCostLineno = nextCostLineno;
             nextCostLineno = (lineIt == lineItEnd) ? 0 : (*lineIt).lineno();
         }
         else
             currLine = nullptr;
 
         // update inside
         if (!inside) {
             if (currLine) inside = true;
         }
         else {
             if ( (fileLineno > lastCostLineno) &&
                  ((nextCostLineno == 0) ||
                   (fileLineno < nextCostLineno - GlobalConfig::noCostInside()) ))
                 inside = false;
         }
 
         int context = GlobalConfig::context();
 
         if ( ((lastCostLineno==0) || (fileLineno > lastCostLineno + context)) &&
              ((nextCostLineno==0) || (fileLineno < nextCostLineno - context))) {
             if ((lineIt == lineItEnd) || fileEndReached) break;
 
             if (!skipLineWritten) {
                 skipLineWritten = true;
                 // a "skipping" line: print "..." instead of a line number
                 strcpy(buf,"...");
             }
             else
                 continue;
         }
         else
             skipLineWritten = false;
 
         QString s = QString(buf);
         if(s.size() > 0 && s.at(s.length()-1) == '\r')
             s = s.left(s.length()-1);
         si = new SourceItem(this, nullptr,
                             fileno, fileLineno, inside, s,
                             currLine);
         items.append(si);
 
         if (!currLine) continue;
 
         if (!selected && (currLine == sLine)) selected = si;
         if (!first) first = si;
 
         if (currLine->subCost(_eventType) > most) {
             item = si;
             most = currLine->subCost(_eventType);
         }
 
         si->setExpanded(true);
         foreach(TraceLineCall* lc,  currLine->lineCalls()) {
             if ((lc->subCost(_eventType)==0) &&
                 (lc->subCost(_eventType2)==0)) continue;
 
             if (lc->subCost(_eventType) > most) {
                 item = si;
                 most = lc->subCost(_eventType);
             }
 
             si2 = new SourceItem(this, si, fileno, fileLineno, currLine, lc);
 
             if (!selected && (lc->call()->called() == _selectedItem))
                 selected = si2;
         }
 
         foreach(TraceLineJump* lj, currLine->lineJumps()) {
             if (lj->executedCount()==0) continue;
 
             new SourceItem(this, si, fileno, fileLineno, currLine, lj);
         }
     }
 
     file.close();
 
     // Resize column 0 (line number) and 1/2 (cost) to contents
 #if QT_VERSION >= 0x050000
     header()->setSectionResizeMode(0, QHeaderView::ResizeToContents);
     header()->setSectionResizeMode(1, QHeaderView::ResizeToContents);
     header()->setSectionResizeMode(2, QHeaderView::ResizeToContents);
 #else
     header()->setResizeMode(0, QHeaderView::ResizeToContents);
     header()->setResizeMode(1, QHeaderView::ResizeToContents);
     header()->setResizeMode(2, QHeaderView::ResizeToContents);
 #endif
 
     setSortingEnabled(false);
     addTopLevelItems(items);
     this->expandAll();
     setSortingEnabled(true);
     // always reset to line number sort
     sortByColumn(0, Qt::AscendingOrder);
     header()->setSortIndicatorShown(false);
 
     // Reallow interactive column size change after resizing to content
 #if QT_VERSION >= 0x050000
     header()->setSectionResizeMode(0, QHeaderView::Interactive);
     header()->setSectionResizeMode(1, QHeaderView::Interactive);
     header()->setSectionResizeMode(2, QHeaderView::Interactive);
 #else
     header()->setResizeMode(0, QHeaderView::Interactive);
     header()->setResizeMode(1, QHeaderView::Interactive);
     header()->setResizeMode(2, QHeaderView::Interactive);
 #endif
 
     if (selected) item = selected;
     if (item) first = item;
     if (first) {
         scrollToItem(first);
         _inSelectionUpdate = true;
         setCurrentItem(first);
         _inSelectionUpdate = false;
     }
 
     // for arrows: go down the list according to list sorting
     QTreeWidgetItem *item1, *item2;
     for (int i=0; i<topLevelItemCount(); i++) {
         item1 = topLevelItem(i);
         si = (SourceItem*)item1;
         updateJumpArray(si->lineno(), si, true, false);
 
         for (int j=0; j<item1->childCount(); j++) {
             item2 = item1->child(j);
             si2 = (SourceItem*)item2;
             if (si2->lineJump())
                 updateJumpArray(si->lineno(), si2, false, true);
             else
                 si2->setJumpArray(_jump);
         }
     }
 
     if (arrowLevels()) {
         //fix this: setColumnWidth(3, 10 + 6*arrowLevels() + itemMargin() * 2);
         setColumnWidth(3, 10 + 6*arrowLevels() + 2);
         setColumnHidden(3, false);
     }
     else
         setColumnHidden(3, true);
 }
 
 
 void SourceView::headerClicked(int col)
 {
     if (col == 0) {
         sortByColumn(col, Qt::AscendingOrder);
     }
     //All others but Source Text column Descending
     else if (col !=4) {
         sortByColumn(col, Qt::DescendingOrder);
     }
 }
 
 #include "moc_sourceview.cpp"