diff --git a/analyzers/cppcheck/parser.cpp b/analyzers/cppcheck/parser.cpp index f20245c7a4..8ae2a72d39 100644 --- a/analyzers/cppcheck/parser.cpp +++ b/analyzers/cppcheck/parser.cpp @@ -1,307 +1,307 @@ /* This file is part of KDevelop Copyright 2013 Christoph Thielecke Copyright 2016 Anton Anikin 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) 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; see the file COPYING. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include "parser.h" #include "debug.h" #include #include #include #include #include #include namespace cppcheck { /** * Convert the value of \ attribute of \ element from cppcheck's * XML-output to 'good-looking' HTML-version. This is necessary because the * displaying of the original message is performed without line breaks - such * tooltips are uncomfortable to read, and large messages will not fit into the * screen. * * This function put the original message into \ tag that automatically * provides line wrapping by builtin capabilities of Qt library. The source text * also can contain tokens '\012' (line break) - they are present in the case of * source code examples. In such cases, the entire text between the first and * last tokens (i.e. source code) is placed into \ tag. * * @param[in] input the original value of \ attribute * @return HTML version for displaying in problem's tooltip */ QString verboseMessageToHtml( const QString & input ) { QString output(QStringLiteral("%1").arg(input.toHtmlEscaped())); output.replace(QLatin1String("\\012"), QLatin1String("\n")); if (output.count('\n') >= 2) { - output.replace(output.indexOf('\n'), 1, QLatin1String("

") );
-        output.replace(output.lastIndexOf('\n'), 1, QLatin1String("

") ); + output.replace(output.indexOf('\n'), 1, QStringLiteral("

") );
+        output.replace(output.lastIndexOf('\n'), 1, QStringLiteral("

") ); } return output; } CppcheckParser::CppcheckParser() : m_errorInconclusive(false) { } CppcheckParser::~CppcheckParser() { } void CppcheckParser::clear() { m_stateStack.clear(); } bool CppcheckParser::startElement() { State newState = Unknown; qCDebug(KDEV_CPPCHECK) << "CppcheckParser::startElement: elem: " << qPrintable(name().toString()); if (name() == "results") { newState = Results; } else if (name() == "cppcheck") { newState = CppCheck; } else if (name() == "errors") { newState = Errors; } else if (name() == "location") { newState = Location; if (attributes().hasAttribute(QStringLiteral("file")) && attributes().hasAttribute(QStringLiteral("line"))) { QString errorFile = attributes().value(QStringLiteral("file")).toString(); // Usually when "file0" attribute exists it associated with source and // attribute "file" associated with header). // But sometimes cppcheck produces errors with "file" and "file0" attributes // both associated with same *source* file. In such cases attribute "file" contains // only file name, without full path. Therefore we should use "file0" instead "file". if (!QFile::exists(errorFile) && attributes().hasAttribute(QStringLiteral("file0"))) { errorFile = attributes().value(QStringLiteral("file0")).toString(); } m_errorFiles += errorFile; m_errorLines += attributes().value(QStringLiteral("line")).toString().toInt(); } } else if (name() == "error") { newState = Error; - m_errorSeverity = QLatin1String("unknown"); + m_errorSeverity = QStringLiteral("unknown"); m_errorInconclusive = false; m_errorFiles.clear(); m_errorLines.clear(); m_errorMessage.clear(); m_errorVerboseMessage.clear(); if (attributes().hasAttribute(QStringLiteral("msg"))) { m_errorMessage = attributes().value(QStringLiteral("msg")).toString(); } if (attributes().hasAttribute(QStringLiteral("verbose"))) { m_errorVerboseMessage = verboseMessageToHtml(attributes().value(QStringLiteral("verbose")).toString()); } if (attributes().hasAttribute(QStringLiteral("severity"))) { m_errorSeverity = attributes().value(QStringLiteral("severity")).toString(); } if (attributes().hasAttribute(QStringLiteral("inconclusive"))) { m_errorInconclusive = true; } } else { m_stateStack.push(m_stateStack.top()); return true; } m_stateStack.push(newState); return true; } bool CppcheckParser::endElement(QVector& problems) { qCDebug(KDEV_CPPCHECK) << "CppcheckParser::endElement: elem: " << qPrintable(name().toString()); State state = m_stateStack.pop(); switch (state) { case CppCheck: if (attributes().hasAttribute(QStringLiteral("version"))) { qCDebug(KDEV_CPPCHECK) << "Cppcheck report version: " << attributes().value(QStringLiteral("version")); } break; case Errors: // errors finished break; case Error: qCDebug(KDEV_CPPCHECK) << "CppcheckParser::endElement: new error elem: line: " << (m_errorLines.isEmpty() ? QStringLiteral("?") : QString::number(m_errorLines.first())) << " at " << (m_errorFiles.isEmpty() ? QStringLiteral("?") : m_errorFiles.first()) << ", msg: " << m_errorMessage; storeError(problems); break; case Results: // results finished break; case Location: break; default: break; } return true; } QVector CppcheckParser::parse() { QVector problems; qCDebug(KDEV_CPPCHECK) << "CppcheckParser::parse!"; while (!atEnd()) { int readNextVal = readNext(); switch (readNextVal) { case StartDocument: clear(); break; case StartElement: startElement(); break; case EndElement: endElement(problems); break; case Characters: break; default: qCDebug(KDEV_CPPCHECK) << "CppcheckParser::startElement: case: " << readNextVal; break; } } qCDebug(KDEV_CPPCHECK) << "CppcheckParser::parse: end"; if (hasError()) { switch (error()) { case CustomError: case UnexpectedElementError: case NotWellFormedError: KMessageBox::error( qApp->activeWindow(), i18n("Cppcheck XML Parsing: error at line %1, column %2: %3", lineNumber(), columnNumber(), errorString()), i18n("Cppcheck Error")); break; case NoError: case PrematureEndOfDocumentError: break; } } return problems; } void CppcheckParser::storeError(QVector& problems) { // Construct problem with using first location element KDevelop::IProblem::Ptr problem = getProblem(); // Adds other elements as diagnostics. // This allows the user to track the problem. for (int locationIdx = 1; locationIdx < m_errorFiles.size(); ++locationIdx) { problem->addDiagnostic(getProblem(locationIdx)); } problems.push_back(problem); } KDevelop::IProblem::Ptr CppcheckParser::getProblem(int locationIdx) const { KDevelop::IProblem::Ptr problem(new KDevelop::DetectedProblem(i18n("Cppcheck"))); QStringList messagePrefix; QString errorMessage(m_errorMessage); if (m_errorSeverity == QLatin1String("error")) { problem->setSeverity(KDevelop::IProblem::Error); } else if (m_errorSeverity == QLatin1String("warning")) { problem->setSeverity(KDevelop::IProblem::Warning); } else { problem->setSeverity(KDevelop::IProblem::Hint); messagePrefix.push_back(m_errorSeverity); } if (m_errorInconclusive) { messagePrefix.push_back(QStringLiteral("inconclusive")); } if (!messagePrefix.isEmpty()) { errorMessage = QStringLiteral("(%1) %2").arg(messagePrefix.join(QStringLiteral(", "))).arg(m_errorMessage); } problem->setDescription(errorMessage); problem->setExplanation(m_errorVerboseMessage); KDevelop::DocumentRange range; if (locationIdx < 0 || locationIdx >= m_errorFiles.size()) { range = KDevelop::DocumentRange::invalid(); } else { range.document = KDevelop::IndexedString(m_errorFiles.at(locationIdx)); range.setBothLines(m_errorLines.at(locationIdx) - 1); range.setBothColumns(0); } problem->setFinalLocation(range); problem->setFinalLocationMode(KDevelop::IProblem::TrimmedLine); return problem; } } diff --git a/debuggers/common/mi/micommand.cpp b/debuggers/common/mi/micommand.cpp index a372d350f3..b7611e2fef 100644 --- a/debuggers/common/mi/micommand.cpp +++ b/debuggers/common/mi/micommand.cpp @@ -1,489 +1,489 @@ /*************************************************************************** begin : Sun Aug 8 1999 copyright : (C) 1999 by John Birch email : jbb@kdevelop.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) any later version. * * * ***************************************************************************/ #include "micommand.h" #include using namespace KDevMI::MI; FunctionCommandHandler::FunctionCommandHandler(const FunctionCommandHandler::Function& callback, CommandFlags flags) : _flags(flags) , _callback(callback) { } bool FunctionCommandHandler::handlesError() { return _flags & CmdHandlesError; } void FunctionCommandHandler::handle(const ResultRecord& r) { _callback(r); } MICommand::MICommand(CommandType type, const QString& command, CommandFlags flags) : type_(type) , flags_(flags) , command_(command) , commandHandler_(nullptr) , stateReloading_(false) , m_thread(-1) , m_frame(-1) { } MICommand::~MICommand() { if (commandHandler_ && commandHandler_->autoDelete()) { delete commandHandler_; } commandHandler_ = nullptr; } QString MICommand::cmdToSend() { return initialString() + '\n'; } QString MICommand::initialString() const { QString result = QString::number(token()); if (type() == NonMI) { result += command_; } else { result += miCommand(); if (m_thread != -1) result = result + QStringLiteral(" --thread %1").arg(m_thread); if (m_frame != -1) result = result + QStringLiteral(" --frame %1").arg(m_frame); if (!command_.isEmpty()) result += ' ' + command_; } return result; } bool MICommand::isUserCommand() const { return false; } void MICommand::setHandler(MICommandHandler* handler) { if (commandHandler_ && commandHandler_->autoDelete()) delete commandHandler_; commandHandler_ = handler; if (!commandHandler_) { flags_ = flags_ & ~CmdHandlesError; } } void MICommand::setHandler(const FunctionCommandHandler::Function& callback) { setHandler(new FunctionCommandHandler(callback, flags())); } bool MICommand::invokeHandler(const ResultRecord& r) { if (commandHandler_) { //ask before calling handler as it might deleted itself in handler bool autoDelete = commandHandler_->autoDelete(); commandHandler_->handle(r); if (autoDelete) { delete commandHandler_; } commandHandler_ = nullptr; return true; } else { return false; } } void MICommand::newOutput(const QString& line) { lines.push_back(line); } const QStringList& MICommand::allStreamOutput() const { return lines; } bool MICommand::handlesError() const { return commandHandler_ ? commandHandler_->handlesError() : false; } UserCommand::UserCommand(CommandType type, const QString& s) : MICommand(type, s, CmdMaybeStartsRunning) { } bool UserCommand::isUserCommand() const { return true; } QString MICommand::miCommand() const { QString command; switch (type()) { case NonMI: command = QLatin1String(""); break; case BreakAfter: - command = QLatin1String("break-after");//"ignore" + command = QStringLiteral("break-after");//"ignore" break; case BreakCommands: - command = QLatin1String("break-commands"); + command = QStringLiteral("break-commands"); break; case BreakCondition: - command = QLatin1String("break-condition");//"cond" + command = QStringLiteral("break-condition");//"cond" break; case BreakDelete: - command = QLatin1String("break-delete");//"delete breakpoint" + command = QStringLiteral("break-delete");//"delete breakpoint" break; case BreakDisable: - command = QLatin1String("break-disable");//"disable breakpoint" + command = QStringLiteral("break-disable");//"disable breakpoint" break; case BreakEnable: - command = QLatin1String("break-enable");//"enable breakpoint" + command = QStringLiteral("break-enable");//"enable breakpoint" break; case BreakInfo: - command = QLatin1String("break-info");//"info break" + command = QStringLiteral("break-info");//"info break" break; case BreakInsert: - command = QLatin1String("break-insert -f"); + command = QStringLiteral("break-insert -f"); break; case BreakList: - command = QLatin1String("break-list");//"info break" + command = QStringLiteral("break-list");//"info break" break; case BreakWatch: - command = QLatin1String("break-watch"); + command = QStringLiteral("break-watch"); break; case DataDisassemble: - command = QLatin1String("data-disassemble"); + command = QStringLiteral("data-disassemble"); break; case DataEvaluateExpression: - command = QLatin1String("data-evaluate-expression"); + command = QStringLiteral("data-evaluate-expression"); break; case DataListChangedRegisters: - command = QLatin1String("data-list-changed-registers"); + command = QStringLiteral("data-list-changed-registers"); break; case DataListRegisterNames: - command = QLatin1String("data-list-register-names"); + command = QStringLiteral("data-list-register-names"); break; case DataListRegisterValues: - command = QLatin1String("data-list-register-values"); + command = QStringLiteral("data-list-register-values"); break; case DataReadMemory: - command = QLatin1String("data-read-memory"); + command = QStringLiteral("data-read-memory"); break; case DataWriteMemory: - command = QLatin1String("data-write-memory"); + command = QStringLiteral("data-write-memory"); break; case DataWriteRegisterVariables: - command = QLatin1String("data-write-register-values"); + command = QStringLiteral("data-write-register-values"); break; case EnablePrettyPrinting: - command = QLatin1String("enable-pretty-printing"); + command = QStringLiteral("enable-pretty-printing"); break; case EnableTimings: - command = QLatin1String("enable-timings"); + command = QStringLiteral("enable-timings"); break; case EnvironmentCd: - command = QLatin1String("environment-cd"); + command = QStringLiteral("environment-cd"); break; case EnvironmentDirectory: - command = QLatin1String("environment-directory"); + command = QStringLiteral("environment-directory"); break; case EnvironmentPath: - command = QLatin1String("environment-path"); + command = QStringLiteral("environment-path"); break; case EnvironmentPwd: - command = QLatin1String("environment-pwd"); + command = QStringLiteral("environment-pwd"); break; case ExecAbort: - command = QLatin1String("exec-abort"); + command = QStringLiteral("exec-abort"); break; case ExecArguments: - command = QLatin1String("exec-arguments");//"set args" + command = QStringLiteral("exec-arguments");//"set args" break; case ExecContinue: - command = QLatin1String("exec-continue"); + command = QStringLiteral("exec-continue"); break; case ExecFinish: - command = QLatin1String("exec-finish"); + command = QStringLiteral("exec-finish"); break; case ExecInterrupt: - command = QLatin1String("exec-interrupt"); + command = QStringLiteral("exec-interrupt"); break; case ExecNext: - command = QLatin1String("exec-next"); + command = QStringLiteral("exec-next"); break; case ExecNextInstruction: - command = QLatin1String("exec-next-instruction"); + command = QStringLiteral("exec-next-instruction"); break; case ExecRun: - command = QLatin1String("exec-run"); + command = QStringLiteral("exec-run"); break; case ExecStep: - command = QLatin1String("exec-step"); + command = QStringLiteral("exec-step"); break; case ExecStepInstruction: - command = QLatin1String("exec-step-instruction"); + command = QStringLiteral("exec-step-instruction"); break; case ExecUntil: - command = QLatin1String("exec-until"); + command = QStringLiteral("exec-until"); break; case FileExecAndSymbols: - command = QLatin1String("file-exec-and-symbols");//"file" + command = QStringLiteral("file-exec-and-symbols");//"file" break; case FileExecFile: - command = QLatin1String("file-exec-file");//"exec-file" + command = QStringLiteral("file-exec-file");//"exec-file" break; case FileListExecSourceFile: - command = QLatin1String("file-list-exec-source-file"); + command = QStringLiteral("file-list-exec-source-file"); break; case FileListExecSourceFiles: - command = QLatin1String("file-list-exec-source-files"); + command = QStringLiteral("file-list-exec-source-files"); break; case FileSymbolFile: - command = QLatin1String("file-symbol-file");//"symbol-file" + command = QStringLiteral("file-symbol-file");//"symbol-file" break; case GdbExit: - command = QLatin1String("gdb-exit"); + command = QStringLiteral("gdb-exit"); break; case GdbSet: - command = QLatin1String("gdb-set");//"set" + command = QStringLiteral("gdb-set");//"set" break; case GdbShow: - command = QLatin1String("gdb-show");//"show" + command = QStringLiteral("gdb-show");//"show" break; case GdbVersion: - command = QLatin1String("gdb-version");//"show version" + command = QStringLiteral("gdb-version");//"show version" break; case InferiorTtySet: - command = QLatin1String("inferior-tty-set"); + command = QStringLiteral("inferior-tty-set"); break; case InferiorTtyShow: - command = QLatin1String("inferior-tty-show"); + command = QStringLiteral("inferior-tty-show"); break; case InterpreterExec: - command = QLatin1String("interpreter-exec"); + command = QStringLiteral("interpreter-exec"); break; case ListFeatures: - command = QLatin1String("list-features"); + command = QStringLiteral("list-features"); break; case SignalHandle: return QStringLiteral("handle"); //command = "signal-handle"; break; case StackInfoDepth: - command = QLatin1String("stack-info-depth"); + command = QStringLiteral("stack-info-depth"); break; case StackInfoFrame: - command = QLatin1String("stack-info-frame"); + command = QStringLiteral("stack-info-frame"); break; case StackListArguments: - command = QLatin1String("stack-list-arguments"); + command = QStringLiteral("stack-list-arguments"); break; case StackListFrames: - command = QLatin1String("stack-list-frames"); + command = QStringLiteral("stack-list-frames"); break; case StackListLocals: - command = QLatin1String("stack-list-locals"); + command = QStringLiteral("stack-list-locals"); break; case StackSelectFrame: - command = QLatin1String("stack-select-frame"); + command = QStringLiteral("stack-select-frame"); break; case SymbolListLines: - command = QLatin1String("symbol-list-lines"); + command = QStringLiteral("symbol-list-lines"); break; case TargetAttach: - command = QLatin1String("target-attach"); + command = QStringLiteral("target-attach"); break; case TargetDetach: - command = QLatin1String("target-detach");//"detach" + command = QStringLiteral("target-detach");//"detach" break; case TargetDisconnect: - command = QLatin1String("target-disconnect");//"disconnect" + command = QStringLiteral("target-disconnect");//"disconnect" break; case TargetDownload: - command = QLatin1String("target-download"); + command = QStringLiteral("target-download"); break; case TargetSelect: - command = QLatin1String("target-select"); + command = QStringLiteral("target-select"); break; case ThreadInfo: - command = QLatin1String("thread-info"); + command = QStringLiteral("thread-info"); break; case ThreadListIds: - command = QLatin1String("thread-list-ids"); + command = QStringLiteral("thread-list-ids"); break; case ThreadSelect: - command = QLatin1String("thread-select"); + command = QStringLiteral("thread-select"); break; case TraceFind: - command = QLatin1String("trace-find"); + command = QStringLiteral("trace-find"); break; case TraceStart: - command = QLatin1String("trace-start"); + command = QStringLiteral("trace-start"); break; case TraceStop: - command = QLatin1String("trace-stop"); + command = QStringLiteral("trace-stop"); break; case VarAssign: - command = QLatin1String("var-assign"); + command = QStringLiteral("var-assign"); break; case VarCreate: - command = QLatin1String("var-create"); + command = QStringLiteral("var-create"); break; case VarDelete: - command = QLatin1String("var-delete"); + command = QStringLiteral("var-delete"); break; case VarEvaluateExpression: - command = QLatin1String("var-evaluate-expression"); + command = QStringLiteral("var-evaluate-expression"); break; case VarInfoPathExpression: - command = QLatin1String("var-info-path-expression"); + command = QStringLiteral("var-info-path-expression"); break; case VarInfoNumChildren: - command = QLatin1String("var-info-num-children"); + command = QStringLiteral("var-info-num-children"); break; case VarInfoType: - command = QLatin1String("var-info-type"); + command = QStringLiteral("var-info-type"); break; case VarListChildren: - command = QLatin1String("var-list-children"); + command = QStringLiteral("var-list-children"); break; case VarSetFormat: - command = QLatin1String("var-set-format"); + command = QStringLiteral("var-set-format"); break; case VarSetFrozen: - command = QLatin1String("var-set-frozen"); + command = QStringLiteral("var-set-frozen"); break; case VarShowAttributes: - command = QLatin1String("var-show-attributes"); + command = QStringLiteral("var-show-attributes"); break; case VarShowFormat: - command = QLatin1String("var-show-format"); + command = QStringLiteral("var-show-format"); break; case VarUpdate: - command = QLatin1String("var-update"); + command = QStringLiteral("var-update"); break; default: - command = QLatin1String("unknown"); + command = QStringLiteral("unknown"); break; } return '-' + command; } CommandType MICommand::type() const { return type_; } int MICommand::thread() const { return m_thread; } void MICommand::setThread(int thread) { m_thread = thread; } int MICommand::frame() const { return m_frame; } void MICommand::setFrame(int frame) { m_frame = frame; } QString MICommand::command() const { return command_; } void MICommand::setStateReloading(bool f) { stateReloading_ = f; } bool MICommand::stateReloading() const { return stateReloading_; } void MICommand::markAsEnqueued() { m_enqueueTimestamp = QDateTime::currentMSecsSinceEpoch(); } void MICommand::markAsSubmitted() { m_submitTimestamp = QDateTime::currentMSecsSinceEpoch(); } void MICommand::markAsCompleted() { m_completeTimestamp = QDateTime::currentMSecsSinceEpoch(); } qint64 MICommand::gdbProcessingTime() const { return m_completeTimestamp - m_submitTimestamp; } qint64 MICommand::queueTime() const { return m_submitTimestamp - m_enqueueTimestamp; } qint64 MICommand::totalProcessingTime() const { return m_completeTimestamp - m_enqueueTimestamp; } diff --git a/debuggers/common/mibreakpointcontroller.cpp b/debuggers/common/mibreakpointcontroller.cpp index 128493edae..0552e22f2f 100644 --- a/debuggers/common/mibreakpointcontroller.cpp +++ b/debuggers/common/mibreakpointcontroller.cpp @@ -1,759 +1,759 @@ /* This file is part of the KDE project Copyright (C) 2002 Matthias Hoelzer-Kluepfel Copyright (C) 2002 John Firebaugh Copyright (C) 2006, 2008 Vladimir Prus Copyright (C) 2007 Hamish Rodda Copyright (C) 2009 Niko Sams 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "mibreakpointcontroller.h" #include "debuglog.h" #include "midebugsession.h" #include "mi/micommand.h" #include "stringhelpers.h" #include #include #include using namespace KDevMI; using namespace KDevMI::MI; using namespace KDevelop; struct MIBreakpointController::Handler : public MICommandHandler { Handler(MIBreakpointController* controller, const BreakpointDataPtr& b, BreakpointModel::ColumnFlags columns) : controller(controller) , breakpoint(b) , columns(columns) { breakpoint->sent |= columns; breakpoint->dirty &= ~columns; } void handle(const ResultRecord& r) override { breakpoint->sent &= ~columns; if (r.reason == QLatin1String("error")) { breakpoint->errors |= columns; int row = controller->breakpointRow(breakpoint); if (row >= 0) { controller->updateErrorText(row, r[QStringLiteral("msg")].literal()); qWarning() << r[QStringLiteral("msg")].literal(); } } else { if (breakpoint->errors & columns) { breakpoint->errors &= ~columns; if (breakpoint->errors) { // Since at least one error column cleared, it's possible that any remaining // error bits were collateral damage; try resending the corresponding columns // to see whether errors remain. breakpoint->dirty |= (breakpoint->errors & ~breakpoint->sent); } } } } bool handlesError() override { return true; } MIBreakpointController* controller; BreakpointDataPtr breakpoint; BreakpointModel::ColumnFlags columns; }; struct MIBreakpointController::UpdateHandler : public MIBreakpointController::Handler { UpdateHandler(MIBreakpointController* c, const BreakpointDataPtr& b, BreakpointModel::ColumnFlags columns) : Handler(c, b, columns) {} void handle(const ResultRecord &r) override { Handler::handle(r); int row = controller->breakpointRow(breakpoint); if (row >= 0) { // Note: send further updates even if we got an error; who knows: perhaps // these additional updates will "unstuck" the error condition. if (breakpoint->sent == 0 && breakpoint->dirty != 0) { controller->sendUpdates(row); } controller->recalculateState(row); } } }; struct MIBreakpointController::InsertedHandler : public MIBreakpointController::Handler { InsertedHandler(MIBreakpointController* c, const BreakpointDataPtr& b, BreakpointModel::ColumnFlags columns) : Handler(c, b, columns) {} void handle(const ResultRecord &r) override { Handler::handle(r); int row = controller->breakpointRow(breakpoint); if (r.reason != QLatin1String("error")) { QString bkptKind; for (auto kind : {"bkpt", "wpt", "hw-rwpt", "hw-awpt"}) { if (r.hasField(kind)) { bkptKind = kind; break; } } if (bkptKind.isEmpty()) { qWarning() << "Gdb sent unknown breakpoint kind"; return; } const Value& miBkpt = r[bkptKind]; breakpoint->debuggerId = miBkpt[QStringLiteral("number")].toInt(); if (row >= 0) { controller->updateFromDebugger(row, miBkpt); if (breakpoint->dirty != 0) controller->sendUpdates(row); } else { // breakpoint was deleted while insertion was in flight controller->debugSession()->addCommand(BreakDelete, QString::number(breakpoint->debuggerId), CmdImmediately); } } if (row >= 0) { controller->recalculateState(row); } } }; struct MIBreakpointController::DeleteHandler : MIBreakpointController::Handler { DeleteHandler(MIBreakpointController* c, const BreakpointDataPtr& b) : Handler(c, b, nullptr) {} void handle(const ResultRecord&) override { controller->m_pendingDeleted.removeAll(breakpoint); } }; struct MIBreakpointController::IgnoreChanges { explicit IgnoreChanges(MIBreakpointController& controller) : controller(controller) { ++controller.m_ignoreChanges; } ~IgnoreChanges() { --controller.m_ignoreChanges; } MIBreakpointController& controller; }; MIBreakpointController::MIBreakpointController(MIDebugSession * parent) : IBreakpointController(parent) { Q_ASSERT(parent); connect(parent, &MIDebugSession::inferiorStopped, this, &MIBreakpointController::programStopped); int numBreakpoints = breakpointModel()->breakpoints().size(); for (int row = 0; row < numBreakpoints; ++row) breakpointAdded(row); } MIDebugSession *MIBreakpointController::debugSession() const { Q_ASSERT(QObject::parent()); return static_cast(const_cast(QObject::parent())); } int MIBreakpointController::breakpointRow(const BreakpointDataPtr& breakpoint) { return m_breakpoints.indexOf(breakpoint); } void MIBreakpointController::setDeleteDuplicateBreakpoints(bool enable) { m_deleteDuplicateBreakpoints = enable; } void MIBreakpointController::initSendBreakpoints() { for (int row = 0; row < m_breakpoints.size(); ++row) { BreakpointDataPtr breakpoint = m_breakpoints[row]; if (breakpoint->debuggerId < 0 && breakpoint->sent == 0) { createBreakpoint(row); } } } void MIBreakpointController::breakpointAdded(int row) { if (m_ignoreChanges > 0) return; auto breakpoint = BreakpointDataPtr::create(); m_breakpoints.insert(row, breakpoint); const Breakpoint* modelBreakpoint = breakpointModel()->breakpoint(row); if (!modelBreakpoint->enabled()) breakpoint->dirty |= BreakpointModel::EnableColumnFlag; if (!modelBreakpoint->condition().isEmpty()) breakpoint->dirty |= BreakpointModel::ConditionColumnFlag; if (modelBreakpoint->ignoreHits() != 0) breakpoint->dirty |= BreakpointModel::IgnoreHitsColumnFlag; if (!modelBreakpoint->address().isEmpty()) breakpoint->dirty |= BreakpointModel::LocationColumnFlag; createBreakpoint(row); } void MIBreakpointController::breakpointModelChanged(int row, BreakpointModel::ColumnFlags columns) { if (m_ignoreChanges > 0) return; BreakpointDataPtr breakpoint = m_breakpoints.at(row); breakpoint->dirty |= columns & (BreakpointModel::EnableColumnFlag | BreakpointModel::LocationColumnFlag | BreakpointModel::ConditionColumnFlag | BreakpointModel::IgnoreHitsColumnFlag); if (breakpoint->sent != 0) { // Throttle the amount of commands we send to GDB; the response handler of currently // in-flight commands will take care of sending the update. // This also prevents us from sending updates while a break-create command is in-flight. return; } if (breakpoint->debuggerId < 0) { createBreakpoint(row); } else { sendUpdates(row); } } void MIBreakpointController::breakpointAboutToBeDeleted(int row) { if (m_ignoreChanges > 0) return; BreakpointDataPtr breakpoint = m_breakpoints.at(row); m_breakpoints.removeAt(row); if (breakpoint->debuggerId < 0) { // Two possibilities: // (1) Breakpoint has never been sent to GDB, so we're done // (2) Breakpoint has been sent to GDB, but we haven't received // the response yet; the response handler will delete the // breakpoint. return; } if (debugSession()->debuggerStateIsOn(s_dbgNotStarted)) return; debugSession()->addCommand( BreakDelete, QString::number(breakpoint->debuggerId), new DeleteHandler(this, breakpoint), CmdImmediately); m_pendingDeleted << breakpoint; } // Note: despite the name, this is in fact session state changed. void MIBreakpointController::debuggerStateChanged(IDebugSession::DebuggerState state) { IgnoreChanges ignoreChanges(*this); if (state == IDebugSession::EndedState || state == IDebugSession::NotStartedState) { for (int row = 0; row < m_breakpoints.size(); ++row) { updateState(row, Breakpoint::NotStartedState); } } else if (state == IDebugSession::StartingState) { for (int row = 0; row < m_breakpoints.size(); ++row) { updateState(row, Breakpoint::DirtyState); } } } void MIBreakpointController::createBreakpoint(int row) { if (debugSession()->debuggerStateIsOn(s_dbgNotStarted)) return; BreakpointDataPtr breakpoint = m_breakpoints.at(row); Breakpoint* modelBreakpoint = breakpointModel()->breakpoint(row); Q_ASSERT(breakpoint->debuggerId < 0 && breakpoint->sent == 0); if (modelBreakpoint->location().isEmpty()) return; if (modelBreakpoint->kind() == Breakpoint::CodeBreakpoint) { QString location; if (modelBreakpoint->line() != -1) { location = QStringLiteral("%0:%1") .arg(modelBreakpoint->url().url(QUrl::PreferLocalFile | QUrl::StripTrailingSlash)) .arg(modelBreakpoint->line() + 1); } else { location = modelBreakpoint->location(); } if (location == QLatin1String("catch throw")) { - location = QLatin1String("exception throw"); + location = QStringLiteral("exception throw"); } // Note: We rely on '-f' to be automatically added by the MICommand logic QString arguments; if (!modelBreakpoint->enabled()) arguments += QLatin1String("-d "); if (!modelBreakpoint->condition().isEmpty()) arguments += QStringLiteral("-c %0 ").arg(Utils::quoteExpression(modelBreakpoint->condition())); if (modelBreakpoint->ignoreHits() != 0) arguments += QStringLiteral("-i %0 ").arg(modelBreakpoint->ignoreHits()); arguments += Utils::quoteExpression(location); BreakpointModel::ColumnFlags sent = BreakpointModel::EnableColumnFlag | BreakpointModel::ConditionColumnFlag | BreakpointModel::IgnoreHitsColumnFlag | BreakpointModel::LocationColumnFlag; debugSession()->addCommand(BreakInsert, arguments, new InsertedHandler(this, breakpoint, sent), CmdImmediately); } else { QString opt; if (modelBreakpoint->kind() == Breakpoint::ReadBreakpoint) - opt = QLatin1String("-r "); + opt = QStringLiteral("-r "); else if (modelBreakpoint->kind() == Breakpoint::AccessBreakpoint) - opt = QLatin1String("-a "); + opt = QStringLiteral("-a "); debugSession()->addCommand(BreakWatch, opt + Utils::quoteExpression(modelBreakpoint->location()), new InsertedHandler(this, breakpoint, BreakpointModel::LocationColumnFlag), CmdImmediately); } recalculateState(row); } void MIBreakpointController::sendUpdates(int row) { if (debugSession()->debuggerStateIsOn(s_dbgNotStarted)) return; BreakpointDataPtr breakpoint = m_breakpoints.at(row); Breakpoint* modelBreakpoint = breakpointModel()->breakpoint(row); Q_ASSERT(breakpoint->debuggerId >= 0 && breakpoint->sent == 0); if (breakpoint->dirty & BreakpointModel::LocationColumnFlag) { // Gdb considers locations as fixed, so delete and re-create the breakpoint debugSession()->addCommand(BreakDelete, QString::number(breakpoint->debuggerId), CmdImmediately); breakpoint->debuggerId = -1; createBreakpoint(row); return; } if (breakpoint->dirty & BreakpointModel::EnableColumnFlag) { debugSession()->addCommand(modelBreakpoint->enabled() ? BreakEnable : BreakDisable, QString::number(breakpoint->debuggerId), new UpdateHandler(this, breakpoint, BreakpointModel::EnableColumnFlag), CmdImmediately); } if (breakpoint->dirty & BreakpointModel::IgnoreHitsColumnFlag) { debugSession()->addCommand(BreakAfter, QStringLiteral("%0 %1").arg(breakpoint->debuggerId) .arg(modelBreakpoint->ignoreHits()), new UpdateHandler(this, breakpoint, BreakpointModel::IgnoreHitsColumnFlag), CmdImmediately); } if (breakpoint->dirty & BreakpointModel::ConditionColumnFlag) { debugSession()->addCommand(BreakCondition, QStringLiteral("%0 %1").arg(breakpoint->debuggerId) .arg(modelBreakpoint->condition()), new UpdateHandler(this, breakpoint, BreakpointModel::ConditionColumnFlag), CmdImmediately); } recalculateState(row); } void MIBreakpointController::recalculateState(int row) { BreakpointDataPtr breakpoint = m_breakpoints.at(row); if (breakpoint->errors == 0) updateErrorText(row, QString()); Breakpoint::BreakpointState newState = Breakpoint::NotStartedState; if (debugSession()->state() != IDebugSession::EndedState && debugSession()->state() != IDebugSession::NotStartedState) { if (!debugSession()->debuggerStateIsOn(s_dbgNotStarted)) { if (breakpoint->dirty == 0 && breakpoint->sent == 0) { if (breakpoint->pending) { newState = Breakpoint::PendingState; } else { newState = Breakpoint::CleanState; } } else { newState = Breakpoint::DirtyState; } } } updateState(row, newState); } int MIBreakpointController::rowFromDebuggerId(int gdbId) const { for (int row = 0; row < m_breakpoints.size(); ++row) { if (gdbId == m_breakpoints[row]->debuggerId) return row; } return -1; } void MIBreakpointController::notifyBreakpointCreated(const AsyncRecord& r) { const Value& miBkpt = r[QStringLiteral("bkpt")]; // Breakpoints with multiple locations are represented by a parent breakpoint (e.g. 1) // and multiple child breakpoints (e.g. 1.1, 1.2, 1.3, ...). // We ignore the child breakpoints here in the current implementation; this can lead to dubious // results in the UI when breakpoints are marked in document views (e.g. when a breakpoint // applies to multiple overloads of a C++ function simultaneously) and in disassembly // (e.g. when a breakpoint is set in an inlined functions). if (miBkpt[QStringLiteral("number")].literal().contains('.')) return; createFromDebugger(miBkpt); } void MIBreakpointController::notifyBreakpointModified(const AsyncRecord& r) { const Value& miBkpt = r[QStringLiteral("bkpt")]; const int gdbId = miBkpt[QStringLiteral("number")].toInt(); const int row = rowFromDebuggerId(gdbId); if (row < 0) { for (const auto& breakpoint : m_pendingDeleted) { if (breakpoint->debuggerId == gdbId) { // Received a modification of a breakpoint whose deletion is currently // in-flight; simply ignore it. return; } } qCWarning(DEBUGGERCOMMON) << "Received a modification of an unknown breakpoint"; createFromDebugger(miBkpt); } else { updateFromDebugger(row, miBkpt); } } void MIBreakpointController::notifyBreakpointDeleted(const AsyncRecord& r) { const int gdbId = r[QStringLiteral("id")].toInt(); const int row = rowFromDebuggerId(gdbId); if (row < 0) { // The user may also have deleted the breakpoint via the UI simultaneously return; } IgnoreChanges ignoreChanges(*this); breakpointModel()->removeRow(row); m_breakpoints.removeAt(row); } void MIBreakpointController::createFromDebugger(const Value& miBkpt) { const QString type = miBkpt[QStringLiteral("type")].literal(); Breakpoint::BreakpointKind gdbKind; if (type == QLatin1String("breakpoint")) { gdbKind = Breakpoint::CodeBreakpoint; } else if (type == QLatin1String("watchpoint") || type == QLatin1String("hw watchpoint")) { gdbKind = Breakpoint::WriteBreakpoint; } else if (type == QLatin1String("read watchpoint")) { gdbKind = Breakpoint::ReadBreakpoint; } else if (type == QLatin1String("acc watchpoint")) { gdbKind = Breakpoint::AccessBreakpoint; } else { qCWarning(DEBUGGERCOMMON) << "Unknown breakpoint type " << type; return; } // During debugger startup, we want to avoid creating duplicate breakpoints when the same breakpoint // appears both in our model and in a init file e.g. .gdbinit BreakpointModel* model = breakpointModel(); const int numRows = model->rowCount(); for (int row = 0; row < numRows; ++row) { BreakpointDataPtr breakpoint = m_breakpoints.at(row); const bool breakpointSent = breakpoint->debuggerId >= 0 || breakpoint->sent != 0; if (breakpointSent && !m_deleteDuplicateBreakpoints) continue; Breakpoint* modelBreakpoint = model->breakpoint(row); if (modelBreakpoint->kind() != gdbKind) continue; if (gdbKind == Breakpoint::CodeBreakpoint) { bool sameLocation = false; if (miBkpt.hasField(QStringLiteral("fullname")) && miBkpt.hasField(QStringLiteral("line"))) { const QString location = Utils::unquoteExpression(miBkpt[QStringLiteral("fullname")].literal()); const int line = miBkpt[QStringLiteral("line")].toInt() - 1; if (location == modelBreakpoint->url().url(QUrl::PreferLocalFile | QUrl::StripTrailingSlash) && line == modelBreakpoint->line()) { sameLocation = true; } } if (!sameLocation && miBkpt.hasField(QStringLiteral("original-location"))) { const QString location = miBkpt[QStringLiteral("original-location")].literal(); if (location == modelBreakpoint->location()) { sameLocation = true; } else { QRegExp rx("^(.+):(\\d+)$"); if (rx.indexIn(location) != -1 && Utils::unquoteExpression(rx.cap(1)) == modelBreakpoint->url().url(QUrl::PreferLocalFile | QUrl::StripTrailingSlash) && rx.cap(2).toInt() - 1 == modelBreakpoint->line()) { sameLocation = true; } } } if (!sameLocation && miBkpt.hasField(QStringLiteral("what")) && miBkpt[QStringLiteral("what")].literal() == QLatin1String("exception throw")) { if (modelBreakpoint->expression() == QLatin1String("catch throw") || modelBreakpoint->expression() == QLatin1String("exception throw")) { sameLocation = true; } } if (!sameLocation) continue; } else { if (Utils::unquoteExpression(miBkpt[QStringLiteral("original-location")].literal()) != modelBreakpoint->expression()) { continue; } } QString condition; if (miBkpt.hasField(QStringLiteral("cond"))) { condition = miBkpt[QStringLiteral("cond")].literal(); } if (condition != modelBreakpoint->condition()) continue; // Breakpoint is equivalent if (!breakpointSent) { breakpoint->debuggerId = miBkpt[QStringLiteral("number")].toInt(); // Reasonable people can probably have different opinions about what the "correct" behavior // should be for the "enabled" and "ignore hits" column. // Here, we let the status in KDevelop's UI take precedence, which we suspect to be // marginally more useful. Dirty data will be sent during the initial sending of the // breakpoint list. const bool gdbEnabled = miBkpt[QStringLiteral("enabled")].literal() == QLatin1String("y"); if (gdbEnabled != modelBreakpoint->enabled()) breakpoint->dirty |= BreakpointModel::EnableColumnFlag; int gdbIgnoreHits = 0; if (miBkpt.hasField(QStringLiteral("ignore"))) gdbIgnoreHits = miBkpt[QStringLiteral("ignore")].toInt(); if (gdbIgnoreHits != modelBreakpoint->ignoreHits()) breakpoint->dirty |= BreakpointModel::IgnoreHitsColumnFlag; updateFromDebugger(row, miBkpt, BreakpointModel::EnableColumnFlag | BreakpointModel::IgnoreHitsColumnFlag); return; } // Breakpoint from the model has already been sent, but we want to delete duplicates // It is not entirely clear _which_ breakpoint ought to be deleted, and reasonable people // may have different opinions. // We suspect that it is marginally more useful to delete the existing model breakpoint; // after all, this only happens when a user command creates a breakpoint, and perhaps the // user intends to modify the breakpoint they created manually. In any case, // this situation should only happen rarely (in particular, when a user sets a breakpoint // inside the remote run script). model->removeRows(row, 1); break; // fall through to pick up the manually created breakpoint in the model } // No equivalent breakpoint found, or we have one but want to be consistent with GDB's // behavior of allowing multiple equivalent breakpoint. IgnoreChanges ignoreChanges(*this); const int row = m_breakpoints.size(); Q_ASSERT(row == model->rowCount()); switch (gdbKind) { case Breakpoint::WriteBreakpoint: model->addWatchpoint(); break; case Breakpoint::ReadBreakpoint: model->addReadWatchpoint(); break; case Breakpoint::AccessBreakpoint: model->addAccessWatchpoint(); break; case Breakpoint::CodeBreakpoint: model->addCodeBreakpoint(); break; default: Q_ASSERT(false); return; } // Since we are in ignore-changes mode, we have to add the BreakpointData manually. auto breakpoint = BreakpointDataPtr::create(); m_breakpoints << breakpoint; breakpoint->debuggerId = miBkpt[QStringLiteral("number")].toInt(); updateFromDebugger(row, miBkpt); } // This method is required for the legacy interface which will be removed void MIBreakpointController::sendMaybe(KDevelop::Breakpoint*) { Q_ASSERT(false); } void MIBreakpointController::updateFromDebugger(int row, const Value& miBkpt, BreakpointModel::ColumnFlags lockedColumns) { IgnoreChanges ignoreChanges(*this); BreakpointDataPtr breakpoint = m_breakpoints[row]; Breakpoint* modelBreakpoint = breakpointModel()->breakpoint(row); // Commands that are currently in flight will overwrite the modification we have received, // so do not update the corresponding data lockedColumns |= breakpoint->sent | breakpoint->dirty; // TODO: // Gdb has a notion of "original-location", which is the "expression" or "location" used // to set the breakpoint, and notions of the actual location of the breakpoint (function name, // address, source file and line). The breakpoint model currently does not map well to this // (though it arguably should), and does not support multi-location breakpoints at all. // We try to do the best we can until the breakpoint model gets cleaned up. if (miBkpt.hasField(QStringLiteral("fullname")) && miBkpt.hasField(QStringLiteral("line"))) { modelBreakpoint->setLocation( QUrl::fromLocalFile(Utils::unquoteExpression(miBkpt[QStringLiteral("fullname")].literal())), miBkpt[QStringLiteral("line")].toInt() - 1); } else if (miBkpt.hasField(QStringLiteral("original-location"))) { QRegExp rx("^(.+):(\\d+)$"); QString location = miBkpt[QStringLiteral("original-location")].literal(); if (rx.indexIn(location) != -1) { modelBreakpoint->setLocation(QUrl::fromLocalFile(Utils::unquoteExpression(rx.cap(1))), rx.cap(2).toInt()-1); } else { modelBreakpoint->setData(Breakpoint::LocationColumn, Utils::unquoteExpression(location)); } } else if (miBkpt.hasField(QStringLiteral("what"))) { modelBreakpoint->setExpression(miBkpt[QStringLiteral("what")].literal()); } else { qWarning() << "Breakpoint doesn't contain required location/expression data"; } if (!(lockedColumns & BreakpointModel::EnableColumnFlag)) { bool enabled = true; if (miBkpt.hasField(QStringLiteral("enabled"))) { if (miBkpt[QStringLiteral("enabled")].literal() == QLatin1String("n")) enabled = false; } modelBreakpoint->setData(Breakpoint::EnableColumn, enabled ? Qt::Checked : Qt::Unchecked); breakpoint->dirty &= ~BreakpointModel::EnableColumnFlag; } if (!(lockedColumns & BreakpointModel::ConditionColumnFlag)) { QString condition; if (miBkpt.hasField(QStringLiteral("cond"))) { condition = miBkpt[QStringLiteral("cond")].literal(); } modelBreakpoint->setCondition(condition); breakpoint->dirty &= ~BreakpointModel::ConditionColumnFlag; } if (!(lockedColumns & BreakpointModel::IgnoreHitsColumnFlag)) { int ignoreHits = 0; if (miBkpt.hasField(QStringLiteral("ignore"))) { ignoreHits = miBkpt[QStringLiteral("ignore")].toInt(); } modelBreakpoint->setIgnoreHits(ignoreHits); breakpoint->dirty &= ~BreakpointModel::IgnoreHitsColumnFlag; } breakpoint->pending = false; if (miBkpt.hasField(QStringLiteral("addr")) && miBkpt[QStringLiteral("addr")].literal() == QLatin1String("")) { breakpoint->pending = true; } int hitCount = 0; if (miBkpt.hasField(QStringLiteral("times"))) { hitCount = miBkpt[QStringLiteral("times")].toInt(); } updateHitCount(row, hitCount); recalculateState(row); } void MIBreakpointController::programStopped(const AsyncRecord& r) { if (!r.hasField(QStringLiteral("reason"))) return; const QString reason = r[QStringLiteral("reason")].literal(); int debuggerId = -1; if (reason == QLatin1String("breakpoint-hit")) { debuggerId = r[QStringLiteral("bkptno")].toInt(); } else if (reason == QLatin1String("watchpoint-trigger")) { debuggerId = r[QStringLiteral("wpt")][QStringLiteral("number")].toInt(); } else if (reason == QLatin1String("read-watchpoint-trigger")) { debuggerId = r[QStringLiteral("hw-rwpt")][QStringLiteral("number")].toInt(); } else if (reason == QLatin1String("access-watchpoint-trigger")) { debuggerId = r[QStringLiteral("hw-awpt")][QStringLiteral("number")].toInt(); } if (debuggerId < 0) return; int row = rowFromDebuggerId(debuggerId); if (row < 0) return; QString msg; if (r.hasField(QStringLiteral("value"))) { if (r[QStringLiteral("value")].hasField(QStringLiteral("old"))) { msg += i18n("
Old value: %1", r["value"]["old"].literal()); } if (r[QStringLiteral("value")].hasField(QStringLiteral("new"))) { msg += i18n("
New value: %1", r["value"]["new"].literal()); } } notifyHit(row, msg); } diff --git a/debuggers/common/midebugsession.cpp b/debuggers/common/midebugsession.cpp index 729d98105c..32856d8382 100644 --- a/debuggers/common/midebugsession.cpp +++ b/debuggers/common/midebugsession.cpp @@ -1,1315 +1,1315 @@ /* * Common code for debugger support * * Copyright 1999-2001 John Birch * Copyright 2001 by Bernd Gehrmann * Copyright 2006 Vladimir Prus * Copyright 2007 Hamish Rodda * Copyright 2009 Niko Sams * Copyright 2016 Aetf * * 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 . * */ #include "midebugsession.h" #include "debuglog.h" #include "midebugger.h" #include "mivariable.h" #include "mi/mi.h" #include "mi/micommand.h" #include "mi/micommandqueue.h" #include "stty.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace KDevelop; using namespace KDevMI; using namespace KDevMI::MI; MIDebugSession::MIDebugSession(MIDebuggerPlugin *plugin) : m_procLineMaker(new ProcessLineMaker(this)) , m_commandQueue(new CommandQueue) , m_sessionState(NotStartedState) , m_debugger(nullptr) , m_debuggerState(s_dbgNotStarted | s_appNotStarted) , m_stateReloadInProgress(false) , m_stateReloadNeeded(false) , m_tty(nullptr) , m_hasCrashed(false) , m_sourceInitFile(true) , m_plugin(plugin) { // setup signals connect(m_procLineMaker, &ProcessLineMaker::receivedStdoutLines, this, &MIDebugSession::inferiorStdoutLines); connect(m_procLineMaker, &ProcessLineMaker::receivedStderrLines, this, &MIDebugSession::inferiorStderrLines); // forward tty output to process line maker connect(this, &MIDebugSession::inferiorTtyStdout, m_procLineMaker, &ProcessLineMaker::slotReceivedStdout); connect(this, &MIDebugSession::inferiorTtyStderr, m_procLineMaker, &ProcessLineMaker::slotReceivedStderr); // FIXME: see if this still works //connect(statusBarIndicator, SIGNAL(doubleClicked()), // controller, SLOT(explainDebuggerStatus())); // FIXME: reimplement / re-enable //connect(this, SIGNAL(addWatchVariable(QString)), controller->variables(), SLOT(slotAddWatchVariable(QString))); //connect(this, SIGNAL(evaluateExpression(QString)), controller->variables(), SLOT(slotEvaluateExpression(QString))); } MIDebugSession::~MIDebugSession() { qCDebug(DEBUGGERCOMMON) << "Destroying MIDebugSession"; // Deleting the session involves shutting down gdb nicely. // When were attached to a process, we must first detach so that the process // can continue running as it was before being attached. gdb is quite slow to // detach from a process, so we must process events within here to get a "clean" // shutdown. if (!debuggerStateIsOn(s_dbgNotStarted)) { stopDebugger(); } } IDebugSession::DebuggerState MIDebugSession::state() const { return m_sessionState; } QMap & MIDebugSession::variableMapping() { return m_allVariables; } MIVariable* MIDebugSession::findVariableByVarobjName(const QString &varobjName) const { if (m_allVariables.count(varobjName) == 0) return nullptr; return m_allVariables.value(varobjName); } void MIDebugSession::markAllVariableDead() { for (auto i = m_allVariables.begin(), e = m_allVariables.end(); i != e; ++i) { i.value()->markAsDead(); } m_allVariables.clear(); } bool MIDebugSession::restartAvaliable() const { if (debuggerStateIsOn(s_attached) || debuggerStateIsOn(s_core)) { return false; } else { return true; } } bool MIDebugSession::startDebugger(ILaunchConfiguration *cfg) { qCDebug(DEBUGGERCOMMON) << "Starting new debugger instance"; if (m_debugger) { qCWarning(DEBUGGERCOMMON) << "m_debugger object still exists"; delete m_debugger; m_debugger = nullptr; } m_debugger = createDebugger(); m_debugger->setParent(this); // output signals connect(m_debugger, &MIDebugger::applicationOutput, this, [this](const QString &output) { auto lines = output.split(QRegularExpression(QStringLiteral("[\r\n]")), QString::SkipEmptyParts); for (auto &line : lines) { int p = line.length(); while (p >= 1 && (line[p-1] == '\r' || line[p-1] == '\n')) p--; if (p != line.length()) line.remove(p, line.length() - p); } emit inferiorStdoutLines(lines); }); connect(m_debugger, &MIDebugger::userCommandOutput, this, &MIDebugSession::debuggerUserCommandOutput); connect(m_debugger, &MIDebugger::internalCommandOutput, this, &MIDebugSession::debuggerInternalCommandOutput); connect(m_debugger, &MIDebugger::debuggerInternalOutput, this, &MIDebugSession::debuggerInternalOutput); // state signals connect(m_debugger, &MIDebugger::programStopped, this, &MIDebugSession::inferiorStopped); connect(m_debugger, &MIDebugger::programRunning, this, &MIDebugSession::inferiorRunning); // internal handlers connect(m_debugger, &MIDebugger::ready, this, &MIDebugSession::slotDebuggerReady); connect(m_debugger, &MIDebugger::exited, this, &MIDebugSession::slotDebuggerExited); connect(m_debugger, &MIDebugger::programStopped, this, &MIDebugSession::slotInferiorStopped); connect(m_debugger, &MIDebugger::programRunning, this, &MIDebugSession::slotInferiorRunning); connect(m_debugger, &MIDebugger::notification, this, &MIDebugSession::processNotification); // start the debugger. Do this after connecting all signals so that initial // debugger output, and important events like the debugger died are reported. QStringList extraArguments; if (!m_sourceInitFile) extraArguments << QStringLiteral("--nx"); auto config = cfg ? cfg->config() // FIXME: this is only used when attachToProcess or examineCoreFile. // Change to use a global launch configuration when calling : KConfigGroup(KSharedConfig::openConfig(), "GDB Config"); if (!m_debugger->start(config, extraArguments)) { // debugger failed to start, ensure debugger and session state are correctly updated. setDebuggerStateOn(s_dbgFailedStart); return false; } // FIXME: here, we should wait until the debugger is up and waiting for input. // Then, clear s_dbgNotStarted // It's better to do this right away so that the state bit is always correct. setDebuggerStateOff(s_dbgNotStarted); // Initialise debugger. At this stage debugger is sitting wondering what to do, // and to whom. initializeDebugger(); qCDebug(DEBUGGERCOMMON) << "Debugger instance started"; return true; } bool MIDebugSession::startDebugging(ILaunchConfiguration* cfg, IExecutePlugin* iexec) { qCDebug(DEBUGGERCOMMON) << "Starting new debug session"; Q_ASSERT(cfg); Q_ASSERT(iexec); // Ensure debugger is started first if (debuggerStateIsOn(s_appNotStarted)) { emit showMessage(i18n("Running program"), 1000); } if (debuggerStateIsOn(s_dbgNotStarted)) { if (!startDebugger(cfg)) return false; } if (debuggerStateIsOn(s_shuttingDown)) { qCDebug(DEBUGGERCOMMON) << "Tried to run when debugger shutting down"; return false; } // Only dummy err here, actual erros have been checked already in the job and we don't get here if there were any QString err; QString executable = iexec->executable(cfg, err).toLocalFile(); configInferior(cfg, iexec, executable); // Set up the tty for the inferior bool config_useExternalTerminal = iexec->useTerminal(cfg); QString config_ternimalName = iexec->terminal(cfg); if (!config_ternimalName.isEmpty()) { // the external terminal cmd contains additional arguments, just get the terminal name config_ternimalName = KShell::splitArgs(config_ternimalName).first(); } m_tty.reset(new STTY(config_useExternalTerminal, config_ternimalName)); if (!config_useExternalTerminal) { connect(m_tty.get(), &STTY::OutOutput, this, &MIDebugSession::inferiorTtyStdout); connect(m_tty.get(), &STTY::ErrOutput, this, &MIDebugSession::inferiorTtyStderr); } QString tty(m_tty->getSlave()); if (tty.isEmpty()) { KMessageBox::information(qApp->activeWindow(), m_tty->lastError(), i18n("warning")); m_tty.reset(nullptr); return false; } addCommand(InferiorTtySet, tty); // Change the working directory to the correct one QString dir = iexec->workingDirectory(cfg).toLocalFile(); if (dir.isEmpty()) { dir = QFileInfo(executable).absolutePath(); } addCommand(EnvironmentCd, '"' + dir + '"'); // Set the run arguments QStringList arguments = iexec->arguments(cfg, err); if (!arguments.isEmpty()) addCommand(ExecArguments, KShell::joinArgs(arguments)); // Do other debugger specific config options and actually start the inferior program if (!execInferior(cfg, iexec, executable)) { return false; } QString config_startWith = cfg->config().readEntry(Config::StartWithEntry, QStringLiteral("ApplicationOutput")); if (config_startWith == QLatin1String("GdbConsole")) { emit raiseDebuggerConsoleViews(); } else if (config_startWith == QLatin1String("FrameStack")) { emit raiseFramestackViews(); } else { // ApplicationOutput is raised in DebugJob (by setting job to Verbose/Silent) } return true; } // FIXME: use same configuration process as startDebugging bool MIDebugSession::attachToProcess(int pid) { qCDebug(DEBUGGERCOMMON) << "Attach to process" << pid; emit showMessage(i18n("Attaching to process %1", pid), 1000); if (debuggerStateIsOn(s_dbgNotStarted)) { // FIXME: use global launch configuration rather than nullptr if (!startDebugger(nullptr)) { return false; } } setDebuggerStateOn(s_attached); //set current state to running, after attaching we will get *stopped response setDebuggerStateOn(s_appRunning); addCommand(TargetAttach, QString::number(pid), this, &MIDebugSession::handleTargetAttach, CmdHandlesError); addCommand(new SentinelCommand(breakpointController(), &MIBreakpointController::initSendBreakpoints)); raiseEvent(connected_to_program); emit raiseFramestackViews(); return true; } void MIDebugSession::handleTargetAttach(const MI::ResultRecord& r) { if (r.reason == QLatin1String("error")) { KMessageBox::error( qApp->activeWindow(), i18n("Could not attach debugger:
")+ r[QStringLiteral("msg")].literal(), i18n("Startup error")); stopDebugger(); } } bool MIDebugSession::examineCoreFile(const QUrl &debugee, const QUrl &coreFile) { emit showMessage(i18n("Examining core file %1", coreFile.toLocalFile()), 1000); if (debuggerStateIsOn(s_dbgNotStarted)) { // FIXME: use global launch configuration rather than nullptr if (!startDebugger(nullptr)) { return false; } } // FIXME: support non-local URLs if (!loadCoreFile(nullptr, debugee.toLocalFile(), coreFile.toLocalFile())) { return false; } raiseEvent(program_state_changed); return true; } #define ENUM_NAME(o,e,v) (o::staticMetaObject.enumerator(o::staticMetaObject.indexOfEnumerator(#e)).valueToKey((v))) void MIDebugSession::setSessionState(DebuggerState state) { qCDebug(DEBUGGERCOMMON) << "Session state changed to" << ENUM_NAME(IDebugSession, DebuggerState, state) << "(" << state << ")"; if (state != m_sessionState) { m_sessionState = state; emit stateChanged(state); } } bool MIDebugSession::debuggerStateIsOn(DBGStateFlags state) const { return m_debuggerState & state; } DBGStateFlags MIDebugSession::debuggerState() const { return m_debuggerState; } void MIDebugSession::setDebuggerStateOn(DBGStateFlags stateOn) { DBGStateFlags oldState = m_debuggerState; debuggerStateChange(m_debuggerState, m_debuggerState | stateOn); m_debuggerState |= stateOn; handleDebuggerStateChange(oldState, m_debuggerState); } void MIDebugSession::setDebuggerStateOff(DBGStateFlags stateOff) { DBGStateFlags oldState = m_debuggerState; debuggerStateChange(m_debuggerState, m_debuggerState & ~stateOff); m_debuggerState &= ~stateOff; handleDebuggerStateChange(oldState, m_debuggerState); } void MIDebugSession::setDebuggerState(DBGStateFlags newState) { DBGStateFlags oldState = m_debuggerState; debuggerStateChange(m_debuggerState, newState); m_debuggerState = newState; handleDebuggerStateChange(oldState, m_debuggerState); } void MIDebugSession::debuggerStateChange(DBGStateFlags oldState, DBGStateFlags newState) { int delta = oldState ^ newState; if (delta) { QString out; #define STATE_CHECK(name) \ do { \ if (delta & name) { \ out += ((newState & name) ? " +" : " -"); \ out += #name; \ delta &= ~name; \ } \ } while (0) STATE_CHECK(s_dbgNotStarted); STATE_CHECK(s_appNotStarted); STATE_CHECK(s_programExited); STATE_CHECK(s_attached); STATE_CHECK(s_core); STATE_CHECK(s_shuttingDown); STATE_CHECK(s_dbgBusy); STATE_CHECK(s_appRunning); STATE_CHECK(s_dbgNotListening); STATE_CHECK(s_automaticContinue); #undef STATE_CHECK for (unsigned int i = 0; delta != 0 && i < 32; ++i) { if (delta & (1 << i)) { delta &= ~(1 << i); out += ((1 << i) & newState) ? " +" : " -"; out += QString::number(i); } } qCDebug(DEBUGGERCOMMON) << "Debugger state change:" << out; } } void MIDebugSession::handleDebuggerStateChange(DBGStateFlags oldState, DBGStateFlags newState) { QString message; DebuggerState oldSessionState = state(); DebuggerState newSessionState = oldSessionState; DBGStateFlags changedState = oldState ^ newState; if (newState & s_dbgNotStarted) { if (changedState & s_dbgNotStarted) { message = i18n("Debugger stopped"); emit finished(); } if (oldSessionState != NotStartedState || newState & s_dbgFailedStart) { newSessionState = EndedState; } } else { if (newState & s_appNotStarted) { if (oldSessionState == NotStartedState || oldSessionState == StartingState) { newSessionState = StartingState; } else { newSessionState = StoppedState; } } else if (newState & s_programExited) { if (changedState & s_programExited) { message = i18n("Process exited"); } newSessionState = StoppedState; } else if (newState & s_appRunning) { if (changedState & s_appRunning) { message = i18n("Application is running"); } newSessionState = ActiveState; } else { if (changedState & s_appRunning) { message = i18n("Application is paused"); } newSessionState = PausedState; } } // And now? :-) qCDebug(DEBUGGERCOMMON) << "Debugger state changed to: " << newState << message; if (!message.isEmpty()) emit showMessage(message, 3000); emit debuggerStateChanged(oldState, newState); // must be last, since it can lead to deletion of the DebugSession if (newSessionState != oldSessionState) { setSessionState(newSessionState); } } void MIDebugSession::restartDebugger() { // We implement restart as kill + slotRun, as opposed as plain "run" // command because kill + slotRun allows any special logic in slotRun // to apply for restart. // // That includes: // - checking for out-of-date project // - special setup for remote debugging. // // Had we used plain 'run' command, restart for remote debugging simply // would not work. if (!debuggerStateIsOn(s_dbgNotStarted|s_shuttingDown)) { // FIXME: s_dbgBusy or m_debugger->isReady()? if (debuggerStateIsOn(s_dbgBusy)) { interruptDebugger(); } // The -exec-abort is not implemented in gdb // addCommand(ExecAbort); addCommand(NonMI, QStringLiteral("kill")); } run(); } void MIDebugSession::stopDebugger() { if (debuggerStateIsOn(s_dbgNotStarted)) { // we are force to stop even before debugger started, just reset qCDebug(DEBUGGERCOMMON) << "Stopping debugger when it's not started"; return; } m_commandQueue->clear(); qCDebug(DEBUGGERCOMMON) << "try stopping debugger"; if (debuggerStateIsOn(s_shuttingDown) || !m_debugger) return; setDebuggerStateOn(s_shuttingDown); qCDebug(DEBUGGERCOMMON) << "stopping debugger"; // Get debugger's attention if it's busy. We need debugger to be at the // command line so we can stop it. if (!m_debugger->isReady()) { qCDebug(DEBUGGERCOMMON) << "debugger busy on shutdown - interruping"; interruptDebugger(); } // If the app is attached then we release it here. This doesn't stop // the app running. if (debuggerStateIsOn(s_attached)) { addCommand(TargetDetach); emit debuggerUserCommandOutput(QStringLiteral("(gdb) detach\n")); } // Now try to stop debugger running. addCommand(GdbExit); emit debuggerUserCommandOutput(QStringLiteral("(gdb) quit")); // We cannot wait forever, kill gdb after 5 seconds if it's not yet quit QPointer guarded_this(this); QTimer::singleShot(5000, [guarded_this](){ if (guarded_this) { if (!guarded_this->debuggerStateIsOn(s_programExited) && guarded_this->debuggerStateIsOn(s_shuttingDown)) { qCDebug(DEBUGGERCOMMON) << "debugger not shutdown - killing"; guarded_this->m_debugger->kill(); guarded_this->setDebuggerState(s_dbgNotStarted | s_appNotStarted); guarded_this->raiseEvent(debugger_exited); } } }); emit reset(); } void MIDebugSession::interruptDebugger() { Q_ASSERT(m_debugger); // Explicitly send the interrupt in case something went wrong with the usual // ensureGdbListening logic. m_debugger->interrupt(); addCommand(ExecInterrupt, QString(), CmdInterrupt); } void MIDebugSession::run() { if (debuggerStateIsOn(s_appNotStarted|s_dbgNotStarted|s_shuttingDown)) return; addCommand(MI::ExecContinue, QString(), CmdMaybeStartsRunning); } void MIDebugSession::runToCursor() { if (IDocument* doc = ICore::self()->documentController()->activeDocument()) { KTextEditor::Cursor cursor = doc->cursorPosition(); if (cursor.isValid()) runUntil(doc->url(), cursor.line() + 1); } } void MIDebugSession::jumpToCursor() { if (IDocument* doc = ICore::self()->documentController()->activeDocument()) { KTextEditor::Cursor cursor = doc->cursorPosition(); if (cursor.isValid()) jumpTo(doc->url(), cursor.line() + 1); } } void MIDebugSession::stepOver() { if (debuggerStateIsOn(s_appNotStarted|s_shuttingDown)) return; addCommand(ExecNext, QString(), CmdMaybeStartsRunning | CmdTemporaryRun); } void MIDebugSession::stepIntoInstruction() { if (debuggerStateIsOn(s_appNotStarted|s_shuttingDown)) return; addCommand(ExecStepInstruction, QString(), CmdMaybeStartsRunning | CmdTemporaryRun); } void MIDebugSession::stepInto() { if (debuggerStateIsOn(s_appNotStarted|s_shuttingDown)) return; addCommand(ExecStep, QString(), CmdMaybeStartsRunning | CmdTemporaryRun); } void MIDebugSession::stepOverInstruction() { if (debuggerStateIsOn(s_appNotStarted|s_shuttingDown)) return; addCommand(ExecNextInstruction, QString(), CmdMaybeStartsRunning | CmdTemporaryRun); } void MIDebugSession::stepOut() { if (debuggerStateIsOn(s_appNotStarted|s_shuttingDown)) return; addCommand(ExecFinish, QString(), CmdMaybeStartsRunning | CmdTemporaryRun); } void MIDebugSession::runUntil(const QUrl& url, int line) { if (debuggerStateIsOn(s_dbgNotStarted|s_shuttingDown)) return; if (!url.isValid()) { addCommand(ExecUntil, QString::number(line), CmdMaybeStartsRunning | CmdTemporaryRun); } else { addCommand(ExecUntil, QStringLiteral("%1:%2").arg(url.toLocalFile()).arg(line), CmdMaybeStartsRunning | CmdTemporaryRun); } } void MIDebugSession::runUntil(const QString& address) { if (debuggerStateIsOn(s_dbgNotStarted|s_shuttingDown)) return; if (!address.isEmpty()) { addCommand(ExecUntil, QStringLiteral("*%1").arg(address), CmdMaybeStartsRunning | CmdTemporaryRun); } } void MIDebugSession::jumpTo(const QUrl& url, int line) { if (debuggerStateIsOn(s_dbgNotStarted|s_shuttingDown)) return; if (url.isValid()) { addCommand(NonMI, QStringLiteral("tbreak %1:%2").arg(url.toLocalFile()).arg(line)); addCommand(NonMI, QStringLiteral("jump %1:%2").arg(url.toLocalFile()).arg(line)); } } void MIDebugSession::jumpToMemoryAddress(const QString& address) { if (debuggerStateIsOn(s_dbgNotStarted|s_shuttingDown)) return; if (!address.isEmpty()) { addCommand(NonMI, QStringLiteral("tbreak *%1").arg(address)); addCommand(NonMI, QStringLiteral("jump *%1").arg(address)); } } void MIDebugSession::addUserCommand(const QString& cmd) { auto usercmd = createUserCommand(cmd); if (!usercmd) return; queueCmd(usercmd); // User command can theoreticall modify absolutely everything, // so need to force a reload. // We can do it right now, and don't wait for user command to finish // since commands used to reload all view will be executed after // user command anyway. if (!debuggerStateIsOn(s_appNotStarted) && !debuggerStateIsOn(s_programExited)) raiseEvent(program_state_changed); } MICommand *MIDebugSession::createUserCommand(const QString &cmd) const { MICommand *res = nullptr; if (!cmd.isEmpty() && cmd[0].isDigit()) { // Add a space to the beginning, so debugger won't get confused if the // command starts with a number (won't mix it up with command token added) res = new UserCommand(MI::NonMI, " " + cmd); } else { res = new UserCommand(MI::NonMI, cmd); } return res; } MICommand *MIDebugSession::createCommand(CommandType type, const QString& arguments, CommandFlags flags) const { return new MICommand(type, arguments, flags); } void MIDebugSession::addCommand(MICommand* cmd) { queueCmd(cmd); } void MIDebugSession::addCommand(MI::CommandType type, const QString& arguments, MI::CommandFlags flags) { queueCmd(createCommand(type, arguments, flags)); } void MIDebugSession::addCommand(MI::CommandType type, const QString& arguments, MI::MICommandHandler *handler, MI::CommandFlags flags) { auto cmd = createCommand(type, arguments, flags); cmd->setHandler(handler); queueCmd(cmd); } void MIDebugSession::addCommand(MI::CommandType type, const QString& arguments, const MI::FunctionCommandHandler::Function& callback, MI::CommandFlags flags) { auto cmd = createCommand(type, arguments, flags); cmd->setHandler(callback); queueCmd(cmd); } // Fairly obvious that we'll add whatever command you give me to a queue // Not quite so obvious though is that if we are going to run again. then any // information requests become redundent and must be removed. // We also try and run whatever command happens to be at the head of // the queue. void MIDebugSession::queueCmd(MICommand *cmd) { if (debuggerStateIsOn(s_dbgNotStarted)) { KMessageBox::information( qApp->activeWindow(), i18n("Gdb command sent when debugger is not running
" "The command was:
%1", cmd->initialString()), i18n("Internal error")); return; } if (m_stateReloadInProgress) cmd->setStateReloading(true); m_commandQueue->enqueue(cmd); qCDebug(DEBUGGERCOMMON) << "QUEUE: " << cmd->initialString() << (m_stateReloadInProgress ? "(state reloading)" : "") << m_commandQueue->count() << "pending"; bool varCommandWithContext= (cmd->type() >= MI::VarAssign && cmd->type() <= MI::VarUpdate && cmd->type() != MI::VarDelete); bool stackCommandWithContext = (cmd->type() >= MI::StackInfoDepth && cmd->type() <= MI::StackListLocals); if (varCommandWithContext || stackCommandWithContext) { if (cmd->thread() == -1) qCDebug(DEBUGGERCOMMON) << "\t--thread will be added on execution"; if (cmd->frame() == -1) qCDebug(DEBUGGERCOMMON) << "\t--frame will be added on execution"; } setDebuggerStateOn(s_dbgBusy); raiseEvent(debugger_busy); executeCmd(); } void MIDebugSession::executeCmd() { Q_ASSERT(m_debugger); if (debuggerStateIsOn(s_dbgNotListening) && m_commandQueue->haveImmediateCommand()) { // We may have to call this even while a command is currently executing, because // debugger can get into a state where a command such as ExecRun does not send a response // while the inferior is running. ensureDebuggerListening(); } if (!m_debugger->isReady()) return; MICommand* currentCmd = m_commandQueue->nextCommand(); if (!currentCmd) return; if (currentCmd->flags() & (CmdMaybeStartsRunning | CmdInterrupt)) { setDebuggerStateOff(s_automaticContinue); } if (currentCmd->flags() & CmdMaybeStartsRunning) { // GDB can be in a state where it is listening for commands while the program is running. // However, when we send a command such as ExecContinue in this state, GDB may return to // the non-listening state without acknowledging that the ExecContinue command has even // finished, let alone sending a new notification about the program's running state. // So let's be extra cautious about ensuring that we will wake GDB up again if required. setDebuggerStateOn(s_dbgNotListening); } bool varCommandWithContext= (currentCmd->type() >= MI::VarAssign && currentCmd->type() <= MI::VarUpdate && currentCmd->type() != MI::VarDelete); bool stackCommandWithContext = (currentCmd->type() >= MI::StackInfoDepth && currentCmd->type() <= MI::StackListLocals); if (varCommandWithContext || stackCommandWithContext) { // Most var commands should be executed in the context // of the selected thread and frame. if (currentCmd->thread() == -1) currentCmd->setThread(frameStackModel()->currentThread()); if (currentCmd->frame() == -1) currentCmd->setFrame(frameStackModel()->currentFrame()); } QString commandText = currentCmd->cmdToSend(); bool bad_command = false; QString message; int length = commandText.length(); // No i18n for message since it's mainly for debugging. if (length == 0) { // The command might decide it's no longer necessary to send // it. if (SentinelCommand* sc = dynamic_cast(currentCmd)) { qCDebug(DEBUGGERCOMMON) << "SEND: sentinel command, not sending"; sc->invokeHandler(); } else { qCDebug(DEBUGGERCOMMON) << "SEND: command " << currentCmd->initialString() << "changed its mind, not sending"; } delete currentCmd; executeCmd(); return; } else { if (commandText[length-1] != '\n') { bad_command = true; - message = QLatin1String("Debugger command does not end with newline"); + message = QStringLiteral("Debugger command does not end with newline"); } } if (bad_command) { KMessageBox::information(qApp->activeWindow(), i18n("Invalid debugger command
%1", message), i18n("Invalid debugger command")); executeCmd(); return; } m_debugger->execute(currentCmd); } void MIDebugSession::ensureDebuggerListening() { Q_ASSERT(m_debugger); // Note: we don't use interruptDebugger() here since // we don't want to queue more commands before queuing a command m_debugger->interrupt(); setDebuggerStateOn(s_interruptSent); if (debuggerStateIsOn(s_appRunning)) setDebuggerStateOn(s_automaticContinue); setDebuggerStateOff(s_dbgNotListening); } void MIDebugSession::destroyCmds() { m_commandQueue->clear(); } // FIXME: I don't fully remember what is the business with // m_stateReloadInProgress and whether we can lift it to the // generic level. void MIDebugSession::raiseEvent(event_t e) { if (e == program_exited || e == debugger_exited) { m_stateReloadInProgress = false; } if (e == program_state_changed) { m_stateReloadInProgress = true; qCDebug(DEBUGGERCOMMON) << "State reload in progress\n"; } IDebugSession::raiseEvent(e); if (e == program_state_changed) { m_stateReloadInProgress = false; } } bool KDevMI::MIDebugSession::hasCrashed() const { return m_hasCrashed; } void MIDebugSession::slotDebuggerReady() { Q_ASSERT(m_debugger); m_stateReloadInProgress = false; executeCmd(); if (m_debugger->isReady()) { /* There is nothing in the command queue and no command is currently executing. */ if (debuggerStateIsOn(s_automaticContinue)) { if (!debuggerStateIsOn(s_appRunning)) { qCDebug(DEBUGGERCOMMON) << "Posting automatic continue"; addCommand(ExecContinue, QString(), CmdMaybeStartsRunning); } setDebuggerStateOff(s_automaticContinue); return; } if (m_stateReloadNeeded && !debuggerStateIsOn(s_appRunning)) { qCDebug(DEBUGGERCOMMON) << "Finishing program stop"; // Set to false right now, so that if 'actOnProgramPauseMI_part2' // sends some commands, we won't call it again when handling replies // from that commands. m_stateReloadNeeded = false; reloadProgramState(); } qCDebug(DEBUGGERCOMMON) << "No more commands"; setDebuggerStateOff(s_dbgBusy); raiseEvent(debugger_ready); } } void MIDebugSession::slotDebuggerExited(bool abnormal, const QString &msg) { /* Technically speaking, GDB is likely not to kill the application, and we should have some backup mechanism to make sure the application is killed by KDevelop. But even if application stays around, we no longer can control it in any way, so mark it as exited. */ setDebuggerStateOn(s_appNotStarted); setDebuggerStateOn(s_dbgNotStarted); setDebuggerStateOn(s_programExited); setDebuggerStateOff(s_shuttingDown); if (!msg.isEmpty()) emit showMessage(msg, 3000); if (abnormal) { /* The error is reported to user in MIDebugger now. KMessageBox::information( KDevelop::ICore::self()->uiController()->activeMainWindow(), i18n("Debugger exited abnormally" "

This is likely a bug in GDB. " "Examine the gdb output window and then stop the debugger"), i18n("Debugger exited abnormally")); */ // FIXME: not sure if the following still applies. // Note: we don't stop the debugger here, becuse that will hide gdb // window and prevent the user from finding the exact reason of the // problem. } /* FIXME: raiseEvent is handled across multiple places where we explicitly * stop/kill the debugger, a better way is to let the debugger itself report * its exited event. */ // raiseEvent(debugger_exited); } void MIDebugSession::slotInferiorStopped(const MI::AsyncRecord& r) { /* By default, reload all state on program stop. */ m_stateReloadNeeded = true; setDebuggerStateOff(s_appRunning); setDebuggerStateOff(s_dbgNotListening); QString reason; if (r.hasField(QStringLiteral("reason"))) reason = r[QStringLiteral("reason")].literal(); if (reason == QLatin1String("exited-normally") || reason == QLatin1String("exited")) { if (r.hasField(QStringLiteral("exit-code"))) { programNoApp(i18n("Exited with return code: %1", r["exit-code"].literal())); } else { programNoApp(i18n("Exited normally")); } m_stateReloadNeeded = false; return; } if (reason == QLatin1String("exited-signalled")) { programNoApp(i18n("Exited on signal %1", r["signal-name"].literal())); m_stateReloadNeeded = false; return; } if (reason == QLatin1String("watchpoint-scope")) { QString number = r[QStringLiteral("wpnum")].literal(); // FIXME: shuld remove this watchpoint // But first, we should consider if removing all // watchpoinst on program exit is the right thing to // do. addCommand(ExecContinue, QString(), CmdMaybeStartsRunning); m_stateReloadNeeded = false; return; } bool wasInterrupt = false; if (reason == QLatin1String("signal-received")) { QString name = r[QStringLiteral("signal-name")].literal(); QString user_name = r[QStringLiteral("signal-meaning")].literal(); // SIGINT is a "break into running program". // We do this when the user set/mod/clears a breakpoint but the // application is running. // And the user does this to stop the program also. if (name == QLatin1String("SIGINT") && debuggerStateIsOn(s_interruptSent)) { wasInterrupt = true; } else { // Whenever we have a signal raised then tell the user, but don't // end the program as we want to allow the user to look at why the // program has a signal that's caused the prog to stop. // Continuing from SIG FPE/SEGV will cause a "Cannot ..." and // that'll end the program. programFinished(i18n("Program received signal %1 (%2)", name, user_name)); m_hasCrashed = true; } } if (!reason.contains(QLatin1String("exited"))) { // FIXME: we should immediately update the current thread and // frame in the framestackmodel, so that any user actions // are in that thread. However, the way current framestack model // is implemented, we can't change thread id until we refresh // the entire list of threads -- otherwise we might set a thread // id that is not already in the list, and it will be upset. //Indicates if program state should be reloaded immediately. bool updateState = false; if (r.hasField(QStringLiteral("frame"))) { const MI::Value& frame = r[QStringLiteral("frame")]; QString file, line, addr; if (frame.hasField(QStringLiteral("fullname"))) file = frame[QStringLiteral("fullname")].literal();; if (frame.hasField(QStringLiteral("line"))) line = frame[QStringLiteral("line")].literal(); if (frame.hasField(QStringLiteral("addr"))) addr = frame[QStringLiteral("addr")].literal(); // gdb counts lines from 1 and we don't setCurrentPosition(QUrl::fromLocalFile(file), line.toInt() - 1, addr); updateState = true; } if (updateState) { reloadProgramState(); } } setDebuggerStateOff(s_interruptSent); if (!wasInterrupt) setDebuggerStateOff(s_automaticContinue); } void MIDebugSession::slotInferiorRunning() { setDebuggerStateOn(s_appRunning); raiseEvent(program_running); if (m_commandQueue->haveImmediateCommand() || (m_debugger->currentCommand() && (m_debugger->currentCommand()->flags() & (CmdImmediately | CmdInterrupt)))) { ensureDebuggerListening(); } else { setDebuggerStateOn(s_dbgNotListening); } } void MIDebugSession::processNotification(const MI::AsyncRecord & async) { if (async.reason == QLatin1String("thread-group-started")) { setDebuggerStateOff(s_appNotStarted | s_programExited); } else if (async.reason == QLatin1String("thread-group-exited")) { setDebuggerStateOn(s_programExited); } else if (async.reason == QLatin1String("library-loaded")) { // do nothing } else if (async.reason == QLatin1String("breakpoint-created")) { breakpointController()->notifyBreakpointCreated(async); } else if (async.reason == QLatin1String("breakpoint-modified")) { breakpointController()->notifyBreakpointModified(async); } else if (async.reason == QLatin1String("breakpoint-deleted")) { breakpointController()->notifyBreakpointDeleted(async); } else { qCDebug(DEBUGGERCOMMON) << "Unhandled notification: " << async.reason; } } void MIDebugSession::reloadProgramState() { raiseEvent(program_state_changed); m_stateReloadNeeded = false; } // There is no app anymore. This can be caused by program exiting // an invalid program specified or ... // gdb is still running though, but only the run command (may) make sense // all other commands are disabled. void MIDebugSession::programNoApp(const QString& msg) { qCDebug(DEBUGGERCOMMON) << msg; setDebuggerState(s_appNotStarted | s_programExited | (m_debuggerState & s_shuttingDown)); destroyCmds(); // The application has existed, but it's possible that // some of application output is still in the pipe. We use // different pipes to communicate with gdb and to get application // output, so "exited" message from gdb might have arrived before // last application output. Get this last bit. // Note: this method can be called when we open an invalid // core file. In that case, tty_ won't be set. if (m_tty){ m_tty->readRemaining(); // Tty is no longer usable, delete it. Without this, QSocketNotifier // will continuously bomd STTY with signals, so we need to either disable // QSocketNotifier, or delete STTY. The latter is simpler, since we can't // reuse it for future debug sessions anyway. m_tty.reset(nullptr); } stopDebugger(); raiseEvent(program_exited); raiseEvent(debugger_exited); emit showMessage(msg, 0); programFinished(msg); } void MIDebugSession::programFinished(const QString& msg) { QString m = QStringLiteral("*** %0 ***").arg(msg.trimmed()); emit inferiorStderrLines(QStringList(m)); /* Also show message in gdb window, so that users who prefer to look at gdb window know what's up. */ emit debuggerUserCommandOutput(m); } void MIDebugSession::explainDebuggerStatus() { MICommand* currentCmd_ = m_debugger->currentCommand(); QString information = i18np("1 command in queue\n", "%1 commands in queue\n", m_commandQueue->count()) + i18ncp("Only the 0 and 1 cases need to be translated", "1 command being processed by gdb\n", "%1 commands being processed by gdb\n", (currentCmd_ ? 1 : 0)) + i18n("Debugger state: %1\n", m_debuggerState); if (currentCmd_) { QString extra = i18n("Current command class: '%1'\n" "Current command text: '%2'\n" "Current command original text: '%3'\n", typeid(*currentCmd_).name(), currentCmd_->cmdToSend(), currentCmd_->initialString()); information += extra; } KMessageBox::information(qApp->activeWindow(), information, i18n("Debugger status")); } // There is no app anymore. This can be caused by program exiting // an invalid program specified or ... // gdb is still running though, but only the run command (may) make sense // all other commands are disabled. void MIDebugSession::handleNoInferior(const QString& msg) { qCDebug(DEBUGGERCOMMON) << msg; setDebuggerState(s_appNotStarted | s_programExited | (debuggerState() & s_shuttingDown)); destroyCmds(); // The application has existed, but it's possible that // some of application output is still in the pipe. We use // different pipes to communicate with gdb and to get application // output, so "exited" message from gdb might have arrived before // last application output. Get this last bit. // Note: this method can be called when we open an invalid // core file. In that case, tty_ won't be set. if (m_tty){ m_tty->readRemaining(); // Tty is no longer usable, delete it. Without this, QSocketNotifier // will continuously bomd STTY with signals, so we need to either disable // QSocketNotifier, or delete STTY. The latter is simpler, since we can't // reuse it for future debug sessions anyway. m_tty.reset(nullptr); } stopDebugger(); raiseEvent(program_exited); raiseEvent(debugger_exited); emit showMessage(msg, 0); handleInferiorFinished(msg); } void MIDebugSession::handleInferiorFinished(const QString& msg) { QString m = QStringLiteral("*** %0 ***").arg(msg.trimmed()); emit inferiorStderrLines(QStringList(m)); /* Also show message in gdb window, so that users who prefer to look at gdb window know what's up. */ emit debuggerUserCommandOutput(m); } // FIXME: connect to debugger's slot. void MIDebugSession::defaultErrorHandler(const MI::ResultRecord& result) { QString msg = result[QStringLiteral("msg")].literal(); if (msg.contains(QLatin1String("No such process"))) { setDebuggerState(s_appNotStarted|s_programExited); raiseEvent(program_exited); return; } KMessageBox::information( qApp->activeWindow(), i18n("Debugger error" "

Debugger reported the following error:" "

") + fontSizePrefix(shorten); addExternalHtml(prefix()); QStringList parameterList; FOREACH_FUNCTION(const auto& parameter, m_macro->parameters) { parameterList << parameter.str(); } const QString parameters = (!parameterList.isEmpty() ? - QStringLiteral("(%1)").arg(parameterList.join(QLatin1String(", "))) : + QStringLiteral("(%1)").arg(parameterList.join(QStringLiteral(", "))) : QString()); const QUrl url = m_macro->url().toUrl(); const QString path = url.toLocalFile(); KTextEditor::Cursor cursor(m_macro->rangeInCurrentRevision().start()); NavigationAction action(url, cursor); modifyHtml() += i18nc("%1: macro type, i.e.: 'Function macro' or just 'Macro'" "%2: the macro name and arguments", "%1: %2", (m_macro->isFunctionLike() ? i18n("Function macro") : i18n("Macro")), importantHighlight(name()) + parameters); modifyHtml() += QStringLiteral(" "); modifyHtml() += i18nc("%1: the link to the definition", "Defined in: %1", createLink(QStringLiteral("%1 :%2").arg(url.fileName()).arg(cursor.line()+1), path, action)); modifyHtml() += QStringLiteral(" "); //The action name _must_ stay "show_uses", since that is also used from outside makeLink(i18n("Show uses"), QStringLiteral("show_uses"), NavigationAction(m_macro.dynamicCast(), NavigationAction::NavigateUses)); auto code = m_macro->definition().str(); modifyHtml() += QLatin1String("

") + i18n("Body: "); modifyHtml() += QLatin1String("") + code.toHtmlEscaped().replace(QStringLiteral("\n"), QStringLiteral(" ")) + QLatin1String(""); - modifyHtml() += QLatin1String("

"); + modifyHtml() += QStringLiteral(""); modifyHtml() += fontSizeSuffix(shorten) + QLatin1String(""); return currentHtml(); } QString MacroNavigationContext::retrievePreprocessedBody(const DocumentCursor& /*expansionLocation*/) const { const TopDUContext* topContext = m_macro->topContext(); if (!topContext) { return QString(); } // TODO: Implement me. Still not exactly sure what do to here... return QString(); } diff --git a/languages/plugins/custom-definesandincludes/compilerprovider/msvccompiler.cpp b/languages/plugins/custom-definesandincludes/compilerprovider/msvccompiler.cpp index 844173938c..5a4f38d8b5 100644 --- a/languages/plugins/custom-definesandincludes/compilerprovider/msvccompiler.cpp +++ b/languages/plugins/custom-definesandincludes/compilerprovider/msvccompiler.cpp @@ -1,130 +1,130 @@ /* * This file is part of KDevelop * * Copyright 2010 Patrick Spendrin * Copyright 2013 Kevin Funk * Copyright 2014 Sergey Kalinichev * * 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 . * */ #include "msvccompiler.h" #include #include #include #include "../debugarea.h" using namespace KDevelop; Defines MsvcCompiler::defines(const QString&) const { Defines ret; //Get standard macros from kdevmsvcdefinehelpers KProcess proc; proc.setOutputChannelMode( KProcess::MergedChannels ); proc.setTextModeEnabled( true ); // we want to use kdevmsvcdefinehelper as a pseudo compiler backend which // returns the defines used in msvc. there is no such thing as -dM with cl.exe proc << path() << QStringLiteral("/nologo") << QStringLiteral("/Bxkdevmsvcdefinehelper") << QStringLiteral("empty.cpp"); // this will fail, so check on that as well if ( proc.execute( 5000 ) == 2 ) { QString line; proc.readLine(); // read the filename while ( proc.canReadLine() ) { QByteArray buff = proc.readLine(); definesAndIncludesDebug() << "msvcstandardmacros:" << buff; if ( !buff.isEmpty() ) { line = buff; if ( line.startsWith( QLatin1String("#define ") ) ) { line = line.right( line.length() - 8 ).trimmed(); int pos = line.indexOf( ' ' ); if ( pos != -1 ) { ret[line.left( pos )] = line.right( line.length() - pos - 1 ).toUtf8(); } else { ret[line] = QLatin1String(""); } } } } } else { definesAndIncludesDebug() << "Unable to read standard c++ macro definitions from " + path(); while ( proc.canReadLine() ){ definesAndIncludesDebug() << proc.readLine(); } definesAndIncludesDebug() << proc.exitCode(); } // MSVC builtin attributes { ret[QStringLiteral("__cdecl")] = QLatin1String(""); ret[QStringLiteral("__fastcall")] = QLatin1String(""); ret[QStringLiteral("__stdcall")] = QLatin1String(""); ret[QStringLiteral("__thiscall")] = QLatin1String(""); } // MSVC builtin types // see http://msdn.microsoft.com/en-us/library/cc953fe1.aspx { - ret[QStringLiteral("__int8")] = QLatin1String("char"); - ret[QStringLiteral("__int16")] = QLatin1String("short"); - ret[QStringLiteral("__int32")] = QLatin1String("int"); - ret[QStringLiteral("__int64")] = QLatin1String("long long"); - ret[QStringLiteral("__int16")] = QLatin1String("short"); + ret[QStringLiteral("__int8")] = QStringLiteral("char"); + ret[QStringLiteral("__int16")] = QStringLiteral("short"); + ret[QStringLiteral("__int32")] = QStringLiteral("int"); + ret[QStringLiteral("__int64")] = QStringLiteral("long long"); + ret[QStringLiteral("__int16")] = QStringLiteral("short"); ret[QStringLiteral("__ptr32")] = QLatin1String(""); ret[QStringLiteral("__ptr64")] = QLatin1String(""); } // MSVC specific modifiers // see http://msdn.microsoft.com/en-us/library/vstudio/s04b5w00.aspx { ret[QStringLiteral("__sptr")] = QLatin1String(""); ret[QStringLiteral("__uptr")] = QLatin1String(""); ret[QStringLiteral("__unaligned")] = QLatin1String(""); ret[QStringLiteral("__w64")] = QLatin1String(""); } // MSVC function specifiers // see http://msdn.microsoft.com/de-de/library/z8y1yy88.aspx { ret[QStringLiteral("__inline")] = QLatin1String(""); ret[QStringLiteral("__forceinline")] = QLatin1String(""); } return ret; } Path::List MsvcCompiler::includes(const QString&) const { QStringList _includePaths = QProcessEnvironment::systemEnvironment().value( QStringLiteral("INCLUDE") ).split( QStringLiteral(";"), QString::SkipEmptyParts ); Path::List includePaths; foreach( const QString &include, _includePaths ) { includePaths.append( Path( QDir::fromNativeSeparators( include ) ) ); } return includePaths; } MsvcCompiler::MsvcCompiler(const QString& name, const QString& path, bool editable, const QString& factoryName): ICompiler(name, path, factoryName, editable) {} diff --git a/languages/plugins/custom-definesandincludes/compilerprovider/settingsmanager.cpp b/languages/plugins/custom-definesandincludes/compilerprovider/settingsmanager.cpp index 295609e863..af3a8c662a 100644 --- a/languages/plugins/custom-definesandincludes/compilerprovider/settingsmanager.cpp +++ b/languages/plugins/custom-definesandincludes/compilerprovider/settingsmanager.cpp @@ -1,428 +1,428 @@ /* * This file is part of KDevelop * * Copyright 2010 Andreas Pakulat * Copyright 2014 Sergey Kalinichev * * 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) 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 "settingsmanager.h" #include #include #include #include #include #include #include #include #include #include #include "compilerprovider.h" using namespace KDevelop; namespace { namespace ConfigConstants { -const QString configKey = QLatin1String( "CustomDefinesAndIncludes" ); -const QString definesKey = QLatin1String( "Defines" ); -const QString includesKey = QLatin1String( "Includes" ); -const QString projectPathPrefix = QLatin1String( "ProjectPath" ); -const QString projectPathKey = QLatin1String( "Path" ); - -const QString customBuildSystemGroup = QLatin1String( "CustomBuildSystem" ); -const QString definesAndIncludesGroup = QLatin1String( "Defines And Includes" ); - -const QString compilersGroup = QLatin1String( "Compilers" ); -const QString compilerNameKey = QLatin1String( "Name" ); -const QString compilerPathKey = QLatin1String( "Path" ); -const QString compilerTypeKey = QLatin1String( "Type" ); +const QString configKey = QStringLiteral( "CustomDefinesAndIncludes" ); +const QString definesKey = QStringLiteral( "Defines" ); +const QString includesKey = QStringLiteral( "Includes" ); +const QString projectPathPrefix = QStringLiteral( "ProjectPath" ); +const QString projectPathKey = QStringLiteral( "Path" ); + +const QString customBuildSystemGroup = QStringLiteral( "CustomBuildSystem" ); +const QString definesAndIncludesGroup = QStringLiteral( "Defines And Includes" ); + +const QString compilersGroup = QStringLiteral( "Compilers" ); +const QString compilerNameKey = QStringLiteral( "Name" ); +const QString compilerPathKey = QStringLiteral( "Path" ); +const QString compilerTypeKey = QStringLiteral( "Type" ); QString parserArgumentsCPP() { return QStringLiteral("parserArguments"); } QString parserArgumentsC() { return QStringLiteral("parserArgumentsC"); } QString parseAmbiguousAsCPP() { return QStringLiteral("parseAmbiguousAsCPP"); } } // the grouplist is randomly sorted b/c it uses QSet internally // we sort the keys here, as the structure is properly defined for us QStringList sorted(QStringList list) { std::sort(list.begin(), list.end()); return list; } ParserArguments defaultArguments() { const static ParserArguments arguments{ QStringLiteral("-ferror-limit=100 -fspell-checking -Wdocumentation -Wunused-parameter -Wunreachable-code -Wall -std=c99"), QStringLiteral("-ferror-limit=100 -fspell-checking -Wdocumentation -Wunused-parameter -Wunreachable-code -Wall -std=c++11"), QStringLiteral("-ferror-limit=100 -fspell-checking -Wdocumentation -Wunused-parameter -Wunreachable-code -Wall -std=c++11"), QStringLiteral("-ferror-limit=100 -fspell-checking -Wdocumentation -Wunused-parameter -Wunreachable-code -Wall -std=c++11"), true }; return arguments; } CompilerPointer createCompilerFromConfig(KConfigGroup& cfg) { auto grp = cfg.group("Compiler"); auto name = grp.readEntry( ConfigConstants::compilerNameKey, QString() ); if (name.isEmpty()) { return SettingsManager::globalInstance()->provider()->checkCompilerExists({}); } for (auto c : SettingsManager::globalInstance()->provider()->compilers()) { if (c->name() == name) { return c; } } // Otherwise we have no such compiler registered (broken config file), return default one return SettingsManager::globalInstance()->provider()->checkCompilerExists({}); } void writeCompilerToConfig(KConfigGroup& cfg, const CompilerPointer& compiler) { Q_ASSERT(compiler); auto grp = cfg.group("Compiler"); // Store only compiler name, path and type retrieved from registered compilers grp.writeEntry(ConfigConstants::compilerNameKey, compiler->name()); } void doWriteSettings( KConfigGroup grp, const QVector& paths ) { int pathIndex = 0; for ( const auto& path : paths ) { KConfigGroup pathgrp = grp.group( ConfigConstants::projectPathPrefix + QString::number( pathIndex++ ) ); pathgrp.writeEntry(ConfigConstants::projectPathKey, path.path); pathgrp.writeEntry(ConfigConstants::parserArgumentsCPP(), path.parserArguments.cppArguments); pathgrp.writeEntry(ConfigConstants::parserArgumentsC(), path.parserArguments.cArguments); pathgrp.writeEntry(ConfigConstants::parseAmbiguousAsCPP(), path.parserArguments.parseAmbiguousAsCPP); { int index = 0; KConfigGroup includes(pathgrp.group(ConfigConstants::includesKey)); for( auto it = path.includes.begin() ; it != path.includes.end(); ++it){ includes.writeEntry(QString::number(++index), *it); } } { KConfigGroup defines(pathgrp.group(ConfigConstants::definesKey)); for (auto it = path.defines.begin(); it != path.defines.end(); ++it) { defines.writeEntry(it.key(), it.value()); } } writeCompilerToConfig(pathgrp, path.compiler); } } /// @param remove if true all read entries will be removed from the config file QVector doReadSettings( KConfigGroup grp, bool remove = false ) { QVector paths; for( const QString &grpName : sorted(grp.groupList()) ) { if ( !grpName.startsWith( ConfigConstants::projectPathPrefix ) ) { continue; } KConfigGroup pathgrp = grp.group( grpName ); ConfigEntry path; path.path = pathgrp.readEntry( ConfigConstants::projectPathKey, "" ); path.parserArguments.cppArguments = pathgrp.readEntry(ConfigConstants::parserArgumentsCPP(), defaultArguments().cppArguments); path.parserArguments.cArguments = pathgrp.readEntry(ConfigConstants::parserArgumentsC(), defaultArguments().cArguments); path.parserArguments.parseAmbiguousAsCPP = pathgrp.readEntry(ConfigConstants::parseAmbiguousAsCPP(), defaultArguments().parseAmbiguousAsCPP); if (path.parserArguments.cppArguments.isEmpty()) { path.parserArguments.cppArguments = defaultArguments().cppArguments; } if (path.parserArguments.cArguments.isEmpty()) { path.parserArguments.cArguments = defaultArguments().cArguments; } { // defines // Backwards compatibility with old config style if(pathgrp.hasKey(ConfigConstants::definesKey)) { QByteArray tmp = pathgrp.readEntry( ConfigConstants::definesKey, QByteArray() ); QDataStream s( tmp ); s.setVersion( QDataStream::Qt_4_5 ); // backwards compatible reading QHash defines; s >> defines; path.setDefines(defines); } else { KConfigGroup defines(pathgrp.group(ConfigConstants::definesKey)); QMap defMap = defines.entryMap(); path.defines.reserve(defMap.size()); for(auto it = defMap.constBegin(); it != defMap.constEnd(); ++it) { QString key = it.key(); if(key.isEmpty()) { // Toss out the invalid key and value since a valid // value needs a valid key continue; } else { path.defines.insert(key, it.value()); } } } } { // includes // Backwards compatibility with old config style if(pathgrp.hasKey(ConfigConstants::includesKey)){ QByteArray tmp = pathgrp.readEntry( ConfigConstants::includesKey, QByteArray() ); QDataStream s( tmp ); s.setVersion( QDataStream::Qt_4_5 ); s >> path.includes; } else { KConfigGroup includes(pathgrp.group(ConfigConstants::includesKey)); QMap incMap = includes.entryMap(); for(auto it = incMap.begin(); it != incMap.end(); ++it){ QString value = it.value(); if(value.isEmpty()){ continue; } path.includes += value; } } } path.compiler = createCompilerFromConfig(pathgrp); if ( remove ) { pathgrp.deleteGroup(); } Q_ASSERT(!path.parserArguments.cppArguments.isEmpty()); Q_ASSERT(!path.parserArguments.cArguments.isEmpty()); paths << path; } return paths; } /** * Reads and converts paths from old (Custom Build System's) format to the current one. * @return all converted paths (if any) */ QVector convertedPaths( KConfig* cfg ) { KConfigGroup group = cfg->group( ConfigConstants::customBuildSystemGroup ); if ( !group.isValid() ) return {}; QVector paths; foreach( const QString &grpName, sorted(group.groupList()) ) { KConfigGroup subgroup = group.group( grpName ); if ( !subgroup.isValid() ) continue; paths += doReadSettings( subgroup, true ); } return paths; } } void ConfigEntry::setDefines(const QHash& newDefines) { defines.clear(); defines.reserve(newDefines.size()); for (auto it = newDefines.begin(); it != newDefines.end(); ++it) { defines[it.key()] = it.value().toString(); } } SettingsManager::SettingsManager() : m_provider(this) {} SettingsManager::~SettingsManager() {} SettingsManager* SettingsManager::globalInstance() { Q_ASSERT(QThread::currentThread() == qApp->thread()); static SettingsManager s_globalInstance; return &s_globalInstance; } CompilerProvider* SettingsManager::provider() { return &m_provider; } const CompilerProvider* SettingsManager::provider() const { return &m_provider; } void SettingsManager::writePaths( KConfig* cfg, const QVector< ConfigEntry >& paths ) { Q_ASSERT(QThread::currentThread() == qApp->thread()); KConfigGroup grp = cfg->group( ConfigConstants::configKey ); if ( !grp.isValid() ) return; grp.deleteGroup(); doWriteSettings( grp, paths ); } QVector SettingsManager::readPaths( KConfig* cfg ) const { Q_ASSERT(QThread::currentThread() == qApp->thread()); auto converted = convertedPaths( cfg ); if ( !converted.isEmpty() ) { const_cast(this)->writePaths( cfg, converted ); return converted; } KConfigGroup grp = cfg->group( ConfigConstants::configKey ); if ( !grp.isValid() ) { return {}; } return doReadSettings( grp ); } bool SettingsManager::needToReparseCurrentProject( KConfig* cfg ) const { auto grp = cfg->group( ConfigConstants::definesAndIncludesGroup ); return grp.readEntry( "reparse", true ); } void SettingsManager::writeUserDefinedCompilers(const QVector< CompilerPointer >& compilers) { QVector< CompilerPointer > editableCompilers; for (const auto& compiler : compilers) { if (!compiler->editable()) { continue; } editableCompilers.append(compiler); } KConfigGroup config = KSharedConfig::openConfig()->group(ConfigConstants::compilersGroup); config.deleteGroup(); config.writeEntry("number", editableCompilers.count()); int i = 0; for (const auto& compiler : editableCompilers) { KConfigGroup grp = config.group(QString::number(i)); ++i; grp.writeEntry(ConfigConstants::compilerNameKey, compiler->name()); grp.writeEntry(ConfigConstants::compilerPathKey, compiler->path()); grp.writeEntry(ConfigConstants::compilerTypeKey, compiler->factoryName()); } config.sync(); } QVector< CompilerPointer > SettingsManager::userDefinedCompilers() const { QVector< CompilerPointer > compilers; KConfigGroup config = KSharedConfig::openConfig()->group(ConfigConstants::compilersGroup); int count = config.readEntry("number", 0); for (int i = 0; i < count; i++) { KConfigGroup grp = config.group(QString::number(i)); auto name = grp.readEntry(ConfigConstants::compilerNameKey, QString()); auto path = grp.readEntry(ConfigConstants::compilerPathKey, QString()); auto type = grp.readEntry(ConfigConstants::compilerTypeKey, QString()); auto cf = m_provider.compilerFactories(); for (auto f : cf) { if (f->name() == type) { auto compiler = f->createCompiler(name, path); compilers.append(compiler); } } } return compilers; } ParserArguments SettingsManager::defaultParserArguments() const { return defaultArguments(); } ConfigEntry::ConfigEntry(const QString& path) : path(path) , compiler(SettingsManager::globalInstance()->provider()->checkCompilerExists({})) , parserArguments(defaultArguments()) {} namespace Utils { LanguageType languageType(const KDevelop::Path& path, bool treatAmbiguousAsCPP) { QMimeDatabase db; const auto mimeType = db.mimeTypeForFile(path.path()).name(); if (mimeType == QStringLiteral("text/x-csrc") || mimeType == QStringLiteral("text/x-chdr") ) { if (treatAmbiguousAsCPP) { if (path.lastPathSegment().endsWith(QLatin1String(".h"), Qt::CaseInsensitive)) { return Cpp; } } // TODO: No proper mime type detection possible yet // cf. https://bugs.freedesktop.org/show_bug.cgi?id=26913 if (path.lastPathSegment().endsWith(QLatin1String(".cl"), Qt::CaseInsensitive)) { return OpenCl; } // TODO: No proper mime type detection possible yet // cf. https://bugs.freedesktop.org/show_bug.cgi?id=23700 if (path.lastPathSegment().endsWith(QLatin1String(".cu"), Qt::CaseInsensitive)) { return Cuda; } return C; } if (mimeType == QStringLiteral("text/x-c++src") || mimeType == QStringLiteral("text/x-c++hdr") ) { return Cpp; } if (mimeType == QStringLiteral("text/x-objcsrc")) { return ObjC; } return Other; } } diff --git a/languages/plugins/custom-definesandincludes/compilerprovider/tests/test_compilerprovider.cpp b/languages/plugins/custom-definesandincludes/compilerprovider/tests/test_compilerprovider.cpp index 8a82e8a2fe..8b9fdb728f 100644 --- a/languages/plugins/custom-definesandincludes/compilerprovider/tests/test_compilerprovider.cpp +++ b/languages/plugins/custom-definesandincludes/compilerprovider/tests/test_compilerprovider.cpp @@ -1,254 +1,254 @@ /* * This file is part of KDevelop * * Copyright 2014 Sergey Kalinichev * * 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 . * */ #include "test_compilerprovider.h" #include #include #include #include #include #include #include #include #include #include "../compilerprovider.h" #include "../settingsmanager.h" #include "../tests/projectsgenerator.h" using namespace KDevelop; namespace { void testCompilerEntry(SettingsManager* settings, KConfig* config){ auto entries = settings->readPaths(config); auto entry = entries.first(); auto compilers = settings->provider()->compilers(); Q_ASSERT(!compilers.isEmpty()); bool gccCompilerInstalled = std::any_of(compilers.begin(), compilers.end(), [](const CompilerPointer& compiler){return compiler->name().contains(QLatin1String("gcc"), Qt::CaseInsensitive);}); if (gccCompilerInstalled) { QCOMPARE(entry.compiler->name(), QStringLiteral("GCC")); } } void testAddingEntry(SettingsManager* settings, KConfig* config){ auto entries = settings->readPaths(config); auto entry = entries.first(); auto compilers = settings->provider()->compilers(); ConfigEntry otherEntry; - otherEntry.defines[QStringLiteral("TEST")] = QLatin1String("lalal"); + otherEntry.defines[QStringLiteral("TEST")] = QStringLiteral("lalal"); otherEntry.includes = QStringList() << QStringLiteral("/foo"); - otherEntry.path = QLatin1String("test"); + otherEntry.path = QStringLiteral("test"); otherEntry.compiler = compilers.first(); entries << otherEntry; settings->writePaths(config, entries); auto readWriteEntries = settings->readPaths(config); QCOMPARE(readWriteEntries.size(), 2); QCOMPARE(readWriteEntries.at(0).path, entry.path); QCOMPARE(readWriteEntries.at(0).defines, entry.defines); QCOMPARE(readWriteEntries.at(0).includes, entry.includes); QCOMPARE(readWriteEntries.at(0).compiler->name(), entry.compiler->name()); QCOMPARE(readWriteEntries.at(1).path, otherEntry.path); QCOMPARE(readWriteEntries.at(1).defines, otherEntry.defines); QCOMPARE(readWriteEntries.at(1).includes, otherEntry.includes); QCOMPARE(readWriteEntries.at(1).compiler->name(), otherEntry.compiler->name()); } } void TestCompilerProvider::initTestCase() { AutoTestShell::init(); TestCore::initialize(); } void TestCompilerProvider::cleanupTestCase() { TestCore::shutdown(); } void TestCompilerProvider::testRegisterCompiler() { auto settings = SettingsManager::globalInstance(); auto provider = settings->provider(); auto cf = provider->compilerFactories(); for (int i = 0 ; i < cf.size(); ++i) { auto compiler = cf[i]->createCompiler(QString::number(i), QString::number(i)); QVERIFY(provider->registerCompiler(compiler)); QVERIFY(!provider->registerCompiler(compiler)); QVERIFY(provider->compilers().contains(compiler)); } QVERIFY(!provider->registerCompiler({})); } void TestCompilerProvider::testCompilerIncludesAndDefines() { auto settings = SettingsManager::globalInstance(); auto provider = settings->provider(); for (auto c : provider->compilers()) { if (!c->editable() && !c->path().isEmpty()) { QVERIFY(!c->defines({}).isEmpty()); QVERIFY(!c->includes({}).isEmpty()); } } QVERIFY(!provider->defines(nullptr).isEmpty()); QVERIFY(!provider->includes(nullptr).isEmpty()); auto compiler = provider->compilerForItem(nullptr); QVERIFY(compiler); QVERIFY(!compiler->defines(QStringLiteral("--std=c++11")).isEmpty()); QVERIFY(!compiler->includes(QStringLiteral("--std=c++11")).isEmpty()); } void TestCompilerProvider::testStorageBackwardsCompatible() { auto settings = SettingsManager::globalInstance(); QTemporaryFile file; QVERIFY(file.open()); QTextStream stream(&file); stream << "[Buildset]\n" << "BuildItems=@Variant(\\x00\\x00\\x00\\t\\x00\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x0b\\x00\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x1a\\x00S\\x00i\\x00m\\x00p\\x00l\\x00e\\x00P\\x00r\\x00o\\x00j\\x00e\\x00c\\x00t)\n" << "[CustomBuildSystem]\n" << "CurrentConfiguration=BuildConfig0\n" << "[CustomDefinesAndIncludes][ProjectPath0]\n" << "Defines=\\x00\\x00\\x00\\x02\\x00\\x00\\x00\\x0c\\x00_\\x00D\\x00E\\x00B\\x00U\\x00G\\x00\\x00\\x00\\n\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x10\\x00V\\x00A\\x00R\\x00I\\x00A\\x00B\\x00L\\x00E\\x00\\x00\\x00\\n\\x00\\x00\\x00\\x00\\n\\x00V\\x00A\\x00L\\x00U\\x00E\n" << "Includes=\\x00\\x00\\x00\\x01\\x00\\x00\\x00$\\x00/\\x00u\\x00s\\x00r\\x00/\\x00i\\x00n\\x00c\\x00l\\x00u\\x00d\\x00e\\x00/\\x00m\\x00y\\x00d\\x00i\\x00r\n" << "Path=/\n" << "[CustomDefinesAndIncludes][ProjectPath0][Compiler]\nName=GCC\nPath=gcc\nType=GCC\n"; file.close(); KConfig config(file.fileName()); auto entries = settings->readPaths(&config); QCOMPARE(entries.size(), 1); auto entry = entries.first(); Defines defines; - defines[QStringLiteral("VARIABLE")] = QLatin1String("VALUE"); + defines[QStringLiteral("VARIABLE")] = QStringLiteral("VALUE"); defines[QStringLiteral("_DEBUG")] = QString(); QCOMPARE(entry.defines, defines); QStringList includes = QStringList() << QStringLiteral("/usr/include/mydir"); QCOMPARE(entry.includes, includes); QCOMPARE(entry.path, QString("/")); QVERIFY(entry.compiler); testCompilerEntry(settings, &config); testAddingEntry(settings, &config); } void TestCompilerProvider::testStorageNewSystem() { auto settings = SettingsManager::globalInstance(); QTemporaryFile file; QVERIFY(file.open()); QTextStream stream(&file); stream << "[Buildset]\n" << "BuildItems=@Variant(\\x00\\x00\\x00\\t\\x00\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x0b\\x00\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x1a\\x00S\\x00i\\x00m\\x00p\\x00l\\x00e\\x00P\\x00r\\x00o\\x00j\\x00e\\x00c\\x00t)\n\n" << "[CustomBuildSystem]\n" << "CurrentConfiguration=BuildConfig0\n\n" << "[CustomDefinesAndIncludes][ProjectPath0]\n" << "Path=/\n\n" << "[CustomDefinesAndIncludes][ProjectPath0][Defines]\n" << "_DEBUG=\n" << "VARIABLE=VALUE\n" << "[CustomDefinesAndIncludes][ProjectPath0][Includes]\n" << "1=/usr/include/mydir\n" << "2=/usr/local/include/mydir\n" << "[CustomDefinesAndIncludes][ProjectPath0][Compiler]\nName=GCC\nPath=gcc\nType=GCC\n"; file.close(); KConfig config(file.fileName()); auto entries = settings->readPaths(&config); QCOMPARE(entries.size(), 1); auto entry = entries.first(); QCOMPARE(entry.path, QString("/")); Defines defines; - defines[QStringLiteral("VARIABLE")] = QLatin1String("VALUE"); + defines[QStringLiteral("VARIABLE")] = QStringLiteral("VALUE"); defines[QStringLiteral("_DEBUG")] = QString(); QCOMPARE(entry.defines, defines); QMap includeMap; - includeMap[QStringLiteral("1")] = QLatin1String("/usr/include/mydir"); - includeMap[QStringLiteral("2")] = QLatin1String("/usr/local/include/mydir"); + includeMap[QStringLiteral("1")] = QStringLiteral("/usr/include/mydir"); + includeMap[QStringLiteral("2")] = QStringLiteral("/usr/local/include/mydir"); int i = 0; for(auto it = includeMap.begin(); it != includeMap.end(); it++) { QCOMPARE(entry.includes.at(i++), it.value()); } testCompilerEntry(settings, &config); testAddingEntry(settings, &config); } void TestCompilerProvider::testCompilerIncludesAndDefinesForProject() { auto project = ProjectsGenerator::GenerateMultiPathProject(); Q_ASSERT(project); auto settings = SettingsManager::globalInstance(); auto provider = settings->provider(); Q_ASSERT(!provider->compilerFactories().isEmpty()); auto compiler = provider->compilerFactories().first()->createCompiler(QStringLiteral("name"), QStringLiteral("path")); QVERIFY(provider->registerCompiler(compiler)); QVERIFY(provider->compilers().contains(compiler)); auto projectCompiler = provider->compilerForItem(project->projectItem()); QVERIFY(projectCompiler); QVERIFY(projectCompiler != compiler); ProjectBaseItem* mainfile = nullptr; for (const auto& file: project->fileSet() ) { for (auto i: project->filesForPath(file)) { if( i->text() == QLatin1String("main.cpp") ) { mainfile = i; break; } } } QVERIFY(mainfile); auto mainCompiler = provider->compilerForItem(mainfile); QVERIFY(mainCompiler); QVERIFY(mainCompiler->name() == projectCompiler->name()); ConfigEntry entry; - entry.path = QLatin1String("src/main.cpp"); + entry.path = QStringLiteral("src/main.cpp"); entry.compiler = compiler; auto entries = settings->readPaths(project->projectConfiguration().data()); entries.append(entry); settings->writePaths(project->projectConfiguration().data(), entries); QVERIFY(provider->compilers().contains(compiler)); mainCompiler = provider->compilerForItem(mainfile); QVERIFY(mainCompiler); QVERIFY(mainCompiler->name() == compiler->name()); ICore::self()->projectController()->closeProject(project); } QTEST_MAIN(TestCompilerProvider) diff --git a/languages/plugins/custom-definesandincludes/tests/projectsgenerator.cpp b/languages/plugins/custom-definesandincludes/tests/projectsgenerator.cpp index 2ce96c3b8d..d15847c992 100644 --- a/languages/plugins/custom-definesandincludes/tests/projectsgenerator.cpp +++ b/languages/plugins/custom-definesandincludes/tests/projectsgenerator.cpp @@ -1,204 +1,204 @@ /* * Copyright 2014 Sergey Kalinichev * * 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 . * */ #include "projectsgenerator.h" #include #include #include #include #include #include #include #include #include using namespace KDevelop; namespace { /// @param projectFile projectName.kdev4 file IProject* loadProject( const QString& projectFile, const QString& projectName ) { KDevSignalSpy* projectSpy = new KDevSignalSpy( ICore::self()->projectController(), SIGNAL(projectOpened(KDevelop::IProject*)) ); ICore::self()->projectController()->openProject( QUrl::fromLocalFile(projectFile) ); if( !projectSpy->wait( 5000 ) ) { qFatal("Expected project to be loaded within 5 seconds, but this didn't happen"); } IProject* project = ICore::self()->projectController()->findProjectByName( projectName ); return project; } void createFile( QFile& file ) { file.remove(); if ( !file.open( QIODevice::ReadWrite ) ) { qFatal("Cannot create the file %s", file.fileName().toUtf8().constData()); } } } IProject* ProjectsGenerator::GenerateSimpleProject() { // directory structure: // ./simpleproject.kdev4 // ./src/main.cpp // ./.kdev4/simpleproject.kdev4 - const QString sp = QLatin1String( "simpleproject" ); + const QString sp = QStringLiteral( "simpleproject" ); auto rootFolder = QDir::temp(); QDir(rootFolder.absolutePath() + "/" + sp).removeRecursively(); rootFolder.mkdir( sp ); rootFolder.cd( sp ); rootFolder.mkdir( QStringLiteral("src") ); rootFolder.mkdir( QStringLiteral(".kdev4") ); { QFile file( rootFolder.filePath( QStringLiteral("simpleproject.kdev4") ) ); createFile( file ); QTextStream stream1( &file ); stream1 << "[Project]\nName=SimpleProject\nManager=KDevCustomBuildSystem"; } { QFile file( rootFolder.filePath( QStringLiteral("src/main.cpp") ) ); createFile( file ); } { QFile file( rootFolder.filePath( QStringLiteral(".kdev4/simpleproject.kdev4") ) ); createFile( file ); QTextStream stream( &file ); stream << "[Buildset]\n" << "BuildItems=@Variant(\\x00\\x00\\x00\\t\\x00\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x0b\\x00\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x1a\\x00S\\x00i\\x00m\\x00p\\x00l\\x00e\\x00P\\x00r\\x00o\\x00j\\x00e\\x00c\\x00t)\n" << "[CustomBuildSystem]\n" << "CurrentConfiguration=BuildConfig0\n" << "[CustomDefinesAndIncludes][ProjectPath0]\n" << "Defines=\\x00\\x00\\x00\\x02\\x00\\x00\\x00\\x0c\\x00_\\x00D\\x00E\\x00B\\x00U\\x00G\\x00\\x00\\x00\\n\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x10\\x00V\\x00A\\x00R\\x00I\\x00A\\x00B\\x00L\\x00E\\x00\\x00\\x00\\n\\x00\\x00\\x00\\x00\\n\\x00V\\x00A\\x00L\\x00U\\x00E\n" << "Includes=\\x00\\x00\\x00\\x01\\x00\\x00\\x00$\\x00/\\x00u\\x00s\\x00r\\x00/\\x00i\\x00n\\x00c\\x00l\\x00u\\x00d\\x00e\\x00/\\x00m\\x00y\\x00d\\x00i\\x00r\n" << "Path=/\n" << "[Project]\n" << "VersionControlSupport=\n"; } return loadProject( QDir::tempPath() + "/simpleproject/simpleproject.kdev4", QStringLiteral("SimpleProject") ); } IProject* ProjectsGenerator::GenerateMultiPathProject() { // directory structure: // ./multipathproject.kdev4 // ./src/main.cpp // ./anotherFolder/tst.h // ./.kdev4/multipathproject.kdev4 - const QString mp = QLatin1String( "multipathproject" ); + const QString mp = QStringLiteral( "multipathproject" ); auto rootFolder = QDir::temp(); QDir(rootFolder.absolutePath() + "/" + mp).removeRecursively(); rootFolder.mkdir( mp ); rootFolder.cd( mp ); rootFolder.mkdir( QStringLiteral("src") ); rootFolder.mkdir( QStringLiteral(".kdev4") ); rootFolder.mkdir( QStringLiteral("anotherFolder") ); { QFile file( rootFolder.filePath( QStringLiteral("multipathproject.kdev4") ) ); createFile( file ); QTextStream stream1( &file ); stream1 << "[Project]\nName=MultiPathProject\nManager=KDevCustomBuildSystem"; ; } { QFile file1( rootFolder.filePath( QStringLiteral("src/main.cpp") ) ); createFile( file1 ); QFile file2( rootFolder.filePath( QStringLiteral("anotherFolder/tst.h") ) ); createFile( file2 ); } { QFile file( rootFolder.filePath( QStringLiteral(".kdev4/multipathproject.kdev4") ) ); createFile( file ); QTextStream stream( &file ); stream << "[Buildset]\n" << "BuildItems=@Variant(\\x00\\x00\\x00\\t\\x00\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x0b\\x00\\x00\\x00\\x00\\x01\\x00\\x00\\x00 \\x00M\\x00u\\x00l\\x00t\\x00i\\x00P\\x00a\\x00t\\x00h\\x00P\\x00r\\x00o\\x00j\\x00e\\x00c\\x00t)\n" << "[CustomBuildSystem]\n" << "CurrentConfiguration=BuildConfig0\n" << "[CustomDefinesAndIncludes][ProjectPath0]\n" << "Defines=\\x00\\x00\\x00\\x02\\x00\\x00\\x00\\n\\x00_\\x00C\\x00O\\x00P\\x00Y\\x00\\x00\\x00\\n\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x0c\\x00S\\x00O\\x00U\\x00R\\x00C\\x00E\\x00\\x00\\x00\\n\\x00\\x00\\x00\\x00\\x0e\\x00C\\x00O\\x00N\\x00T\\x00E\\x00N\\x00T\n" << "Includes=\\x00\\x00\\x00\\x01\\x00\\x00\\x00*\\x00/\\x00u\\x00s\\x00r\\x00/\\x00i\\x00n\\x00c\\x00l\\x00u\\x00d\\x00e\\x00/\\x00o\\x00t\\x00h\\x00e\\x00r\\x00d\\x00i\\x00r\n" << "Path=.\n" << "[CustomDefinesAndIncludes][ProjectPath1]\n" << "Defines=\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\n\\x00B\\x00U\\x00I\\x00L\\x00D\\x00\\x00\\x00\\n\\x00\\x00\\x00\\x00\\n\\x00d\\x00e\\x00b\\x00u\\x00g\n" << "Includes=\\x00\\x00\\x00\\x01\\x00\\x00\\x000\\x00/\\x00u\\x00s\\x00r\\x00/\\x00l\\x00o\\x00c\\x00a\\x00l\\x00/\\x00i\\x00n\\x00c\\x00l\\x00u\\x00d\\x00e\\x00/\\x00m\\x00y\\x00d\\x00i\\x00r\n" << "Path=src\n" << "[CustomDefinesAndIncludes][ProjectPath2]\n" << "Defines=\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x0c\\x00H\\x00I\\x00D\\x00D\\x00E\\x00N\\x00\\x00\\x00\\n\\x00\\x00\\x00\\x00\\x00\n" << "Path=anotherFolder\n" << "[Project]\n" << "VersionControlSupport=\n"; } return loadProject( QDir::tempPath() + "/multipathproject/multipathproject.kdev4", QStringLiteral("MultiPathProject") ); } IProject* ProjectsGenerator::GenerateSimpleProjectWithOutOfProjectFiles() { auto project = GenerateSimpleProject(); Q_ASSERT(project); auto rootFolder = QDir(project->path().path()); const QString includePaths = QStringLiteral(".kdev_include_paths"); QFile file(rootFolder.filePath(includePaths)); createFile(file); QTextStream stream( &file ); stream << "." + QDir::separator() + "include1.h" << endl << rootFolder.canonicalPath() + QDir::separator() + "include2.h"; return project; } IProject* ProjectsGenerator::GenerateEmptyProject() { // directory structure: // ./emptyproject.kdev4 // ./.kdev4/emptyproject.kdev4 - const QString ep = QLatin1String("emptyproject"); + const QString ep = QStringLiteral("emptyproject"); auto rootFolder = QDir::temp(); QDir(rootFolder.absolutePath() + "/" + ep).removeRecursively(); rootFolder.mkdir(ep); rootFolder.cd(ep); rootFolder.mkdir(QStringLiteral(".kdev4")); { QFile file(rootFolder.filePath(QStringLiteral("emptyproject.kdev4"))); createFile(file); QTextStream stream(&file); stream << "[Project]\nName=EmptyProject\nManager=KDevCustomBuildSystem"; } { QFile file(rootFolder.filePath(QStringLiteral(".kdev4/emptyproject.kdev4"))); createFile(file); QTextStream stream(&file); stream << "[Project]\n" << "VersionControlSupport=\n"; } return loadProject(QDir::tempPath() + "/emptyproject/emptyproject.kdev4", QStringLiteral("EmptyProject")); } diff --git a/languages/qmljs/codecompletion/context.cpp b/languages/qmljs/codecompletion/context.cpp index 0ef3dbc052..360dab3f1f 100644 --- a/languages/qmljs/codecompletion/context.cpp +++ b/languages/qmljs/codecompletion/context.cpp @@ -1,501 +1,501 @@ /* * This file is part of qmljs, the QML/JS language support plugin for KDevelop * Copyright (c) 2013 Sven Brauch * * 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 . * */ #include "context.h" #include "items/modulecompletionitem.h" #include "items/functioncalltipcompletionitem.h" #include #include #include #include #include #include #include #include #include #include "../duchain/expressionvisitor.h" #include "../duchain/helper.h" #include "../duchain/cache.h" #include "../duchain/frameworks/nodejs.h" #include #include using namespace KDevelop; typedef QPair DeclarationDepthPair; namespace QmlJS { CodeCompletionContext::CodeCompletionContext(const DUContextPointer& context, const QString& text, const CursorInRevision& position, int depth) : KDevelop::CodeCompletionContext(context, extractLastLine(text), position, depth), m_completionKind(NormalCompletion) { // Detect "import ..." and provide import completions if (m_text.startsWith(QLatin1String("import "))) { m_completionKind = ImportCompletion; } // Node.js module completions if (m_text.endsWith(QLatin1String("require("))) { m_completionKind = NodeModulesCompletion; } // Detect whether the cursor is in a comment bool isLastLine = true; bool inString = false; for (int index = text.size()-1; index > 0; --index) { const QChar c = text.at(index); const QChar prev = text.at(index - 1); if (c == QLatin1Char('\n')) { isLastLine = false; } else if (isLastLine && prev == QLatin1Char('/') && c == QLatin1Char('/')) { // Single-line comment on the current line, we are in a comment m_completionKind = CommentCompletion; break; } else if (prev == QLatin1Char('/') && c == QLatin1Char('*')) { // Start of a multi-line comment encountered m_completionKind = CommentCompletion; break; } else if (prev == QLatin1Char('*') && c == QLatin1Char('/')) { // End of a multi-line comment. Because /* and */ cannot be nested, // encountering a */ is enough to know that the cursor is outside a // comment break; } else if (prev != QLatin1Char('\\') && (c == QLatin1Char('"') || c == QLatin1Char('\''))) { // Toggle whether we are in a string or not inString = !inString; } } if (inString) { m_completionKind = StringCompletion; } // Some specific constructs don't need any code-completion at all (mainly // because the user will declare new things, not use ones) if (m_text.contains(QRegExp(QLatin1String("(var|function)\\s+$"))) || // "var |" or "function |" m_text.contains(QRegExp(QLatin1String("property\\s+[a-zA-Z0-9_]+\\s+$"))) || // "property |" m_text.contains(QRegExp(QLatin1String("function(\\s+[a-zA-Z0-9_]+)?\\s*\\($"))) || // "function (|" or "function (|" m_text.contains(QRegExp(QLatin1String("id:\\s*"))) // "id: |" ) { m_completionKind = NoCompletion; } } QList CodeCompletionContext::completionItems(bool& abort, bool fullCompletion) { Q_UNUSED (fullCompletion); if (abort) { return QList(); } switch (m_completionKind) { case NormalCompletion: return normalCompletion(); case CommentCompletion: return commentCompletion(); case ImportCompletion: return importCompletion(); case NodeModulesCompletion: return nodeModuleCompletions(); case StringCompletion: case NoCompletion: break; } return QList(); } AbstractType::Ptr CodeCompletionContext::typeToMatch() const { return m_typeToMatch; } QList CodeCompletionContext::normalCompletion() { QList items; QChar lastChar = m_text.size() > 0 ? m_text.at(m_text.size() - 1) : QLatin1Char('\0'); bool inQmlObjectScope = (m_duContext->type() == DUContext::Class); // Start with the function call-tips, because functionCallTips is also responsible // for setting m_declarationForTypeMatch items << functionCallTips(); if (lastChar == QLatin1Char('.') || lastChar == QLatin1Char('[')) { // Offer completions for object members and array subscripts items << fieldCompletions( m_text.left(m_text.size() - 1), lastChar == QLatin1Char('[') ? CompletionItem::QuotesAndBracket : CompletionItem::NoDecoration ); } // "object." must only display the members of object, the declarations // available in the current context. if (lastChar != QLatin1Char('.')) { if (inQmlObjectScope) { DUChainReadLocker lock; // The cursor is in a QML object and there is nothing before it. Display // a list of properties and signals that can be used in a script binding. // Note that the properties/signals of parent QML objects are not displayed here items << completionsInContext(m_duContext, CompletionOnlyLocal | CompletionHideWrappers, CompletionItem::ColonOrBracket); items << completionsFromImports(CompletionHideWrappers); items << completionsInContext(DUContextPointer(m_duContext->topContext()), CompletionHideWrappers, CompletionItem::NoDecoration); } else { items << completionsInContext(m_duContext, nullptr, CompletionItem::NoDecoration); items << completionsFromImports(nullptr); - items << completionsFromNodeModule(nullptr, QLatin1String("__builtin_ecmascript")); + items << completionsFromNodeModule(nullptr, QStringLiteral("__builtin_ecmascript")); if (!QmlJS::isQmlFile(m_duContext.data())) { - items << completionsFromNodeModule(nullptr, QLatin1String("__builtin_dom")); + items << completionsFromNodeModule(nullptr, QStringLiteral("__builtin_dom")); } } } return items; } QList CodeCompletionContext::commentCompletion() { return QList(); } QList CodeCompletionContext::importCompletion() { QList items; QString fragment = m_text.section(QLatin1Char(' '), -1, -1); // Use the cache to find the directory corresponding to the fragment // (org.kde is, for instance, /usr/lib64/kde4/imports/org/kde), and list // its subdirectories QString dataDir = Cache::instance().modulePath(m_duContext->url(), fragment); QDir dir; if (!dataDir.isEmpty()) { dir.setPath(dataDir); for (const QString& entry : dir.entryList(QDir::Dirs | QDir::NoDotAndDotDot, QDir::Name)) { items.append(CompletionTreeItemPointer(new ModuleCompletionItem( fragment + entry.section(QLatin1Char('.'), 0, 0), ModuleCompletionItem::Import ))); } } return items; } QList CodeCompletionContext::nodeModuleCompletions() { QList items; QDir dir; for (auto path : NodeJS::instance().moduleDirectories(m_duContext->url().str())) { dir.setPath(path.toLocalFile()); for (QString entry : dir.entryList(QDir::Files, QDir::Name)) { entry.replace(QLatin1String(".js"), QString()); if (entry.startsWith(QLatin1String("__"))) { // Internal module, don't show continue; } items.append(CompletionTreeItemPointer( new ModuleCompletionItem(entry, ModuleCompletionItem::Quotes) )); } } return items; } QList CodeCompletionContext::functionCallTips() { Stack stack = expressionStack(m_text); QList items; int argumentHintDepth = 1; bool isTopOfStack = true; DUChainReadLocker lock; while (!stack.isEmpty()) { ExpressionStackEntry entry = stack.pop(); if (isTopOfStack && entry.operatorStart > entry.startPosition) { // Deduce the declaration for type matching using operatorStart: // // table[document.base + // [ ^ // // ^ = operatorStart. Just before operatorStart is a code snippet that ends // with the declaration whose type should be used. DeclarationPointer decl = declarationAtEndOfString(m_text.left(entry.operatorStart)); if (decl) { m_typeToMatch = decl->abstractType(); } } if (entry.startPosition > 0 && m_text.at(entry.startPosition - 1) == QLatin1Char('(')) { // The current entry represents a function call, create a call-tip for it DeclarationPointer functionDecl = declarationAtEndOfString(m_text.left(entry.startPosition - 1)); if (functionDecl) { auto item = new FunctionCalltipCompletionItem( functionDecl, argumentHintDepth, entry.commas ); items << CompletionTreeItemPointer(item); argumentHintDepth++; if (isTopOfStack && !m_typeToMatch) { m_typeToMatch = item->currentArgumentType(); } } } isTopOfStack = false; } return items; } QList CodeCompletionContext::completionsFromImports(CompletionInContextFlags flags) { QList items; // Iterate over all the imported namespaces and add their definitions DUChainReadLocker lock; QList imports = m_duContext->findDeclarations(globalImportIdentifier()); QList realImports; foreach (Declaration* import, imports) { if (import->kind() != Declaration::NamespaceAlias) { continue; } NamespaceAliasDeclaration* decl = static_cast(import); realImports << m_duContext->findDeclarations(decl->importIdentifier()); } foreach (Declaration* import, realImports) { items << completionsInContext( DUContextPointer(import->internalContext()), flags, CompletionItem::NoDecoration ); } return items; } QList CodeCompletionContext::completionsFromNodeModule(CompletionInContextFlags flags, const QString& module) { return completionsInContext( DUContextPointer(QmlJS::getInternalContext( QmlJS::NodeJS::instance().moduleExports(module, m_duContext->url()) )), flags | CompletionOnlyLocal, CompletionItem::NoDecoration ); } QList CodeCompletionContext::completionsInContext(const DUContextPointer& context, CompletionInContextFlags flags, CompletionItem::Decoration decoration) { QList items; DUChainReadLocker lock; if (context) { const QList& declarations = context->allDeclarations( CursorInRevision::invalid(), context->topContext(), !flags.testFlag(CompletionOnlyLocal) ); foreach (const DeclarationDepthPair& decl, declarations) { DeclarationPointer declaration(decl.first); CompletionItem::Decoration decorationOfThisItem = decoration; if (declaration->identifier() == globalImportIdentifier()) { continue; } if (declaration->qualifiedIdentifier().isEmpty()) { continue; } else if (context->owner() && ( context->owner()->kind() == Declaration::Namespace || context->owner()->kind() == Declaration::NamespaceAlias ) && decl.second != 0 && decl.second != 1001) { // Only show the local declarations of modules, or the declarations // immediately in its imported parent contexts (that are global // contexts, hence the distance of 1001). This prevens "String()", // "QtQuick1.0" and "builtins" from being listed when the user // types "PlasmaCore.". continue; } else if (decorationOfThisItem == CompletionItem::NoDecoration && declaration->abstractType() && declaration->abstractType()->whichType() == AbstractType::TypeFunction) { // Decorate function calls with brackets decorationOfThisItem = CompletionItem::Brackets; } else if (flags.testFlag(CompletionHideWrappers)) { ClassDeclaration* classDecl = dynamic_cast(declaration.data()); if (classDecl && classDecl->classType() == ClassDeclarationData::Interface) { continue; } } items << CompletionTreeItemPointer(new CompletionItem(declaration, decl.second, decorationOfThisItem)); } } return items; } QList CodeCompletionContext::fieldCompletions(const QString& expression, CompletionItem::Decoration decoration) { // The statement given to this method ends with an expression that may identify // a declaration ("foo" in "test(1, 2, foo"). List the declarations of this // inner context DUContext* context = getInternalContext(declarationAtEndOfString(expression)); if (context) { return completionsInContext(DUContextPointer(context), CompletionOnlyLocal, decoration); } else { return QList(); } } Stack CodeCompletionContext::expressionStack(const QString& expression) { Stack stack; ExpressionStackEntry entry; QmlJS::Lexer lexer(nullptr); bool atEnd = false; lexer.setCode(expression, 1, false); entry.startPosition = 0; entry.operatorStart = 0; entry.operatorEnd = 0; entry.commas = 0; stack.push(entry); // NOTE: KDevelop uses 0-indexed columns while QMLJS uses 1-indexed columns while (!atEnd) { switch (lexer.lex()) { case QmlJSGrammar::EOF_SYMBOL: atEnd = true; break; case QmlJSGrammar::T_LBRACE: case QmlJSGrammar::T_LBRACKET: case QmlJSGrammar::T_LPAREN: entry.startPosition = lexer.tokenEndColumn() - 1; entry.operatorStart = entry.startPosition; entry.operatorEnd = entry.startPosition; entry.commas = 0; stack.push(entry); break; case QmlJSGrammar::T_RBRACE: case QmlJSGrammar::T_RBRACKET: case QmlJSGrammar::T_RPAREN: if (stack.count() > 1) { stack.pop(); } break; case QmlJSGrammar::T_IDENTIFIER: case QmlJSGrammar::T_DOT: case QmlJSGrammar::T_THIS: break; case QmlJSGrammar::T_COMMA: stack.top().commas++; default: // The last operator of every sub-expression is stored on the stack // so that "A = foo." can know that attributes of foo having the same // type as A should be highlighted. stack.top().operatorStart = lexer.tokenStartColumn() - 1; stack.top().operatorEnd = lexer.tokenEndColumn() - 1; } } return stack; } DeclarationPointer CodeCompletionContext::declarationAtEndOfString(const QString& expression) { // Build the expression stack of expression and use the valid portion of the // top sub-expression to find the right-most declaration that can be found // in expression. QmlJS::Document::MutablePtr doc = QmlJS::Document::create(QStringLiteral("inline"), Dialect::JavaScript); ExpressionStackEntry topEntry = expressionStack(expression).top(); doc->setSource(expression.mid(topEntry.operatorEnd)); doc->parseExpression(); if (!doc || !doc->isParsedCorrectly()) { return DeclarationPointer(); } // Use ExpressionVisitor to find the type (and associated declaration) of // the snippet that has been parsed. The inner context of the declaration // can be used to get the list of completions ExpressionVisitor visitor(m_duContext.data()); doc->ast()->accept(&visitor); return visitor.lastDeclaration(); } bool CodeCompletionContext::containsOnlySpaces(const QString& str) { for (int i=0; i * * 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 . * */ #include "completionitem.h" #include "context.h" #include #include #include #include #include #include #include #include #include #include #include "../../duchain/functiontype.h" using namespace QmlJS; using namespace KDevelop; CompletionItem::CompletionItem(DeclarationPointer decl, int inheritanceDepth, Decoration decoration) : NormalDeclarationCompletionItem(decl, QExplicitlySharedDataPointer(), inheritanceDepth), m_decoration(decoration) { } QVariant CompletionItem::data(const QModelIndex& index, int role, const CodeCompletionModel* model) const { DUChainReadLocker lock; Declaration* decl = declaration().data(); if (!decl) { return QVariant(); } ClassDeclaration* classDecl = dynamic_cast(decl); StructureType::Ptr declType = StructureType::Ptr::dynamicCast(decl->abstractType()); auto funcType = QmlJS::FunctionType::Ptr::dynamicCast(decl->abstractType()); if (role == CodeCompletionModel::BestMatchesCount) { return 5; } else if (role == CodeCompletionModel::MatchQuality) { AbstractType::Ptr referenceType = static_cast(model->completionContext().data())->typeToMatch(); if (!referenceType) { return QVariant(); } AbstractType::Ptr declType = decl->abstractType(); if (!declType) { return QVariant(); } QmlJS::FunctionType::Ptr declFunc = QmlJS::FunctionType::Ptr::dynamicCast(declType); if (declType->equals(referenceType.constData())) { // Perfect type match return QVariant(10); } else if (declFunc && declFunc->returnType() && declFunc->returnType()->equals(referenceType.constData())) { // Also very nice: a function returning the proper type return QVariant(9); } else { // Completely different types, no luck return QVariant(); } } else if (role == Qt::DisplayRole && funcType) { // Functions are displayed using the "type funcName(arg, arg, arg...)" format Declaration* funcDecl = funcType->declaration(decl->topContext()); if (funcDecl) { switch (index.column()) { case CodeCompletionModel::Prefix: return funcType->returnType()->toString(); case CodeCompletionModel::Name: // Return the identifier of the declaration being listed, not of its // function declaration (because the function may have been declared // anonymously, even if it has been assigned to a variable) return decl->identifier().toString(); case CodeCompletionModel::Arguments: { QStringList args; for (auto arg : funcDecl->internalContext()->localDeclarations()) { args.append(arg->toString()); } - return QStringLiteral("(%1)").arg(args.join(QLatin1String(", "))); + return QStringLiteral("(%1)").arg(args.join(QStringLiteral(", "))); } } } } else if (role == Qt::DisplayRole && index.column() == CodeCompletionModel::Prefix) { if (classDecl) { if (classDecl->classType() == ClassDeclarationData::Class) { // QML component return QStringLiteral("component"); } else if (classDecl->classType() == ClassDeclarationData::Interface) { // C++-ish QML component return QStringLiteral("wrapper"); } } if (decl && ( decl->kind() == Declaration::NamespaceAlias || decl->kind() == Declaration::Namespace )) { // Display namespaces and namespace aliases as modules return QStringLiteral("module"); } if (decl && decl->abstractType() && decl->kind() == Declaration::Type && decl->abstractType()->whichType() == AbstractType::TypeEnumeration) { // Enum return QStringLiteral("enum"); } if (declType && decl->kind() == Declaration::Instance && declType->declarationId().qualifiedIdentifier().isEmpty()) { // QML component instance. The type that should be displayed is the // base class of its anonymous class ClassDeclaration* anonymousClass = dynamic_cast(declType->declaration(decl->topContext())); if (anonymousClass && anonymousClass->baseClassesSize() > 0) { return anonymousClass->baseClasses()[0].baseClass.abstractType()->toString(); } } } return NormalDeclarationCompletionItem::data(index, role, model); } QString CompletionItem::declarationName() const { ClassFunctionDeclaration* classFuncDecl = dynamic_cast(declaration().data()); if (classFuncDecl && classFuncDecl->isSignal() && m_decoration == QmlJS::CompletionItem::ColonOrBracket) { // Signals, when completed in a QML component context, are transformed into slots QString signal = classFuncDecl->identifier().toString(); if (signal.size() > 0) { return QLatin1String("on") + signal.at(0).toUpper() + signal.mid(1); } } return NormalDeclarationCompletionItem::declarationName(); } CodeCompletionModel::CompletionProperties CompletionItem::completionProperties() const { DUChainReadLocker lock; // Variables having a function type should have a function icon. FunctionDeclarations // are skipped here because they are already handled properly by completionProperties() if (declaration() && declaration()->abstractType() && !declaration()->isFunctionDeclaration() && declaration()->abstractType()->whichType() == AbstractType::TypeFunction) { return CodeCompletionModel::Function; } // Put declarations in a context owned by a namespace in the namespace scope auto properties = NormalDeclarationCompletionItem::completionProperties(); if (declaration() && declaration()->context() && declaration()->context()->owner() && ( declaration()->context()->owner()->kind() == Declaration::Namespace || declaration()->context()->type() == DUContext::Enum )) { properties &= ~(CodeCompletionModel::LocalScope | CodeCompletionModel::GlobalScope | CodeCompletionModel::Public); properties |= CodeCompletionModel::NamespaceScope; } return properties; } void CompletionItem::execute(KTextEditor::View* view, const KTextEditor::Range& word) { KTextEditor::Document* document = view->document(); QString base = declarationName(); switch (m_decoration) { case QmlJS::CompletionItem::NoDecoration: document->replaceText(word, base); break; case QmlJS::CompletionItem::Quotes: document->replaceText(word, "\"" + base + "\""); break; case QmlJS::CompletionItem::QuotesAndBracket: document->replaceText(word, "\"" + base + "\"]"); break; case QmlJS::CompletionItem::ColonOrBracket: if (declaration() && declaration()->abstractType() && declaration()->abstractType()->whichType() == AbstractType::TypeStructure) { document->replaceText(word, base + " {}"); } else { document->replaceText(word, base + ": "); } break; case QmlJS::CompletionItem::Brackets: document->replaceText(word, base + "()"); } } diff --git a/languages/qmljs/codecompletion/items/functioncalltipcompletionitem.cpp b/languages/qmljs/codecompletion/items/functioncalltipcompletionitem.cpp index 7b01a650dd..124f7ce056 100644 --- a/languages/qmljs/codecompletion/items/functioncalltipcompletionitem.cpp +++ b/languages/qmljs/codecompletion/items/functioncalltipcompletionitem.cpp @@ -1,178 +1,178 @@ /* * This file is part of qmljs, the QML/JS language support plugin for KDevelop * Copyright (c) 2014 Denis Steckelmacher * * 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 . * */ #include "functioncalltipcompletionitem.h" #include "../../duchain/helper.h" #include "../../duchain/functiontype.h" #include #include #include #include using namespace KDevelop; using namespace QmlJS; FunctionCalltipCompletionItem::FunctionCalltipCompletionItem(const DeclarationPointer& decl, int depth, int argumentIndex) : m_declaration(decl), m_depth(depth) { // Ensure that decl has a function type if (!decl) { return; } QmlJS::FunctionType::Ptr func = QmlJS::FunctionType::Ptr::dynamicCast(decl->abstractType()); if (!func) { return; } // Arguments can be fetch from the function declaration (if available), or // from its function type Declaration* funcDecl = func->declaration(decl->topContext()); DUContext* argsContext = (funcDecl ? funcDecl->internalContext() : nullptr); QStringList arguments; if (argsContext) { auto args = argsContext->allDeclarations(CursorInRevision::invalid(), decl->topContext(), false); for (auto pair : args) { arguments.append(pair.first->toString()); } if (argumentIndex < args.count()) { m_currentArgumentType = args.at(argumentIndex).first->abstractType(); } } else { for (auto type : func->arguments()) { arguments.append(type->toString()); } if (argumentIndex < func->arguments().count()) { m_currentArgumentType = func->arguments().at(argumentIndex); } } // [type] functionName if (func->returnType()) { m_prefix = func->returnType()->toString() + QLatin1String(" "); } m_prefix += decl->identifier().toString(); // (arg1, arg2, [currentArgument in m_currentArgument], arg4, arg5) - m_arguments = QLatin1String("("); + m_arguments = QStringLiteral("("); for (int i=0; i 0) { m_arguments += QLatin1String(", "); } if (i == argumentIndex) { m_currentArgumentStart = m_arguments.length(); m_currentArgumentLength = arguments.at(i).length(); } m_arguments += arguments.at(i); } m_arguments += QLatin1String(")"); } AbstractType::Ptr FunctionCalltipCompletionItem::currentArgumentType() const { return m_currentArgumentType; } QVariant FunctionCalltipCompletionItem::data(const QModelIndex& index, int role, const CodeCompletionModel* model) const { Q_UNUSED(model) switch (role) { case Qt::DisplayRole: switch (index.column()) { case CodeCompletionModel::Prefix: return m_prefix; case CodeCompletionModel::Arguments: return m_arguments; } break; case CodeCompletionModel::ArgumentHintDepth: return argumentHintDepth(); case CodeCompletionModel::CompletionRole: return (int)completionProperties(); case CodeCompletionModel::HighlightingMethod: if (index.column() == CodeCompletionModel::Arguments) { return (int)CodeCompletionModel::CustomHighlighting; } break; case CodeCompletionModel::CustomHighlight: if (index.column() == CodeCompletionModel::Arguments) { QTextFormat format; format.setBackground(QBrush(QColor::fromRgb(142, 186, 255))); // Same color as kdev-python format.setProperty(QTextFormat::FontWeight, 99); return QVariantList() << m_currentArgumentStart << m_currentArgumentLength << format; } break; case Qt::DecorationRole: if (index.column() == CodeCompletionModel::Prefix) { return DUChainUtils::iconForProperties(completionProperties()); } break; } return QVariant(); } DeclarationPointer FunctionCalltipCompletionItem::declaration() const { return m_declaration; } int FunctionCalltipCompletionItem::argumentHintDepth() const { return m_depth; } int FunctionCalltipCompletionItem::inheritanceDepth() const { return 0; } CodeCompletionModel::CompletionProperties FunctionCalltipCompletionItem::completionProperties() const { return CodeCompletionModel::Function; } diff --git a/languages/qmljs/duchain/declarationbuilder.cpp b/languages/qmljs/duchain/declarationbuilder.cpp index fcc1e5e307..2519139164 100644 --- a/languages/qmljs/duchain/declarationbuilder.cpp +++ b/languages/qmljs/duchain/declarationbuilder.cpp @@ -1,1541 +1,1541 @@ /************************************************************************************* * Copyright (C) 2012 by Aleix Pol * * Copyright (C) 2012 by Milian Wolff * * * * 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) 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 "declarationbuilder.h" #include "debug.h" #include #include #include #include #include #include #include #include #include #include #include "expressionvisitor.h" #include "parsesession.h" #include "functiondeclaration.h" #include "functiontype.h" #include "helper.h" #include "cache.h" #include "frameworks/nodejs.h" #include #include #include using namespace KDevelop; DeclarationBuilder::DeclarationBuilder(ParseSession* session) : m_prebuilding(false) { m_session = session; } ReferencedTopDUContext DeclarationBuilder::build(const IndexedString& url, QmlJS::AST::Node* node, ReferencedTopDUContext updateContext) { Q_ASSERT(m_session->url() == url); // The declaration builder needs to run twice, so it can resolve uses of e.g. functions // which are called before they are defined (which is easily possible, due to JS's dynamic nature). if (!m_prebuilding) { qCDebug(KDEV_QMLJS_DUCHAIN) << "building, but running pre-builder first"; auto prebuilder = new DeclarationBuilder(m_session); prebuilder->m_prebuilding = true; updateContext = prebuilder->build(url, node, updateContext); qCDebug(KDEV_QMLJS_DUCHAIN) << "pre-builder finished"; delete prebuilder; if (!m_session->allDependenciesSatisfied()) { qCDebug(KDEV_QMLJS_DUCHAIN) << "dependencies were missing, don't perform the second parsing pass"; return updateContext; } } else { qCDebug(KDEV_QMLJS_DUCHAIN) << "prebuilding"; } return DeclarationBuilderBase::build(url, node, updateContext); } void DeclarationBuilder::startVisiting(QmlJS::AST::Node* node) { DUContext* builtinQmlContext = nullptr; if (QmlJS::isQmlFile(currentContext()) && !currentContext()->url().str().contains(QLatin1String("__builtin_qml.qml"))) { builtinQmlContext = m_session->contextOfFile( - QStandardPaths::locate(QStandardPaths::GenericDataLocation, QLatin1String("kdevqmljssupport/nodejsmodules/__builtin_qml.qml")) + QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("kdevqmljssupport/nodejsmodules/__builtin_qml.qml")) ); } { DUChainWriteLocker lock; // Remove all the imported parent contexts: imports may have been edited // and there musn't be any leftover parent context currentContext()->topContext()->clearImportedParentContexts(); // Initialize Node.js QmlJS::NodeJS::instance().initialize(this); // Built-in QML types (color, rect, etc) if (builtinQmlContext) { topContext()->addImportedParentContext(builtinQmlContext); } } DeclarationBuilderBase::startVisiting(node); } /* * Functions */ template void DeclarationBuilder::declareFunction(QmlJS::AST::Node* node, bool newPrototypeContext, const QualifiedIdentifier& name, const RangeInRevision& nameRange, QmlJS::AST::Node* parameters, const RangeInRevision& parametersRange, QmlJS::AST::Node* body, const RangeInRevision& bodyRange) { setComment(node); // Declare the function QmlJS::FunctionType::Ptr func(new QmlJS::FunctionType); Decl* decl; { DUChainWriteLocker lock; decl = openDeclaration(name, nameRange); decl->setKind(Declaration::Type); func->setDeclaration(decl); decl->setType(func); } openType(func); // Parameters, if any (a function must always have an internal function context, // so always open a context here even if there are no parameters) DUContext* parametersContext = openContext( node + 1, // Don't call setContextOnNode on node, only the body context can be associated with node RangeInRevision(parametersRange.start, bodyRange.end), // Ensure that this context contains both the parameters and the body DUContext::Function, name ); if (parameters) { QmlJS::AST::Node::accept(parameters, this); } // The internal context of the function is its parameter context { DUChainWriteLocker lock; decl->setInternalContext(parametersContext); } // Open the prototype context, if any. This has to be done before the body // because this context is needed for "this" to be properly resolved // in it. if (newPrototypeContext) { DUChainWriteLocker lock; QmlJS::FunctionDeclaration* d = reinterpret_cast(decl); d->setPrototypeContext(openContext( node + 2, // Don't call setContextOnNode on node, only the body context can be associated with node RangeInRevision(parametersRange.start, parametersRange.start), DUContext::Function, // This allows QmlJS::getOwnerOfContext to know that the parent of this context is the function declaration QualifiedIdentifier(name) )); - if (name.last() != Identifier(QLatin1String("Object"))) { + if (name.last() != Identifier(QStringLiteral("Object"))) { // Every class inherit from Object QmlJS::importObjectContext(currentContext(), topContext()); } closeContext(); } // Body, if any (it is a child context of the parameters) openContext( node, bodyRange, DUContext::Other, name ); if (body) { QmlJS::AST::Node::accept(body, this); } // Close the body context and then the parameters context closeContext(); closeContext(); } template void DeclarationBuilder::declareParameters(Node* node, QStringRef Node::*typeAttribute) { for (Node *plist = node; plist; plist = plist->next) { const QualifiedIdentifier name(plist->name.toString()); const RangeInRevision range = m_session->locationToRange(plist->identifierToken); AbstractType::Ptr type = (typeAttribute ? typeFromName((plist->*typeAttribute).toString()) : // The typeAttribute attribute of plist contains the type name of the argument AbstractType::Ptr(new IntegralType(IntegralType::TypeMixed)) // No type information, use mixed ); { DUChainWriteLocker lock; openDeclaration(name, range); } openType(type); closeAndAssignType(); if (QmlJS::FunctionType::Ptr funType = currentType()) { funType->addArgument(type); } } } bool DeclarationBuilder::visit(QmlJS::AST::FunctionDeclaration* node) { declareFunction( node, true, // A function declaration always has its own prototype context QualifiedIdentifier(node->name.toString()), m_session->locationToRange(node->identifierToken), node->formals, m_session->locationsToRange(node->lparenToken, node->rparenToken), node->body, m_session->locationsToRange(node->lbraceToken, node->rbraceToken) ); return false; } bool DeclarationBuilder::visit(QmlJS::AST::FunctionExpression* node) { declareFunction( node, false, QualifiedIdentifier(), QmlJS::emptyRangeOnLine(node->functionToken), node->formals, m_session->locationsToRange(node->lparenToken, node->rparenToken), node->body, m_session->locationsToRange(node->lbraceToken, node->rbraceToken) ); return false; } bool DeclarationBuilder::visit(QmlJS::AST::FormalParameterList* node) { declareParameters(node, (QStringRef QmlJS::AST::FormalParameterList::*)nullptr); return DeclarationBuilderBase::visit(node); } bool DeclarationBuilder::visit(QmlJS::AST::UiParameterList* node) { declareParameters(node, &QmlJS::AST::UiParameterList::type); return DeclarationBuilderBase::visit(node); } bool DeclarationBuilder::visit(QmlJS::AST::ReturnStatement* node) { if (QmlJS::FunctionType::Ptr func = currentType()) { AbstractType::Ptr returnType; if (node->expression) { returnType = findType(node->expression).type; } else { returnType = new IntegralType(IntegralType::TypeVoid); } DUChainWriteLocker lock; func->setReturnType(QmlJS::mergeTypes(func->returnType(), returnType)); } return false; // findType has already explored node } void DeclarationBuilder::endVisitFunction() { QmlJS::FunctionType::Ptr func = currentType(); if (func && !func->returnType()) { // A function that returns nothing returns void DUChainWriteLocker lock; func->setReturnType(AbstractType::Ptr(new IntegralType(IntegralType::TypeVoid))); } closeAndAssignType(); } void DeclarationBuilder::endVisit(QmlJS::AST::FunctionDeclaration* node) { DeclarationBuilderBase::endVisit(node); endVisitFunction(); } void DeclarationBuilder::endVisit(QmlJS::AST::FunctionExpression* node) { DeclarationBuilderBase::endVisit(node); endVisitFunction(); } /* * Variables */ void DeclarationBuilder::inferArgumentsFromCall(QmlJS::AST::Node* base, QmlJS::AST::ArgumentList* arguments) { ContextBuilder::ExpressionType expr = findType(base); QmlJS::FunctionType::Ptr func_type = QmlJS::FunctionType::Ptr::dynamicCast(expr.type); DUChainWriteLocker lock; if (!func_type) { return; } auto func_declaration = dynamic_cast(func_type->declaration(topContext())); if (!func_declaration || !func_declaration->internalContext()) { return; } // Put the argument nodes in a list that has a definite size QVector argumentDecls = func_declaration->internalContext()->localDeclarations(); QVector args; for (auto argument = arguments; argument; argument = argument->next) { args.append(argument); } // Don't update a function when it is called with the wrong number // of arguments if (args.size() != argumentDecls.count()) { return; } // Update the types of the function arguments QmlJS::FunctionType::Ptr new_func_type(new QmlJS::FunctionType); for (int i=0; iabstractType(); // Merge the current type of the argument with its type in the call expression AbstractType::Ptr call_type = findType(argument->expression).type; AbstractType::Ptr new_type = QmlJS::mergeTypes(current_type, call_type); // Update the declaration of the argument and its type in the function type if (func_declaration->topContext() == topContext()) { new_func_type->addArgument(new_type); argumentDecls.at(i)->setAbstractType(new_type); } // Add a warning if it is possible that the argument types don't match if (!m_prebuilding && !areTypesEqual(current_type, call_type)) { m_session->addProblem(argument, i18n( "Possible type mismatch between the argument type (%1) and the value passed as argument (%2)", current_type->toString(), call_type->toString() ), IProblem::Hint); } } // Replace the function's type with the new type having updated arguments if (func_declaration->topContext() == topContext()) { new_func_type->setReturnType(func_type->returnType()); new_func_type->setDeclaration(func_declaration); func_declaration->setAbstractType(new_func_type.cast()); if (expr.declaration) { // expr.declaration is the variable that contains the function, while // func_declaration is the declaration of the function. They can be // different and both need to be updated expr.declaration->setAbstractType(new_func_type.cast()); } } return; } bool DeclarationBuilder::visit(QmlJS::AST::VariableDeclaration* node) { setComment(m_session->commentForLocation(node->firstSourceLocation()).toUtf8()); const QualifiedIdentifier name(node->name.toString()); const RangeInRevision range = m_session->locationToRange(node->identifierToken); const AbstractType::Ptr type = findType(node->expression).type; { DUChainWriteLocker lock; openDeclaration(name, range); } openType(type); return false; // findType has already explored node } void DeclarationBuilder::endVisit(QmlJS::AST::VariableDeclaration* node) { DeclarationBuilderBase::endVisit(node); closeAndAssignType(); } bool DeclarationBuilder::visit(QmlJS::AST::BinaryExpression* node) { if (node->op == QSOperator::Assign) { ExpressionType leftType = findType(node->left); ExpressionType rightType = findType(node->right); DUChainWriteLocker lock; if (leftType.declaration) { DUContext* leftCtx = leftType.declaration->context(); DUContext* leftInternalCtx = QmlJS::getInternalContext(leftType.declaration); // object.prototype.method = function(){} : when assigning a function // to a variable living in a Class context, set the prototype // context of the function to the context of the variable if (rightType.declaration && leftCtx->type() == DUContext::Class) { auto func = rightType.declaration.dynamicCast(); if (!QmlJS::getOwnerOfContext(leftCtx) && !leftCtx->importers().isEmpty()) { // MyClass.prototype.myfunc declares "myfunc" in a small context // that is imported by MyClass. The prototype of myfunc should // be the context of MyClass, not the small context in which // it has been declared leftCtx = leftCtx->importers().at(0); } if (func && !func->prototypeContext()) { func->setPrototypeContext(leftCtx); } } if (leftType.declaration->topContext() != topContext()) { // Do not modify a declaration of another file } else if (leftType.isPrototype && leftInternalCtx) { // Assigning something to a prototype is equivalent to making it // inherit from a class: "Class.prototype = ClassOrObject;" leftInternalCtx->clearImportedParentContexts(); QmlJS::importDeclarationInContext( leftInternalCtx, rightType.declaration ); } else { // Merge the already-known type of the variable with the new one leftType.declaration->setAbstractType(QmlJS::mergeTypes(leftType.type, rightType.type)); } } return false; // findType has already explored node } return DeclarationBuilderBase::visit(node); } bool DeclarationBuilder::visit(QmlJS::AST::CallExpression* node) { inferArgumentsFromCall(node->base, node->arguments); return false; } bool DeclarationBuilder::visit(QmlJS::AST::NewMemberExpression* node) { inferArgumentsFromCall(node->base, node->arguments); return false; } /* * Arrays */ void DeclarationBuilder::declareFieldMember(const KDevelop::DeclarationPointer& declaration, const QString& member, QmlJS::AST::Node* node, const QmlJS::AST::SourceLocation& location) { if (QmlJS::isPrototypeIdentifier(member)) { // Don't declare "prototype", this is a special member return; } if (!m_session->allDependenciesSatisfied()) { // Don't declare anything automatically if dependencies are missing: the // checks hereafter may pass now but fail later, thus causing disappearing // declarations return; } DUChainWriteLocker lock; QualifiedIdentifier identifier(member); // Declaration must have an internal context so that the member can be added // into it. DUContext* ctx = QmlJS::getInternalContext(declaration); if (!ctx || ctx->topContext() != topContext()) { return; } // No need to re-declare a field if it already exists if (QmlJS::getDeclaration(identifier, ctx, false)) { return; } // The internal context of declaration is already closed and does not contain // location. This can be worked around by opening a new context, declaring the // new field in it, and then adding the context as a parent of // declaration->internalContext(). RangeInRevision range = m_session->locationToRange(location); IntegralType::Ptr type = IntegralType::Ptr(new IntegralType(IntegralType::TypeMixed)); DUContext* importedContext = openContext(node, range, DUContext::Class); Declaration* decl = openDeclaration(identifier, range); decl->setInSymbolTable(false); // This declaration is in an anonymous context, and the symbol table acts as if the declaration was in the global context openType(type); closeAndAssignType(); closeContext(); ctx->addImportedParentContext(importedContext); } bool DeclarationBuilder::visit(QmlJS::AST::FieldMemberExpression* node) { setComment(m_session->commentForLocation(node->firstSourceLocation()).toUtf8()); ExpressionType type = findType(node->base); if (type.declaration) { declareFieldMember( type.declaration, node->name.toString(), node, node->identifierToken ); } return false; // findType has already visited node->base } bool DeclarationBuilder::visit(QmlJS::AST::ArrayMemberExpression* node) { setComment(m_session->commentForLocation(node->firstSourceLocation()).toUtf8()); // When the user types array["new_key"], declare "new_key" as a new field of // array. auto stringLiteral = QmlJS::AST::cast(node->expression); if (!stringLiteral) { return DeclarationBuilderBase::visit(node); } ExpressionType type = findType(node->base); if (type.declaration) { declareFieldMember( type.declaration, stringLiteral->value.toString(), node, stringLiteral->literalToken ); } node->expression->accept(this); return false; // findType has already visited node->base, and we have just visited node->expression } bool DeclarationBuilder::visit(QmlJS::AST::ObjectLiteral* node) { setComment(m_session->commentForLocation(node->firstSourceLocation()).toUtf8()); // Object literals can appear in the "values" property of enumerations. Their // keys must be declared in the enumeration, not in an anonymous class if (currentContext()->type() == DUContext::Enum) { return DeclarationBuilderBase::visit(node); } // Open an anonymous class declaration, with its internal context StructureType::Ptr type(new StructureType); { DUChainWriteLocker lock; ClassDeclaration* decl = openDeclaration( QualifiedIdentifier(), QmlJS::emptyRangeOnLine(node->lbraceToken) ); decl->setKind(Declaration::Type); decl->setInternalContext(openContext( node, m_session->locationsToRange(node->lbraceToken, node->rbraceToken), DUContext::Class )); type->setDeclaration(decl); // Every object literal inherits from Object QmlJS::importObjectContext(currentContext(), topContext()); } openType(type); return DeclarationBuilderBase::visit(node); } bool DeclarationBuilder::visit(QmlJS::AST::PropertyNameAndValue* node) { setComment(node); if (!node->name || !node->value) { return DeclarationBuilderBase::visit(node); } RangeInRevision range(m_session->locationToRange(node->name->propertyNameToken)); QualifiedIdentifier name(QmlJS::getNodeValue(node->name)); // The type of the declaration can either be an enumeration value or the type // of its expression ExpressionType type; bool inSymbolTable = false; if (currentContext()->type() == DUContext::Enum) { // This is an enumeration value auto value = QmlJS::AST::cast(node->value); EnumeratorType::Ptr enumerator(new EnumeratorType); enumerator->setDataType(IntegralType::TypeInt); if (value) { enumerator->setValue((int)value->value); } type.type = AbstractType::Ptr::staticCast(enumerator); type.declaration = nullptr; inSymbolTable = true; } else { // Normal value type = findType(node->value); } // If a function is assigned to an object member, set the prototype context // of the function to the object containing the member if (type.declaration) { DUChainWriteLocker lock; auto func = type.declaration.dynamicCast(); if (func && !func->prototypeContext()) { func->setPrototypeContext(currentContext()); } } // Open the declaration { DUChainWriteLocker lock; ClassMemberDeclaration* decl = openDeclaration(name, range); decl->setInSymbolTable(inSymbolTable); } openType(type.type); return false; // findType has already explored node->expression } void DeclarationBuilder::endVisit(QmlJS::AST::PropertyNameAndValue* node) { DeclarationBuilderBase::endVisit(node); closeAndAssignType(); } void DeclarationBuilder::endVisit(QmlJS::AST::ObjectLiteral* node) { DeclarationBuilderBase::endVisit(node); if (currentContext()->type() != DUContext::Enum) { // Enums are special-cased in visit(ObjectLiteral) closeContext(); closeAndAssignType(); } } /* * plugins.qmltypes files */ void DeclarationBuilder::declareComponent(QmlJS::AST::UiObjectInitializer* node, const RangeInRevision &range, const QualifiedIdentifier &name) { QString baseClass = QmlJS::getQMLAttributeValue(node->members, QStringLiteral("prototype")).value.section('/', -1, -1); // Declare the component itself StructureType::Ptr type(new StructureType); ClassDeclaration* decl; { DUChainWriteLocker lock; decl = openDeclaration(name, range); decl->setKind(Declaration::Type); decl->setClassType(ClassDeclarationData::Interface); decl->clearBaseClasses(); if (!baseClass.isNull()) { addBaseClass(decl, baseClass); } type->setDeclaration(decl); decl->setType(type); // declareExports needs to know the type of decl } openType(type); } void DeclarationBuilder::declareMethod(QmlJS::AST::UiObjectInitializer* node, const RangeInRevision &range, const QualifiedIdentifier &name, bool isSlot, bool isSignal) { QString type_name = QmlJS::getQMLAttributeValue(node->members, QStringLiteral("type")).value; QmlJS::FunctionType::Ptr type(new QmlJS::FunctionType); if (type_name.isNull()) { type->setReturnType(typeFromName(QStringLiteral("void"))); } else { type->setReturnType(typeFromName(type_name)); } { DUChainWriteLocker lock; ClassFunctionDeclaration* decl = openDeclaration(name, range); decl->setIsSlot(isSlot); decl->setIsSignal(isSignal); type->setDeclaration(decl); } openType(type); } void DeclarationBuilder::declareProperty(QmlJS::AST::UiObjectInitializer* node, const RangeInRevision &range, const QualifiedIdentifier &name) { AbstractType::Ptr type = typeFromName(QmlJS::getQMLAttributeValue(node->members, QStringLiteral("type")).value); { DUChainWriteLocker lock; ClassMemberDeclaration* decl = openDeclaration(name, range); decl->setAbstractType(type); } openType(type); } void DeclarationBuilder::declareParameter(QmlJS::AST::UiObjectInitializer* node, const RangeInRevision &range, const QualifiedIdentifier &name) { QmlJS::FunctionType::Ptr function = currentType(); AbstractType::Ptr type = typeFromName(QmlJS::getQMLAttributeValue(node->members, QStringLiteral("type")).value); Q_ASSERT(function); function->addArgument(type); { DUChainWriteLocker lock; openDeclaration(name, range); } openType(type); } void DeclarationBuilder::declareEnum(const RangeInRevision &range, const QualifiedIdentifier &name) { EnumerationType::Ptr type(new EnumerationType); { DUChainWriteLocker lock; ClassMemberDeclaration* decl = openDeclaration(name, range); decl->setKind(Declaration::Type); decl->setType(type); // The type needs to be set here because closeContext is called before closeAndAssignType and needs to know the type of decl type->setDataType(IntegralType::TypeEnumeration); type->setDeclaration(decl); } openType(type); } void DeclarationBuilder::declareComponentSubclass(QmlJS::AST::UiObjectInitializer* node, const KDevelop::RangeInRevision& range, const QString& baseclass, QmlJS::AST::UiQualifiedId* qualifiedId) { QualifiedIdentifier name( QmlJS::getQMLAttributeValue(node->members, QStringLiteral("name")).value.section('/', -1, -1) ); DUContext::ContextType contextType = DUContext::Class; if (baseclass == QLatin1String("Component")) { // QML component, equivalent to a QML class declareComponent(node, range, name); } else if (baseclass == QLatin1String("Method") || baseclass == QLatin1String("Signal") || baseclass == QLatin1String("Slot")) { // Method (that can also be a signal or a slot) declareMethod(node, range, name, baseclass == QLatin1String("Slot"), baseclass == QLatin1String("Signal")); contextType = DUContext::Function; } else if (baseclass == QLatin1String("Property")) { // A property declareProperty(node, range, name); } else if (baseclass == QLatin1String("Parameter") && currentType()) { // One parameter of a signal/slot/method declareParameter(node, range, name); } else if (baseclass == QLatin1String("Enum")) { // Enumeration. The "values" key contains a dictionary of name -> number entries. declareEnum(range, name); contextType = DUContext::Enum; name = QualifiedIdentifier(); // Enum contexts should have no name so that their members have the correct scope } else { // Define an anonymous subclass of the baseclass. This subclass will // be instantiated when "id:" is encountered name = QualifiedIdentifier(); // Use ExpressionVisitor to find the declaration of the base class DeclarationPointer baseClass = findType(qualifiedId).declaration; StructureType::Ptr type(new StructureType); { DUChainWriteLocker lock; ClassDeclaration* decl = openDeclaration( currentContext()->type() == DUContext::Global ? QualifiedIdentifier(m_session->moduleName()) : name, QmlJS::emptyRangeOnLine(node->lbraceToken) ); decl->clearBaseClasses(); decl->setKind(Declaration::Type); decl->setType(type); // The class needs to know its type early because it contains definitions that depend on that type type->setDeclaration(decl); if (baseClass) { addBaseClass(decl, baseClass->indexedType()); } } openType(type); } // Open a context of the proper type and identifier openContext( node, m_session->locationsToInnerRange(node->lbraceToken, node->rbraceToken), contextType, name ); DUContext* ctx = currentContext(); Declaration* decl = currentDeclaration(); { // Set the inner context of the current declaration, because nested classes // need to know the inner context of their parents DUChainWriteLocker lock; decl->setInternalContext(ctx); if (contextType == DUContext::Enum) { ctx->setPropagateDeclarations(true); } } // If we have have declared a class, import the context of its base classes registerBaseClasses(); } void DeclarationBuilder::declareComponentInstance(QmlJS::AST::ExpressionStatement* expression) { if (!expression) { return; } auto identifier = QmlJS::AST::cast(expression->expression); if (!identifier) { return; } { DUChainWriteLocker lock; injectContext(topContext()); Declaration* decl = openDeclaration( QualifiedIdentifier(identifier->name.toString()), m_session->locationToRange(identifier->identifierToken) ); closeInjectedContext(); // Put the declaration in the global scope decl->setKind(Declaration::Instance); decl->setType(currentAbstractType()); } closeDeclaration(); } DeclarationBuilder::ExportLiteralsAndNames DeclarationBuilder::exportedNames(QmlJS::AST::ExpressionStatement* exports) { ExportLiteralsAndNames res; if (!exports) { return res; } auto exportslist = QmlJS::AST::cast(exports->expression); if (!exportslist) { return res; } // Explore all the exported symbols for this component and keep only those // having a version compatible with the one of this module QSet knownNames; for (auto it = exportslist->elements; it && it->expression; it = it->next) { auto stringliteral = QmlJS::AST::cast(it->expression); if (!stringliteral) { continue; } // String literal like "Namespace/Class version". QStringList nameAndVersion = stringliteral->value.toString().section('/', -1, -1).split(' '); QString name = nameAndVersion.at(0); - QString version = (nameAndVersion.count() > 1 ? nameAndVersion.at(1) : QLatin1String("1.0")); + QString version = (nameAndVersion.count() > 1 ? nameAndVersion.at(1) : QStringLiteral("1.0")); if (!knownNames.contains(name)) { knownNames.insert(name); res.append(qMakePair(stringliteral, name)); } } return res; } void DeclarationBuilder::declareExports(const ExportLiteralsAndNames& exports, ClassDeclaration* classdecl) { DUChainWriteLocker lock; // Create the exported versions of the component for (auto exp : exports) { QmlJS::AST::StringLiteral* literal = exp.first; QString name = exp.second; StructureType::Ptr type(new StructureType); injectContext(currentContext()->parentContext()); // Don't declare the export in its C++-ish component, but in the scope above ClassDeclaration* decl = openDeclaration( QualifiedIdentifier(name), m_session->locationToRange(literal->literalToken) ); closeInjectedContext(); // The exported version inherits from the C++ component decl->setKind(Declaration::Type); decl->setClassType(ClassDeclarationData::Class); decl->clearBaseClasses(); type->setDeclaration(decl); addBaseClass(decl, classdecl->indexedType()); // Open a context for the exported class, and register its base class in it decl->setInternalContext(openContext( literal, DUContext::Class, QualifiedIdentifier(name) )); registerBaseClasses(); closeContext(); openType(type); closeAndAssignType(); } } /* * UI */ void DeclarationBuilder::importDirectory(const QString& directory, QmlJS::AST::UiImport* node) { DUChainWriteLocker lock; QString currentFilePath = currentContext()->topContext()->url().str(); QFileInfo dir(directory); QFileInfoList entries; if (dir.isDir()) { // Import all the files in the given directory entries = QDir(directory).entryInfoList( QStringList() << (QLatin1String("*.") + currentFilePath.section(QLatin1Char('.'), -1, -1)) - << QLatin1String("*.qmltypes") - << QLatin1String("*.so"), + << QStringLiteral("*.qmltypes") + << QStringLiteral("*.so"), QDir::Files ); } else if (dir.isFile()) { // Import the specific file given in the import statement entries.append(dir); } else if (!m_prebuilding) { m_session->addProblem(node, i18n("Module not found, some types or properties may not be recognized")); return; } // Translate the QFileInfos into QStrings (and replace .so files with // qmlplugindump dumps) lock.unlock(); QStringList filePaths = QmlJS::Cache::instance().getFileNames(entries); lock.lock(); if (node && !node->importId.isEmpty()) { // Open a namespace that will contain the declarations QualifiedIdentifier identifier(node->importId.toString()); RangeInRevision range = m_session->locationToRange(node->importIdToken); Declaration* decl = openDeclaration(identifier, range); decl->setKind(Declaration::Namespace); decl->setInternalContext(openContext(node, range, DUContext::Class, identifier)); } for (const QString& filePath : filePaths) { if (filePath == currentFilePath) { continue; } ReferencedTopDUContext context = m_session->contextOfFile(filePath); if (context) { currentContext()->addImportedParentContext(context.data()); } } if (node && !node->importId.isEmpty()) { // Close the namespace containing the declarations closeContext(); closeDeclaration(); } } void DeclarationBuilder::importModule(QmlJS::AST::UiImport* node) { QmlJS::AST::UiQualifiedId *part = node->importUri; QString uri; while (part) { if (!uri.isEmpty()) { uri.append('.'); } uri.append(part->name.toString()); part = part->next; } // Version of the import QString version = m_session->symbolAt(node->versionToken); // Import the directory containing the module QString modulePath = QmlJS::Cache::instance().modulePath(m_session->url(), uri, version); importDirectory(modulePath, node); } bool DeclarationBuilder::visit(QmlJS::AST::UiImport* node) { if (node->importUri) { importModule(node); } else if (!node->fileName.isNull() && node->fileName != QLatin1String(".")) { QUrl currentFileUrl = currentContext()->topContext()->url().toUrl(); QUrl importUrl = QUrl(node->fileName.toString()); importDirectory(currentFileUrl.resolved(importUrl).toLocalFile(), node); } return DeclarationBuilderBase::visit(node); } bool DeclarationBuilder::visit(QmlJS::AST::UiObjectDefinition* node) { setComment(node); // Do not crash if the user has typed an empty object definition if (!node->initializer || !node->initializer->members) { m_skipEndVisit.push(true); return DeclarationBuilderBase::visit(node); } RangeInRevision range(m_session->locationToRange(node->qualifiedTypeNameId->identifierToken)); QString baseclass = node->qualifiedTypeNameId->name.toString(); // "Component" needs special care: a component that appears only in a future // version of this module, or that already appeared in a former version, must // be skipped because it is useless ExportLiteralsAndNames exports; if (baseclass == QLatin1String("Component")) { - QmlJS::AST::Statement* statement = QmlJS::getQMLAttribute(node->initializer->members, QLatin1String("exports")); + QmlJS::AST::Statement* statement = QmlJS::getQMLAttribute(node->initializer->members, QStringLiteral("exports")); exports = exportedNames(QmlJS::AST::cast(statement)); if (statement && exports.count() == 0) { // This component has an "exports:" member but no export matched // the version of this module. Skip the component m_skipEndVisit.push(true); return false; } } else if (baseclass == QLatin1String("Module")) { // "Module" is disabled. This allows the declarations of a module // dump to appear in the same namespace as the .qml files in the same // directory. m_skipEndVisit.push(true); return true; } // Declare the component subclass declareComponentSubclass(node->initializer, range, baseclass, node->qualifiedTypeNameId); // If we had a component with exported names, declare these exports if (baseclass == QLatin1String("Component")) { ClassDeclaration* classDecl = currentDeclaration(); if (classDecl) { declareExports(exports, classDecl); } } m_skipEndVisit.push(false); return DeclarationBuilderBase::visit(node); } void DeclarationBuilder::endVisit(QmlJS::AST::UiObjectDefinition* node) { DeclarationBuilderBase::endVisit(node); // Do not crash if the user has typed an empty object definition if (!m_skipEndVisit.pop()) { closeContext(); closeAndAssignType(); } } bool DeclarationBuilder::visit(QmlJS::AST::UiScriptBinding* node) { setComment(node); if (!node->qualifiedId) { return DeclarationBuilderBase::visit(node); } // Special-case some binding names QString bindingName = node->qualifiedId->name.toString(); if (bindingName == QLatin1String("id")) { // Instantiate a QML component: its type is the current type (the anonymous // QML class that surrounds the declaration) declareComponentInstance(QmlJS::AST::cast(node->statement)); } // Use ExpressionVisitor to find the signal/property bound DeclarationPointer bindingDecl = findType(node->qualifiedId).declaration; DUChainPointer signal; // If a Javascript block is used as expression or if the script binding is a // slot, open a subcontext so that variables declared in the binding are kept // local, and the signal parameters can be visible to the slot if (( bindingDecl && (signal = bindingDecl.dynamicCast()) && signal->isSignal() ) || node->statement->kind == QmlJS::AST::Node::Kind_Block) { openContext( node->statement, m_session->locationsToInnerRange( node->statement->firstSourceLocation(), node->statement->lastSourceLocation() ), DUContext::Other ); // If this script binding is a slot, import the parameters of its signal if (signal && signal->isSignal() && signal->internalContext()) { DUChainWriteLocker lock; currentContext()->addIndirectImport(DUContext::Import( signal->internalContext(), nullptr )); } } else { // Check that the type of the value matches the type of the property AbstractType::Ptr expressionType = findType(node->statement).type; DUChainReadLocker lock; if (!m_prebuilding && bindingDecl && !areTypesEqual(bindingDecl->abstractType(), expressionType)) { m_session->addProblem(node->qualifiedId, i18n( "Mismatch between the value type (%1) and the property type (%2)", expressionType->toString(), bindingDecl->abstractType()->toString() ), IProblem::Error); } } return DeclarationBuilderBase::visit(node); } void DeclarationBuilder::endVisit(QmlJS::AST::UiScriptBinding* node) { QmlJS::AST::Visitor::endVisit(node); // If visit(UiScriptBinding) has opened a context, close it if (currentContext()->type() == DUContext::Other) { closeContext(); } } bool DeclarationBuilder::visit(QmlJS::AST::UiObjectBinding* node) { setComment(node); if (!node->qualifiedId || !node->qualifiedTypeNameId || !node->initializer) { return DeclarationBuilderBase::visit(node); } // Declare the component subclass. "Behavior on ... {}" is treated exactly // like "Behavior {}". RangeInRevision range = m_session->locationToRange(node->qualifiedTypeNameId->identifierToken); QString baseclass = node->qualifiedTypeNameId->name.toString(); declareComponentSubclass(node->initializer, range, baseclass, node->qualifiedTypeNameId); return DeclarationBuilderBase::visit(node); } void DeclarationBuilder::endVisit(QmlJS::AST::UiObjectBinding* node) { DeclarationBuilderBase::endVisit(node); if (node->qualifiedId && node->qualifiedTypeNameId && node->initializer) { closeContext(); closeAndAssignType(); } } bool DeclarationBuilder::visit(QmlJS::AST::UiPublicMember* node) { setComment(node); RangeInRevision range = m_session->locationToRange(node->identifierToken); QualifiedIdentifier id(node->name.toString()); QString typeName = node->memberType.toString(); bool res = DeclarationBuilderBase::visit(node); // Build the type of the public member if (node->type == QmlJS::AST::UiPublicMember::Signal) { // Open a function declaration corresponding to this signal declareFunction( node, false, QualifiedIdentifier(node->name.toString()), m_session->locationToRange(node->identifierToken), node->parameters, m_session->locationToRange(node->identifierToken), // The AST does not provide the location of the parens nullptr, m_session->locationToRange(node->identifierToken) // A body range must be provided ); // This declaration is a signal and its return type is void { DUChainWriteLocker lock; currentDeclaration()->setIsSignal(true); currentType()->setReturnType(typeFromName(QStringLiteral("void"))); } } else { AbstractType::Ptr type; if (typeName == QLatin1String("alias")) { // Property aliases take the type of their aliased property type = findType(node->statement).type; res = false; // findType has already explored node->statement } else { type = typeFromName(typeName); if (node->typeModifier == QLatin1String("list")) { // QML list, noted "list" in the source file ArrayType::Ptr array(new ArrayType); array->setElementType(type); type = array.cast(); } } { DUChainWriteLocker lock; Declaration* decl = openDeclaration(id, range); decl->setInSymbolTable(false); } openType(type); } return res; } void DeclarationBuilder::endVisit(QmlJS::AST::UiPublicMember* node) { DeclarationBuilderBase::endVisit(node); closeAndAssignType(); } /* * Utils */ void DeclarationBuilder::setComment(QmlJS::AST::Node* node) { setComment(m_session->commentForLocation(node->firstSourceLocation()).toUtf8()); } void DeclarationBuilder::closeAndAssignType() { closeType(); Declaration* dec = currentDeclaration(); Q_ASSERT(dec); if (auto type = lastType()) { DUChainWriteLocker lock; dec->setType(type); } closeDeclaration(); } AbstractType::Ptr DeclarationBuilder::typeFromName(const QString& name) { auto type = IntegralType::TypeNone; QString realName = name; // Built-in types if (name == QLatin1String("string")) { type = IntegralType::TypeString; } else if (name == QLatin1String("bool")) { type = IntegralType::TypeBoolean; } else if (name == QLatin1String("int")) { type = IntegralType::TypeInt; } else if (name == QLatin1String("float")) { type = IntegralType::TypeFloat; } else if (name == QLatin1String("double") || name == QLatin1String("real")) { type = IntegralType::TypeDouble; } else if (name == QLatin1String("void")) { type = IntegralType::TypeVoid; } else if (name == QLatin1String("var") || name == QLatin1String("variant")) { type = IntegralType::TypeMixed; } else if (m_session->language() == QmlJS::Dialect::Qml) { // In QML files, some Qt type names need to be renamed to the QML equivalent if (name == QLatin1String("QFont")) { realName = QStringLiteral("Font"); } else if (name == QLatin1String("QColor")) { realName = QStringLiteral("color"); } else if (name == QLatin1String("QDateTime")) { realName = QStringLiteral("date"); } else if (name == QLatin1String("QDate")) { realName = QStringLiteral("date"); } else if (name == QLatin1String("QTime")) { realName = QStringLiteral("time"); } else if (name == QLatin1String("QRect") || name == QLatin1String("QRectF")) { realName = QStringLiteral("rect"); } else if (name == QLatin1String("QPoint") || name == QLatin1String("QPointF")) { realName = QStringLiteral("point"); } else if (name == QLatin1String("QSize") || name == QLatin1String("QSizeF")) { realName = QStringLiteral("size"); } else if (name == QLatin1String("QUrl")) { realName = QStringLiteral("url"); } else if (name == QLatin1String("QVector3D")) { realName = QStringLiteral("vector3d"); } else if (name.endsWith(QLatin1String("ScriptString"))) { // Q{Declarative,Qml}ScriptString represents a JS snippet auto func = new QmlJS::FunctionType; func->setReturnType(AbstractType::Ptr(new IntegralType(IntegralType::TypeVoid))); return AbstractType::Ptr(func); } } if (type == IntegralType::TypeNone) { // Not a built-in type, but a class return typeFromClassName(realName); } else { return AbstractType::Ptr(new IntegralType(type)); } } AbstractType::Ptr DeclarationBuilder::typeFromClassName(const QString& name) { DeclarationPointer decl = QmlJS::getDeclaration(QualifiedIdentifier(name), currentContext()); if (!decl) { if (name == QLatin1String("QRegExp")) { decl = QmlJS::NodeJS::instance().moduleMember(QStringLiteral("__builtin_ecmascript"), QStringLiteral("RegExp"), currentContext()->url()); } } if (decl) { return decl->abstractType(); } else { DelayedType::Ptr type(new DelayedType); type->setKind(DelayedType::Unresolved); type->setIdentifier(IndexedTypeIdentifier(name)); return type; } } void DeclarationBuilder::addBaseClass(ClassDeclaration* classDecl, const QString& name) { addBaseClass(classDecl, IndexedType(typeFromClassName(name))); } void DeclarationBuilder::addBaseClass(ClassDeclaration* classDecl, const IndexedType& type) { BaseClassInstance baseClass; baseClass.access = Declaration::Public; baseClass.virtualInheritance = false; baseClass.baseClass = type; classDecl->addBaseClass(baseClass); } void DeclarationBuilder::registerBaseClasses() { ClassDeclaration* classdecl = currentDeclaration(); DUContext *ctx = currentContext(); if (classdecl) { DUChainWriteLocker lock; for (uint i=0; ibaseClassesSize(); ++i) { const BaseClassInstance &baseClass = classdecl->baseClasses()[i]; StructureType::Ptr baseType = StructureType::Ptr::dynamicCast(baseClass.baseClass.abstractType()); TopDUContext* topctx = topContext(); if (baseType && baseType->declaration(topctx)) { QmlJS::importDeclarationInContext(ctx, DeclarationPointer(baseType->declaration(topctx))); } } } } static bool enumContainsEnumerator(const AbstractType::Ptr& a, const AbstractType::Ptr& b) { Q_ASSERT(a->whichType() == AbstractType::TypeEnumeration); auto aEnum = EnumerationType::Ptr::staticCast(a); Q_ASSERT(b->whichType() == AbstractType::TypeEnumerator); auto bEnumerator = EnumeratorType::Ptr::staticCast(b); return bEnumerator->qualifiedIdentifier().beginsWith(aEnum->qualifiedIdentifier()); } static bool isNumeric(const IntegralType::Ptr& type) { return type->dataType() == IntegralType::TypeInt || type->dataType() == IntegralType::TypeIntegral || type->dataType() == IntegralType::TypeFloat || type->dataType() == IntegralType::TypeDouble; } bool DeclarationBuilder::areTypesEqual(const AbstractType::Ptr& a, const AbstractType::Ptr& b) { if (!a || !b) { return true; } if (a->whichType() == AbstractType::TypeUnsure || b->whichType() == AbstractType::TypeUnsure) { // Don't try to guess something if one of the types is unsure return true; } const auto bIntegral = IntegralType::Ptr::dynamicCast(b); if (bIntegral && (bIntegral->dataType() == IntegralType::TypeString || bIntegral->dataType() == IntegralType::TypeMixed)) { // In QML/JS, a string can be converted to nearly everything else, similarly ignore mixed types return true; } const auto aIntegral = IntegralType::Ptr::dynamicCast(a); if (aIntegral && (aIntegral->dataType() == IntegralType::TypeString || aIntegral->dataType() == IntegralType::TypeMixed)) { // In QML/JS, nearly everything can be to a string, similarly ignore mixed types return true; } if (aIntegral && bIntegral) { if (isNumeric(aIntegral) && isNumeric(bIntegral)) { // Casts between integral types is possible return true; } } if (a->whichType() == AbstractType::TypeEnumeration && b->whichType() == AbstractType::TypeEnumerator) { return enumContainsEnumerator(a, b); } else if (a->whichType() == AbstractType::TypeEnumerator && b->whichType() == AbstractType::TypeEnumeration) { return enumContainsEnumerator(b, a); } { auto aId = dynamic_cast(a.constData()); auto bId = dynamic_cast(b.constData()); if (aId && bId && aId->qualifiedIdentifier() == bId->qualifiedIdentifier()) return true; } { auto aStruct = StructureType::Ptr::dynamicCast(a); auto bStruct = StructureType::Ptr::dynamicCast(b); if (aStruct && bStruct) { auto top = currentContext()->topContext(); auto aDecl = dynamic_cast(aStruct->declaration(top)); auto bDecl = dynamic_cast(bStruct->declaration(top)); if (aDecl && bDecl) { if (aDecl->isPublicBaseClass(bDecl, top) || bDecl->isPublicBaseClass(aDecl, top)) { return true; } } } } return a->equals(b.constData()); } diff --git a/languages/qmljs/kdevqmljsplugin.cpp b/languages/qmljs/kdevqmljsplugin.cpp index 9e50b688d1..cdc349f0c8 100644 --- a/languages/qmljs/kdevqmljsplugin.cpp +++ b/languages/qmljs/kdevqmljsplugin.cpp @@ -1,204 +1,204 @@ /************************************************************************************* * Copyright (C) 2012 by Aleix Pol * * Copyright (C) 2012 by Milian Wolff * * Copyright (C) 2013 by Sven Brauch * * * * 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) 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 "kdevqmljsplugin.h" #include "qmljsparsejob.h" #include "qmljshighlighting.h" #include "codecompletion/model.h" #include "navigation/propertypreviewwidget.h" #include "duchain/helper.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include K_PLUGIN_FACTORY_WITH_JSON(KDevQmlJsSupportFactory, "kdevqmljs.json", registerPlugin(); ) using namespace KDevelop; /// TODO: Extend? See qmljsmodelmanager.h in qt-creator.git class ModelManager: public QmlJS::ModelManagerInterface { Q_OBJECT public: explicit ModelManager(QObject *parent = nullptr); ~ModelManager() override; }; ModelManager::ModelManager(QObject* parent) : QmlJS::ModelManagerInterface(parent) {} ModelManager::~ModelManager() {} KDevQmlJsPlugin::KDevQmlJsPlugin(QObject* parent, const QVariantList& ) -: IPlugin(QLatin1String("kdevqmljssupport"), parent ) +: IPlugin(QStringLiteral("kdevqmljssupport"), parent ) , ILanguageSupport() , m_highlighting(new QmlJsHighlighting(this)) , m_refactoring(new BasicRefactoring(this)) , m_modelManager(new ModelManager(this)) { QmlJS::registerDUChainItems(); CodeCompletionModel* codeCompletion = new QmlJS::CodeCompletionModel(this); new KDevelop::CodeCompletion(this, codeCompletion, name()); auto assistantsManager = core()->languageController()->staticAssistantsManager(); assistantsManager->registerAssistant(StaticAssistant::Ptr(new RenameAssistant(this))); } KDevQmlJsPlugin::~KDevQmlJsPlugin() { parseLock()->lockForWrite(); // By locking the parse-mutexes, we make sure that parse jobs get a chance to finish in a good state parseLock()->unlock(); QmlJS::unregisterDUChainItems(); } ParseJob* KDevQmlJsPlugin::createParseJob(const IndexedString& url) { return new QmlJsParseJob(url, this); } QString KDevQmlJsPlugin::name() const { return QStringLiteral("qml/js"); } ICodeHighlighting* KDevQmlJsPlugin::codeHighlighting() const { return m_highlighting; } BasicRefactoring* KDevQmlJsPlugin::refactoring() const { return m_refactoring; } ContextMenuExtension KDevQmlJsPlugin::contextMenuExtension(Context* context) { ContextMenuExtension cm; EditorContext *ec = dynamic_cast(context); if (ec && ICore::self()->languageController()->languagesForUrl(ec->url()).contains(this)) { // It's a QML/JS file, let's add our context menu. m_refactoring->fillContextMenu(cm, context); } return cm; } const QString textFromDoc(const IDocument* doc, const KTextEditor::Range& range) { return doc->textDocument()->line(range.start().line()).mid(range.start().column(), range.end().column()-range.start().column()); }; // Finds how many spaces the given string has at one end. // direction=+1 -> left end of the string, -1 for right end. int spacesAtCorner(const QString& string, int direction = +1) { int spaces = 0; QString::const_iterator it; for ( it = direction == 1 ? string.begin() : string.end()-1 ; it != string.end(); it += direction ) { if ( ! it->isSpace() ) break; spaces += 1; } return spaces; } // Take the given QML line and check if it's a line of the form foo.bar: value. // Return ranges for the key and the value. const QPair parseProperty(const QString& line, const KTextEditor::Cursor& position) { QStringList items = line.split(';'); QString matchingItem; int col_offset = -1; // This is to also support FooAnimation { foo: bar; baz: bang; duration: 200 } // or similar foreach ( const QString& item, items ) { col_offset += item.size() + 1; if ( position.column() < col_offset ) { matchingItem = item; break; } } QStringList split = matchingItem.split(':'); if ( split.size() != 2 ) { // The expression is not of the form foo:bar, thus invalid. return qMakePair(KTextEditor::Range::invalid(), KTextEditor::Range::invalid()); } QString key = split.at(0); QString value = split.at(1); // For animations or similar, remove the trailing '}' if there's no semicolon after the last entry if ( value.trimmed().endsWith('}') ) { col_offset -= value.size() - value.lastIndexOf('}') + 1; value = value.left(value.lastIndexOf('}')-1); } return qMakePair( KTextEditor::Range( KTextEditor::Cursor(position.line(), col_offset - value.size() - key.size() + spacesAtCorner(key, +1) - 1), KTextEditor::Cursor(position.line(), col_offset - value.size() - 1 + spacesAtCorner(key, -1)) ), KTextEditor::Range( KTextEditor::Cursor(position.line(), col_offset - value.size() + spacesAtCorner(value, +1)), KTextEditor::Cursor(position.line(), col_offset + spacesAtCorner(value, -1)) )); }; QWidget* KDevQmlJsPlugin::specialLanguageObjectNavigationWidget(const QUrl& url, const KTextEditor::Cursor& position) { IDocument* doc = ICore::self()->documentController()->documentForUrl(url); if ( doc && doc->textDocument() ) { // Check for a QML property, and construct a property preview widget // if the property key is listed in the supported properties. QPair property = parseProperty(doc->textDocument()->line(position.line()), position); if ( property.first.isValid() && property.second.isValid() ) { Declaration* decl = DUChainUtils::itemUnderCursor(url, property.first.start()).declaration; return PropertyPreviewWidget::constructIfPossible( doc->textDocument(), property.first, property.second, decl, textFromDoc(doc, property.first), textFromDoc(doc, property.second) ); } } // Otherwise, display no special "navigation" widget. return KDevelop::ILanguageSupport::specialLanguageObjectNavigationWidget(url, position); } #include "kdevqmljsplugin.moc" diff --git a/languages/qmljs/libs/languageutils/fakemetaobject.cpp b/languages/qmljs/libs/languageutils/fakemetaobject.cpp index 2c4f669e3a..20e944bf8e 100644 --- a/languages/qmljs/libs/languageutils/fakemetaobject.cpp +++ b/languages/qmljs/libs/languageutils/fakemetaobject.cpp @@ -1,601 +1,601 @@ /**************************************************************************** ** ** Copyright (C) 2015 The Qt Company Ltd. ** Contact: http://www.qt.io/licensing ** ** This file is part of Qt Creator. ** ** Commercial License Usage ** Licensees holding valid commercial Qt licenses may use this file in ** accordance with the commercial license agreement provided with the ** Software or, alternatively, in accordance with the terms contained in ** a written agreement between you and The Qt Company. For licensing terms and ** conditions see http://www.qt.io/terms-conditions. For further information ** use the contact form at http://www.qt.io/contact-us. ** ** 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 or version 3 as published by the Free ** Software Foundation and appearing in the file LICENSE.LGPLv21 and ** LICENSE.LGPLv3 included in the packaging of this file. Please review the ** following information to ensure the GNU Lesser General Public License ** requirements will be met: https://www.gnu.org/licenses/lgpl.html and ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ** ** In addition, as a special exception, The Qt Company gives you certain additional ** rights. These rights are described in The Qt Company LGPL Exception ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ** ****************************************************************************/ #include "fakemetaobject.h" #include using namespace LanguageUtils; FakeMetaEnum::FakeMetaEnum() {} FakeMetaEnum::FakeMetaEnum(const QString &name) : m_name(name) {} bool FakeMetaEnum::isValid() const { return !m_name.isEmpty(); } QString FakeMetaEnum::name() const { return m_name; } void FakeMetaEnum::setName(const QString &name) { m_name = name; } void FakeMetaEnum::addKey(const QString &key, int value) { m_keys.append(key); m_values.append(value); } QString FakeMetaEnum::key(int index) const { return m_keys.at(index); } int FakeMetaEnum::keyCount() const { return m_keys.size(); } QStringList FakeMetaEnum::keys() const { return m_keys; } bool FakeMetaEnum::hasKey(const QString &key) const { return m_keys.contains(key); } void FakeMetaEnum::addToHash(QCryptographicHash &hash) const { int len = m_name.size(); hash.addData(reinterpret_cast(&len), sizeof(len)); hash.addData(reinterpret_cast(m_name.constData()), len * sizeof(QChar)); len = m_keys.size(); hash.addData(reinterpret_cast(&len), sizeof(len)); foreach (const QString &key, m_keys) { len = key.size(); hash.addData(reinterpret_cast(&len), sizeof(len)); hash.addData(reinterpret_cast(key.constData()), len * sizeof(QChar)); } len = m_values.size(); hash.addData(reinterpret_cast(&len), sizeof(len)); foreach (int value, m_values) hash.addData(reinterpret_cast(&value), sizeof(value)); } QString FakeMetaEnum::describe(int baseIndent) const { QString newLine = QString::fromLatin1("\n") + QString::fromLatin1(" ").repeated(baseIndent); - QString res = QLatin1String("Enum "); + QString res = QStringLiteral("Enum "); res += name(); res += QLatin1String(":{"); for (int i = 0; i < keyCount(); ++i) { res += newLine; res += QLatin1String(" "); res += key(i); res += QLatin1String(": "); res += QString::number(m_values.value(i, -1)); } res += newLine; res += QLatin1Char('}'); return res; } QString FakeMetaEnum::toString() const { return describe(); } FakeMetaMethod::FakeMetaMethod(const QString &name, const QString &returnType) : m_name(name) , m_returnType(returnType) , m_methodTy(FakeMetaMethod::Method) , m_methodAccess(FakeMetaMethod::Public) , m_revision(0) {} FakeMetaMethod::FakeMetaMethod() : m_methodTy(FakeMetaMethod::Method) , m_methodAccess(FakeMetaMethod::Public) , m_revision(0) {} QString FakeMetaMethod::methodName() const { return m_name; } void FakeMetaMethod::setMethodName(const QString &name) { m_name = name; } void FakeMetaMethod::setReturnType(const QString &type) { m_returnType = type; } QStringList FakeMetaMethod::parameterNames() const { return m_paramNames; } QStringList FakeMetaMethod::parameterTypes() const { return m_paramTypes; } void FakeMetaMethod::addParameter(const QString &name, const QString &type) { m_paramNames.append(name); m_paramTypes.append(type); } int FakeMetaMethod::methodType() const { return m_methodTy; } void FakeMetaMethod::setMethodType(int methodType) { m_methodTy = methodType; } int FakeMetaMethod::access() const { return m_methodAccess; } int FakeMetaMethod::revision() const { return m_revision; } void FakeMetaMethod::setRevision(int r) { m_revision = r; } void FakeMetaMethod::addToHash(QCryptographicHash &hash) const { int len = m_name.size(); hash.addData(reinterpret_cast(&len), sizeof(len)); hash.addData(reinterpret_cast(m_name.constData()), len * sizeof(QChar)); hash.addData(reinterpret_cast(&m_methodAccess), sizeof(m_methodAccess)); hash.addData(reinterpret_cast(&m_methodTy), sizeof(m_methodTy)); hash.addData(reinterpret_cast(&m_revision), sizeof(m_revision)); len = m_paramNames.size(); hash.addData(reinterpret_cast(&len), sizeof(len)); foreach (const QString &pName, m_paramNames) { len = pName.size(); hash.addData(reinterpret_cast(&len), sizeof(len)); hash.addData(reinterpret_cast(pName.constData()), len * sizeof(QChar)); } len = m_paramTypes.size(); hash.addData(reinterpret_cast(&len), sizeof(len)); foreach (const QString &pType, m_paramTypes) { len = pType.size(); hash.addData(reinterpret_cast(&len), sizeof(len)); hash.addData(reinterpret_cast(pType.constData()), len * sizeof(QChar)); } len = m_returnType.size(); hash.addData(reinterpret_cast(&len), sizeof(len)); hash.addData(reinterpret_cast(m_returnType.constData()), len * sizeof(QChar)); } QString FakeMetaMethod::describe(int baseIndent) const { QString newLine = QString::fromLatin1("\n") + QString::fromLatin1(" ").repeated(baseIndent); - QString res = QLatin1String("Method {"); + QString res = QStringLiteral("Method {"); res += newLine; res += QLatin1String(" methodName:"); res += methodName(); res += newLine; res += QLatin1String(" methodType:"); res += methodType(); res += newLine; res += QLatin1String(" parameterNames:["); foreach (const QString &pName, parameterNames()) { res += newLine; res += QLatin1String(" "); res += pName; } res += QLatin1Char(']'); res += newLine; res += QLatin1String(" parameterTypes:["); foreach (const QString &pType, parameterTypes()) { res += newLine; res += QLatin1String(" "); res += pType; } res += QLatin1Char(']'); res += newLine; res += QLatin1Char('}'); return res; } QString FakeMetaMethod::toString() const { return describe(); } FakeMetaProperty::FakeMetaProperty(const QString &name, const QString &type, bool isList, bool isWritable, bool isPointer, int revision) : m_propertyName(name) , m_type(type) , m_isList(isList) , m_isWritable(isWritable) , m_isPointer(isPointer) , m_revision(revision) {} QString FakeMetaProperty::name() const { return m_propertyName; } QString FakeMetaProperty::typeName() const { return m_type; } bool FakeMetaProperty::isList() const { return m_isList; } bool FakeMetaProperty::isWritable() const { return m_isWritable; } bool FakeMetaProperty::isPointer() const { return m_isPointer; } int FakeMetaProperty::revision() const { return m_revision; } void FakeMetaProperty::addToHash(QCryptographicHash &hash) const { int len = m_propertyName.size(); hash.addData(reinterpret_cast(&len), sizeof(len)); hash.addData(reinterpret_cast(m_propertyName.constData()), len * sizeof(QChar)); hash.addData(reinterpret_cast(&m_revision), sizeof(m_revision)); int flags = (m_isList ? (1 << 0) : 0) + (m_isPointer ? (1 << 1) : 0) + (m_isWritable ? (1 << 2) : 0); hash.addData(reinterpret_cast(&flags), sizeof(flags)); len = m_type.size(); hash.addData(reinterpret_cast(&len), sizeof(len)); hash.addData(reinterpret_cast(m_type.constData()), len * sizeof(QChar)); } QString FakeMetaProperty::describe(int baseIndent) const { QString newLine = QString::fromLatin1("\n") + QString::fromLatin1(" ").repeated(baseIndent); - QString res = QLatin1String("Property {"); + QString res = QStringLiteral("Property {"); res += newLine; res += QLatin1String(" name:"); res += name(); res += newLine; res += QLatin1String(" typeName:"); res += typeName(); res += newLine; res += QLatin1String(" typeName:"); res += QString::number(revision()); res += newLine; res += QLatin1String(" isList:"); res += isList(); res += newLine; res += QLatin1String(" isPointer:"); res += isPointer(); res += newLine; res += QLatin1String(" isWritable:"); res += isWritable(); res += newLine; res += QLatin1Char('}'); return res; } QString FakeMetaProperty::toString() const { return describe(); } FakeMetaObject::FakeMetaObject() : m_isSingleton(false), m_isCreatable(true), m_isComposite(false) { } QString FakeMetaObject::className() const { return m_className; } void FakeMetaObject::setClassName(const QString &name) { m_className = name; } void FakeMetaObject::addExport(const QString &name, const QString &package, const ComponentVersion& version) { Export exp; exp.type = name; exp.package = package; exp.version = version; m_exports.append(exp); } void FakeMetaObject::setExportMetaObjectRevision(int exportIndex, int metaObjectRevision) { m_exports[exportIndex].metaObjectRevision = metaObjectRevision; } QList FakeMetaObject::exports() const { return m_exports; } FakeMetaObject::Export FakeMetaObject::exportInPackage(const QString &package) const { foreach (const Export &exp, m_exports) { if (exp.package == package) return exp; } return Export(); } void FakeMetaObject::setSuperclassName(const QString &superclass) { m_superName = superclass; } QString FakeMetaObject::superclassName() const { return m_superName; } void FakeMetaObject::addEnum(const FakeMetaEnum &fakeEnum) { m_enumNameToIndex.insert(fakeEnum.name(), m_enums.size()); m_enums.append(fakeEnum); } int FakeMetaObject::enumeratorCount() const { return m_enums.size(); } int FakeMetaObject::enumeratorOffset() const { return 0; } FakeMetaEnum FakeMetaObject::enumerator(int index) const { return m_enums.at(index); } int FakeMetaObject::enumeratorIndex(const QString &name) const { return m_enumNameToIndex.value(name, -1); } void FakeMetaObject::addProperty(const FakeMetaProperty &property) { m_propNameToIdx.insert(property.name(), m_props.size()); m_props.append(property); } int FakeMetaObject::propertyCount() const { return m_props.size(); } int FakeMetaObject::propertyOffset() const { return 0; } FakeMetaProperty FakeMetaObject::property(int index) const { return m_props.at(index); } int FakeMetaObject::propertyIndex(const QString &name) const { return m_propNameToIdx.value(name, -1); } void FakeMetaObject::addMethod(const FakeMetaMethod &method) { m_methods.append(method); } int FakeMetaObject::methodCount() const { return m_methods.size(); } int FakeMetaObject::methodOffset() const { return 0; } FakeMetaMethod FakeMetaObject::method(int index) const { return m_methods.at(index); } int FakeMetaObject::methodIndex(const QString &name) const //If performances becomes an issue, just use a nameToIdx hash { for (int i=0; i(&len), sizeof(len)); hash.addData(reinterpret_cast(m_className.constData()), len * sizeof(QChar)); len = m_attachedTypeName.size(); hash.addData(reinterpret_cast(&len), sizeof(len)); hash.addData(reinterpret_cast(m_attachedTypeName.constData()), len * sizeof(QChar)); len = m_defaultPropertyName.size(); hash.addData(reinterpret_cast(&len), sizeof(len)); hash.addData(reinterpret_cast(m_defaultPropertyName.constData()), len * sizeof(QChar)); len = m_enumNameToIndex.size(); hash.addData(reinterpret_cast(&len), sizeof(len)); { QStringList keys(m_enumNameToIndex.keys()); keys.sort(); foreach (const QString &key, keys) { len = key.size(); hash.addData(reinterpret_cast(&len), sizeof(len)); hash.addData(reinterpret_cast(key.constData()), len * sizeof(QChar)); int value = m_enumNameToIndex.value(key); hash.addData(reinterpret_cast(&value), sizeof(value)); // avoid? this adds order dependency to fingerprint... m_enums.at(value).addToHash(hash); } } len = m_exports.size(); hash.addData(reinterpret_cast(&len), sizeof(len)); foreach (const Export &e, m_exports) e.addToHash(hash); // normalize order? len = m_exports.size(); hash.addData(reinterpret_cast(&len), sizeof(len)); foreach (const FakeMetaMethod &m, m_methods) m.addToHash(hash); // normalize order? { QStringList keys(m_propNameToIdx.keys()); keys.sort(); foreach (const QString &key, keys) { len = key.size(); hash.addData(reinterpret_cast(&len), sizeof(len)); hash.addData(reinterpret_cast(key.constData()), len * sizeof(QChar)); int value = m_propNameToIdx.value(key); hash.addData(reinterpret_cast(&value), sizeof(value)); // avoid? this adds order dependency to fingerprint... m_props.at(value).addToHash(hash); } } len = m_superName.size(); hash.addData(reinterpret_cast(&len), sizeof(len)); hash.addData(reinterpret_cast(m_superName.constData()), len * sizeof(QChar)); QByteArray res = hash.result(); res.append('F'); return res; } void FakeMetaObject::updateFingerprint() { m_fingerprint = calculateFingerprint(); } QByteArray FakeMetaObject::fingerprint() const { return m_fingerprint; } bool FakeMetaObject::isSingleton() const { return m_isSingleton; } bool FakeMetaObject::isCreatable() const { return m_isCreatable; } bool FakeMetaObject::isComposite() const { return m_isComposite; } void FakeMetaObject::setIsSingleton(bool value) { m_isSingleton = value; } void FakeMetaObject::setIsCreatable(bool value) { m_isCreatable = value; } void FakeMetaObject::setIsComposite(bool value) { m_isSingleton = value; } QString FakeMetaObject::toString() const { return describe(); } QString FakeMetaObject::describe(bool printDetails, int baseIndent) const { QString res = QString::fromLatin1("FakeMetaObject@%1") .arg((quintptr)(void *)this, 0, 16); if (!printDetails) return res; QString newLine = QString::fromLatin1("\n") + QString::fromLatin1(" ").repeated(baseIndent); res += QLatin1Char('{'); res += newLine; res += QLatin1String("className:"); res += className(); res += newLine; res += QLatin1String("superClassName:"); res += superclassName(); res += newLine; res += QLatin1String("isSingleton:"); res += isSingleton(); res += newLine; res += QLatin1String("isCreatable:"); res += isCreatable(); res += newLine; res += QLatin1String("isComposite:"); res += isComposite(); res += newLine; res += QLatin1String("defaultPropertyName:"); res += defaultPropertyName(); res += newLine; res += QLatin1String("attachedTypeName:"); res += attachedTypeName(); res += newLine; res += QLatin1String("fingerprint:"); res += QString::fromUtf8(fingerprint()); res += newLine; res += QLatin1String("exports:["); foreach (const Export &e, exports()) { res += newLine; res += QLatin1String(" "); res += e.describe(baseIndent + 2); } res += QLatin1Char(']'); res += newLine; res += QLatin1String("enums:["); for (int iEnum = 0; iEnum < enumeratorCount() ; ++ iEnum) { FakeMetaEnum e = enumerator(enumeratorOffset() + iEnum); res += newLine; res += QLatin1String(" "); res += e.describe(baseIndent + 2); } res += QLatin1Char(']'); res += newLine; res += QLatin1String("properties:["); for (int iProp = 0; iProp < propertyCount() ; ++ iProp) { FakeMetaProperty prop = property(propertyOffset() + iProp); res += newLine; res += QLatin1String(" "); res += prop.describe(baseIndent + 2); } res += QLatin1Char(']'); res += QLatin1String("methods:["); for (int iMethod = 0; iMethod < methodOffset() ; ++ iMethod) { FakeMetaMethod m = method(methodOffset() + iMethod); res += newLine; res += QLatin1String(" "); m.describe(baseIndent + 2); } res += QLatin1Char(']'); res += newLine; res += QLatin1Char('}'); return res; } FakeMetaObject::Export::Export() : metaObjectRevision(0) {} bool FakeMetaObject::Export::isValid() const { return version.isValid() || !package.isEmpty() || !type.isEmpty(); } void FakeMetaObject::Export::addToHash(QCryptographicHash &hash) const { int len = package.size(); hash.addData(reinterpret_cast(&len), sizeof(len)); hash.addData(reinterpret_cast(package.constData()), len * sizeof(QChar)); len = type.size(); hash.addData(reinterpret_cast(&len), sizeof(len)); hash.addData(reinterpret_cast(type.constData()), len * sizeof(QChar)); version.addToHash(hash); hash.addData(reinterpret_cast(&metaObjectRevision), sizeof(metaObjectRevision)); } QString FakeMetaObject::Export::describe(int baseIndent) const { QString newLine = QString::fromLatin1("\n") + QString::fromLatin1(" ").repeated(baseIndent); - QString res = QLatin1String("Export {"); + QString res = QStringLiteral("Export {"); res += newLine; res += QLatin1String(" package:"); res += package; res += newLine; res += QLatin1String(" type:"); res += type; res += newLine; res += QLatin1String(" version:"); res += version.toString(); res += newLine; res += QLatin1String(" metaObjectRevision:"); res += QString::number(metaObjectRevision); res += newLine; res += QLatin1String(" isValid:"); res += QString::number(isValid()); res += newLine; res += QLatin1Char('}'); return res; } QString FakeMetaObject::Export::toString() const { return describe(); } diff --git a/languages/qmljs/libs/utils/environment.cpp b/languages/qmljs/libs/utils/environment.cpp index c691f68e8d..45a67b91b9 100644 --- a/languages/qmljs/libs/utils/environment.cpp +++ b/languages/qmljs/libs/utils/environment.cpp @@ -1,517 +1,517 @@ /**************************************************************************** ** ** Copyright (C) 2015 The Qt Company Ltd. ** Contact: http://www.qt.io/licensing ** ** This file is part of Qt Creator. ** ** Commercial License Usage ** Licensees holding valid commercial Qt licenses may use this file in ** accordance with the commercial license agreement provided with the ** Software or, alternatively, in accordance with the terms contained in ** a written agreement between you and The Qt Company. For licensing terms and ** conditions see http://www.qt.io/terms-conditions. For further information ** use the contact form at http://www.qt.io/contact-us. ** ** 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 or version 3 as published by the Free ** Software Foundation and appearing in the file LICENSE.LGPLv21 and ** LICENSE.LGPLv3 included in the packaging of this file. Please review the ** following information to ensure the GNU Lesser General Public License ** requirements will be met: https://www.gnu.org/licenses/lgpl.html and ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ** ** In addition, as a special exception, The Qt Company gives you certain additional ** rights. These rights are described in The Qt Company LGPL Exception ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ** ****************************************************************************/ #include "environment.h" #include #include #include #include class SystemEnvironment : public Utils::Environment { public: SystemEnvironment() : Environment(QProcessEnvironment::systemEnvironment().toStringList()) { if (Utils::HostOsInfo::isLinuxHost()) { - QString ldLibraryPath = value(QLatin1String("LD_LIBRARY_PATH")); + QString ldLibraryPath = value(QStringLiteral("LD_LIBRARY_PATH")); QDir lib(QCoreApplication::applicationDirPath()); - lib.cd(QLatin1String("../lib")); + lib.cd(QStringLiteral("../lib")); QString toReplace = lib.path(); - lib.cd(QLatin1String("qtcreator")); + lib.cd(QStringLiteral("qtcreator")); toReplace.append(QLatin1Char(':')); toReplace.append(lib.path()); if (ldLibraryPath.startsWith(toReplace)) - set(QLatin1String("LD_LIBRARY_PATH"), ldLibraryPath.remove(0, toReplace.length())); + set(QStringLiteral("LD_LIBRARY_PATH"), ldLibraryPath.remove(0, toReplace.length())); } } }; Q_GLOBAL_STATIC(SystemEnvironment, staticSystemEnvironment) namespace Utils { static bool sortEnvironmentItem(const EnvironmentItem &a, const EnvironmentItem &b) { return a.name < b.name; } void EnvironmentItem::sort(QList *list) { std::sort(list->begin(), list->end(), &sortEnvironmentItem); } QList EnvironmentItem::fromStringList(const QStringList &list) { QList result; foreach (const QString &string, list) { int pos = string.indexOf(QLatin1Char('='), 1); if (pos == -1) { EnvironmentItem item(string, QString()); item.unset = true; result.append(item); } else { EnvironmentItem item(string.left(pos), string.mid(pos+1)); result.append(item); } } return result; } QStringList EnvironmentItem::toStringList(const QList &list) { QStringList result; foreach (const EnvironmentItem &item, list) { if (item.unset) result << QString(item.name); else result << QString(item.name + QLatin1Char('=') + item.value); } return result; } Environment::Environment(const QStringList &env, OsType osType) : m_osType(osType) { foreach (const QString &s, env) { int i = s.indexOf(QLatin1Char('='), 1); if (i >= 0) { if (m_osType == OsTypeWindows) m_values.insert(s.left(i).toUpper(), s.mid(i+1)); else m_values.insert(s.left(i), s.mid(i+1)); } } } QStringList Environment::toStringList() const { QStringList result; const QMap::const_iterator end = m_values.constEnd(); for (QMap::const_iterator it = m_values.constBegin(); it != end; ++it) { QString entry = it.key(); entry += QLatin1Char('='); entry += it.value(); result.push_back(entry); } return result; } QProcessEnvironment Environment::toProcessEnvironment() const { QProcessEnvironment result; const QMap::const_iterator end = m_values.constEnd(); for (QMap::const_iterator it = m_values.constBegin(); it != end; ++it) result.insert(it.key(), it.value()); return result; } void Environment::set(const QString &key, const QString &value) { m_values.insert(m_osType == OsTypeWindows ? key.toUpper() : key, value); } void Environment::unset(const QString &key) { m_values.remove(m_osType == OsTypeWindows ? key.toUpper() : key); } void Environment::appendOrSet(const QString &key, const QString &value, const QString &sep) { const QString &_key = m_osType == OsTypeWindows ? key.toUpper() : key; QMap::iterator it = m_values.find(_key); if (it == m_values.end()) { m_values.insert(_key, value); } else { // Append unless it is already there const QString toAppend = sep + value; if (!it.value().endsWith(toAppend)) it.value().append(toAppend); } } void Environment::prependOrSet(const QString&key, const QString &value, const QString &sep) { const QString &_key = m_osType == OsTypeWindows ? key.toUpper() : key; QMap::iterator it = m_values.find(_key); if (it == m_values.end()) { m_values.insert(_key, value); } else { // Prepend unless it is already there const QString toPrepend = value + sep; if (!it.value().startsWith(toPrepend)) it.value().prepend(toPrepend); } } void Environment::appendOrSetPath(const QString &value) { - appendOrSet(QLatin1String("PATH"), QDir::toNativeSeparators(value), + appendOrSet(QStringLiteral("PATH"), QDir::toNativeSeparators(value), QString(OsSpecificAspects(m_osType).pathListSeparator())); } void Environment::prependOrSetPath(const QString &value) { - prependOrSet(QLatin1String("PATH"), QDir::toNativeSeparators(value), + prependOrSet(QStringLiteral("PATH"), QDir::toNativeSeparators(value), QString(OsSpecificAspects(m_osType).pathListSeparator())); } void Environment::prependOrSetLibrarySearchPath(const QString &value) { switch (m_osType) { case OsTypeWindows: { const QChar sep = QLatin1Char(';'); const QLatin1String path("PATH"); prependOrSet(path, QDir::toNativeSeparators(value), QString(sep)); break; } case OsTypeMac: { - const QString sep = QLatin1String(":"); + const QString sep = QStringLiteral(":"); const QString nativeValue = QDir::toNativeSeparators(value); - prependOrSet(QLatin1String("DYLD_LIBRARY_PATH"), nativeValue, sep); - prependOrSet(QLatin1String("DYLD_FRAMEWORK_PATH"), nativeValue, sep); + prependOrSet(QStringLiteral("DYLD_LIBRARY_PATH"), nativeValue, sep); + prependOrSet(QStringLiteral("DYLD_FRAMEWORK_PATH"), nativeValue, sep); break; } case OsTypeLinux: case OsTypeOtherUnix: { const QChar sep = QLatin1Char(':'); const QLatin1String path("LD_LIBRARY_PATH"); prependOrSet(path, QDir::toNativeSeparators(value), QString(sep)); break; } default: break; } } Environment Environment::systemEnvironment() { return *staticSystemEnvironment(); } void Environment::clear() { m_values.clear(); } FileName Environment::searchInDirectory(const QStringList &execs, QString directory) const { const QChar slash = QLatin1Char('/'); if (directory.isEmpty()) return FileName(); // Avoid turing / into // on windows which triggers windows to check // for network drives! if (!directory.endsWith(slash)) directory += slash; foreach (const QString &exec, execs) { QFileInfo fi(directory + exec); if (fi.exists() && fi.isFile() && fi.isExecutable()) return FileName::fromString(fi.absoluteFilePath()); } return FileName(); } QStringList Environment::appendExeExtensions(const QString &executable) const { QFileInfo fi(executable); QStringList execs(executable); if (m_osType == OsTypeWindows) { // Check all the executable extensions on windows: // PATHEXT is only used if the executable has no extension if (fi.suffix().isEmpty()) { - QStringList extensions = value(QLatin1String("PATHEXT")).split(QLatin1Char(';')); + QStringList extensions = value(QStringLiteral("PATHEXT")).split(QLatin1Char(';')); foreach (const QString &ext, extensions) execs << executable + ext.toLower(); } } return execs; } FileName Environment::searchInPath(const QString &executable, const QStringList &additionalDirs) const { if (executable.isEmpty()) return FileName(); QString exec = QDir::cleanPath(expandVariables(executable)); QFileInfo fi(exec); QStringList execs = appendExeExtensions(exec); if (fi.isAbsolute()) { foreach (const QString &path, execs) if (QFile::exists(path)) return FileName::fromString(path); return FileName::fromString(exec); } QSet alreadyChecked; foreach (const QString &dir, additionalDirs) { if (alreadyChecked.contains(dir)) continue; alreadyChecked.insert(dir); FileName tmp = searchInDirectory(execs, dir); if (!tmp.isEmpty()) return tmp; } if (executable.indexOf(QLatin1Char('/')) != -1) return FileName(); foreach (const QString &p, path()) { if (alreadyChecked.contains(p)) continue; alreadyChecked.insert(p); FileName tmp = searchInDirectory(execs, QDir::fromNativeSeparators(p)); if (!tmp.isEmpty()) return tmp; } return FileName(); } QStringList Environment::path() const { - return m_values.value(QLatin1String("PATH")) + return m_values.value(QStringLiteral("PATH")) .split(OsSpecificAspects(m_osType).pathListSeparator(), QString::SkipEmptyParts); } QString Environment::value(const QString &key) const { return m_values.value(key); } QString Environment::key(Environment::const_iterator it) const { return it.key(); } QString Environment::value(Environment::const_iterator it) const { return it.value(); } Environment::const_iterator Environment::constBegin() const { return m_values.constBegin(); } Environment::const_iterator Environment::constEnd() const { return m_values.constEnd(); } Environment::const_iterator Environment::constFind(const QString &name) const { QMap::const_iterator it = m_values.constFind(name); if (it == m_values.constEnd()) return constEnd(); else return it; } int Environment::size() const { return m_values.size(); } void Environment::modify(const QList & list) { Environment resultEnvironment = *this; foreach (const EnvironmentItem &item, list) { if (item.unset) { resultEnvironment.unset(item.name); } else { // TODO use variable expansion QString value = item.value; for (int i=0; i < value.size(); ++i) { if (value.at(i) == QLatin1Char('$')) { if ((i + 1) < value.size()) { const QChar &c = value.at(i+1); int end = -1; if (c == QLatin1Char('(')) end = value.indexOf(QLatin1Char(')'), i); else if (c == QLatin1Char('{')) end = value.indexOf(QLatin1Char('}'), i); if (end != -1) { const QString &name = value.mid(i+2, end-i-2); Environment::const_iterator it = constFind(name); if (it != constEnd()) value.replace(i, end-i+1, it.value()); } } } } resultEnvironment.set(item.name, value); } } *this = resultEnvironment; } QList Environment::diff(const Environment &other) const { QMap::const_iterator thisIt = constBegin(); QMap::const_iterator otherIt = other.constBegin(); QList result; while (thisIt != constEnd() || otherIt != other.constEnd()) { if (thisIt == constEnd()) { result.append(EnvironmentItem(otherIt.key(), otherIt.value())); ++otherIt; } else if (otherIt == other.constEnd()) { EnvironmentItem item(thisIt.key(), QString()); item.unset = true; result.append(item); ++thisIt; } else if (thisIt.key() < otherIt.key()) { EnvironmentItem item(thisIt.key(), QString()); item.unset = true; result.append(item); ++thisIt; } else if (thisIt.key() > otherIt.key()) { result.append(EnvironmentItem(otherIt.key(), otherIt.value())); ++otherIt; } else { if (thisIt.value() != otherIt.value()) result.append(EnvironmentItem(otherIt.key(), otherIt.value())); ++otherIt; ++thisIt; } } return result; } bool Environment::hasKey(const QString &key) const { return m_values.contains(key); } QString Environment::userName() const { return value(QLatin1String(m_osType == OsTypeWindows ? "USERNAME" : "USER")); } bool Environment::operator!=(const Environment &other) const { return !(*this == other); } bool Environment::operator==(const Environment &other) const { return m_osType == other.m_osType && m_values == other.m_values; } /** Expand environment variables in a string. * * Environment variables are accepted in the following forms: * $SOMEVAR, ${SOMEVAR} on Unix and %SOMEVAR% on Windows. * No escapes and quoting are supported. * If a variable is not found, it is not substituted. */ QString Environment::expandVariables(const QString &input) const { QString result = input; if (m_osType == OsTypeWindows) { for (int vStart = -1, i = 0; i < result.length(); ) { if (result.at(i++) == QLatin1Char('%')) { if (vStart > 0) { const_iterator it = m_values.constFind(result.mid(vStart, i - vStart - 1).toUpper()); if (it != m_values.constEnd()) { result.replace(vStart - 1, i - vStart + 1, *it); i = vStart - 1 + it->length(); vStart = -1; } else { vStart = i; } } else { vStart = i; } } } } else { enum { BASE, OPTIONALVARIABLEBRACE, VARIABLE, BRACEDVARIABLE } state = BASE; int vStart = -1; for (int i = 0; i < result.length();) { QChar c = result.at(i++); if (state == BASE) { if (c == QLatin1Char('$')) state = OPTIONALVARIABLEBRACE; } else if (state == OPTIONALVARIABLEBRACE) { if (c == QLatin1Char('{')) { state = BRACEDVARIABLE; vStart = i; } else if (c.isLetterOrNumber() || c == QLatin1Char('_')) { state = VARIABLE; vStart = i - 1; } else { state = BASE; } } else if (state == BRACEDVARIABLE) { if (c == QLatin1Char('}')) { const_iterator it = m_values.constFind(result.mid(vStart, i - 1 - vStart)); if (it != constEnd()) { result.replace(vStart - 2, i - vStart + 2, *it); i = vStart - 2 + it->length(); } state = BASE; } } else if (state == VARIABLE) { if (!c.isLetterOrNumber() && c != QLatin1Char('_')) { const_iterator it = m_values.constFind(result.mid(vStart, i - vStart - 1)); if (it != constEnd()) { result.replace(vStart - 1, i - vStart, *it); i = vStart - 1 + it->length(); } state = BASE; } } } if (state == VARIABLE) { const_iterator it = m_values.constFind(result.mid(vStart)); if (it != constEnd()) result.replace(vStart - 1, result.length() - vStart + 1, *it); } } return result; } QStringList Environment::expandVariables(const QStringList &variables) const { QStringList results; foreach (const QString &i, variables) results << expandVariables(i); return results; } } // namespace Utils diff --git a/languages/qmljs/libs/utils/fileutils.cpp b/languages/qmljs/libs/utils/fileutils.cpp index 2443059eaa..5f6ffa023c 100644 --- a/languages/qmljs/libs/utils/fileutils.cpp +++ b/languages/qmljs/libs/utils/fileutils.cpp @@ -1,793 +1,793 @@ /**************************************************************************** ** ** Copyright (C) 2015 The Qt Company Ltd. ** Contact: http://www.qt.io/licensing ** ** This file is part of Qt Creator. ** ** Commercial License Usage ** Licensees holding valid commercial Qt licenses may use this file in ** accordance with the commercial license agreement provided with the ** Software or, alternatively, in accordance with the terms contained in ** a written agreement between you and The Qt Company. For licensing terms and ** conditions see http://www.qt.io/terms-conditions. For further information ** use the contact form at http://www.qt.io/contact-us. ** ** 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 or version 3 as published by the Free ** Software Foundation and appearing in the file LICENSE.LGPLv21 and ** LICENSE.LGPLv3 included in the packaging of this file. Please review the ** following information to ensure the GNU Lesser General Public License ** requirements will be met: https://www.gnu.org/licenses/lgpl.html and ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ** ** In addition, as a special exception, The Qt Company gives you certain additional ** rights. These rights are described in The Qt Company LGPL Exception ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ** ****************************************************************************/ #include "fileutils.h" #include "savefile.h" #include "algorithm.h" #include "hostosinfo.h" #include "qtcassert.h" #include #include #include #include #include #include #include #ifdef Q_OS_WIN #include #include #endif #ifdef Q_OS_OSX #include "fileutils_mac.h" #endif QT_BEGIN_NAMESPACE QDebug operator<<(QDebug dbg, const Utils::FileName &c) { return dbg << c.toString(); } QT_END_NAMESPACE namespace Utils { /*! \class Utils::FileUtils \brief The FileUtils class contains file and directory related convenience functions. */ /*! Removes the directory \a filePath and its subdirectories recursively. \note The \a error parameter is optional. Returns whether the operation succeeded. */ bool FileUtils::removeRecursively(const FileName &filePath, QString *error) { QFileInfo fileInfo = filePath.toFileInfo(); if (!fileInfo.exists() && !fileInfo.isSymLink()) return true; QFile::setPermissions(filePath.toString(), fileInfo.permissions() | QFile::WriteUser); if (fileInfo.isDir()) { QDir dir(filePath.toString()); dir = dir.canonicalPath(); if (dir.isRoot()) { if (error) { *error = QCoreApplication::translate("Utils::FileUtils", "Refusing to remove root directory."); } return false; } if (dir.path() == QDir::home().canonicalPath()) { if (error) { *error = QCoreApplication::translate("Utils::FileUtils", "Refusing to remove your home directory."); } return false; } QStringList fileNames = dir.entryList(QDir::Files | QDir::Hidden | QDir::System | QDir::Dirs | QDir::NoDotAndDotDot); foreach (const QString &fileName, fileNames) { if (!removeRecursively(FileName(filePath).appendPath(fileName), error)) return false; } if (!QDir::root().rmdir(dir.path())) { if (error) { *error = QCoreApplication::translate("Utils::FileUtils", "Failed to remove directory \"%1\".") .arg(filePath.toUserOutput()); } return false; } } else { if (!QFile::remove(filePath.toString())) { if (error) { *error = QCoreApplication::translate("Utils::FileUtils", "Failed to remove file \"%1\".") .arg(filePath.toUserOutput()); } return false; } } return true; } /*! Copies the directory specified by \a srcFilePath recursively to \a tgtFilePath. \a tgtFilePath will contain the target directory, which will be created. Example usage: \code QString error; book ok = Utils::FileUtils::copyRecursively("/foo/bar", "/foo/baz", &error); if (!ok) qDebug() << error; \endcode This will copy the contents of /foo/bar into to the baz directory under /foo, which will be created in the process. \note The \a error parameter is optional. Returns whether the operation succeeded. */ bool FileUtils::copyRecursively(const FileName &srcFilePath, const FileName &tgtFilePath, QString *error, const std::function ©Helper) { QFileInfo srcFileInfo = srcFilePath.toFileInfo(); if (srcFileInfo.isDir()) { if (!tgtFilePath.exists()) { QDir targetDir(tgtFilePath.toString()); targetDir.cdUp(); if (!targetDir.mkdir(tgtFilePath.fileName())) { if (error) { *error = QCoreApplication::translate("Utils::FileUtils", "Failed to create directory \"%1\".") .arg(tgtFilePath.toUserOutput()); } return false; } } QDir sourceDir(srcFilePath.toString()); QStringList fileNames = sourceDir.entryList(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot | QDir::Hidden | QDir::System); foreach (const QString &fileName, fileNames) { FileName newSrcFilePath = srcFilePath; newSrcFilePath.appendPath(fileName); FileName newTgtFilePath = tgtFilePath; newTgtFilePath.appendPath(fileName); if (!copyRecursively(newSrcFilePath, newTgtFilePath, error, copyHelper)) return false; } } else { if (copyHelper) { if (!copyHelper(srcFileInfo, tgtFilePath.toFileInfo(), error)) return false; } else { if (!QFile::copy(srcFilePath.toString(), tgtFilePath.toString())) { if (error) { *error = QCoreApplication::translate("Utils::FileUtils", "Could not copy file \"%1\" to \"%2\".") .arg(srcFilePath.toUserOutput(), tgtFilePath.toUserOutput()); } return false; } } } return true; } /*! If \a filePath is a directory, the function will recursively check all files and return true if one of them is newer than \a timeStamp. If \a filePath is a single file, true will be returned if the file is newer than \a timeStamp. Returns whether at least one file in \a filePath has a newer date than \a timeStamp. */ bool FileUtils::isFileNewerThan(const FileName &filePath, const QDateTime &timeStamp) { QFileInfo fileInfo = filePath.toFileInfo(); if (!fileInfo.exists() || fileInfo.lastModified() >= timeStamp) return true; if (fileInfo.isDir()) { const QStringList dirContents = QDir(filePath.toString()) .entryList(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot); foreach (const QString &curFileName, dirContents) { if (isFileNewerThan(FileName(filePath).appendPath(curFileName), timeStamp)) return true; } } return false; } /*! Recursively resolves possibly present symlinks in \a filePath. Unlike QFileInfo::canonicalFilePath(), this function will still return the expected target file even if the symlink is dangling. \note Maximum recursion depth == 16. Returns the symlink target file path. */ FileName FileUtils::resolveSymlinks(const FileName &path) { QFileInfo f = path.toFileInfo(); int links = 16; while (links-- && f.isSymLink()) f.setFile(f.symLinkTarget()); if (links <= 0) return FileName(); return FileName::fromString(f.filePath()); } /*! Like QDir::toNativeSeparators(), but use prefix '~' instead of $HOME on unix systems when an absolute path is given. Returns the possibly shortened path with native separators. */ QString FileUtils::shortNativePath(const FileName &path) { if (HostOsInfo::isAnyUnixHost()) { const FileName home = FileName::fromString(QDir::cleanPath(QDir::homePath())); if (path.isChildOf(home)) { return QLatin1Char('~') + QDir::separator() + QDir::toNativeSeparators(path.relativeChildPath(home).toString()); } } return path.toUserOutput(); } QString FileUtils::fileSystemFriendlyName(const QString &name) { QString result = name; - result.replace(QRegExp(QLatin1String("\\W")), QLatin1String("_")); - result.replace(QRegExp(QLatin1String("_+")), QLatin1String("_")); // compact _ + result.replace(QRegExp(QLatin1String("\\W")), QStringLiteral("_")); + result.replace(QRegExp(QLatin1String("_+")), QStringLiteral("_")); // compact _ result.remove(QRegExp(QLatin1String("^_*"))); // remove leading _ result.remove(QRegExp(QLatin1String("_+$"))); // remove trailing _ if (result.isEmpty()) - result = QLatin1String("unknown"); + result = QStringLiteral("unknown"); return result; } int FileUtils::indexOfQmakeUnfriendly(const QString &name, int startpos) { static QRegExp checkRegExp(QLatin1String("[^a-zA-Z0-9_.-]")); return checkRegExp.indexIn(name, startpos); } QString FileUtils::qmakeFriendlyName(const QString &name) { QString result = name; // Remove characters that might trip up a build system (especially qmake): int pos = indexOfQmakeUnfriendly(result); while (pos >= 0) { result[pos] = QLatin1Char('_'); pos = indexOfQmakeUnfriendly(result, pos); } return fileSystemFriendlyName(result); } bool FileUtils::makeWritable(const FileName &path) { const QString fileName = path.toString(); return QFile::setPermissions(fileName, QFile::permissions(fileName) | QFile::WriteUser); } // makes sure that capitalization of directories is canonical on Windows and OS X. // This mimics the logic in QDeclarative_isFileCaseCorrect QString FileUtils::normalizePathName(const QString &name) { #ifdef Q_OS_WIN const QString nativeSeparatorName(QDir::toNativeSeparators(name)); const LPCTSTR nameC = reinterpret_cast(nativeSeparatorName.utf16()); // MinGW PIDLIST_ABSOLUTE file; HRESULT hr = SHParseDisplayName(nameC, NULL, &file, 0, NULL); if (FAILED(hr)) return name; TCHAR buffer[MAX_PATH]; if (!SHGetPathFromIDList(file, buffer)) return name; return QDir::fromNativeSeparators(QString::fromUtf16(reinterpret_cast(buffer))); #elif defined(Q_OS_OSX) return Internal::normalizePathName(name); #else // do not try to handle case-insensitive file systems on Linux return name; #endif } bool FileUtils::isRelativePath(const QString &path) { if (path.startsWith(QLatin1Char('/'))) return false; if (HostOsInfo::isWindowsHost()) { if (path.startsWith(QLatin1Char('\\'))) return false; // Unlike QFileInfo, this won't accept a relative path with a drive letter. // Such paths result in a royal mess anyway ... if (path.length() >= 3 && path.at(1) == QLatin1Char(':') && path.at(0).isLetter() && (path.at(2) == QLatin1Char('/') || path.at(2) == QLatin1Char('\\'))) return false; } return true; } QString FileUtils::resolvePath(const QString &baseDir, const QString &fileName) { if (fileName.isEmpty()) return QString(); if (isAbsolutePath(fileName)) return QDir::cleanPath(fileName); return QDir::cleanPath(baseDir + QLatin1Char('/') + fileName); } QByteArray FileReader::fetchQrc(const QString &fileName) { QTC_ASSERT(fileName.startsWith(QLatin1Char(':')), return QByteArray()); QFile file(fileName); bool ok = file.open(QIODevice::ReadOnly); QTC_ASSERT(ok, qWarning() << fileName << "not there!"; return QByteArray()); return file.readAll(); } bool FileReader::fetch(const QString &fileName, QIODevice::OpenMode mode) { QTC_ASSERT(!(mode & ~(QIODevice::ReadOnly | QIODevice::Text)), return false); QFile file(fileName); if (!file.open(QIODevice::ReadOnly | mode)) { m_errorString = tr("Cannot open %1 for reading: %2").arg( QDir::toNativeSeparators(fileName), file.errorString()); return false; } m_data = file.readAll(); if (file.error() != QFile::NoError) { m_errorString = tr("Cannot read %1: %2").arg( QDir::toNativeSeparators(fileName), file.errorString()); return false; } return true; } bool FileReader::fetch(const QString &fileName, QIODevice::OpenMode mode, QString *errorString) { if (fetch(fileName, mode)) return true; if (errorString) *errorString = m_errorString; return false; } bool FileReader::fetch(const QString &fileName, QIODevice::OpenMode mode, QWidget *parent) { if (fetch(fileName, mode)) return true; if (parent) QMessageBox::critical(parent, tr("File Error"), m_errorString); return false; } FileSaverBase::FileSaverBase() : m_file(nullptr) , m_hasError(false) { } FileSaverBase::~FileSaverBase() { } bool FileSaverBase::finalize() { m_file->close(); setResult(m_file->error() == QFile::NoError); // We delete the object, so it is really closed even if it is a QTemporaryFile. delete m_file; m_file = 0; return !m_hasError; } bool FileSaverBase::finalize(QString *errStr) { if (finalize()) return true; if (errStr) *errStr = errorString(); return false; } bool FileSaverBase::finalize(QWidget *parent) { if (finalize()) return true; QMessageBox::critical(parent, tr("File Error"), errorString()); return false; } bool FileSaverBase::write(const char *data, int len) { if (m_hasError) return false; return setResult(m_file->write(data, len) == len); } bool FileSaverBase::write(const QByteArray &bytes) { if (m_hasError) return false; return setResult(m_file->write(bytes) == bytes.count()); } bool FileSaverBase::setResult(bool ok) { if (!ok && !m_hasError) { m_errorString = tr("Cannot write file %1. Disk full?").arg( QDir::toNativeSeparators(m_fileName)); m_hasError = true; } return ok; } bool FileSaverBase::setResult(QTextStream *stream) { stream->flush(); return setResult(stream->status() == QTextStream::Ok); } bool FileSaverBase::setResult(QDataStream *stream) { return setResult(stream->status() == QDataStream::Ok); } bool FileSaverBase::setResult(QXmlStreamWriter *stream) { return setResult(!stream->hasError()); } FileSaver::FileSaver(const QString &filename, QIODevice::OpenMode mode) { m_fileName = filename; if (mode & (QIODevice::ReadOnly | QIODevice::Append)) { m_file = new QFile(filename); m_isSafe = false; } else { m_file = new SaveFile(filename); m_isSafe = true; } if (!m_file->open(QIODevice::WriteOnly | mode)) { QString err = QFile::exists(filename) ? tr("Cannot overwrite file %1: %2") : tr("Cannot create file %1: %2"); m_errorString = err.arg(QDir::toNativeSeparators(filename), m_file->errorString()); m_hasError = true; } } bool FileSaver::finalize() { if (!m_isSafe) return FileSaverBase::finalize(); SaveFile *sf = static_cast(m_file); if (m_hasError) { if (sf->isOpen()) sf->rollback(); } else { setResult(sf->commit()); } delete sf; m_file = 0; return !m_hasError; } TempFileSaver::TempFileSaver(const QString &templ) : m_autoRemove(true) { QTemporaryFile *tempFile = new QTemporaryFile(); if (!templ.isEmpty()) tempFile->setFileTemplate(templ); tempFile->setAutoRemove(false); if (!tempFile->open()) { m_errorString = tr("Cannot create temporary file in %1: %2").arg( QDir::toNativeSeparators(QFileInfo(tempFile->fileTemplate()).absolutePath()), tempFile->errorString()); m_hasError = true; } m_file = tempFile; m_fileName = tempFile->fileName(); } TempFileSaver::~TempFileSaver() { delete m_file; m_file = 0; if (m_autoRemove) QFile::remove(m_fileName); } /*! \class Utils::FileName \brief The FileName class is a light-weight convenience class for filenames. On windows filenames are compared case insensitively. */ FileName::FileName() : QString() { } /// Constructs a FileName from \a info FileName::FileName(const QFileInfo &info) : QString(info.absoluteFilePath()) { } /// \returns a QFileInfo QFileInfo FileName::toFileInfo() const { return QFileInfo(*this); } /// \returns a QString for passing on to QString based APIs const QString &FileName::toString() const { return *this; } /// \returns a QString to display to the user /// Converts the separators to the native format QString FileName::toUserOutput() const { return QDir::toNativeSeparators(toString()); } QString FileName::fileName(int pathComponents) const { if (pathComponents < 0) return *this; const QChar slash = QLatin1Char('/'); QTC_CHECK(!endsWith(slash)); int i = lastIndexOf(slash); if (pathComponents == 0 || i == -1) return mid(i + 1); int component = i + 1; // skip adjacent slashes while (i > 0 && at(--i) == slash); while (i >= 0 && --pathComponents >= 0) { i = lastIndexOf(slash, i); component = i + 1; while (i > 0 && at(--i) == slash); } // If there are no more slashes before the found one, return the entire string if (i > 0 && lastIndexOf(slash, i) != -1) return mid(component); return *this; } /// \returns a bool indicating whether a file with this /// FileName exists. bool FileName::exists() const { return QFileInfo::exists(*this); } /// Find the parent directory of a given directory. /// Returns an empty FileName if the current directory is already /// a root level directory. /// \returns \a FileName with the last segment removed. FileName FileName::parentDir() const { const QString basePath = toString(); if (basePath.isEmpty()) return FileName(); const QDir base(basePath); if (base.isRoot()) return FileName(); const QString path = basePath + QLatin1String("/.."); const QString parent = QDir::cleanPath(path); return FileName::fromString(parent); } /// Constructs a FileName from \a filename /// \a filename is not checked for validity. FileName FileName::fromString(const QString &filename) { return FileName(filename); } /// Constructs a FileName from \a fileName. The \a defaultExtension is appended /// to \a filename if that does not have an extension already. /// \a fileName is not checked for validity. FileName FileName::fromString(const QString &filename, const QString &defaultExtension) { if (filename.isEmpty() || defaultExtension.isEmpty()) return filename; QString rc = filename; QFileInfo fi(filename); // Add extension unless user specified something else const QChar dot = QLatin1Char('.'); if (!fi.fileName().contains(dot)) { if (!defaultExtension.startsWith(dot)) rc += dot; rc += defaultExtension; } return rc; } /// Constructs a FileName from \a fileName /// \a fileName is not checked for validity. FileName FileName::fromLatin1(const QByteArray &filename) { return FileName(QString::fromLatin1(filename)); } /// Constructs a FileName from \a fileName /// \a fileName is only passed through QDir::cleanPath FileName FileName::fromUserInput(const QString &filename) { QString clean = QDir::cleanPath(filename); if (clean.startsWith(QLatin1String("~/"))) clean = QDir::homePath() + clean.mid(1); return FileName(clean); } /// Constructs a FileName from \a fileName, which is encoded as UTF-8. /// \a fileName is not checked for validity. FileName FileName::fromUtf8(const char *filename, int filenameSize) { return FileName(QString::fromUtf8(filename, filenameSize)); } FileName::FileName(const QString &string) : QString(string) { } bool FileName::operator==(const FileName &other) const { return QString::compare(*this, other, HostOsInfo::fileNameCaseSensitivity()) == 0; } bool FileName::operator!=(const FileName &other) const { return !(*this == other); } bool FileName::operator<(const FileName &other) const { return QString::compare(*this, other, HostOsInfo::fileNameCaseSensitivity()) < 0; } bool FileName::operator<=(const FileName &other) const { return QString::compare(*this, other, HostOsInfo::fileNameCaseSensitivity()) <= 0; } bool FileName::operator>(const FileName &other) const { return other < *this; } bool FileName::operator>=(const FileName &other) const { return other <= *this; } /// \returns whether FileName is a child of \a s bool FileName::isChildOf(const FileName &s) const { if (s.isEmpty()) return false; if (!QString::startsWith(s, HostOsInfo::fileNameCaseSensitivity())) return false; if (size() <= s.size()) return false; // s is root, '/' was already tested in startsWith if (s.QString::endsWith(QLatin1Char('/'))) return true; // s is a directory, next character should be '/' (/tmpdir is NOT a child of /tmp) return at(s.size()) == QLatin1Char('/'); } /// \overload bool FileName::isChildOf(const QDir &dir) const { return isChildOf(FileName::fromString(dir.absolutePath())); } /// \returns whether FileName endsWith \a s bool FileName::endsWith(const QString &s) const { return QString::endsWith(s, HostOsInfo::fileNameCaseSensitivity()); } /// \returns the relativeChildPath of FileName to parent if FileName is a child of parent /// \note returns a empty FileName if FileName is not a child of parent /// That is, this never returns a path starting with "../" FileName FileName::relativeChildPath(const FileName &parent) const { if (!isChildOf(parent)) return FileName(); return FileName(QString::mid(parent.size() + 1, -1)); } /// Appends \a s, ensuring a / between the parts FileName &FileName::appendPath(const QString &s) { if (s.isEmpty()) return *this; if (!isEmpty() && !QString::endsWith(QLatin1Char('/'))) appendString(QLatin1Char('/')); appendString(s); return *this; } FileName &FileName::appendString(const QString &str) { QString::append(str); return *this; } FileName &FileName::appendString(QChar str) { QString::append(str); return *this; } QTextStream &operator<<(QTextStream &s, const FileName &fn) { return s << fn.toString(); } int FileNameList::removeDuplicates() { QSet seen; int removed = 0; for (int i = 0; i < size(); ) { const FileName &fn = at(i); if (seen.contains(fn)) { removeAt(i); ++removed; } else { seen.insert(fn); ++i; } } return removed; } } // namespace Utils QT_BEGIN_NAMESPACE uint qHash(const Utils::FileName &a) { if (Utils::HostOsInfo::fileNameCaseSensitivity() == Qt::CaseInsensitive) return qHash(a.toString().toUpper()); return qHash(a.toString()); } QT_END_NAMESPACE diff --git a/languages/qmljs/libs/utils/json.cpp b/languages/qmljs/libs/utils/json.cpp index 47f1230c44..f06441c4a8 100644 --- a/languages/qmljs/libs/utils/json.cpp +++ b/languages/qmljs/libs/utils/json.cpp @@ -1,752 +1,752 @@ /**************************************************************************** ** ** Copyright (C) 2015 The Qt Company Ltd. ** Contact: http://www.qt.io/licensing ** ** This file is part of Qt Creator. ** ** Commercial License Usage ** Licensees holding valid commercial Qt licenses may use this file in ** accordance with the commercial license agreement provided with the ** Software or, alternatively, in accordance with the terms contained in ** a written agreement between you and The Qt Company. For licensing terms and ** conditions see http://www.qt.io/terms-conditions. For further information ** use the contact form at http://www.qt.io/contact-us. ** ** 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 or version 3 as published by the Free ** Software Foundation and appearing in the file LICENSE.LGPLv21 and ** LICENSE.LGPLv3 included in the packaging of this file. Please review the ** following information to ensure the GNU Lesser General Public License ** requirements will be met: https://www.gnu.org/licenses/lgpl.html and ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ** ** In addition, as a special exception, The Qt Company gives you certain additional ** rights. These rights are described in The Qt Company LGPL Exception ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ** ****************************************************************************/ #include "json.h" #include #include #include #include #include #include using namespace Utils; JsonMemoryPool::~JsonMemoryPool() { foreach (char *obj, _objs) { reinterpret_cast(obj)->~JsonValue(); delete[] obj; } } JsonValue::JsonValue(Kind kind) : m_kind(kind) {} JsonValue::~JsonValue() {} JsonValue *JsonValue::create(const QString &s, JsonMemoryPool *pool) { const QJsonDocument document = QJsonDocument::fromJson(s.toUtf8()); if (document.isNull()) return 0; return build(document.toVariant(), pool); } void *JsonValue::operator new(size_t size, JsonMemoryPool *pool) { return pool->allocate(size); } void JsonValue::operator delete(void *) { } void JsonValue::operator delete(void *, JsonMemoryPool *) { } QString JsonValue::kindToString(JsonValue::Kind kind) { if (kind == String) - return QLatin1String("string"); + return QStringLiteral("string"); if (kind == Double) - return QLatin1String("number"); + return QStringLiteral("number"); if (kind == Int) - return QLatin1String("integer"); + return QStringLiteral("integer"); if (kind == Object) - return QLatin1String("object"); + return QStringLiteral("object"); if (kind == Array) - return QLatin1String("array"); + return QStringLiteral("array"); if (kind == Boolean) - return QLatin1String("boolean"); + return QStringLiteral("boolean"); if (kind == Null) - return QLatin1String("null"); + return QStringLiteral("null"); - return QLatin1String("unknown"); + return QStringLiteral("unknown"); } JsonValue *JsonValue::build(const QVariant &variant, JsonMemoryPool *pool) { switch (variant.type()) { case QVariant::List: { JsonArrayValue *newValue = new (pool) JsonArrayValue; foreach (const QVariant &element, variant.toList()) newValue->addElement(build(element, pool)); return newValue; } case QVariant::Map: { JsonObjectValue *newValue = new (pool) JsonObjectValue; const QVariantMap variantMap = variant.toMap(); for (QVariantMap::const_iterator it = variantMap.begin(); it != variantMap.end(); ++it) newValue->addMember(it.key(), build(it.value(), pool)); return newValue; } case QVariant::String: return new (pool) JsonStringValue(variant.toString()); case QVariant::Int: return new (pool) JsonIntValue(variant.toInt()); case QVariant::Double: return new (pool) JsonDoubleValue(variant.toDouble()); case QVariant::Bool: return new (pool) JsonBooleanValue(variant.toBool()); case QVariant::Invalid: return new (pool) JsonNullValue; default: break; } return 0; } /////////////////////////////////////////////////////////////////////////////// QString JsonSchema::kType() { return QStringLiteral("type"); } QString JsonSchema::kProperties() { return QStringLiteral("properties"); } QString JsonSchema::kPatternProperties() { return QStringLiteral("patternProperties"); } QString JsonSchema::kAdditionalProperties() { return QStringLiteral("additionalProperties"); } QString JsonSchema::kItems() { return QStringLiteral("items"); } QString JsonSchema::kAdditionalItems() { return QStringLiteral("additionalItems"); } QString JsonSchema::kRequired() { return QStringLiteral("required"); } QString JsonSchema::kDependencies() { return QStringLiteral("dependencies"); } QString JsonSchema::kMinimum() { return QStringLiteral("minimum"); } QString JsonSchema::kMaximum() { return QStringLiteral("maximum"); } QString JsonSchema::kExclusiveMinimum() { return QStringLiteral("exclusiveMinimum"); } QString JsonSchema::kExclusiveMaximum() { return QStringLiteral("exclusiveMaximum"); } QString JsonSchema::kMinItems() { return QStringLiteral("minItems"); } QString JsonSchema::kMaxItems() { return QStringLiteral("maxItems"); } QString JsonSchema::kUniqueItems() { return QStringLiteral("uniqueItems"); } QString JsonSchema::kPattern() { return QStringLiteral("pattern"); } QString JsonSchema::kMinLength() { return QStringLiteral("minLength"); } QString JsonSchema::kMaxLength() { return QStringLiteral("maxLength"); } QString JsonSchema::kTitle() { return QStringLiteral("title"); } QString JsonSchema::kDescription() { return QStringLiteral("description"); } QString JsonSchema::kExtends() { return QStringLiteral("extends"); } QString JsonSchema::kRef() { return QStringLiteral("$ref"); } JsonSchema::JsonSchema(JsonObjectValue *rootObject, const JsonSchemaManager *manager) : m_manager(manager) { enter(rootObject); } bool JsonSchema::isTypeConstrained() const { // Simple types if (JsonStringValue *sv = getStringValue(kType(), currentValue())) return isCheckableType(sv->value()); // Union types if (JsonArrayValue *av = getArrayValue(kType(), currentValue())) { QTC_ASSERT(currentIndex() != -1, return false); QTC_ASSERT(av->elements().at(currentIndex())->kind() == JsonValue::String, return false); JsonStringValue *sv = av->elements().at(currentIndex())->toString(); return isCheckableType(sv->value()); } return false; } bool JsonSchema::acceptsType(const QString &type) const { // Simple types if (JsonStringValue *sv = getStringValue(kType(), currentValue())) return typeMatches(sv->value(), type); // Union types if (JsonArrayValue *av = getArrayValue(kType(), currentValue())) { QTC_ASSERT(currentIndex() != -1, return false); QTC_ASSERT(av->elements().at(currentIndex())->kind() == JsonValue::String, return false); JsonStringValue *sv = av->elements().at(currentIndex())->toString(); return typeMatches(sv->value(), type); } return false; } QStringList JsonSchema::validTypes(JsonObjectValue *v) { QStringList all; if (JsonStringValue *sv = getStringValue(kType(), v)) all.append(sv->value()); if (JsonObjectValue *ov = getObjectValue(kType(), v)) return validTypes(ov); if (JsonArrayValue *av = getArrayValue(kType(), v)) { foreach (JsonValue *v, av->elements()) { if (JsonStringValue *sv = v->toString()) all.append(sv->value()); else if (JsonObjectValue *ov = v->toObject()) all.append(validTypes(ov)); } } return all; } bool JsonSchema::typeMatches(const QString &expected, const QString &actual) { if (expected == QLatin1String("number") && actual == QLatin1String("integer")) return true; return expected == actual; } bool JsonSchema::isCheckableType(const QString &s) { if (s == QLatin1String("string") || s == QLatin1String("number") || s == QLatin1String("integer") || s == QLatin1String("boolean") || s == QLatin1String("object") || s == QLatin1String("array") || s == QLatin1String("null")) { return true; } return false; } QStringList JsonSchema::validTypes() const { return validTypes(currentValue()); } bool JsonSchema::hasTypeSchema() const { return getObjectValue(kType(), currentValue()); } void JsonSchema::enterNestedTypeSchema() { QTC_ASSERT(hasTypeSchema(), return); enter(getObjectValue(kType(), currentValue())); } QStringList JsonSchema::properties(JsonObjectValue *v) const { typedef QHash::ConstIterator MemberConstIterator; QStringList all; if (JsonObjectValue *ov = getObjectValue(kProperties(), v)) { const MemberConstIterator cend = ov->members().constEnd(); for (MemberConstIterator it = ov->members().constBegin(); it != cend; ++it) if (hasPropertySchema(it.key())) all.append(it.key()); } if (JsonObjectValue *base = resolveBase(v)) all.append(properties(base)); return all; } QStringList JsonSchema::properties() const { QTC_ASSERT(acceptsType(JsonValue::kindToString(JsonValue::Object)), return QStringList()); return properties(currentValue()); } JsonObjectValue *JsonSchema::propertySchema(const QString &property, JsonObjectValue *v) const { if (JsonObjectValue *ov = getObjectValue(kProperties(), v)) { JsonValue *member = ov->member(property); if (member && member->kind() == JsonValue::Object) return member->toObject(); } if (JsonObjectValue *base = resolveBase(v)) return propertySchema(property, base); return 0; } bool JsonSchema::hasPropertySchema(const QString &property) const { return propertySchema(property, currentValue()); } void JsonSchema::enterNestedPropertySchema(const QString &property) { QTC_ASSERT(hasPropertySchema(property), return); JsonObjectValue *schema = propertySchema(property, currentValue()); enter(schema); } /*! * An array schema is allowed to have its \e items specification in the form of * another schema * or in the form of an array of schemas [Sec. 5.5]. This functions checks whether this is case * in which the items are a schema. * * Returns whether or not the items from the array are a schema. */ bool JsonSchema::hasItemSchema() const { QTC_ASSERT(acceptsType(JsonValue::kindToString(JsonValue::Array)), return false); return getObjectValue(kItems(), currentValue()); } void JsonSchema::enterNestedItemSchema() { QTC_ASSERT(hasItemSchema(), return); enter(getObjectValue(kItems(), currentValue())); } /*! * An array schema is allowed to have its \e items specification in the form of another schema * or in the form of an array of schemas [Sec. 5.5]. This functions checks whether this is case * in which the items are an array of schemas. * * Returns whether or not the items from the array are a an array of schemas. */ bool JsonSchema::hasItemArraySchema() const { QTC_ASSERT(acceptsType(JsonValue::kindToString(JsonValue::Array)), return false); return getArrayValue(kItems(), currentValue()); } int JsonSchema::itemArraySchemaSize() const { QTC_ASSERT(hasItemArraySchema(), return false); return getArrayValue(kItems(), currentValue())->size(); } /*! * When evaluating the items of an array it might be necessary to \e enter a * particular schema, * since this API assumes that there's always a valid schema in context (the one the user is * interested on). This shall only happen if the item at the supplied array index is of type * object, which is then assumed to be a schema. * * The function also marks the context as being inside an array evaluation. * * Returns whether it was necessary to enter a schema for the supplied * array \a index, false if index is out of bounds. */ bool JsonSchema::maybeEnterNestedArraySchema(int index) { QTC_ASSERT(itemArraySchemaSize(), return false); QTC_ASSERT(index >= 0 && index < itemArraySchemaSize(), return false); JsonValue *v = getArrayValue(kItems(), currentValue())->elements().at(index); return maybeEnter(v, Array, index); } /*! * The type of a schema can be specified in the form of a union type, which is basically an * array of allowed types for the particular instance [Sec. 5.1]. This function checks whether * the current schema is one of such. * * Returns whether or not the current schema specifies a union type. */ bool JsonSchema::hasUnionSchema() const { return getArrayValue(kType(), currentValue()); } int JsonSchema::unionSchemaSize() const { return getArrayValue(kType(), currentValue())->size(); } /*! * When evaluating union types it might be necessary to enter a particular * schema, since this * API assumes that there's always a valid schema in context (the one the user is interested on). * This shall only happen if the item at the supplied union \a index, which is then assumed to be * a schema. * * The function also marks the context as being inside an union evaluation. * * Returns whether or not it was necessary to enter a schema for the * supplied union index. */ bool JsonSchema::maybeEnterNestedUnionSchema(int index) { QTC_ASSERT(unionSchemaSize(), return false); QTC_ASSERT(index >= 0 && index < unionSchemaSize(), return false); JsonValue *v = getArrayValue(kType(), currentValue())->elements().at(index); return maybeEnter(v, Union, index); } void JsonSchema::leaveNestedSchema() { QTC_ASSERT(!m_schemas.isEmpty(), return); leave(); } bool JsonSchema::required() const { if (JsonBooleanValue *bv = getBooleanValue(kRequired(), currentValue())) return bv->value(); return false; } bool JsonSchema::hasMinimum() const { QTC_ASSERT(acceptsType(JsonValue::kindToString(JsonValue::Int)), return false); return getDoubleValue(kMinimum(), currentValue()); } double JsonSchema::minimum() const { QTC_ASSERT(hasMinimum(), return 0); return getDoubleValue(kMinimum(), currentValue())->value(); } bool JsonSchema::hasExclusiveMinimum() { QTC_ASSERT(acceptsType(JsonValue::kindToString(JsonValue::Int)), return false); if (JsonBooleanValue *bv = getBooleanValue(kExclusiveMinimum(), currentValue())) return bv->value(); return false; } bool JsonSchema::hasMaximum() const { QTC_ASSERT(acceptsType(JsonValue::kindToString(JsonValue::Int)), return false); return getDoubleValue(kMaximum(), currentValue()); } double JsonSchema::maximum() const { QTC_ASSERT(hasMaximum(), return 0); return getDoubleValue(kMaximum(), currentValue())->value(); } bool JsonSchema::hasExclusiveMaximum() { QTC_ASSERT(acceptsType(JsonValue::kindToString(JsonValue::Int)), return false); if (JsonBooleanValue *bv = getBooleanValue(kExclusiveMaximum(), currentValue())) return bv->value(); return false; } QString JsonSchema::pattern() const { QTC_ASSERT(acceptsType(JsonValue::kindToString(JsonValue::String)), return QString()); if (JsonStringValue *sv = getStringValue(kPattern(), currentValue())) return sv->value(); return QString(); } int JsonSchema::minimumLength() const { QTC_ASSERT(acceptsType(JsonValue::kindToString(JsonValue::String)), return -1); if (JsonDoubleValue *dv = getDoubleValue(kMinLength(), currentValue())) return dv->value(); return -1; } int JsonSchema::maximumLength() const { QTC_ASSERT(acceptsType(JsonValue::kindToString(JsonValue::String)), return -1); if (JsonDoubleValue *dv = getDoubleValue(kMaxLength(), currentValue())) return dv->value(); return -1; } bool JsonSchema::hasAdditionalItems() const { QTC_ASSERT(acceptsType(JsonValue::kindToString(JsonValue::Array)), return false); return currentValue()->member(kAdditionalItems()); } bool JsonSchema::maybeSchemaName(const QString &s) { if (s.isEmpty() || s == QLatin1String("any")) return false; return !isCheckableType(s); } JsonObjectValue *JsonSchema::rootValue() const { QTC_ASSERT(!m_schemas.isEmpty(), return 0); return m_schemas.first().m_value; } JsonObjectValue *JsonSchema::currentValue() const { QTC_ASSERT(!m_schemas.isEmpty(), return 0); return m_schemas.last().m_value; } int JsonSchema::currentIndex() const { QTC_ASSERT(!m_schemas.isEmpty(), return 0); return m_schemas.last().m_index; } void JsonSchema::evaluate(EvaluationMode eval, int index) { QTC_ASSERT(!m_schemas.isEmpty(), return); m_schemas.last().m_eval = eval; m_schemas.last().m_index = index; } void JsonSchema::enter(JsonObjectValue *ov, EvaluationMode eval, int index) { Context context; context.m_eval = eval; context.m_index = index; context.m_value = resolveReference(ov); m_schemas.push_back(context); } bool JsonSchema::maybeEnter(JsonValue *v, EvaluationMode eval, int index) { evaluate(eval, index); if (v->kind() == JsonValue::Object) { enter(v->toObject()); return true; } if (v->kind() == JsonValue::String) { const QString &s = v->toString()->value(); if (maybeSchemaName(s)) { JsonSchema *schema = m_manager->schemaByName(s); if (schema) { enter(schema->rootValue()); return true; } } } return false; } void JsonSchema::leave() { QTC_ASSERT(!m_schemas.isEmpty(), return); m_schemas.pop_back(); } JsonObjectValue *JsonSchema::resolveReference(JsonObjectValue *ov) const { if (JsonStringValue *sv = getStringValue(kRef(), ov)) { JsonSchema *referenced = m_manager->schemaByName(sv->value()); if (referenced) return referenced->rootValue(); } return ov; } JsonObjectValue *JsonSchema::resolveBase(JsonObjectValue *ov) const { if (JsonValue *v = ov->member(kExtends())) { if (v->kind() == JsonValue::String) { JsonSchema *schema = m_manager->schemaByName(v->toString()->value()); if (schema) return schema->rootValue(); } else if (v->kind() == JsonValue::Object) { return resolveReference(v->toObject()); } } return 0; } JsonStringValue *JsonSchema::getStringValue(const QString &name, JsonObjectValue *value) { JsonValue *v = value->member(name); if (!v) return 0; return v->toString(); } JsonObjectValue *JsonSchema::getObjectValue(const QString &name, JsonObjectValue *value) { JsonValue *v = value->member(name); if (!v) return 0; return v->toObject(); } JsonBooleanValue *JsonSchema::getBooleanValue(const QString &name, JsonObjectValue *value) { JsonValue *v = value->member(name); if (!v) return 0; return v->toBoolean(); } JsonArrayValue *JsonSchema::getArrayValue(const QString &name, JsonObjectValue *value) { JsonValue *v = value->member(name); if (!v) return 0; return v->toArray(); } JsonDoubleValue *JsonSchema::getDoubleValue(const QString &name, JsonObjectValue *value) { JsonValue *v = value->member(name); if (!v) return 0; return v->toDouble(); } /////////////////////////////////////////////////////////////////////////////// JsonSchemaManager::JsonSchemaManager(const QStringList &searchPaths) : m_searchPaths(searchPaths) { foreach (const QString &path, m_searchPaths) { QDir dir(path); if (!dir.exists() && !dir.mkpath(path)) continue; - dir.setNameFilters(QStringList(QLatin1String("*.json"))); + dir.setNameFilters(QStringList(QStringLiteral("*.json"))); foreach (const QFileInfo &fi, dir.entryInfoList()) m_schemas.insert(fi.baseName(), JsonSchemaData(fi.absoluteFilePath())); } } JsonSchemaManager::~JsonSchemaManager() { foreach (const JsonSchemaData &schemaData, m_schemas) delete schemaData.m_schema; } /*! * Tries to find a JSON schema to validate \a fileName against. According * to the specification, how the schema/instance association is done is implementation defined. * Currently we use a quite naive approach which is simply based on file names. Specifically, * if one opens a foo.json file we'll look for a schema named foo.json. We should probably * investigate alternative settings later. * * Returns a valid schema or 0. */ JsonSchema *JsonSchemaManager::schemaForFile(const QString &fileName) const { QString baseName(QFileInfo(fileName).baseName()); return schemaByName(baseName); } JsonSchema *JsonSchemaManager::schemaByName(const QString &baseName) const { QHash::iterator it = m_schemas.find(baseName); if (it == m_schemas.end()) { foreach (const QString &path, m_searchPaths) { QFileInfo candidate(path % baseName % QLatin1String(".json")); if (candidate.exists()) { m_schemas.insert(baseName, candidate.absoluteFilePath()); break; } } } it = m_schemas.find(baseName); if (it == m_schemas.end()) return 0; JsonSchemaData *schemaData = &it.value(); if (!schemaData->m_schema) { // Schemas are built on-demand. QFileInfo currentSchema(schemaData->m_absoluteFileName); Q_ASSERT(currentSchema.exists()); if (schemaData->m_lastParseAttempt.isNull() || schemaData->m_lastParseAttempt < currentSchema.lastModified()) { schemaData->m_schema = parseSchema(currentSchema.absoluteFilePath()); } } return schemaData->m_schema; } JsonSchema *JsonSchemaManager::parseSchema(const QString &schemaFileName) const { FileReader reader; if (reader.fetch(schemaFileName, QIODevice::Text)) { const QString &contents = QString::fromUtf8(reader.data()); JsonValue *json = JsonValue::create(contents, &m_pool); if (json && json->kind() == JsonValue::Object) return new JsonSchema(json->toObject(), this); } return 0; } diff --git a/languages/qmljs/navigation/propertypreviewwidget.cpp b/languages/qmljs/navigation/propertypreviewwidget.cpp index 2640ee9f31..e80630fec2 100644 --- a/languages/qmljs/navigation/propertypreviewwidget.cpp +++ b/languages/qmljs/navigation/propertypreviewwidget.cpp @@ -1,183 +1,183 @@ /************************************************************************************* * Copyright (C) 2013 by Sven Brauch * * * * 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) 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 "propertypreviewwidget.h" #include #include #include #include #include #include #include #include #include #include #include // List of supported properties. The string must be the name of the property, // which can contain dots if necessary QHash PropertyPreviewWidget::supportedProperties; QWidget* PropertyPreviewWidget::constructIfPossible(KTextEditor::Document* doc, KTextEditor::Range keyRange, KTextEditor::Range valueRange, Declaration* decl, const QString& key, const QString& value) { #define PROP(key, filename, type, class) \ supportedProperties.insertMulti(key, SupportedProperty(QUrl(base + filename), type, class)); if ( supportedProperties.isEmpty() ) { QString base = QStandardPaths::locate( QStandardPaths::GenericDataLocation, - QLatin1String("kdevqmljssupport/propertywidgets"), + QStringLiteral("kdevqmljssupport/propertywidgets"), QStandardPaths::LocateDirectory ) + '/'; // Positioning PROP("width", "Width.qml", QString(), QString()) PROP("height", "Height.qml", QString(), QString()) PROP("spacing", "Spacing.qml", QString(), QString()) // Margins PROP("margins", "Spacing.qml", QString(), "QQuickAnchors"); // matches anchors.margins and anchors { margins: } PROP("margins", "Spacing.qml", QString(), "QDeclarativeAnchors"); PROP("leftMargin", "Spacing.qml", QString(), "QQuickAnchors"); PROP("leftMargin", "Spacing.qml", QString(), "QDeclarativeAnchors"); PROP("rightMargin", "Spacing.qml", QString(), "QQuickAnchors"); PROP("rightMargin", "Spacing.qml", QString(), "QDeclarativeAnchors"); PROP("topMargin", "Spacing.qml", QString(), "QQuickAnchors"); PROP("topMargin", "Spacing.qml", QString(), "QDeclarativeAnchors"); PROP("bottomMargin", "Spacing.qml", QString(), "QQuickAnchors"); PROP("bottomMargin", "Spacing.qml", QString(), "QDeclarativeAnchors"); // Animations PROP("duration", "Duration.qml", QString(), QString()) // Font QDeclarativeFontValueType, QQuickFontValueType PROP("family", "FontFamily.qml", QString(), "QDeclarativeFontValueType") PROP("family", "FontFamily.qml", QString(), "QQuickFontValueType") PROP("pointSize", "FontSize.qml", QString(), "QDeclarativeFontValueType") PROP("pointSize", "FontSize.qml", QString(), "QQuickFontValueType") // Appearance PROP("opacity", "Opacity.qml", QString(), QString()) // Type-dependent widgets PROP(QString(), "ColorPicker.qml", "color", QString()) } #undef PROP QList properties; properties << supportedProperties.values(key.section(QLatin1Char('.'), -1, -1)); properties << supportedProperties.values(QString()); // Explore each possible supported property and return the first supported widget DUChainReadLocker lock; for (const SupportedProperty& property : properties) { if (!decl || !decl->abstractType() || !decl->context() || !decl->context()->owner()) { continue; } if (!decl->abstractType()->toString().contains(property.typeContains)) { continue; } if (!decl->context()->owner()->toString().contains(property.classContains)) { continue; } return new PropertyPreviewWidget(doc, keyRange, valueRange, property, value); } return nullptr; } void PropertyPreviewWidget::updateValue() { QString newValue = view->rootObject()->property("value").toString(); // set the cursor to the edited range, otherwise the view will jump if we call doc->endEditing() //document->activeView()->setCursorPosition(KTextEditor::Cursor(valueRange.start.line, valueRange.start.column)); if (valueRange.end().column() - valueRange.start().column() == newValue.size()) { document->replaceText(valueRange, newValue); } else { // the length of the text changed so don't replace it but remove the old // and insert the new text. KTextEditor::Document::EditingTransaction transaction(document); document->removeText(valueRange); document->insertText(valueRange.start(), newValue); valueRange.setRange( valueRange.start(), KTextEditor::Cursor(valueRange.start().line(), valueRange.start().column() + newValue.size()) ); } } PropertyPreviewWidget::~PropertyPreviewWidget() { } PropertyPreviewWidget::PropertyPreviewWidget(KTextEditor::Document* doc, KTextEditor::Range keyRange, KTextEditor::Range valueRange, const SupportedProperty& property, const QString& value) : QWidget() , view(new QQuickWidget) , document(doc) , keyRange(keyRange) , valueRange(valueRange) , property(property) { //setup kdeclarative library KDeclarative::KDeclarative kdeclarative; kdeclarative.setDeclarativeEngine(view->engine()); kdeclarative.setupBindings(); //binds things like kconfig and icons // Configure layout auto l = new QHBoxLayout; l->setContentsMargins(0, 0, 0, 0); setLayout(l); // see docstring for ILanguageSupport::specialLanguageObjectNavigationWidget setProperty("DoNotCloseOnCursorMove", true); view->setSource(property.qmlfile); if (!view->rootObject()) { // don't crash because of a syntax error or missing QML file l->addWidget(new QLabel(i18n("Error loading QML file: %1", property.qmlfile.path()))); delete view; return; } // set the initial value read from the document view->rootObject()->setProperty("initialValue", value); // connect to the slot which has to be emitted from QML when the value changes QObject::connect(view->rootObject(), SIGNAL(valueChanged()), this, SLOT(updateValue())); l->addWidget(view); } diff --git a/projectmanagers/cmake/cmakeserverimportjob.cpp b/projectmanagers/cmake/cmakeserverimportjob.cpp index c7e1023bff..1a4ebf9c93 100644 --- a/projectmanagers/cmake/cmakeserverimportjob.cpp +++ b/projectmanagers/cmake/cmakeserverimportjob.cpp @@ -1,180 +1,180 @@ /* KDevelop CMake Support * * Copyright 2017 Aleix Pol Gonzalez * * 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) 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 "cmakeserverimportjob.h" #include "cmakeutils.h" #include "cmakeserver.h" #include #include #include #include #include #include #include "debug.h" template static T kTransform(const Q& list, W func) { T ret; ret.reserve(list.size()); for (auto it = list.constBegin(), itEnd = list.constEnd(); it!=itEnd; ++it) ret += func(*it); return ret; } static QString unescape(const QStringRef& input) { QString output; output.reserve(input.length()); bool isEscaped = false; for (auto it = input.data(), end = it + input.length(); it != end; ++it) { QChar c = *it; if (!isEscaped && c == '\\') { isEscaped = true; } else { output.append(c); isEscaped = false; } } return output; } static QHash processDefines(const QString &compileFlags, const QJsonArray &defines) { QHash ret; const auto& defineRx = MakeFileResolver::defineRegularExpression(); auto it = defineRx.globalMatch(compileFlags); while (it.hasNext()) { const auto match = it.next(); QString value; if (match.lastCapturedIndex() > 1) { value = unescape(match.capturedRef(match.lastCapturedIndex())); } ret[match.captured(1)] = value; } for (const QJsonValue& defineValue: defines) { const QString define = defineValue.toString(); const int eqIdx = define.indexOf(QLatin1Char('=')); if (eqIdx<0) { ret[define] = QString(); } else { ret[define.left(eqIdx)] = define.mid(eqIdx+1); } } return ret; } void CMakeServerImportJob::processFileData(const QJsonObject &response, CMakeProjectData &data) { - const auto configs = response.value(QLatin1String("configurations")).toArray(); + const auto configs = response.value(QStringLiteral("configurations")).toArray(); qCDebug(CMAKE) << "process response" << response; for (const auto &config: configs) { - const auto projects = config.toObject().value(QLatin1String("projects")).toArray(); + const auto projects = config.toObject().value(QStringLiteral("projects")).toArray(); for (const auto &project: projects) { - const auto targets = project.toObject().value(QLatin1String("targets")).toArray(); + const auto targets = project.toObject().value(QStringLiteral("targets")).toArray(); for (const auto &targetObject: targets) { const auto target = targetObject.toObject(); - const KDevelop::Path targetDir(target.value(QLatin1String("sourceDirectory")).toString()); + const KDevelop::Path targetDir(target.value(QStringLiteral("sourceDirectory")).toString()); - data.targets[targetDir] += target.value(QLatin1String("name")).toString(); + data.targets[targetDir] += target.value(QStringLiteral("name")).toString(); - const auto fileGroups = target.value(QLatin1String("fileGroups")).toArray(); + const auto fileGroups = target.value(QStringLiteral("fileGroups")).toArray(); for (const auto &fileGroupValue: fileGroups) { const auto fileGroup = fileGroupValue.toObject(); CMakeFile file; - file.includes = kTransform(fileGroup.value(QLatin1String("includePath")).toArray(), [](const QJsonValue& val) { return KDevelop::Path(val.toObject().value(QLatin1String("path")).toString()); }); - file.defines = processDefines(fileGroup.value(QLatin1String("compileFlags")).toString(), fileGroup.value(QLatin1String("defines")).toArray()); + file.includes = kTransform(fileGroup.value(QStringLiteral("includePath")).toArray(), [](const QJsonValue& val) { return KDevelop::Path(val.toObject().value(QStringLiteral("path")).toString()); }); + file.defines = processDefines(fileGroup.value(QStringLiteral("compileFlags")).toString(), fileGroup.value(QStringLiteral("defines")).toArray()); - const auto sourcesArray = fileGroup.value(QLatin1String("sources")).toArray(); + const auto sourcesArray = fileGroup.value(QStringLiteral("sources")).toArray(); const KDevelop::Path::List sources = kTransform(sourcesArray, [targetDir](const QJsonValue& val) { return KDevelop::Path(targetDir, val.toString()); }); for (const auto& source: sources) { // NOTE: we use the canonical file path to prevent issues with symlinks in the path // leading to lookup failures const auto localFile = source.toLocalFile(); const auto canonicalFile = QFileInfo(source.toLocalFile()).canonicalFilePath(); const auto sourcePath = localFile == canonicalFile ? source : KDevelop::Path(canonicalFile); data.compilationData.files[sourcePath] = file; } qCDebug(CMAKE) << "registering..." << sources << file; } } } } } CMakeServerImportJob::CMakeServerImportJob(KDevelop::IProject* project, CMakeServer* server, QObject* parent) : KJob(parent) , m_server(server) , m_project(project) { connect(m_server.data(), &CMakeServer::disconnected, this, [this]() { setError(UnexpectedDisconnect); emitResult(); }); } void CMakeServerImportJob::start() { if (m_server->isServerAvailable()) doStart(); else connect(m_server.data(), &CMakeServer::connected, this, &CMakeServerImportJob::doStart); } void CMakeServerImportJob::doStart() { connect(m_server.data(), &CMakeServer::response, this, &CMakeServerImportJob::processResponse); m_server->handshake(m_project->path(), CMake::currentBuildDir(m_project)); } void CMakeServerImportJob::processResponse(const QJsonObject& response) { - const auto responseType = response.value(QLatin1String("type")); + const auto responseType = response.value(QStringLiteral("type")); if (responseType == QLatin1String("reply")) { - const auto inReplyTo = response.value(QLatin1String("inReplyTo")); + const auto inReplyTo = response.value(QStringLiteral("inReplyTo")); qCDebug(CMAKE) << "replying..." << inReplyTo; if (inReplyTo == QLatin1String("handshake")) { m_server->configure({}); } else if (inReplyTo == QLatin1String("configure")) { m_server->compute(); } else if (inReplyTo == QLatin1String("compute")) { m_server->codemodel(); } else if(inReplyTo == QLatin1String("codemodel")) { processFileData(response, m_data); m_data.m_server = m_server; emitResult(); } else { qWarning() << "unhandled reply" << response; } } else if(responseType == QLatin1String("error")) { setError(ErrorResponse); - setErrorText(response.value(QLatin1String("errorMessage")).toString()); + setErrorText(response.value(QStringLiteral("errorMessage")).toString()); qWarning() << "error!!" << response; emitResult(); } else { qWarning() << "unhandled message" << response; } } diff --git a/projectmanagers/qmake/parser/tests/functionscopetest.cpp b/projectmanagers/qmake/parser/tests/functionscopetest.cpp index a2ffc4d5ae..0ae83b0584 100644 --- a/projectmanagers/qmake/parser/tests/functionscopetest.cpp +++ b/projectmanagers/qmake/parser/tests/functionscopetest.cpp @@ -1,342 +1,342 @@ /* KDevelop * * Copyright 2007 Andreas Pakulat * * 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) 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 "functionscopetest.h" #include "ast.h" #include "qmakedriver.h" #include "testhelpers.h" QTEST_MAIN(FunctionScopeTest) FunctionScopeTest::FunctionScopeTest(QObject* parent) : QObject(parent) , ast(nullptr) { } FunctionScopeTest::~FunctionScopeTest() { } void FunctionScopeTest::init() { ast = new QMake::ProjectAST(); QVERIFY(ast != nullptr); } void FunctionScopeTest::cleanup() { delete ast; ast = nullptr; QVERIFY(ast == nullptr); } BEGINTESTFUNCIMPL(FunctionScopeTest, execBasicFunc, 1) QMake::FunctionCallAST* scope = dynamic_cast(ast->statements.first()); TESTFUNCNAME(scope, "foobar") QVERIFY(scope->body == nullptr); ENDTESTFUNCIMPL DATAFUNCIMPL(FunctionScopeTest, execBasicFunc, "foobar()\n") BEGINTESTFUNCIMPL(FunctionScopeTest, execSimpleFunc, 1) QMake::FunctionCallAST* scope = dynamic_cast(ast->statements.first()); TESTFUNCNAME(scope, "foobar") QVERIFY(scope->body == nullptr); ENDTESTFUNCIMPL DATAFUNCIMPL(FunctionScopeTest, execSimpleFunc, "foobar( arg1, arg2 )\n") BEGINTESTFUNCIMPL(FunctionScopeTest, argWithEqual, 1) QMake::FunctionCallAST* scope = dynamic_cast(ast->statements.first()); TESTFUNCNAME(scope, "foobar") QVERIFY(scope->body == nullptr); ENDTESTFUNCIMPL DATAFUNCIMPL(FunctionScopeTest, argWithEqual, "foobar( arg1 = arg2 )\n") BEGINTESTFUNCIMPL(FunctionScopeTest, evalQMakeSyntax, 1) QMake::FunctionCallAST* scope = dynamic_cast(ast->statements.first()); TESTFUNCNAME(scope, "eval") QVERIFY(scope->body == nullptr); ENDTESTFUNCIMPL DATAFUNCIMPL(FunctionScopeTest, evalQMakeSyntax, "eval($${subdir}.depends = $$basename($${subdir})/$(MAKEFILE) )\n") BEGINTESTFUNCIMPL(FunctionScopeTest, simpleVarArg, 1) QMake::FunctionCallAST* scope = dynamic_cast(ast->statements.first()); TESTFUNCNAME(scope, "eval") QVERIFY(scope->body == nullptr); ENDTESTFUNCIMPL DATAFUNCIMPL(FunctionScopeTest, simpleVarArg, "eval($${subdir}, $$SOMEVAR, $(SHELLVAR))\n") BEGINTESTFUNCIMPL(FunctionScopeTest, partlyQuotedArg, 1) QMake::FunctionCallAST* scope = dynamic_cast(ast->statements.first()); TESTFUNCNAME(scope, "eval") QVERIFY(scope->body == nullptr); ENDTESTFUNCIMPL DATAFUNCIMPL(FunctionScopeTest, partlyQuotedArg, "eval(\"SOMELITERALSTRNIG\" SOMETHINGELSE)\n") BEGINTESTFUNCIMPL(FunctionScopeTest, slashArg, 1) QMake::FunctionCallAST* scope = dynamic_cast(ast->statements.first()); TESTFUNCNAME(scope, "eval") QVERIFY(scope->body == nullptr); ENDTESTFUNCIMPL DATAFUNCIMPL(FunctionScopeTest, slashArg, "eval(SOMELITERALSTRNIG/$$SOMETHINGELSE)\n") BEGINTESTFUNCIMPL(FunctionScopeTest, nestedFunccalls, 1) QMake::FunctionCallAST* scope = dynamic_cast(ast->statements.first()); TESTFUNCNAME(scope, "eval") QVERIFY(scope->body == nullptr); ENDTESTFUNCIMPL DATAFUNCIMPL(FunctionScopeTest, nestedFunccalls, "eval(val, $$contains(QT_PROJECT, $$foobar(some)))\n") BEGINTESTFUNCIMPL(FunctionScopeTest, oneStatementScope, 1) QMake::FunctionCallAST* scope = dynamic_cast(ast->statements.first()); TESTFUNCNAME(scope, "contains") QList teststmts; auto tst = new QMake::AssignmentAST(scope->body); auto val = new QMake::ValueAST(tst); - val->value = QLatin1String("VARIABLE"); + val->value = QStringLiteral("VARIABLE"); tst->identifier = val; val = new QMake::ValueAST(tst); - val->value = QLatin1String("="); + val->value = QStringLiteral("="); tst->op = val; val = new QMake::ValueAST(tst); - val->value = QLatin1String("val1"); + val->value = QStringLiteral("val1"); tst->values.append(val); val = new QMake::ValueAST(tst); - val->value = QLatin1String("val2"); + val->value = QStringLiteral("val2"); tst->values.append(val); teststmts.append(tst); TESTSCOPEBODY(scope, teststmts, 1) ENDTESTFUNCIMPL DATAFUNCIMPL(FunctionScopeTest, oneStatementScope, "contains(SOMETHINGELSE, foobar) : VARIABLE = val1 val2\n") BEGINTESTFUNCIMPL(FunctionScopeTest, oneStatementSubScope, 1) QMake::FunctionCallAST* scope = dynamic_cast(ast->statements.first()); TESTFUNCNAME(scope, "contains") QList teststmts; auto call = new QMake::FunctionCallAST(scope->body); auto val = new QMake::ValueAST(call); - val->value = QLatin1String("contains"); + val->value = QStringLiteral("contains"); call->identifier = val; val = new QMake::ValueAST(call); - val->value = QLatin1String("foobar"); + val->value = QStringLiteral("foobar"); call->args.insert(0, val); auto body = new QMake::ScopeBodyAST(call); auto tst = new QMake::AssignmentAST(body); val = new QMake::ValueAST(tst); - val->value = QLatin1String("VARIABLE"); + val->value = QStringLiteral("VARIABLE"); tst->identifier = val; val = new QMake::ValueAST(tst); - val->value = QLatin1String("="); + val->value = QStringLiteral("="); tst->op = val; val = new QMake::ValueAST(tst); - val->value = QLatin1String("val1"); + val->value = QStringLiteral("val1"); tst->values.append(val); val = new QMake::ValueAST(tst); - val->value = QLatin1String("val2"); + val->value = QStringLiteral("val2"); tst->values.append(val); body->statements.insert(0, tst); call->body = body; teststmts.append(call); TESTSCOPEBODY(scope, teststmts, 1) ENDTESTFUNCIMPL DATAFUNCIMPL(FunctionScopeTest, oneStatementSubScope, "contains(SOMETHINGELSE, foobar) : contains( foobar ) : VARIABLE = val1 val2\n") BEGINTESTFUNCIMPL(FunctionScopeTest, multiLineScope, 1) QMake::FunctionCallAST* scope = dynamic_cast(ast->statements.first()); TESTFUNCNAME(scope, "contains") QList teststmts; auto tst = new QMake::AssignmentAST(scope->body); auto val = new QMake::ValueAST(tst); - val->value = QLatin1String("VARIABLE"); + val->value = QStringLiteral("VARIABLE"); tst->identifier = val; val = new QMake::ValueAST(tst); - val->value = QLatin1String("="); + val->value = QStringLiteral("="); tst->op = val; val = new QMake::ValueAST(tst); - val->value = QLatin1String("val1"); + val->value = QStringLiteral("val1"); tst->values.append(val); val = new QMake::ValueAST(tst); - val->value = QLatin1String("val2"); + val->value = QStringLiteral("val2"); tst->values.append(val); teststmts.append(tst); tst = new QMake::AssignmentAST(scope->body); val = new QMake::ValueAST(tst); - val->value = QLatin1String("VARIABLE2"); + val->value = QStringLiteral("VARIABLE2"); tst->identifier = val; val = new QMake::ValueAST(tst); - val->value = QLatin1String("="); + val->value = QStringLiteral("="); tst->op = val; val = new QMake::ValueAST(tst); - val->value = QLatin1String("val2"); + val->value = QStringLiteral("val2"); tst->values.append(val); teststmts.append(tst); TESTSCOPEBODY(scope, teststmts, 2) ENDTESTFUNCIMPL DATAFUNCIMPL(FunctionScopeTest, multiLineScope, "contains(SOMETHINGELSE, foobar) {\n VARIABLE = val1 val2\nVARIABLE2 = val2\n}\n") BEGINTESTFUNCIMPL(FunctionScopeTest, multiLineScopeFuncCall, 1) QMake::FunctionCallAST* scope = dynamic_cast(ast->statements.first()); TESTFUNCNAME(scope, "contains") QList teststmts; auto tst = new QMake::AssignmentAST(scope->body); auto val = new QMake::ValueAST(tst); - val->value = QLatin1String("VARIABLE"); + val->value = QStringLiteral("VARIABLE"); tst->identifier = val; val = new QMake::ValueAST(tst); - val->value = QLatin1String("="); + val->value = QStringLiteral("="); tst->op = val; val = new QMake::ValueAST(tst); - val->value = QLatin1String("val1"); + val->value = QStringLiteral("val1"); tst->values.append(val); val = new QMake::ValueAST(tst); - val->value = QLatin1String("val2"); + val->value = QStringLiteral("val2"); tst->values.append(val); teststmts.append(tst); QMake::FunctionCallAST* call; call = new QMake::FunctionCallAST(scope->body); val = new QMake::ValueAST(call); - val->value = QLatin1String("func2"); + val->value = QStringLiteral("func2"); call->identifier = val; QMake::ScopeBodyAST* body; body = new QMake::ScopeBodyAST(call); tst = new QMake::AssignmentAST(body); val = new QMake::ValueAST(tst); - val->value = QLatin1String("VARIABLE2"); + val->value = QStringLiteral("VARIABLE2"); tst->identifier = val; val = new QMake::ValueAST(tst); - val->value = QLatin1String("="); + val->value = QStringLiteral("="); tst->op = val; val = new QMake::ValueAST(tst); - val->value = QLatin1String("val2"); + val->value = QStringLiteral("val2"); tst->values.append(val); body->statements.insert(0, tst); call->body = body; teststmts.append(call); TESTSCOPEBODY(scope, teststmts, 2) ENDTESTFUNCIMPL DATAFUNCIMPL(FunctionScopeTest, multiLineScopeFuncCall, "contains(SOMETHINGELSE, foobar) {\n VARIABLE = val1 val2\n func2() {\n VARIABLE2 = val2\n}\n}\n") BEGINTESTFUNCIMPL(FunctionScopeTest, notFunc, 1) QMake::FunctionCallAST* scope = dynamic_cast(ast->statements.first()); TESTFUNCNAME(scope, "!contains") QList teststmts; auto tst = new QMake::AssignmentAST(scope->body); auto val = new QMake::ValueAST(tst); - val->value = QLatin1String("VARIABLE"); + val->value = QStringLiteral("VARIABLE"); tst->identifier = val; val = new QMake::ValueAST(tst); - val->value = QLatin1String("="); + val->value = QStringLiteral("="); tst->op = val; val = new QMake::ValueAST(tst); - val->value = QLatin1String("val1"); + val->value = QStringLiteral("val1"); tst->values.append(val); val = new QMake::ValueAST(tst); - val->value = QLatin1String("val2"); + val->value = QStringLiteral("val2"); tst->values.append(val); teststmts.append(tst); TESTSCOPEBODY(scope, teststmts, 1) ENDTESTFUNCIMPL DATAFUNCIMPL(FunctionScopeTest, notFunc, "!contains(SOMETHINGELSE, foobar) : VARIABLE = val1 val2\n") BEGINTESTFUNCIMPL(FunctionScopeTest, orOperator, 1) QMake::OrAST* orop = dynamic_cast(ast->statements.first()); QStringList funcs; funcs << QStringLiteral("!contains") << QStringLiteral("contains"); TESTOROP(orop, funcs) QList teststmts; auto tst = new QMake::AssignmentAST(orop->body); auto val = new QMake::ValueAST(tst); - val->value = QLatin1String("VARIABLE"); + val->value = QStringLiteral("VARIABLE"); tst->identifier = val; val = new QMake::ValueAST(tst); - val->value = QLatin1String("="); + val->value = QStringLiteral("="); tst->op = val; val = new QMake::ValueAST(tst); - val->value = QLatin1String("val1"); + val->value = QStringLiteral("val1"); tst->values.append(val); val = new QMake::ValueAST(tst); - val->value = QLatin1String("val2"); + val->value = QStringLiteral("val2"); tst->values.append(val); teststmts.append(tst); TESTSCOPEBODY(orop, teststmts, 1) ENDTESTFUNCIMPL DATAFUNCIMPL(FunctionScopeTest, orOperator, "!contains(SOMETHINGELSE, foobar) | contains(OTHER,foo) : VARIABLE = val1 val2\n") BEGINTESTFUNCIMPL(FunctionScopeTest, spaceBeforeBrace, 1) QMake::FunctionCallAST* fn = dynamic_cast(ast->statements.first()); TESTFUNCNAME(fn, "func") QStringList testlist; testlist << QStringLiteral("some "); ENDTESTFUNCIMPL DATAFUNCIMPL(FunctionScopeTest, spaceBeforeBrace, "func ( some )\n") BEGINTESTFAILFUNCIMPL(FunctionScopeTest, missingParenthesis, "No closing parenthesis for function call") ENDTESTFUNCIMPL DATAFUNCIMPL(FunctionScopeTest, missingParenthesis, "eval(SOMETHINGELSE\n") BEGINTESTFUNCIMPL(FunctionScopeTest, missingStatement, 1) QMake::FunctionCallAST* fn = dynamic_cast(ast->statements.first()); TESTFUNCNAME(fn, "eval") QStringList testlist; testlist << QStringLiteral("SOMETHINGELSE "); ENDTESTFUNCIMPL DATAFUNCIMPL(FunctionScopeTest, missingStatement, "eval(SOMETHINGELSE):\n") BEGINTESTFAILFUNCIMPL(FunctionScopeTest, missingBrace, "No closing brace for function scope") ENDTESTFUNCIMPL DATAFUNCIMPL(FunctionScopeTest, missingBrace, "eval(SOMETHINGELSE){\n") diff --git a/projectmanagers/qmake/parser/tests/scopetest.cpp b/projectmanagers/qmake/parser/tests/scopetest.cpp index e916c48e7e..47ffe268e9 100644 --- a/projectmanagers/qmake/parser/tests/scopetest.cpp +++ b/projectmanagers/qmake/parser/tests/scopetest.cpp @@ -1,138 +1,138 @@ /* KDevelop * * Copyright 2007 Andreas Pakulat * * 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) 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 "scopetest.h" #include "ast.h" #include "qmakedriver.h" #include "testhelpers.h" QTEST_MAIN(ScopeTest) ScopeTest::ScopeTest(QObject* parent) : QObject(parent) , ast(nullptr) { } ScopeTest::~ScopeTest() { } void ScopeTest::init() { ast = new QMake::ProjectAST(); QVERIFY(ast != nullptr); } void ScopeTest::cleanup() { delete ast; ast = nullptr; QVERIFY(ast == nullptr); } BEGINTESTFUNCIMPL(ScopeTest, basicScope, 1) QMake::SimpleScopeAST* scope = dynamic_cast(ast->statements.first()); TESTSCOPENAME(scope, "foobar") QList testlist; auto tst = new QMake::AssignmentAST(scope->body); auto val = new QMake::ValueAST(tst); - val->value = QLatin1String("VARIABLE"); + val->value = QStringLiteral("VARIABLE"); tst->identifier = val; val = new QMake::ValueAST(tst); - val->value = QLatin1String("="); + val->value = QStringLiteral("="); tst->op = val; val = new QMake::ValueAST(tst); - val->value = QLatin1String("FOO"); + val->value = QStringLiteral("FOO"); tst->values.append(val); testlist.append(tst); TESTSCOPEBODY(scope, testlist, 1) ENDTESTFUNCIMPL DATAFUNCIMPL(ScopeTest, basicScope, "foobar : VARIABLE = FOO\n") BEGINTESTFUNCIMPL(ScopeTest, basicScopeBrace, 1) QMake::SimpleScopeAST* scope = dynamic_cast(ast->statements.first()); TESTSCOPENAME(scope, "foobar") QList testlist; auto tst = new QMake::AssignmentAST(scope->body); auto val = new QMake::ValueAST(tst); - val->value = QLatin1String("VARIABLE"); + val->value = QStringLiteral("VARIABLE"); tst->identifier = val; val = new QMake::ValueAST(tst); - val->value = QLatin1String("="); + val->value = QStringLiteral("="); tst->op = val; val = new QMake::ValueAST(tst); - val->value = QLatin1String("FOO"); + val->value = QStringLiteral("FOO"); tst->values.append(val); testlist.append(tst); TESTSCOPEBODY(scope, testlist, 1) ENDTESTFUNCIMPL DATAFUNCIMPL(ScopeTest, basicScopeBrace, "foobar {\n VARIABLE = FOO\n}\n") BEGINTESTFUNCIMPL(ScopeTest, nestedScope, 1) QMake::SimpleScopeAST* scope = dynamic_cast(ast->statements.first()); TESTSCOPENAME(scope, "foobar") QList testlist; auto simple = new QMake::SimpleScopeAST(scope->body); auto val = new QMake::ValueAST(simple); - val->value = QLatin1String("barfoo"); + val->value = QStringLiteral("barfoo"); simple->identifier = val; auto body = new QMake::ScopeBodyAST(simple); QList sublist; auto tst = new QMake::AssignmentAST(body); val = new QMake::ValueAST(tst); - val->value = QLatin1String("VARIABLE"); + val->value = QStringLiteral("VARIABLE"); tst->identifier = val; val = new QMake::ValueAST(tst); - val->value = QLatin1String("="); + val->value = QStringLiteral("="); tst->op = val; val = new QMake::ValueAST(tst); - val->value = QLatin1String("FOO"); + val->value = QStringLiteral("FOO"); tst->values.append(val); body->statements.append(tst); simple->body = body; testlist.append(simple); TESTSCOPEBODY(scope, testlist, 1) ENDTESTFUNCIMPL DATAFUNCIMPL(ScopeTest, nestedScope, "foobar :barfoo : VARIABLE = FOO\n") BEGINTESTFUNCIMPL(ScopeTest, missingStatement, 1) QMake::SimpleScopeAST* scope = dynamic_cast(ast->statements.first()); TESTSCOPENAME(scope, "eval") ENDTESTFUNCIMPL DATAFUNCIMPL(ScopeTest, missingStatement, "eval :\n") BEGINTESTFAILFUNCIMPL(ScopeTest, missingColon, "No colon") ENDTESTFUNCIMPL DATAFUNCIMPL(ScopeTest, missingColon, "eval \n") void ScopeTest::strangeScopeNames() { QMake::Driver d; d.setContent(QStringLiteral("linux-gcc++-* {\n VARIABLE = FOO\n}\n")); bool ret = d.parse(&ast); QVERIFY(ret); } diff --git a/projectmanagers/qmake/qmakefile.cpp b/projectmanagers/qmake/qmakefile.cpp index 0d80fb412b..f7994fd299 100644 --- a/projectmanagers/qmake/qmakefile.cpp +++ b/projectmanagers/qmake/qmakefile.cpp @@ -1,211 +1,211 @@ /*************************************************************************** * This file is part of KDevelop * * Copyright 2007 Andreas Pakulat * * * * 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 Library 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 "qmakefile.h" #include #include #include #include "debug.h" #include "parser/ast.h" #include "qmakedriver.h" #define ifDebug(x) //@TODO: Make the globbing stuff work with drives on win32 void resolveShellGlobbingInternal(QStringList& entries, const QStringList& segments, const QFileInfo& match, QDir& dir, int offset); QStringList resolveShellGlobbingInternal(const QStringList& segments, QDir& dir, int offset = 0) { if (offset >= segments.size()) { return QStringList(); } const QString& pathPattern = segments.at(offset); QStringList entries; if (pathPattern.contains('*') || pathPattern.contains('?') || pathPattern.contains('[')) { // pattern contains globbing chars foreach (const QFileInfo& match, dir.entryInfoList(QStringList() << pathPattern, QDir::AllEntries | QDir::NoDotAndDotDot, QDir::Unsorted)) { resolveShellGlobbingInternal(entries, segments, match, dir, offset); } } else { // pattern is "simple" hence be fast, but make sure the file exists QFileInfo info(dir.filePath(pathPattern)); if (info.exists()) { resolveShellGlobbingInternal(entries, segments, info, dir, offset); } } return entries; } void resolveShellGlobbingInternal(QStringList& entries, const QStringList& segments, const QFileInfo& match, QDir& dir, int offset) { if (match.isDir() && offset + 1 < segments.size()) { dir.cd(match.fileName()); entries += resolveShellGlobbingInternal(segments, dir, offset + 1); dir.cdUp(); } else { entries << match.canonicalFilePath(); } } QStringList resolveShellGlobbingInternal(const QString& pattern, const QString& dir) { if (pattern.isEmpty()) { return QStringList(); } - QDir dir_(pattern.startsWith('/') ? QLatin1String("/") : dir); + QDir dir_(pattern.startsWith('/') ? QStringLiteral("/") : dir); // break up pattern into path segments return resolveShellGlobbingInternal(pattern.split(QLatin1Char('/'), QString::SkipEmptyParts), dir_); } QMakeFile::QMakeFile(QString file) : m_ast(nullptr) , m_projectFile(std::move(file)) , m_project(nullptr) { Q_ASSERT(!m_projectFile.isEmpty()); } bool QMakeFile::read() { Q_ASSERT(!m_projectFile.isEmpty()); QFileInfo fi(m_projectFile); ifDebug(qCDebug(KDEV_QMAKE) << "Is" << m_projectFile << "a dir?" << fi.isDir();) if (fi.isDir()) { QDir dir(m_projectFile); QStringList l = dir.entryList(QStringList() << QStringLiteral("*.pro")); QString projectfile; if (!l.count() || (l.count() && l.indexOf(fi.baseName() + ".pro") != -1)) { projectfile = fi.baseName() + ".pro"; } else { projectfile = l.first(); } m_projectFile += '/' + projectfile; } QMake::Driver d; d.readFile(m_projectFile); if (!d.parse(&m_ast)) { qCWarning(KDEV_QMAKE) << "Couldn't parse project:" << m_projectFile; delete m_ast; m_ast = nullptr; m_projectFile = QString(); return false; } else { ifDebug(qCDebug(KDEV_QMAKE) << "found ast:" << m_ast->statements.count();) QMakeFileVisitor visitor(this, this); /// TODO: cleanup, re-use m_variableValues directly in the visitor visitor.setVariables(m_variableValues); m_variableValues = visitor.visitFile(m_ast); ifDebug(qCDebug(KDEV_QMAKE) << "Variables found:" << m_variableValues;) } return true; } QMakeFile::~QMakeFile() { delete m_ast; m_ast = nullptr; } QString QMakeFile::absoluteDir() const { return QFileInfo(m_projectFile).absoluteDir().canonicalPath(); } QString QMakeFile::absoluteFile() const { return m_projectFile; } QMake::ProjectAST* QMakeFile::ast() const { return m_ast; } QStringList QMakeFile::variables() const { return m_variableValues.keys(); } QStringList QMakeFile::variableValues(const QString& variable) const { return m_variableValues.value(variable, QStringList()); } bool QMakeFile::containsVariable(const QString& variable) const { return m_variableValues.contains(variable); } QMakeFile::VariableMap QMakeFile::variableMap() const { return m_variableValues; } QStringList QMakeFile::resolveVariable(const QString& variable, VariableInfo::VariableType type) const { if (type == VariableInfo::QMakeVariable && m_variableValues.contains(variable)) { return m_variableValues.value(variable); } else { qCWarning(KDEV_QMAKE) << "unresolved variable:" << variable << "type:" << type; return QStringList(); } } QStringList QMakeFile::resolveShellGlobbing(const QString& pattern, const QString& base) const { return resolveShellGlobbingInternal(pattern, base.isEmpty() ? absoluteDir() : base); } QString QMakeFile::resolveToSingleFileName(const QString& file, const QString& base) const { QStringList l = resolveFileName(file, base); if (l.isEmpty()) return QString(); else return l.first(); } QStringList QMakeFile::resolveFileName(const QString& file, const QString& base) const { return resolveShellGlobbing(file, base); } void QMakeFile::setProject(KDevelop::IProject* project) { m_project = project; } KDevelop::IProject* QMakeFile::project() const { return m_project; } diff --git a/projectmanagers/qmake/qmakeprojectfile.cpp b/projectmanagers/qmake/qmakeprojectfile.cpp index ab47a19803..05314040ed 100644 --- a/projectmanagers/qmake/qmakeprojectfile.cpp +++ b/projectmanagers/qmake/qmakeprojectfile.cpp @@ -1,426 +1,426 @@ /* KDevelop QMake Support * * Copyright 2006 Andreas Pakulat * * 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) 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 "qmakeprojectfile.h" #include #include #include #include "debug.h" #include "parser/ast.h" #include "qmakecache.h" #include "qmakemkspecs.h" #include "qmakeconfig.h" #include #include #define ifDebug(x) QHash> QMakeProjectFile::m_qmakeQueryCache; const QStringList QMakeProjectFile::FileVariables = QStringList() << QStringLiteral("IDLS") << QStringLiteral("RESOURCES") << QStringLiteral("IMAGES") << QStringLiteral("LEXSOURCES") << QStringLiteral("DISTFILES") << QStringLiteral("YACCSOURCES") << QStringLiteral("TRANSLATIONS") << QStringLiteral("HEADERS") << QStringLiteral("SOURCES") << QStringLiteral("INTERFACES") << QStringLiteral("FORMS"); QMakeProjectFile::QMakeProjectFile(const QString& projectfile) : QMakeFile(projectfile) , m_mkspecs(nullptr) , m_cache(nullptr) { } void QMakeProjectFile::setQMakeCache(QMakeCache* cache) { m_cache = cache; } void QMakeProjectFile::setMkSpecs(QMakeMkSpecs* mkspecs) { m_mkspecs = mkspecs; } bool QMakeProjectFile::read() { // default values // NOTE: if we already have such a var, e.g. in an include file, we must not overwrite it here! if (!m_variableValues.contains(QStringLiteral("QT"))) { m_variableValues[QStringLiteral("QT")] = QStringList() << QStringLiteral("core") << QStringLiteral("gui"); } if (!m_variableValues.contains(QStringLiteral("CONFIG"))) { m_variableValues[QStringLiteral("CONFIG")] = QStringList() << QStringLiteral("qt"); } Q_ASSERT(m_mkspecs); foreach (const QString& var, m_mkspecs->variables()) { if (!m_variableValues.contains(var)) { m_variableValues[var] = m_mkspecs->variableValues(var); } } if (m_cache) { foreach (const QString& var, m_cache->variables()) { if (!m_variableValues.contains(var)) { m_variableValues[var] = m_cache->variableValues(var); } } } /// TODO: more special variables m_variableValues[QStringLiteral("PWD")] = QStringList() << pwd(); m_variableValues[QStringLiteral("_PRO_FILE_")] = QStringList() << proFile(); m_variableValues[QStringLiteral("_PRO_FILE_PWD_")] = QStringList() << proFilePwd(); m_variableValues[QStringLiteral("OUT_PWD")] = QStringList() << outPwd(); const QString qtInstallHeaders = QStringLiteral("QT_INSTALL_HEADERS"); const QString qtVersion = QStringLiteral("QT_VERSION"); const QString qtInstallLibs = QStringLiteral("QT_INSTALL_LIBS"); const QString executable = QMakeConfig::qmakeExecutable(project()); if (!m_qmakeQueryCache.contains(executable)) { const auto queryResult = QMakeConfig::queryQMake(executable, {qtInstallHeaders, qtVersion, qtInstallLibs}); if (queryResult.isEmpty()) { qCWarning(KDEV_QMAKE) << "Failed to query qmake - bad qmake executable configured?" << executable; } m_qmakeQueryCache[executable] = queryResult; } const auto cachedQueryResult = m_qmakeQueryCache.value(executable); m_qtIncludeDir = cachedQueryResult.value(qtInstallHeaders); m_qtVersion = cachedQueryResult.value(qtVersion); m_qtLibDir = cachedQueryResult.value(qtInstallLibs); return QMakeFile::read(); } QStringList QMakeProjectFile::subProjects() const { ifDebug(qCDebug(KDEV_QMAKE) << "Fetching subprojects";) QStringList list; foreach (QString subdir, variableValues("SUBDIRS")) { QString fileOrPath; ifDebug(qCDebug(KDEV_QMAKE) << "Found value:" << subdir;) if (containsVariable(subdir + ".file") && !variableValues(subdir + ".file").isEmpty()) { subdir = variableValues(subdir + ".file").first(); } else if (containsVariable(subdir + ".subdir") && !variableValues(subdir + ".subdir").isEmpty()) { subdir = variableValues(subdir + ".subdir").first(); } if (subdir.endsWith(QLatin1String(".pro"))) { fileOrPath = resolveToSingleFileName(subdir.trimmed()); } else { fileOrPath = resolveToSingleFileName(subdir.trimmed()); } if (fileOrPath.isEmpty()) { qCWarning(KDEV_QMAKE) << "could not resolve subdir" << subdir << "to file or path, skipping"; continue; } list << fileOrPath; } ifDebug(qCDebug(KDEV_QMAKE) << "found" << list.size() << "subprojects";) return list; } bool QMakeProjectFile::hasSubProject(const QString& file) const { foreach (const QString& sub, subProjects()) { if (sub == file) { return true; } else if (QFileInfo(file).absoluteDir() == sub) { return true; } } return false; } void QMakeProjectFile::addPathsForVariable(const QString& variable, QStringList* list, const QString& base) const { const QStringList values = variableValues(variable); ifDebug(qCDebug(KDEV_QMAKE) << variable << values;) foreach (const QString& val, values) { QString path = resolveToSingleFileName(val, base); if (!path.isEmpty() && !list->contains(val)) { list->append(path); } } } QStringList QMakeProjectFile::includeDirectories() const { ifDebug(qCDebug(KDEV_QMAKE) << "Fetching include dirs" << m_qtIncludeDir;) ifDebug(qCDebug(KDEV_QMAKE) << "CONFIG" << variableValues("CONFIG");) QStringList list; addPathsForVariable(QStringLiteral("INCLUDEPATH"), &list); addPathsForVariable(QStringLiteral("QMAKE_INCDIR"), &list); if (variableValues(QStringLiteral("CONFIG")).contains(QStringLiteral("opengl"))) { addPathsForVariable(QStringLiteral("QMAKE_INCDIR_OPENGL"), &list); } if (variableValues(QStringLiteral("CONFIG")).contains(QStringLiteral("qt"))) { if (!list.contains(m_qtIncludeDir)) list << m_qtIncludeDir; QDir incDir(m_qtIncludeDir); auto modules = variableValues(QStringLiteral("QT")); if (!modules.isEmpty() && !modules.contains(QStringLiteral("core"))) { // TODO: proper dependency tracking of modules // for now, at least include core if we include any other module modules << QStringLiteral("core"); } // TODO: This is all very fragile, should rather read QMake module .pri files (e.g. qt_lib_core_private.pri) foreach (const QString& module, modules) { QString pattern = module; bool isPrivate = false; if (module.endsWith(QLatin1String("-private"))) { pattern.chop(qstrlen("-private")); isPrivate = true; } else if (module.endsWith(QLatin1String("_private"))) { // _private is less common, but still a valid suffix pattern.chop(qstrlen("_private")); isPrivate = true; } if (pattern == QLatin1String("qtestlib") || pattern == QLatin1String("testlib")) { - pattern = QLatin1String("QtTest"); + pattern = QStringLiteral("QtTest"); } else if (pattern == QLatin1String("qaxcontainer")) { - pattern = QLatin1String("ActiveQt"); + pattern = QStringLiteral("ActiveQt"); } else if (pattern == QLatin1String("qaxserver")) { - pattern = QLatin1String("ActiveQt"); + pattern = QStringLiteral("ActiveQt"); } QFileInfoList match = incDir.entryInfoList({QString("Qt%1").arg(pattern)}, QDir::Dirs); if (match.isEmpty()) { // try non-prefixed pattern match = incDir.entryInfoList({pattern}, QDir::Dirs); if (match.isEmpty()) { qCWarning(KDEV_QMAKE) << "unhandled Qt module:" << module << pattern; continue; } } QString path = match.first().canonicalFilePath(); if (isPrivate) { path += '/' + m_qtVersion + '/' + match.first().fileName() + "/private/"; } if (!list.contains(path)) { list << path; } } } if (variableValues(QStringLiteral("CONFIG")).contains(QStringLiteral("thread"))) { addPathsForVariable(QStringLiteral("QMAKE_INCDIR_THREAD"), &list); } if (variableValues(QStringLiteral("CONFIG")).contains(QStringLiteral("x11"))) { addPathsForVariable(QStringLiteral("QMAKE_INCDIR_X11"), &list); } addPathsForVariable(QStringLiteral("MOC_DIR"), &list, outPwd()); addPathsForVariable(QStringLiteral("OBJECTS_DIR"), &list, outPwd()); addPathsForVariable(QStringLiteral("UI_DIR"), &list, outPwd()); ifDebug(qCDebug(KDEV_QMAKE) << "final list:" << list;) return list; } // Scan QMAKE_C*FLAGS for -F and -iframework and QMAKE_LFLAGS for good measure. Time will // tell if we need to scan the release/debug/... specific versions of QMAKE_C*FLAGS. // Also include QT_INSTALL_LIBS which corresponds to Qt's framework directory on OS X. QStringList QMakeProjectFile::frameworkDirectories() const { const auto variablesToCheck = {QStringLiteral("QMAKE_CFLAGS"), QStringLiteral("QMAKE_CXXFLAGS"), QStringLiteral("QMAKE_LFLAGS")}; const QLatin1String fOption("-F"); const QLatin1String iframeworkOption("-iframework"); QStringList fwDirs; foreach (const auto& var, variablesToCheck) { bool storeArg = false; foreach (const auto& arg, variableValues(var)) { if (arg == fOption || arg == iframeworkOption) { // detached -F/-iframework arg; set a warrant to store the next argument storeArg = true; } else { if (arg.startsWith(fOption)) { fwDirs << arg.mid(fOption.size()); } else if (arg.startsWith(iframeworkOption)) { fwDirs << arg.mid(iframeworkOption.size()); } else if (storeArg) { fwDirs << arg; } // cancel any outstanding warrants to store the next argument storeArg = false; } } } #ifdef Q_OS_OSX fwDirs << m_qtLibDir; #endif return fwDirs; } QStringList QMakeProjectFile::files() const { ifDebug(qCDebug(KDEV_QMAKE) << "Fetching files";) QStringList list; foreach (const QString& variable, QMakeProjectFile::FileVariables) { foreach (const QString& value, variableValues(variable)) { list += resolveFileName(value); } } ifDebug(qCDebug(KDEV_QMAKE) << "found" << list.size() << "files";) return list; } QStringList QMakeProjectFile::filesForTarget(const QString& s) const { ifDebug(qCDebug(KDEV_QMAKE) << "Fetching files";) QStringList list; if (variableValues(QStringLiteral("INSTALLS")).contains(s)) { const QStringList files = variableValues(s + ".files"); if (!files.isEmpty()) { foreach (const QString& val, files) { list += QStringList(resolveFileName(val)); } } } if (!variableValues(QStringLiteral("INSTALLS")).contains(s) || s == QLatin1String("target")) { foreach (const QString& variable, QMakeProjectFile::FileVariables) { foreach (const QString& value, variableValues(variable)) { list += QStringList(resolveFileName(value)); } } } ifDebug(qCDebug(KDEV_QMAKE) << "found" << list.size() << "files";) return list; } QString QMakeProjectFile::getTemplate() const { QString templ = QStringLiteral("app"); if (!variableValues(QStringLiteral("TEMPLATE")).isEmpty()) { templ = variableValues(QStringLiteral("TEMPLATE")).first(); } return templ; } QStringList QMakeProjectFile::targets() const { ifDebug(qCDebug(KDEV_QMAKE) << "Fetching targets";) QStringList list; list += variableValues(QStringLiteral("TARGET")); if (list.isEmpty() && getTemplate() != QLatin1String("subdirs")) { list += QFileInfo(absoluteFile()).baseName(); } foreach (const QString& target, variableValues("INSTALLS")) { if (!target.isEmpty() && target != QLatin1String("target")) list << target; } if (list.removeAll(QString())) { // remove empty targets - which is probably a bug... qCWarning(KDEV_QMAKE) << "got empty entry in TARGET of file" << absoluteFile(); } ifDebug(qCDebug(KDEV_QMAKE) << "found" << list.size() << "targets";) return list; } QMakeProjectFile::~QMakeProjectFile() { // TODO: delete cache, specs, ...? } QStringList QMakeProjectFile::resolveVariable(const QString& variable, VariableInfo::VariableType type) const { if (type == VariableInfo::QtConfigVariable) { if (m_mkspecs->isQMakeInternalVariable(variable)) { return QStringList() << m_mkspecs->qmakeInternalVariable(variable); } else { qCWarning(KDEV_QMAKE) << "unknown QtConfig Variable:" << variable; return QStringList(); } } return QMakeFile::resolveVariable(variable, type); } QMakeMkSpecs* QMakeProjectFile::mkSpecs() const { return m_mkspecs; } QMakeCache* QMakeProjectFile::qmakeCache() const { return m_cache; } QList QMakeProjectFile::defines() const { QList d; foreach (QString def, variableMap()["DEFINES"]) { int pos = def.indexOf('='); if (pos >= 0) { // a value is attached to define d.append(DefinePair(def.left(pos), def.right(def.length() - (pos + 1)))); } else { // a value-less define d.append(DefinePair(def, QLatin1String(""))); } } return d; } QString QMakeProjectFile::pwd() const { return absoluteDir(); } QString QMakeProjectFile::outPwd() const { if (!project()) { return absoluteDir(); } else { return QMakeConfig::buildDirFromSrc(project(), KDevelop::Path(absoluteDir())).toLocalFile(); } } QString QMakeProjectFile::proFile() const { return absoluteFile(); } QString QMakeProjectFile::proFilePwd() const { return absoluteDir(); } diff --git a/projectmanagers/qmake/tests/test_qmakefile.cpp b/projectmanagers/qmake/tests/test_qmakefile.cpp index d0147be27a..62bad7e52b 100644 --- a/projectmanagers/qmake/tests/test_qmakefile.cpp +++ b/projectmanagers/qmake/tests/test_qmakefile.cpp @@ -1,651 +1,651 @@ /* KDevelop QMake Support * * Copyright 2010 Milian Wolff * * 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) 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 "test_qmakefile.h" #include "qmakefile.h" #include "variablereferenceparser.h" #include "qmakeprojectfile.h" #include "qmakemkspecs.h" #include #include #include #include #include #include #include #include #include #include QTEST_MAIN(TestQMakeFile); typedef QHash DefineHash; Q_DECLARE_METATYPE(QMakeFile::VariableMap) Q_DECLARE_METATYPE(DefineHash) namespace QTest { template <> char* toString(const QStringList& list) { QByteArray ba; if (list.isEmpty()) { ba = "()"; } else { ba = "(\"" + list.join(QStringLiteral("\", \"")).toLocal8Bit() + "\")"; } return qstrdup(ba.data()); } template <> char* toString(const QMakeFile::VariableMap& variables) { QByteArray ba = "VariableMap("; QMakeFile::VariableMap::const_iterator it = variables.constBegin(); while (it != variables.constEnd()) { ba += "["; ba += it.key().toLocal8Bit(); ba += "] = "; ba += toString(it.value()); ++it; if (it != variables.constEnd()) { ba += ", "; } } ba += ")"; return qstrdup(ba.data()); } } QHash setDefaultMKSpec(QMakeProjectFile& file) { static const QHash qmvars = QMakeConfig::queryQMake(QMakeConfig::qmakeExecutable(nullptr)); static const QString specFile = QMakeConfig::findBasicMkSpec(qmvars); Q_ASSERT(QFile::exists(specFile)); QMakeMkSpecs* mkspecs = new QMakeMkSpecs(specFile, qmvars); mkspecs->read(); file.setMkSpecs(mkspecs); return qmvars; } void TestQMakeFile::varResolution() { QFETCH(QString, fileContents); QFETCH(QMakeFile::VariableMap, variables); QTemporaryFile tmpfile; tmpfile.open(); QTextStream stream(&tmpfile); stream << fileContents; stream << flush; tmpfile.close(); QMakeFile file(tmpfile.fileName()); QVERIFY(file.read()); QCOMPARE(file.variableMap(), variables); } void TestQMakeFile::varResolution_data() { QTest::addColumn("fileContents"); QTest::addColumn("variables"); { QMakeFile::VariableMap variables; variables[QStringLiteral("VAR1")] = QStringList() << QStringLiteral("1"); QTest::newRow("simple") << "VAR1 = 1\n" << variables; } { QMakeFile::VariableMap variables; variables[QStringLiteral("VAR1")] = QStringList() << QStringLiteral("1"); variables[QStringLiteral("VAR2")] = QStringList() << QStringLiteral("1"); QTest::newRow("var-in-var") << "VAR1 = 1\nVAR2 = $$VAR1\n" << variables; } { QMakeFile::VariableMap variables; variables[QStringLiteral("VAR1")] = QStringList() << QStringLiteral("foo"); variables[QStringLiteral("VAR2")] = QStringList() << QStringLiteral("foo"); QTest::newRow("curlyvar") << "VAR1 = foo\nVAR2 = $${VAR1}\n" << variables; } { QMakeFile::VariableMap variables; variables[QStringLiteral("VAR1")] = QStringList() << QProcessEnvironment::systemEnvironment().value(QStringLiteral("USER")); QTest::newRow("qmakeshell") << "VAR1 = $$(USER)\n" << variables; } { QMakeFile::VariableMap variables; variables[QStringLiteral("VAR1")] = QStringList() << QStringLiteral("foo"); variables[QStringLiteral("VAR2")] = QStringList() << QStringLiteral("foo/bar"); QTest::newRow("path") << "VAR1 = foo\nVAR2 = $$VAR1/bar\n" << variables; } { QMakeFile::VariableMap variables; variables[QStringLiteral("VAR_1")] = QStringList() << QStringLiteral("foo"); variables[QStringLiteral("VAR_2")] = QStringList() << QStringLiteral("foo/bar"); QTest::newRow("var-underscore") << "VAR_1 = foo\nVAR_2 = $$VAR_1/bar" << variables; } } void TestQMakeFile::referenceParser() { QFETCH(QString, var); VariableReferenceParser parser; parser.setContent(var); QVERIFY(parser.parse()); } void TestQMakeFile::referenceParser_data() { QTest::addColumn("var"); QTest::newRow("dot") << "."; QTest::newRow("dotdot") << ".."; } void TestQMakeFile::libTarget() { QFETCH(QString, target); QFETCH(QString, resolved); QTemporaryFile tmpfile; tmpfile.open(); QTextStream stream(&tmpfile); stream << "TARGET = " << target << "\nTEMPLATE = lib\n"; stream << flush; tmpfile.close(); QMakeProjectFile file(tmpfile.fileName()); setDefaultMKSpec(file); QVERIFY(file.read()); QCOMPARE(file.targets(), QStringList() << resolved); } void TestQMakeFile::libTarget_data() { QTest::addColumn("target"); QTest::addColumn("resolved"); QTest::newRow("simple") << "MyLib" << "MyLib"; QTest::newRow("qtLibraryTarget") << "$$qtLibraryTarget(MyLib)" << "MyLib"; QTest::newRow("qtLibraryTarget-Var") << "MyLib\nTARGET = $$qtLibraryTarget($$TARGET)" << "MyLib"; } void TestQMakeFile::defines() { QFETCH(QString, fileContents); QFETCH(DefineHash, expectedDefines); QTemporaryFile tmpfile; tmpfile.open(); QTextStream stream(&tmpfile); stream << fileContents; stream << flush; tmpfile.close(); QMakeProjectFile file(tmpfile.fileName()); setDefaultMKSpec(file); QVERIFY(file.read()); QList list = file.defines(); QCOMPARE(list.size(), expectedDefines.size()); foreach (QMakeProjectFile::DefinePair define, list) { QVERIFY(expectedDefines.find(define.first) != expectedDefines.end()); QCOMPARE(define.second, expectedDefines[define.first]); } } void TestQMakeFile::defines_data() { QTest::addColumn("fileContents"); QTest::addColumn("expectedDefines"); { DefineHash list; list.insert(QStringLiteral("VAR1"), QLatin1String("")); QTest::newRow("Simple define") << "DEFINES += VAR1" << list; } { DefineHash list; list.insert(QStringLiteral("ANSWER"), QStringLiteral("42")); QTest::newRow("Define with value") << "DEFINES += ANSWER=42" << list; } { DefineHash list; list.insert(QStringLiteral("ANSWER"), QStringLiteral("42")); list.insert(QStringLiteral("ANOTHER_DEFINE"), QLatin1String("")); QTest::newRow("Multiple defines") << "DEFINES += ANSWER=42 ANOTHER_DEFINE" << list; } } void TestQMakeFile::replaceFunctions_data() { QTest::addColumn("fileContents"); QTest::addColumn("definedVariables"); QTest::addColumn("undefinedVariables"); { QString contents = "defineReplace(test) {\n" " FOO = $$1\n" " return($$FOO)\n" "}\n" "BAR = $$test(asdf)\n"; QMakeFile::VariableMap vars; vars[QStringLiteral("BAR")] = QStringList() << QStringLiteral("asdf"); QStringList undefined; undefined << QStringLiteral("FOO") << QStringLiteral("1"); QTest::newRow("defineReplace-1") << contents << vars << undefined; } } void TestQMakeFile::replaceFunctions() { QFETCH(QString, fileContents); QFETCH(QMakeFile::VariableMap, definedVariables); QFETCH(QStringList, undefinedVariables); QTemporaryFile tmpFile; tmpFile.open(); tmpFile.write(fileContents.toUtf8()); tmpFile.close(); QMakeProjectFile file(tmpFile.fileName()); setDefaultMKSpec(file); QVERIFY(file.read()); QMakeFile::VariableMap::const_iterator it = definedVariables.constBegin(); while (it != definedVariables.constEnd()) { QCOMPARE(file.variableValues(it.key()), it.value()); ++it; } foreach (const QString& var, undefinedVariables) { QVERIFY(!file.containsVariable(var)); } } void TestQMakeFile::qtIncludeDirs_data() { QTest::addColumn("fileContents"); QTest::addColumn("modules"); QTest::addColumn("missingModules"); { QStringList list; list << QStringLiteral("core") << QStringLiteral("gui"); QTest::newRow("defaults") << "" << list; } { QStringList list; list << QStringLiteral("core"); QTest::newRow("minimal") << "QT -= gui" << list; } { QStringList modules; modules << QStringLiteral("core") << QStringLiteral("gui") << QStringLiteral("network") << QStringLiteral("opengl") << QStringLiteral("phonon") << QStringLiteral("script") << QStringLiteral("scripttools") << QStringLiteral("sql") << QStringLiteral("svg") << QStringLiteral("webkit") << QStringLiteral("xml") << QStringLiteral("xmlpatterns") << QStringLiteral("qt3support") << QStringLiteral("designer") << QStringLiteral("uitools") << QStringLiteral("help") << QStringLiteral("assistant") << QStringLiteral("qtestlib") << QStringLiteral("testlib") << QStringLiteral("qaxcontainer") << QStringLiteral("qaxserver") << QStringLiteral("dbus") << QStringLiteral("declarative"); foreach (const QString& module, modules) { QStringList expected; expected << module; if (module != QLatin1String("core")) { expected << QStringLiteral("core"); } QTest::newRow(qPrintable(module)) << QStringLiteral("QT = %1").arg(module) << expected; } } } void TestQMakeFile::qtIncludeDirs() { QFETCH(QString, fileContents); QFETCH(QStringList, modules); QMap moduleMap; - moduleMap[QStringLiteral("core")] = QLatin1String("QtCore"); - moduleMap[QStringLiteral("gui")] = QLatin1String("QtGui"); - moduleMap[QStringLiteral("network")] = QLatin1String("QtNetwork"); - moduleMap[QStringLiteral("opengl")] = QLatin1String("QtOpenGL"); - moduleMap[QStringLiteral("phonon")] = QLatin1String("Phonon"); - moduleMap[QStringLiteral("script")] = QLatin1String("QtScript"); - moduleMap[QStringLiteral("scripttools")] = QLatin1String("QtScriptTools"); - moduleMap[QStringLiteral("sql")] = QLatin1String("QtSql"); - moduleMap[QStringLiteral("svg")] = QLatin1String("QtSvg"); - moduleMap[QStringLiteral("webkit")] = QLatin1String("QtWebKit"); - moduleMap[QStringLiteral("xml")] = QLatin1String("QtXml"); - moduleMap[QStringLiteral("xmlpatterns")] = QLatin1String("QtXmlPatterns"); - moduleMap[QStringLiteral("qt3support")] = QLatin1String("Qt3Support"); - moduleMap[QStringLiteral("designer")] = QLatin1String("QtDesigner"); - moduleMap[QStringLiteral("uitools")] = QLatin1String("QtUiTools"); - moduleMap[QStringLiteral("help")] = QLatin1String("QtHelp"); - moduleMap[QStringLiteral("assistant")] = QLatin1String("QtAssistant"); - moduleMap[QStringLiteral("qtestlib")] = QLatin1String("QtTest"); - moduleMap[QStringLiteral("testlib")] = QLatin1String("QtTest"); - moduleMap[QStringLiteral("qaxcontainer")] = QLatin1String("ActiveQt"); - moduleMap[QStringLiteral("qaxserver")] = QLatin1String("ActiveQt"); - moduleMap[QStringLiteral("dbus")] = QLatin1String("QtDBus"); - moduleMap[QStringLiteral("declarative")] = QLatin1String("QtDeclarative"); + moduleMap[QStringLiteral("core")] = QStringLiteral("QtCore"); + moduleMap[QStringLiteral("gui")] = QStringLiteral("QtGui"); + moduleMap[QStringLiteral("network")] = QStringLiteral("QtNetwork"); + moduleMap[QStringLiteral("opengl")] = QStringLiteral("QtOpenGL"); + moduleMap[QStringLiteral("phonon")] = QStringLiteral("Phonon"); + moduleMap[QStringLiteral("script")] = QStringLiteral("QtScript"); + moduleMap[QStringLiteral("scripttools")] = QStringLiteral("QtScriptTools"); + moduleMap[QStringLiteral("sql")] = QStringLiteral("QtSql"); + moduleMap[QStringLiteral("svg")] = QStringLiteral("QtSvg"); + moduleMap[QStringLiteral("webkit")] = QStringLiteral("QtWebKit"); + moduleMap[QStringLiteral("xml")] = QStringLiteral("QtXml"); + moduleMap[QStringLiteral("xmlpatterns")] = QStringLiteral("QtXmlPatterns"); + moduleMap[QStringLiteral("qt3support")] = QStringLiteral("Qt3Support"); + moduleMap[QStringLiteral("designer")] = QStringLiteral("QtDesigner"); + moduleMap[QStringLiteral("uitools")] = QStringLiteral("QtUiTools"); + moduleMap[QStringLiteral("help")] = QStringLiteral("QtHelp"); + moduleMap[QStringLiteral("assistant")] = QStringLiteral("QtAssistant"); + moduleMap[QStringLiteral("qtestlib")] = QStringLiteral("QtTest"); + moduleMap[QStringLiteral("testlib")] = QStringLiteral("QtTest"); + moduleMap[QStringLiteral("qaxcontainer")] = QStringLiteral("ActiveQt"); + moduleMap[QStringLiteral("qaxserver")] = QStringLiteral("ActiveQt"); + moduleMap[QStringLiteral("dbus")] = QStringLiteral("QtDBus"); + moduleMap[QStringLiteral("declarative")] = QStringLiteral("QtDeclarative"); QTemporaryFile tmpFile; tmpFile.open(); tmpFile.write(fileContents.toUtf8()); tmpFile.close(); QMakeProjectFile file(tmpFile.fileName()); QHash qmvars = setDefaultMKSpec(file); QVERIFY(file.read()); const QStringList includes = file.includeDirectories(); // should always be there QVERIFY(includes.contains(qmvars["QT_INSTALL_HEADERS"])); for (QMap::const_iterator it = moduleMap.constBegin(); it != moduleMap.constEnd(); ++it) { QFileInfo include(qmvars[QStringLiteral("QT_INSTALL_HEADERS")] + "/" + it.value()); bool shouldBeIncluded = include.exists(); if (shouldBeIncluded) { shouldBeIncluded = modules.contains(it.key()); if (!shouldBeIncluded) { foreach (const QString& module, modules) { if (module != it.key() && moduleMap.value(module) == it.value()) { shouldBeIncluded = true; break; } } } } QCOMPARE((bool)includes.contains(include.filePath()), shouldBeIncluded); } } void TestQMakeFile::testInclude() { QTemporaryDir tempDir; QVERIFY(tempDir.isValid()); QTemporaryFile includeFile(tempDir.path() + "/qmake-include"); QVERIFY(includeFile.open()); includeFile.write("DEFINES += SOME_INCLUDE_DEF\n" "SOURCES += includedFile.cpp\n" "INCLUDEPATH += $$PWD\n" "QT += webkit\n"); includeFile.close(); QTemporaryFile baseFile; baseFile.open(); baseFile.write("TEMPLATE = app\n" "TARGET = includeTest\n" "QT += network\n" "DEFINES += SOME_DEF\n" "SOURCES += file.cpp\n" /* "CONFIG += console" "# Comment to enable Debug Messages" "DEFINES += QT_NO_DEBUG_OUTPUT" "DESTDIR = ../bin" "RESOURCES = phantomjs.qrc" "HEADERS += csconverter.h \\" " phantom.h \\" " webpage.h \\" " consts.h \\" " utils.h \\" " networkaccessmanager.h \\" " cookiejar.h \\" " filesystem.h \\" " terminal.h \\" " encoding.h \\" " config.h \\" " mimesniffer.cpp \\" " third_party/mongoose/mongoose.h \\" " webserver.h" "SOURCES += phantom.cpp \\" " webpage.cpp \\" " main.cpp \\" " csconverter.cpp \\" " utils.cpp \\" " networkaccessmanager.cpp \\" " cookiejar.cpp \\" " filesystem.cpp \\" " terminal.cpp \\" " encoding.cpp \\" " config.cpp \\" " mimesniffer.cpp \\" " third_party/mongoose/mongoose.c \\" " webserver.cpp" "" "OTHER_FILES += usage.txt \\" " bootstrap.js \\" " configurator.js \\" " modules/fs.js \\" " modules/webpage.js \\" " modules/webserver.js" "" */ "include(" + includeFile.fileName().toLocal8Bit() + ")\n"); baseFile.close(); QMakeProjectFile file(baseFile.fileName()); setDefaultMKSpec(file); QVERIFY(file.read()); QCOMPARE(file.variableValues("DEFINES"), QStringList() << "SOME_DEF" << "SOME_INCLUDE_DEF"); QCOMPARE(file.variableValues("SOURCES"), QStringList() << "file.cpp" << "includedFile.cpp"); QCOMPARE(file.variableValues("QT"), QStringList() << "core" << "gui" << "network" << "webkit"); // verify that include path was properly propagated QVERIFY(file.includeDirectories().contains(tempDir.path())); } void TestQMakeFile::globbing_data() { QTest::addColumn("files"); QTest::addColumn("pattern"); QTest::addColumn("matches"); QTest::newRow("wildcard-simple") << (QStringList() << QStringLiteral("foo.cpp")) << "*.cpp" << (QStringList() << QStringLiteral("foo.cpp")); QTest::newRow("wildcard-extended") << (QStringList() << QStringLiteral("foo.cpp") << QStringLiteral("bar.h") << QStringLiteral("asdf.cpp")) << "*.cpp" << (QStringList() << QStringLiteral("foo.cpp") << QStringLiteral("asdf.cpp")); QTest::newRow("wildcard-multiple") << (QStringList() << QStringLiteral("foo.cpp") << QStringLiteral("bar.h") << QStringLiteral("asdf.cpp")) << "*.cpp *.h" << (QStringList() << QStringLiteral("foo.cpp") << QStringLiteral("bar.h") << QStringLiteral("asdf.cpp")); QTest::newRow("wildcard-subdir") << (QStringList() << QStringLiteral("foo/bar.cpp") << QStringLiteral("fooasdf/bar.cpp") << QStringLiteral("asdf/asdf.cpp")) << "foo*/*.cpp" << (QStringList() << QStringLiteral("foo/bar.cpp") << QStringLiteral("fooasdf/bar.cpp")); QTest::newRow("bracket") << (QStringList() << QStringLiteral("foo1.cpp") << QStringLiteral("foo2.cpp") << QStringLiteral("fooX.cpp")) << "foo[0-9].cpp" << (QStringList() << QStringLiteral("foo1.cpp") << QStringLiteral("foo2.cpp")); QTest::newRow("questionmark") << (QStringList() << QStringLiteral("foo1.cpp") << QStringLiteral("fooX.cpp") << QStringLiteral("foo.cpp") << QStringLiteral("fooXY.cpp")) << "foo?.cpp" << (QStringList() << QStringLiteral("foo1.cpp") << QStringLiteral("fooX.cpp")); QTest::newRow("mixed") << (QStringList() << QStringLiteral("foo/asdf/test.cpp") << QStringLiteral("fooX/asdf1/test.cpp")) << "foo?/asdf[0-9]/*.cpp" << (QStringList() << QStringLiteral("fooX/asdf1/test.cpp")); } void TestQMakeFile::globbing() { QFETCH(QStringList, files); QFETCH(QString, pattern); QFETCH(QStringList, matches); QTemporaryDir tempDir; QDir tempDirDir(tempDir.path()); QVERIFY(tempDir.isValid()); foreach (const QString& file, files) { QVERIFY(tempDirDir.mkpath(QFileInfo(file).path())); QFile f(tempDir.path() + '/' + file); QVERIFY(f.open(QIODevice::WriteOnly)); } QTemporaryFile testFile(tempDir.path() + "/XXXXXX.pro"); QVERIFY(testFile.open()); testFile.write(("SOURCES = " + pattern + "\n").toUtf8()); testFile.close(); QMakeProjectFile pro(testFile.fileName()); setDefaultMKSpec(pro); QVERIFY(pro.read()); QStringList actual; foreach (QString path, pro.files()) { actual << path.remove(tempDir.path() + '/'); } std::sort(actual.begin(), actual.end()); std::sort(matches.begin(), matches.end()); QCOMPARE(actual, matches); } void TestQMakeFile::benchGlobbing() { QTemporaryDir tempDir; QDir dir(tempDir.path()); const int folders = 10; const int files = 100; for (int i = 0; i < folders; ++i) { QString folder = QStringLiteral("folder%1").arg(i); dir.mkdir(folder); for (int j = 0; j < files; ++j) { QFile f1(dir.filePath(folder + QStringLiteral("/file%1.cpp").arg(j))); QVERIFY(f1.open(QIODevice::WriteOnly)); QFile f2(dir.filePath(folder + QStringLiteral("/file%1.h").arg(j))); QVERIFY(f2.open(QIODevice::WriteOnly)); } } QTemporaryFile testFile(tempDir.path() + "/XXXXXX.pro"); QVERIFY(testFile.open()); testFile.write("SOURCES = fo?der[0-9]/*.cpp\n"); testFile.close(); QMakeProjectFile pro(testFile.fileName()); setDefaultMKSpec(pro); QVERIFY(pro.read()); int found = 0; QBENCHMARK { found = pro.files().size(); } QCOMPARE(found, files * folders); } void TestQMakeFile::benchGlobbingNoPattern() { QTemporaryDir tempDir; QDir dir(tempDir.path()); const int folders = 10; const int files = 100; for (int i = 0; i < folders; ++i) { QString folder = QStringLiteral("folder%1").arg(i); dir.mkdir(folder); for (int j = 0; j < files; ++j) { QFile f1(dir.filePath(folder + QStringLiteral("/file%1.cpp").arg(j))); QVERIFY(f1.open(QIODevice::WriteOnly)); QFile f2(dir.filePath(folder + QStringLiteral("/file%1.h").arg(j))); QVERIFY(f2.open(QIODevice::WriteOnly)); } } QTemporaryFile testFile(tempDir.path() + "/XXXXXX.pro"); QVERIFY(testFile.open()); testFile.write("SOURCES = folder0/file1.cpp\n"); testFile.close(); QMakeProjectFile pro(testFile.fileName()); setDefaultMKSpec(pro); QVERIFY(pro.read()); int found = 0; QBENCHMARK { found = pro.files().size(); } QCOMPARE(found, 1); } diff --git a/providers/ghprovider/ghproviderwidget.cpp b/providers/ghprovider/ghproviderwidget.cpp index 0f9409c6ef..0a4bbea769 100644 --- a/providers/ghprovider/ghproviderwidget.cpp +++ b/providers/ghprovider/ghproviderwidget.cpp @@ -1,174 +1,174 @@ /* This file is part of KDevelop * * Copyright (C) 2012-2013 Miquel Sabaté * * 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) 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace KDevelop; namespace gh { ProviderWidget::ProviderWidget(QWidget *parent) : IProjectProviderWidget(parent) { setLayout(new QVBoxLayout()); m_projects = new QListView(this); connect(m_projects, &QListView::clicked, this, &ProviderWidget::projectIndexChanged); m_waiting = new QLabel(i18n("Waiting for response"), this); m_waiting->setAlignment(Qt::AlignCenter); m_waiting->hide(); ProviderModel *model = new ProviderModel(this); m_projects->setModel(model); m_projects->setEditTriggers(QAbstractItemView::NoEditTriggers); m_resource = new Resource(this, model); m_account = new Account(m_resource); connect(m_resource, &Resource::reposUpdated, m_waiting, &QLabel::hide); QHBoxLayout *topLayout = new QHBoxLayout(); m_edit = new LineEdit(this); m_edit->setPlaceholderText(i18n("Search")); m_edit->setToolTip(i18n("You can press the Return key if you do not want to wait")); connect(m_edit, &LineEdit::returnPressed, this, &ProviderWidget::searchRepo); topLayout->addWidget(m_edit); m_combo = new QComboBox(this); m_combo->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Fixed); connect(m_combo, static_cast(&QComboBox::currentIndexChanged), this, &ProviderWidget::searchRepo); fillCombo(); topLayout->addWidget(m_combo); QPushButton *settings = new QPushButton(QIcon::fromTheme(QStringLiteral("configure")), QLatin1String(""), this); settings->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Fixed); settings->setToolTip(i18n("Click this button to configure your GitHub account")); connect(settings, &QPushButton::clicked, this, &ProviderWidget::showSettings); topLayout->addWidget(settings); layout()->addItem(topLayout); layout()->addWidget(m_waiting); layout()->addWidget(m_projects); } KDevelop::VcsJob * ProviderWidget::createWorkingCopy(const QUrl &dest) { QModelIndex pos = m_projects->currentIndex(); if (!pos.isValid()) return nullptr; auto plugin = ICore::self()->pluginController()->pluginForExtension(QStringLiteral("org.kdevelop.IBasicVersionControl"), QStringLiteral("kdevgit")); if (!plugin) { KMessageBox::error(0, i18n("The Git plugin could not be loaded which is required to import a GitHub project."), i18n("GitHub Provider Error")); return nullptr; } QString url = pos.data(ProviderModel::VcsLocationRole).toString(); if (m_account->validAccount()) url = "https://" + m_account->token() + "@" + url.mid(8); QUrl real = QUrl(url); VcsLocation loc(real); auto vc = plugin->extension(); Q_ASSERT(vc); return vc->createWorkingCopy(loc, dest); } void ProviderWidget::fillCombo() { m_combo->clear(); m_combo->addItem(i18n("User"), 1); m_combo->addItem(i18n("Organization"), 3); if (m_account->validAccount()) { m_combo->addItem(m_account->name(), 0); m_combo->setCurrentIndex(2); } const QStringList &orgs = m_account->orgs(); foreach (const QString &org, orgs) m_combo->addItem(org, 2); } bool ProviderWidget::isCorrect() const { return m_projects->currentIndex().isValid(); } void ProviderWidget::projectIndexChanged(const QModelIndex ¤tIndex) { if (currentIndex.isValid()) { QString name = currentIndex.data().toString(); emit changed(name); } } void ProviderWidget::showSettings() { Dialog *dialog = new Dialog(this, m_account); connect(dialog, &Dialog::shouldUpdate, this, &ProviderWidget::fillCombo); dialog->show(); } void ProviderWidget::searchRepo() { bool enabled = true; QString uri, text = m_edit->text(); int idx = m_combo->itemData(m_combo->currentIndex()).toInt(); switch (idx) { case 0: /* Looking for this user's repo */ - uri = QLatin1String("/user/repos"); + uri = QStringLiteral("/user/repos"); enabled = false; break; case 1: /* Looking for some user's repo */ if (text == m_account->name()) - uri = QLatin1String("/user/repos"); + uri = QStringLiteral("/user/repos"); else uri = QStringLiteral("/users/%1/repos").arg(text); break; case 2: /* Known organization */ text = m_combo->currentText(); enabled = false; default:/* Looking for some organization's repo. */ uri = QStringLiteral("/orgs/%1/repos").arg(text); break; } m_edit->setEnabled(enabled); m_waiting->show(); m_resource->searchRepos(uri, m_account->token()); } } // End of namespace gh diff --git a/utils/okteta/oktetawidget.cpp b/utils/okteta/oktetawidget.cpp index 625737a900..d32fca66fa 100644 --- a/utils/okteta/oktetawidget.cpp +++ b/utils/okteta/oktetawidget.cpp @@ -1,156 +1,156 @@ /* This file is part of the KDevelop Okteta module, part of the KDE project. Copyright 2010 Friedrich W. H. Kossebau This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 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 6 of version 3 of the license. 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #include "oktetawidget.h" // plugin #include "oktetadocument.h" #include "oktetaplugin.h" // Okteta Kasten #include //#include //#include #include #include #include #include #include #include #include #include #include #include #include #include // Kasten #include // #include // #include #include #include #include #include #include #include #include #include // KDevelop #include // KDE #include #include #include #include // Qt #include namespace KDevelop { OktetaWidget::OktetaWidget( QWidget* parent, Kasten::ByteArrayView* byteArrayView, OktetaPlugin* plugin ) : QWidget( parent ), KXMLGUIClient(), mByteArrayView( byteArrayView ) { setComponentName( QStringLiteral("kdevokteta") , QStringLiteral("KDevelop Okteta")); setXMLFile( QStringLiteral("kdevokteta.rc") ); setupActions(plugin); QVBoxLayout* layout = new QVBoxLayout( this ); layout->setMargin( 0 ); QWidget* widget = mByteArrayView->widget(); layout->addWidget( widget ); setFocusProxy( widget ); } void OktetaWidget::setupActions(OktetaPlugin* plugin) { mControllers.append( new Kasten::VersionController(this) ); mControllers.append( new Kasten::ReadOnlyController(this) ); // TODO: save_as // mControllers.append( new ExportController(mProgram->viewManager(),mProgram->documentManager(),this) ); mControllers.append( new Kasten::ZoomController(this) ); mControllers.append( new Kasten::SelectController(this) ); mControllers.append( new Kasten::ClipboardController(this) ); // if( modus != BrowserViewModus ) // mControllers.append( new Kasten::InsertController(mProgram->viewManager(),mProgram->documentManager(),this) ); // mControllers.append( new Kasten::CopyAsController(mProgram->viewManager(),mProgram->documentManager(),this) ); mControllers.append( new Kasten::OverwriteModeController(this) ); mControllers.append( new Kasten::SearchController(this,this) ); mControllers.append( new Kasten::ReplaceController(this,this) ); // mControllers.append( new Kasten::GotoOffsetController(mGroupedViews,this) ); // mControllers.append( new Kasten::SelectRangeController(mGroupedViews,this) ); mControllers.append( new Kasten::BookmarksController(this) ); mControllers.append( new Kasten::PrintController( this ) ); mControllers.append( new Kasten::ViewConfigController(this) ); mControllers.append( new Kasten::ViewModeController(this) ); Kasten::ByteArrayViewProfileManager* viewProfileManager = plugin->viewProfileManager(); mControllers.append( new Kasten::ViewProfileController(viewProfileManager, mByteArrayView->widget(), this) ); mControllers.append( new Kasten::ViewProfilesManageController(this, viewProfileManager, mByteArrayView->widget()) ); // update the text of the viewprofiles_manage action, to make clear this is just for byte arrays - QAction* viewprofilesManageAction = actionCollection()->action(QLatin1String("settings_viewprofiles_manage")); + QAction* viewprofilesManageAction = actionCollection()->action(QStringLiteral("settings_viewprofiles_manage")); viewprofilesManageAction->setText( i18nc("@action:inmenu", "Manage Byte Array View Profiles...") ); // Kasten::StatusBar* bottomBar = static_cast( statusBar() ); // mControllers.append( new ViewStatusController(bottomBar) ); // mControllers.append( new ReadOnlyBarController(bottomBar) ); // mControllers.append( new ZoomBarController(bottomBar) ); foreach( Kasten::AbstractXmlGuiController* controller, mControllers ) controller->setTargetModel( mByteArrayView ); #if 0 QDesignerFormWindowManagerInterface* manager = mDocument->form()->core()->formWindowManager(); KActionCollection* ac = actionCollection(); KStandardAction::save( this, SLOT(save()), ac); ac->addAction( "adjust_size", manager->actionAdjustSize() ); ac->addAction( "break_layout", manager->actionBreakLayout() ); ac->addAction( "designer_cut", manager->actionCut() ); ac->addAction( "designer_copy", manager->actionCopy() ); ac->addAction( "designer_paste", manager->actionPaste() ); ac->addAction( "designer_delete", manager->actionDelete() ); ac->addAction( "layout_grid", manager->actionGridLayout() ); ac->addAction( "layout_horiz", manager->actionHorizontalLayout() ); ac->addAction( "layout_vertical", manager->actionVerticalLayout() ); ac->addAction( "layout_split_horiz", manager->actionSplitHorizontal() ); ac->addAction( "layout_split_vert", manager->actionSplitVertical() ); ac->addAction( "designer_undo", manager->actionUndo() ); ac->addAction( "designer_redo", manager->actionRedo() ); ac->addAction( "designer_select_all", manager->actionSelectAll() ); #endif } #if 0 void OktetaWidget::save() { mDocument->save(); } #endif OktetaWidget::~OktetaWidget() { qDeleteAll( mControllers ); } }