File indexing completed on 2024-05-19 15:42:36

 /*
     SPDX-FileCopyrightText: 2012 Sven Brauch svenbrauch @googlemail.com
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "codehelpers.h"
 #include <QStack>
 
 namespace Python {
     
 
 FileIndentInformation::FileIndentInformation(const QStringList& lines)
 {
     initialize(lines);
 }
 
 void FileIndentInformation::initialize(const QStringList& lines)
 {
     m_indents.clear();
     for ( int atLine = 0; atLine < lines.length(); atLine++ ) {
         const QString& currentLine = lines.at(atLine);
         const int currentLength = currentLine.length();
         bool lineIsEmpty = true;
         for ( int indent = 0; indent < currentLength; indent++ ) {
             if ( ! currentLine.at(indent).isSpace() ) {
                 m_indents.append(indent);
                 lineIsEmpty = false;
                 break;
             }
         }
         if ( lineIsEmpty ) {
             m_indents.append(currentLine.length());
         }
     }
 }
 
 FileIndentInformation::FileIndentInformation(const QString& data)
 {
     initialize(data.split('\n'));
 }
 
 FileIndentInformation::FileIndentInformation(const QByteArray& data)
 {
     initialize(QString(data.data()).split('\n'));
 }
 
 FileIndentInformation::FileIndentInformation(KTextEditor::Document* document)
 {
     QStringList lines;
     for ( int i = 0; i < document->lines(); i++ ) {
         lines << document->line(i);
     }
     initialize(lines);
 }
 
 int FileIndentInformation::indentForLine(int line) const
 {
     return m_indents.at(line);
 }
 
 int FileIndentInformation::linesCount() const
 {
     return m_indents.length();
 }
 
 int FileIndentInformation::nextChange(int line, ChangeTypes type, ScanDirection direction) const
 {
     line = qMin(line, m_indents.length() - 1);
     line = qMax(line, 0);
     const int currentIndent = m_indents.at(line);
     const int length = m_indents.length();
     const char scandir = direction == Forward ? 1 : -1;
     int atIndent = 0;
     do {
         if ( line >= length - 1 || line < 0 ) {
            break;
         }
         line += scandir;
         atIndent = m_indents.at(line);
     } while ( type == Indent ? atIndent <= currentIndent :
               type == Dedent ? atIndent >= currentIndent :
                                atIndent == currentIndent );
     return line;
 }
 
 CodeHelpers::CodeHelpers()
 {
     
 }
 
 CodeHelpers::EndLocation CodeHelpers::endsInside(const QString &code)
 {
     bool insideSingleLineComment = false;
     QStringList stringDelimiters;
     stringDelimiters << "\"\"\"" << "\'\'\'" << "'" << "\"";
     QStack<QString> stringStack;
     const int max_len = code.length();
     for ( int atChar = 0; atChar < max_len; atChar++ ) {
         const QChar c = code.at(atChar);
         if ( c == ' ' || c.isLetterOrNumber() ) {
             continue;
         }
         if ( stringStack.isEmpty() && c == '#' ) {
             insideSingleLineComment = true;
             continue;
         }
         if ( c == '\n' ) {
             insideSingleLineComment = false;
             continue;
         }
         if ( insideSingleLineComment ) {
             // don't count string delimiters in a comment line
             continue;
         }
         if ( c != '"' && c != '\'' && c != '\\' ) {
             continue;
         }
         QStringRef t;
         if ( max_len - atChar > 2 ) {
             t = code.midRef(atChar, 3);
         }
         foreach ( const QString& check, stringDelimiters ) {
             if ( t != check && ! ( check.size() == 1 && c == check.at(0) ) ) {
                 continue;
             }
             if ( stringStack.isEmpty() ) {
                 stringStack.push(check);
                 atChar += check.length() - 1;
                 break;
             }
             else if ( stringStack.top() == check ) {
                 stringStack.pop();
                 atChar += check.length() - 1;
                 break;
             }
         }
         if ( c == '\\' ) {
             atChar ++;
             continue;
         }
     }
 
     if ( ! stringStack.isEmpty() ) {
         return String;
     }
     else if ( insideSingleLineComment ) {
         return Comment;
     }
 
     return Code;
 }
 
 QString CodeHelpers::killStrings(QString stringWithStrings)
 {
     QRegExp replaceStrings("(\".*\"|\'.*\'|\"\"\".*\"\"\"|\'\'\'.*\'\'\')");
     replaceStrings.setMinimal(true);
     QString stripped = stringWithStrings.replace(replaceStrings, "\"S\"");
     return stripped;
 }
 
 QString CodeHelpers::expressionUnderCursor(Python::LazyLineFetcher& lineFetcher, KTextEditor::Cursor cursor,
                                            KTextEditor::Cursor& startCursor, bool forceScanExpression)
 {
     startCursor = cursor;
     QString line = lineFetcher.fetchLine(cursor.line());
     int index = cursor.column();
     QChar c = line[index];
     
     int end = index;
     // This flag is used by codecompletion (in contrast to the debugger)
     if ( ! forceScanExpression ) {
         if ( ! c.isLetterOrNumber() && c != '_' ) {
             return QString();
         }
     }
     for (; end < line.size(); ++end)
     {
         QChar c = line[end];
         if ( ! ( c.isLetterOrNumber() || c == '_' ) ) {
             if ( ! forceScanExpression ) end--;
             break;
         }
     }
     int start = index;
     QStringList openingBrackets = QStringList() << "(" << "[" << "{" << "\"" << "'";
     QStringList closingBrackets = QStringList() << ")" << "]" << "}" << "\"" << "'";
     QStringList sliceChars = QStringList() << "." << "(" << "["; // chars which are allowed to be preceded by a space
     QStringList seperatorChars = QStringList() << "," << "=" << ":" << "*" << "-" << "+" << "/" << "%" << "^" << "~";
     QStack<QString> brackets;
     bool lastWasSlice = false;
     int linesFetched = 1;
     QString text;
     bool done = false;
     while ( start != 0 ) {
         while ( start >= 0 ) {
             QChar c = line[start];
             int bracket = closingBrackets.indexOf(c);
             if ( ! brackets.isEmpty() && brackets.top() == c ) {
                 brackets.pop();
             }
             else if ( bracket != -1 ) {
                 brackets.push(openingBrackets.at(bracket));
             }
             else if ( openingBrackets.contains(c) ) {
                 start += 1;
                 done = true;
                 break;
             }
             
             if ( brackets.isEmpty() && ( (c.isSpace() && ! lastWasSlice) || seperatorChars.contains(c) ) ) {
                 done = true;
                 start += 1;
                 break;
             }
             
             if ( sliceChars.contains(c) ) {
                 lastWasSlice = true;
             }
             else {
                 lastWasSlice = false;
             }
             start--;
         }
         if ( done ) {
             break;
         }
         if ( cursor.line() < linesFetched ) {
             break;
         }
         if ( brackets.isEmpty() && ! lineFetcher.fetchLine(cursor.line() - linesFetched).trimmed().endsWith('\\') ) {
             // break at newline without previous backslash
             break;
         }
         // store this line for multi-line expressions
         if ( linesFetched != 1 ) {
             text.prepend(line);
         }
         else {
             text.prepend(line.mid(0, end));
         }
         line.clear();
         while ( line.isEmpty() && cursor.line() >= linesFetched ) {
             line = lineFetcher.fetchLine(cursor.line() - linesFetched);
             linesFetched++;
             start = line.length() - 1;
         }
     }
     start = qMax(0, start);
     QString linePart;
     if ( start > end ) {
         linePart = QString();
     }
     else {
         linePart = line.mid(start, end-start + 1);
         startCursor.setColumn(start);
     }
 
     QString expression(linePart + text);
     expression = expression.trimmed();
     return expression;
 }
 
 QString CodeHelpers::extractStringUnderCursor(const QString &code, KTextEditor::Range range, KTextEditor::Cursor cursor, int *cursorPositionInString = nullptr)
 {
     QPair<QString, QString> beforeAndAfter = splitCodeByCursor(code, range, cursor);
 
     // TODO is this even necessary?
     if ( endsInside(beforeAndAfter.first) != String ) {
         return QString();
     }
 
     QStringList quoteCharacters = QStringList() << "\"" << "'";
 
     // using a stack is probably overkill for this...
     QStack<QString> quotes;
     QString string;
 
     int start = beforeAndAfter.first.size() - 1;
 
 
     while ( start >= 0 ) {
         QChar c = beforeAndAfter.first.at(start);
         int quote = quoteCharacters.indexOf(c);
 
         // if we've found a quote character and we're either at the beginning of the code or the previous char is not a backslash
         if ( quote != -1 && (start == 0 || (start != 0 && beforeAndAfter.first.at(start - 1) != '\\')) ) {
             if ( endsInside(beforeAndAfter.first.left(start)) != String ) {
                 quotes.push(quoteCharacters.at(quote));
                 break;
             }
         }
 
         start--;
     }
 
     int end = start + 1;
 
     while ( ! quotes.isEmpty() && end < beforeAndAfter.first.size() + beforeAndAfter.second.size() ) {
         QChar c;
         if (end < beforeAndAfter.first.size()) {
             c = beforeAndAfter.first.at(end);
         }
         else {
             c = beforeAndAfter.second.at(end - beforeAndAfter.first.size());
         }
 
         if (c == '\\') {
             end += 2;
         }
 
         if ( quotes.top() == c ) {
             quotes.pop();
         }
 
         end++;
     }
 
     string = code.mid(start, end - start);
 
     if ( cursorPositionInString ) {
         *cursorPositionInString = beforeAndAfter.first.size() - start;
     }
 
     return string;
 }
 
 QPair<QString, QString> CodeHelpers::splitCodeByCursor(const QString &code, KTextEditor::Range range, KTextEditor::Cursor cursor)
 {
     QStringList lines = code.split('\n');
 
     int position = 0;
     bool firstRow = true;
     int startColumn = range.start().column();
     int endColumn;
     for ( int row = range.start().line(), i = 0; row <= cursor.line(); row++, i++ ) {
         if ( row != cursor.line() ) {
             if ( i >= lines.size() ) {
                 // something went wrong with the context ranges
                 break;
             }
             endColumn = lines.at(i).size();
         }
         else {
             endColumn = cursor.column();
         }
 
         position += endColumn - startColumn + 1;
 
         if ( firstRow ) {
             startColumn = 0;
             firstRow = false;
         }
     }
 
     QString before(code.mid(0, position - 1));
     QString after(code.mid(position - 1, code.size() - position + 1));
 
     return QPair<QString, QString>(before, after);
 }
 
 }