diff --git a/projectmanagers/cmake/CMakeLists.txt b/projectmanagers/cmake/CMakeLists.txt index 28ec91a4d0..f415afa6c2 100644 --- a/projectmanagers/cmake/CMakeLists.txt +++ b/projectmanagers/cmake/CMakeLists.txt @@ -1,120 +1,109 @@ project(cmakemanager) add_definitions(-DTRANSLATION_DOMAIN=\"kdevcmake\") include_directories(${CMAKE_CURRENT_SOURCE_DIR}/parser) add_subdirectory(tests) add_subdirectory(icons) # enable this if you want to have the cmake debug visitor run on each CMakeLists.txt # the debug visitor prints out the Ast for the CMakeLists.txt file. #add_definitions( -DCMAKEDEBUGVISITOR ) add_definitions( -DQT_USE_FAST_CONCATENATION -DQT_USE_FAST_OPERATOR_PLUS) set( cmakecommon_SRCS parser/cmListFileLexer.c -# parser/astfactory.cpp -# parser/cmakelistsparser.cpp -# parser/cmakeast.cpp -# parser/cmakecondition.cpp -# parser/cmakeprojectvisitor.cpp -# parser/variablemap.cpp -# parser/cmakedebugvisitor.cpp parser/cmakecachereader.cpp parser/cmakelistsparser.cpp parser/cmakeduchaintypes.cpp -# parser/cmakeparserutils.cpp -# parser/cmakeduchaintypes.cpp -# parser/generationexpressionsolver.cpp cmakeutils.cpp cmakeextraargumentshistory.cpp cmakebuilddirchooser.cpp cmakeserver.cpp debug.cpp ) set( cmakecommon_UI cmakebuilddirchooser.ui ) set( cmakemanager_SRCS testing/ctestutils.cpp testing/ctestfindjob.cpp testing/ctestrunjob.cpp testing/ctestsuite.cpp testing/qttestdelegate.cpp cmakeimportjsonjob.cpp cmakeserverimportjob.cpp cmakenavigationwidget.cpp cmakemanager.cpp cmakeprojectdata.cpp cmakemodelitems.cpp duchain/cmakeparsejob.cpp duchain/usebuilder.cpp duchain/declarationbuilder.cpp duchain/contextbuilder.cpp cmakecodecompletionmodel.cpp # cmakecommitchangesjob.cpp -# cmakeimportjob.cpp # cmakeedit.cpp debug.cpp ) set( cmakemanager_UI cmakepossibleroots.ui ) set( cmakesettings_SRCS settings/cmakepreferences.cpp settings/cmakecachemodel.cpp settings/cmakecachedelegate.cpp settings/cmakecachemodel.cpp debug.cpp ) ki18n_wrap_ui(cmakesettings_SRCS settings/cmakebuildsettings.ui) set( cmakedoc_SRCS cmakedocumentation.cpp cmakehelpdocumentation.cpp ) remove_definitions( -DQT_NO_STL ) if(WIN32) add_definitions(-DYY_NO_UNISTD_H) endif() # Note: This library doesn't follow API/ABI/BC rules and shouldn't have a SOVERSION # Its only purpose is to support the plugin without needing to add all source files # to the plugin target ki18n_wrap_ui( cmakecommon_SRCS ${cmakecommon_UI} ) add_library( kdevcmakecommon SHARED ${cmakecommon_SRCS} ) target_link_libraries( kdevcmakecommon KF5::TextEditor KDev::Interfaces KDev::Project KDev::Util KDev::Language ) generate_export_header(kdevcmakecommon EXPORT_FILE_NAME cmakecommonexport.h) ki18n_wrap_ui( cmakemanager_SRCS ${cmakemanager_UI} ) add_library( kdevcmakemanagernosettings STATIC ${cmakemanager_SRCS}) target_link_libraries( kdevcmakemanagernosettings KF5::KIOWidgets KDev::Util KDev::Interfaces kdevcmakecommon kdevmakefileresolver KDev::Project KDev::Language KDev::OutputView KF5::TextEditor Qt5::Concurrent) kdevplatform_add_plugin(kdevcmakemanager JSON kdevcmakemanager.json SOURCES ${cmakemanager_SRCS} ${cmakesettings_SRCS}) target_link_libraries( kdevcmakemanager KF5::KIOWidgets KDev::Util KDev::Interfaces kdevcmakecommon kdevmakefileresolver KDev::Project KDev::Language KDev::OutputView KF5::TextEditor Qt5::Concurrent) kdevplatform_add_plugin(kdevcmakedocumentation JSON kdevcmakedocumentation.json SOURCES ${cmakedoc_SRCS}) target_link_libraries( kdevcmakedocumentation KDev::Interfaces kdevcmakecommon KDev::Project KDev::Language KDev::Documentation KF5::TextEditor) install(TARGETS kdevcmakecommon ${INSTALL_TARGETS_DEFAULT_ARGS} ) diff --git a/projectmanagers/cmake/cmakecodecompletionmodel.cpp b/projectmanagers/cmake/cmakecodecompletionmodel.cpp index a719d2d5c5..b4a78de767 100644 --- a/projectmanagers/cmake/cmakecodecompletionmodel.cpp +++ b/projectmanagers/cmake/cmakecodecompletionmodel.cpp @@ -1,317 +1,316 @@ /* KDevelop CMake Support * * Copyright 2008 Aleix Pol * * 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 "cmakecodecompletionmodel.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include -#include "astfactory.h" #include #include "cmakeutils.h" #include "icmakedocumentation.h" using namespace KTextEditor; using namespace KDevelop; QStringList CMakeCodeCompletionModel::s_commands; CMakeCodeCompletionModel::CMakeCodeCompletionModel(QObject* parent) : CodeCompletionModel(parent) , m_inside(false) {} bool isFunction(const Declaration* decl) { return decl->abstractType().cast(); } bool isPathChar(const QChar& c) { return c.isLetterOrNumber() || c=='/' || c=='.'; } QString escapePath(QString path) { static const QChar toBeEscaped[] = {'(', ')'}; for(const QChar &ch : toBeEscaped) { path.replace(ch, "\\" + ch); } return path; } void CMakeCodeCompletionModel::completionInvoked(View* view, const Range& range, InvocationType invocationType) { beginResetModel(); if(s_commands.isEmpty()) { ICMakeDocumentation* cmakedoc=CMake::cmakeDocumentation(); if(cmakedoc) s_commands=cmakedoc->names(ICMakeDocumentation::Command); } Q_UNUSED(invocationType); m_declarations.clear(); DUChainReadLocker lock(DUChain::lock()); KTextEditor::Document* d=view->document(); TopDUContext* ctx = DUChain::self()->chainForDocument( d->url() ); QString line=d->line(range.end().line()); // m_inside=line.lastIndexOf('(', range.end().column())>=0; m_inside=line.lastIndexOf('(', range.end().column()-line.size()-1)>=0; for(int l=range.end().line(); l>=0 && !m_inside; --l) { QString cline=d->line(l); QString line=cline.left(cline.indexOf('#')); int close=line.lastIndexOf(')'), open=line.indexOf('('); if(close>=0 && open>=0) { m_inside=open>close; break; } else if(open>=0) { m_inside=true; break; } else if(close>=0) { m_inside=false; break; } } int numRows = 0; if(m_inside) { Cursor start=range.start(); for(; isPathChar(d->characterAt(start)); start-=Cursor(0,1)) {} start+=Cursor(0,1); QString tocomplete=d->text(Range(start, range.end()-Cursor(0,1))); int lastdir=tocomplete.lastIndexOf('/'); QString path = KIO::upUrl(QUrl(d->url())).adjusted(QUrl::StripTrailingSlash).toLocalFile()+'/'; QString basePath; if(lastdir>=0) { basePath=tocomplete.mid(0, lastdir); path+=basePath; } QDir dir(path); QFileInfoList paths=dir.entryInfoList(QStringList() << tocomplete.mid(lastdir+1)+'*', QDir::AllEntries | QDir::NoDotAndDotDot); m_paths.clear(); foreach(const QFileInfo& f, paths) { QString currentPath = f.fileName(); if(f.isDir()) currentPath+='/'; m_paths += currentPath; } numRows += m_paths.count(); } else numRows += s_commands.count(); if(ctx) { typedef QPair DeclPair; QList list=ctx->allDeclarations( ctx->transformToLocalRevision(KTextEditor::Cursor(range.start())), ctx ); foreach(const DeclPair& pair, list) { bool func=isFunction(pair.first); if((func && !m_inside) || (!func && m_inside)) m_declarations.append(pair.first); } numRows+=m_declarations.count(); } setRowCount(numRows); endResetModel(); } CMakeCodeCompletionModel::Type CMakeCodeCompletionModel::indexType(int row) const { if(m_inside) { if(row < m_declarations.count()) { KDevelop::DUChainReadLocker lock; Declaration* dec = m_declarations.at(row).declaration(); if (dec && dec->type()) return Target; else return Variable; } else return Path; } else { if(rowidentifier().toString() : i18n("INVALID"); } } } else if(role==Qt::DisplayRole && index.column()==CodeCompletionModel::Prefix) { switch(type) { case Command: return i18n("Command"); case Variable: return i18n("Variable"); case Macro: return i18n("Macro"); case Path: return i18n("Path"); case Target: return i18n("Target"); } } else if(role==Qt::DecorationRole && index.column()==CodeCompletionModel::Icon) { switch(type) { case Command: return QIcon::fromTheme("code-block"); case Variable: return QIcon::fromTheme("code-variable"); case Macro: return QIcon::fromTheme("code-function"); case Target: return QIcon::fromTheme("system-run"); case Path: { QUrl url = QUrl::fromUserInput(m_paths[index.row()-m_declarations.size()]); QString iconName; if (url.isLocalFile()) { // don't read contents even if it is a local file iconName = QMimeDatabase().mimeTypeForFile(url.toLocalFile(), QMimeDatabase::MatchExtension).iconName(); } else { // remote always only looks at the extension iconName = QMimeDatabase().mimeTypeForUrl(url).iconName(); } return QIcon::fromTheme(iconName); } } } else if(role==Qt::DisplayRole && index.column()==CodeCompletionModel::Arguments) { switch(type) { case Variable: case Command: case Path: case Target: break; case Macro: { DUChainReadLocker lock(DUChain::lock()); int pos=index.row(); FunctionType::Ptr func; if(m_declarations[pos].data()) func = m_declarations[pos].data()->abstractType().cast(); if(!func) return QVariant(); QStringList args; foreach(const AbstractType::Ptr& t, func->arguments()) { DelayedType::Ptr delay = t.cast(); args.append(delay ? delay->identifier().toString() : i18n("wrong")); } return QString('('+args.join(", ")+')'); } } } return QVariant(); } void CMakeCodeCompletionModel::executeCompletionItem(View* view, const Range& word, const QModelIndex& idx) const { Document* document = view->document(); const int row = idx.row(); switch(indexType(row)) { case Path: { Range r=word; for(QChar c=document->characterAt(r.end()); c.isLetterOrNumber() || c=='.'; c=document->characterAt(r.end())) { r.setEnd(KTextEditor::Cursor(r.end().line(), r.end().column()+1)); } QString path = data(index(row, Name, QModelIndex())).toString(); document->replaceText(r, escapePath(path)); } break; case Macro: case Command: { QString code=data(index(row, Name, QModelIndex())).toString(); if(!document->line(word.start().line()).contains('(')) code.append('('); document->replaceText(word, code); } break; case Variable: { Range r=word, prefix(word.start()-Cursor(0,2), word.start()); QString bef=document->text(prefix); if(r.start().column()>=2 && bef=="${") r.setStart(KTextEditor::Cursor(r.start().line(), r.start().column()-2)); QString code="${"+data(index(row, Name, QModelIndex())).toString(); if(document->characterAt(word.end())!='}') code+='}'; document->replaceText(r, code); } break; case Target: document->replaceText(word, data(index(row, Name, QModelIndex())).toString()); break; } } diff --git a/projectmanagers/cmake/cmakedocumentation.cpp b/projectmanagers/cmake/cmakedocumentation.cpp index 62b8698648..709bc842e7 100644 --- a/projectmanagers/cmake/cmakedocumentation.cpp +++ b/projectmanagers/cmake/cmakedocumentation.cpp @@ -1,204 +1,205 @@ /* KDevelop CMake Support * * Copyright 2009 Aleix Pol * * 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 "cmakedocumentation.h" #include "cmakeutils.h" #include #include #include #include #include #include #include +#include #include #include #include #include +#include #include #include #include #include "cmakemanager.h" -#include "cmakeparserutils.h" #include "cmakehelpdocumentation.h" #include "cmakedoc.h" #include "debug.h" K_PLUGIN_FACTORY_WITH_JSON(CMakeSupportDocFactory, "kdevcmakedocumentation.json", registerPlugin(); ) CMakeDocumentation* CMakeDoc::s_provider=nullptr; KDevelop::IDocumentationProvider* CMakeDoc::provider() const { return s_provider; } CMakeDocumentation::CMakeDocumentation(QObject* parent, const QVariantList&) : KDevelop::IPlugin( "kdevcmakedocumentation", parent ) , m_cmakeExecutable(CMake::findExecutable()) , m_index(nullptr) { if (m_cmakeExecutable.isEmpty()) { setErrorDescription(i18n("Unable to find a CMake executable. Is one installed on the system?")); return; } CMakeDoc::s_provider=this; m_index= new QStringListModel(this); initializeModel(); } static const char* const args[] = { "--help-command", "--help-variable", "--help-module", "--help-property", nullptr, nullptr }; void CMakeDocumentation::delayedInitialization() { for(int i=0; i<=Property; i++) { collectIds(QString(args[i])+"-list", (Type) i); } m_index->setStringList(m_typeForName.keys()); } void CMakeDocumentation::collectIds(const QString& param, Type type) { QStringList ids = CMake::executeProcess(m_cmakeExecutable, QStringList(param)).split(QLatin1Char('\n')); ids.takeFirst(); foreach(const QString& name, ids) { m_typeForName[name]=type; } } QStringList CMakeDocumentation::names(CMakeDocumentation::Type t) const { return m_typeForName.keys(t); } QString CMakeDocumentation::descriptionForIdentifier(const QString& id, Type t) const { QString desc; if(args[t]) { desc = CMake::executeProcess(m_cmakeExecutable, { args[t], id.simplified() }); desc = desc.remove(":ref:"); const QString rst2html = QStandardPaths::findExecutable(QStringLiteral("rst2html")); if (rst2html.isEmpty()) { desc = ("
" + desc.toHtmlEscaped() + "
" + i18n("

For better cmake documentation rendering, install rst2html

") + ""); } else { QProcess p; p.start(rst2html, { "--no-toc-backlinks" }); p.write(desc.toUtf8()); p.closeWriteChannel(); p.waitForFinished(); desc = QString::fromUtf8(p.readAllStandardOutput()); } } return desc; } KDevelop::IDocumentation::Ptr CMakeDocumentation::description(const QString& identifier, const QUrl &file) const { initializeModel(); //make it not queued if (!file.isEmpty() && !QMimeDatabase().mimeTypeForUrl(file).inherits("text/x-cmake")) { return KDevelop::IDocumentation::Ptr(); } QString desc; if(m_typeForName.contains(identifier)) { desc=descriptionForIdentifier(identifier, m_typeForName[identifier]); } else if(m_typeForName.contains(identifier.toLower())) { desc=descriptionForIdentifier(identifier, m_typeForName[identifier.toLower()]); } else if(m_typeForName.contains(identifier.toUpper())) { desc=descriptionForIdentifier(identifier, m_typeForName[identifier.toUpper()]); } KDevelop::IProject* p=KDevelop::ICore::self()->projectController()->findProjectForUrl(file); ICMakeManager* m=nullptr; if(p) m=p->managerPlugin()->extension(); if(m) { QPair entry = m->cacheValue(p, identifier); if(!entry.first.isEmpty()) desc += i18n("
Cache Value: %1\n", entry.first); if(!entry.second.isEmpty()) desc += i18n("
Cache Documentation: %1\n", entry.second); } if(desc.isEmpty()) return KDevelop::IDocumentation::Ptr(); else return KDevelop::IDocumentation::Ptr(new CMakeDoc(identifier, desc)); } KDevelop::IDocumentation::Ptr CMakeDocumentation::documentationForDeclaration(KDevelop::Declaration* decl) const { return description(decl->identifier().toString(), decl->url().toUrl()); } KDevelop::IDocumentation::Ptr CMakeDocumentation::documentationForIndex(const QModelIndex& idx) const { return description(idx.data().toString(), QUrl()); } QAbstractListModel* CMakeDocumentation::indexModel() const { initializeModel(); return m_index; } QIcon CMakeDocumentation::icon() const { return QIcon::fromTheme("cmake"); } QString CMakeDocumentation::name() const { return "CMake"; } KDevelop::IDocumentation::Ptr CMakeDocumentation::homePage() const { if(m_typeForName.isEmpty()) const_cast(this)->delayedInitialization(); // initializeModel(); return KDevelop::IDocumentation::Ptr(new CMakeHomeDocumentation); } void CMakeDocumentation::initializeModel() const { if(!m_typeForName.isEmpty()) return; QMetaObject::invokeMethod(const_cast(this), "delayedInitialization", Qt::QueuedConnection); } //////////CMakeDoc QWidget* CMakeDoc::documentationWidget(KDevelop::DocumentationFindWidget* findWidget, QWidget* parent) { KDevelop::StandardDocumentationView* view = new KDevelop::StandardDocumentationView(findWidget, parent); view->setHtml(mDesc); return view; } #include "cmakedocumentation.moc" diff --git a/projectmanagers/cmake/cmakeimportjob.cpp b/projectmanagers/cmake/cmakeimportjob.cpp deleted file mode 100644 index d24997ae48..0000000000 --- a/projectmanagers/cmake/cmakeimportjob.cpp +++ /dev/null @@ -1,257 +0,0 @@ -/* KDevelop CMake Support - * - * Copyright 2013 Aleix Pol - * - * 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 "cmakeimportjob.h" -#include "cmakeutils.h" -#include -#include "cmakecommitchangesjob.h" -#include "cmakemanager.h" -#include "cmakeprojectdata.h" -#include "cmakemodelitems.h" -#include "debug.h" -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -using namespace KDevelop; - -class WaitAllJobs : public KCompositeJob -{ -Q_OBJECT -public: - friend class CMakeManager; - WaitAllJobs(QObject* parent) - : KCompositeJob(parent) - , m_started(false) {} - - virtual void slotResult(KJob* job) { - KCompositeJob::slotResult(job); - reconsider(); - } - void addJob(KJob* job) { - Q_ASSERT(thread() == QThread::currentThread()); -// Q_ASSERT(thread() == job->thread()); - addSubjob(job); - job->start(); - } - -public slots: - virtual void start() { - m_started = true; - QMetaObject::invokeMethod(this, "reconsider", Qt::QueuedConnection); - } - -private slots: - void reconsider() - { - if(subjobs().isEmpty() && m_started) { - m_started = false; //don't emit the result twice! - emitResult(); - } - } - -private: - bool m_started; -}; - -CMakeImportJsonJob::CMakeImportJsonJob(ProjectFolderItem* dom, CMakeManager* parent) - : KJob(parent) - , m_project(dom->project()) - , m_dom(dom) - , m_data(parent->projectData(dom->project())) - , m_manager(parent) - , m_futureWatcher(new QFutureWatcher) -{ - connect(m_futureWatcher, SIGNAL(finished()), SLOT(importFinished())); -} - -void CMakeImportJsonJob::start() -{ - QFuture future = QtConcurrent::run(this, &CMakeImportJob::initialize); - m_futureWatcher->setFuture(future); -} - -void CMakeImportJsonJob::importCompileCommandsJsonFinished() -{ - Q_ASSERT(m_project->thread() == QThread::currentThread()); - - WaitAllJobs* wjob = new WaitAllJobs(this); - connect(wjob, SIGNAL(finished(KJob*)), SLOT(waitFinished(KJob*))); - foreach(KJob* job, m_jobs) { - wjob->addJob(job); - } - wjob->start(); -} - -void CMakeImportJsonJob::initialize() -{ - ReferencedTopDUContext ctx; - ProjectBaseItem* parent = m_dom->parent(); - while (parent && !ctx) { - DUChainReadLocker lock; - ctx = DUChain::self()->chainForDocument(IndexedString(Path(parent->path(), "CMakeLists.txt").pathOrUrl())); - parent = parent->parent(); - } - if (!ctx) { - ctx = initializeProject(dynamic_cast(m_dom)); - } - importDirectory(m_project, m_dom->path(), ctx); -} - -KDevelop::ReferencedTopDUContext CMakeImportJsonJob::initializeProject(CMakeFolderItem* rootFolder) -{ - Path base(CMake::projectRoot(m_project)); - - QPair initials = CMakeParserUtils::initialVariables(); - - m_data.clear(); - m_data.modulePath=initials.first["CMAKE_MODULE_PATH"]; - m_data.vm=initials.first; - m_data.vm.insertGlobal("CMAKE_SOURCE_DIR", QStringList(base.toLocalFile())); - m_data.vm.insertGlobal("CMAKE_BINARY_DIR", QStringList(CMake::currentBuildDir(m_project).toLocalFile(QUrl::RemoveTrailingSlash))); - - const Path cachefile(m_manager->buildDirectory(m_project->projectItem()), "CMakeCache.txt"); - m_data.cache = CMakeParserUtils::readCache(cachefile); - - KDevelop::ReferencedTopDUContext buildstrapContext; - { - const IndexedString idxpath(Path(base, "buildstrap").pathOrUrl()); - DUChainWriteLocker lock; - - buildstrapContext = DUChain::self()->chainForDocument(idxpath); - - if(buildstrapContext) { - buildstrapContext->clearLocalDeclarations(); - buildstrapContext->clearImportedParentContexts(); - buildstrapContext->deleteChildContextsRecursively(); - }else{ - buildstrapContext=new TopDUContext(idxpath, RangeInRevision(0,0, 0,0), - new ParsingEnvironmentFile(idxpath)); - DUChain::self()->addDocumentChain(buildstrapContext); - } - - Q_ASSERT(buildstrapContext); - } - ReferencedTopDUContext ref=buildstrapContext; - foreach(const QString& script, initials.second) - { - ref = includeScript(CMakeProjectVisitor::findFile(script, m_data.modulePath, QStringList()), base.toLocalFile(), ref); - } - - //Initialize parent parts of the project that don't belong to the tree (because it's a partial import) - if(base.isParentOf(m_project->path())) - { - QList toimport; - toimport += base; - QStringList includes; - while(!toimport.isEmpty()) { - const Path currentDir = toimport.takeFirst(); - const Path script(currentDir, "CMakeLists.txt"); - - QString dir = currentDir.toLocalFile(); - ref = includeScript(script.toLocalFile(), dir, ref); - Q_ASSERT(ref); - includes << m_data.properties[DirectoryProperty][dir]["INCLUDE_DIRECTORIES"]; - CMakeParserUtils::addDefinitions(m_data.properties[DirectoryProperty][dir]["COMPILE_DEFINITIONS"], &m_data.definitions); - CMakeParserUtils::addDefinitions(m_data.vm["CMAKE_CXX_FLAGS"], &m_data.definitions, true); - rootFolder->setDefinitions(m_data.definitions); - - foreach(const Subdirectory& s, m_data.subdirectories) { - const Path candidate(currentDir, s.name); - - if(candidate.isParentOf(m_project->path())) - toimport += candidate; - } - } - rootFolder->setIncludeDirectories(includes); - rootFolder->setBuildDir(base.relativePath(m_project->path())); - } - return ref; -} - -void CMakeImportJsonJob::waitFinished(KJob*) -{ - emitResult(); -} - -KDevelop::ReferencedTopDUContext CMakeImportJsonJob::includeScript(const QString& file, const QString& dir, ReferencedTopDUContext parent) -{ - m_manager->addWatcher(m_project, file); - QString profile = CMake::currentEnvironment(m_project); - const KDevelop::EnvironmentProfileList env(KSharedConfig::openConfig()); - return CMakeParserUtils::includeScript( file, parent, &m_data, dir, env.variables(profile)); -} - -CMakeCommitChangesJob* CMakeImportJsonJob::importDirectory(IProject* project, const Path& path, const KDevelop::ReferencedTopDUContext& parentTop) -{ - Q_ASSERT(thread() == m_project->thread()); - Path cmakeListsPath(path, "CMakeLists.txt"); - CMakeCommitChangesJob* commitJob = new CMakeCommitChangesJob(path, m_manager, project); - commitJob->moveToThread(thread()); - m_jobs += commitJob; - if(QFile::exists(cmakeListsPath.toLocalFile())) - { - qCDebug(CMAKE) << "Adding cmake: " << cmakeListsPath << " to the model"; - - m_data.vm.pushScope(); - ReferencedTopDUContext ctx = includeScript(cmakeListsPath.toLocalFile(), - path.toLocalFile(), parentTop); - Path::List folderList = commitJob->addProjectData(m_data); - foreach(const Path& folder, folderList) { - if (!m_manager->filterManager()->isValid(folder, true, project)) { - continue; - } - Path newcmakeListsPath(folder, "CMakeLists.txt"); - if(!QFile::exists(newcmakeListsPath.toLocalFile())) { - qWarning() << "Unable to open " << newcmakeListsPath.toLocalFile(); - continue; - } - CMakeCommitChangesJob* job = importDirectory(project, folder, ctx); - job->setFindParentItem(false); - connect(commitJob, SIGNAL(folderCreated(KDevelop::ProjectFolderItem*)), - job, SLOT(folderAvailable(KDevelop::ProjectFolderItem*))); - } - m_data.vm.popScope(); - } - - return commitJob; -} - -IProject* CMakeImportJsonJob::project() const -{ - Q_ASSERT(!m_futureWatcher->isRunning()); - return m_project; -} - -CMakeProjectData CMakeImportJsonJob::projectData() const -{ - Q_ASSERT(!m_futureWatcher->isRunning()); - return m_data; -} - -#include "moc_cmakeimportjob.cpp" -#include "cmakeimportjob.moc" diff --git a/projectmanagers/cmake/cmakeimportjob.h b/projectmanagers/cmake/cmakeimportjob.h deleted file mode 100644 index 2bb0afbf9e..0000000000 --- a/projectmanagers/cmake/cmakeimportjob.h +++ /dev/null @@ -1,67 +0,0 @@ -/* KDevelop CMake Support - * - * Copyright 2013 Aleix Pol - * - * 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. - */ - -#ifndef CMAKEIMPORTJOB_H -#define CMAKEIMPORTJOB_H - -#include -#include "cmakeprojectdata.h" - -templateclass QFutureWatcher; -class CMakeManager; -class CMakeFolderItem; -class CMakeCommitChangesJob; -namespace KDevelop -{ - class Path; - class IProject; - class ProjectFolderItem; - class ReferencedTopDUContext; -} - -class CMakeImportJsonJob : public KJob -{ - Q_OBJECT - public: - CMakeImportJsonJob(KDevelop::ProjectFolderItem* dom, CMakeManager* parent); - - virtual void start(); - KDevelop::IProject* project() const; - CMakeProjectData projectData() const; - - private slots: - void waitFinished(KJob* job); - void importCompileCommandsJsonFinished(); - - private: - void initialize(); - CMakeCommitChangesJob* importDirectory(KDevelop::IProject* project, const KDevelop::Path& path, const KDevelop::ReferencedTopDUContext& parentTop); - KDevelop::ReferencedTopDUContext initializeProject(CMakeFolderItem*); - KDevelop::ReferencedTopDUContext includeScript(const QString& file, const QString& currentDir, KDevelop::ReferencedTopDUContext parent); - - KDevelop::IProject* m_project; - KDevelop::ProjectFolderItem* m_dom; - CMakeProjectData m_data; - CMakeManager* m_manager; - QFutureWatcher* m_futureWatcher; - QVector m_jobs; -}; - -#endif // CMAKEIMPORTJOB_H diff --git a/projectmanagers/cmake/cmakemanager.h b/projectmanagers/cmake/cmakemanager.h index af761b6b69..6720441b51 100644 --- a/projectmanagers/cmake/cmakemanager.h +++ b/projectmanagers/cmake/cmakemanager.h @@ -1,169 +1,168 @@ /* KDevelop CMake Support * * Copyright 2006 Matt Rogers * Copyright 2007-2009 Aleix Pol * * 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. */ #ifndef CMAKEMANAGER_H #define CMAKEMANAGER_H #include #include #include #include #include #include #include #include #include #include #include "cmakeprojectdata.h" #include "icmakemanager.h" -#include "cmakeprojectvisitor.h" class WaitAllJobs; class CMakeCommitChangesJob; struct CMakeProjectData; class QStandardItem; class QDir; class QObject; class CMakeHighlighting; class CMakeDocumentation; namespace KDevelop { class IProject; class IProjectBuilder; class ICodeHighlighting; class ProjectFolderItem; class ProjectBaseItem; class ProjectFileItem; class ProjectTargetItem; class ProjectFilterManager; class IProjectFilter; class ParseJob; class ContextMenuExtension; class Context; } class CMakeFolderItem; class CMakeManager : public KDevelop::AbstractFileManagerPlugin , public KDevelop::IBuildSystemManager , public KDevelop::ILanguageSupport , public ICMakeManager { Q_OBJECT Q_INTERFACES( KDevelop::IBuildSystemManager ) Q_INTERFACES( KDevelop::IProjectFileManager ) Q_INTERFACES( KDevelop::ILanguageSupport ) Q_INTERFACES( ICMakeManager ) public: explicit CMakeManager( QObject* parent = nullptr, const QVariantList& args = QVariantList() ); ~CMakeManager() override; Features features() const override { return Features(Folders | Targets | Files ); } KDevelop::IProjectBuilder* builder() const override; bool hasBuildInfo(KDevelop::ProjectBaseItem*) const override; KDevelop::Path buildDirectory(KDevelop::ProjectBaseItem*) const override; KDevelop::Path::List includeDirectories(KDevelop::ProjectBaseItem *) const override; KDevelop::Path::List frameworkDirectories(KDevelop::ProjectBaseItem *item) const override; QHash defines(KDevelop::ProjectBaseItem *) const override; KDevelop::ProjectTargetItem* createTarget( const QString&, KDevelop::ProjectFolderItem* ) override { return nullptr; } virtual QList targets() const; QList targets(KDevelop::ProjectFolderItem* folder) const override; // virtual KDevelop::ProjectFolderItem* addFolder( const KDevelop::Path& folder, KDevelop::ProjectFolderItem* parent ); // virtual KDevelop::ProjectFileItem* addFile( const KDevelop::Path&, KDevelop::ProjectFolderItem* ); bool addFilesToTarget( const QList &files, KDevelop::ProjectTargetItem* target) override; bool removeTarget( KDevelop::ProjectTargetItem* ) override { return false; } bool removeFilesFromTargets( const QList &files ) override; // virtual bool removeFilesAndFolders( const QList &items); // // virtual bool renameFile(KDevelop::ProjectFileItem*, const KDevelop::Path&); // virtual bool renameFolder(KDevelop::ProjectFolderItem*, const KDevelop::Path&); // virtual bool moveFilesAndFolders(const QList< KDevelop::ProjectBaseItem* > &items, KDevelop::ProjectFolderItem *newParent); // virtual bool copyFilesAndFolders(const KDevelop::Path::List &items, KDevelop::ProjectFolderItem* newParent); // // virtual QList parse( KDevelop::ProjectFolderItem* dom ); KDevelop::ProjectFolderItem* import( KDevelop::IProject *project ) override; KJob* createImportJob(KDevelop::ProjectFolderItem* item) override; // bool reload(KDevelop::ProjectFolderItem*) override; // // virtual KDevelop::ContextMenuExtension contextMenuExtension( KDevelop::Context* context ); KDevelop::ProjectFolderItem* createFolderItem(KDevelop::IProject* project, const KDevelop::Path& path, KDevelop::ProjectBaseItem* parent = nullptr) override; QPair cacheValue(KDevelop::IProject* project, const QString& id) const override; //LanguageSupport QString name() const override; KDevelop::ParseJob *createParseJob(const KDevelop::IndexedString &url) override; KDevelop::ICodeHighlighting* codeHighlighting() const override; QWidget* specialLanguageObjectNavigationWidget(const QUrl &url, const KTextEditor::Cursor& position) override; // void addPending(const KDevelop::Path& path, CMakeFolderItem* folder); // CMakeFolderItem* takePending(const KDevelop::Path& path); // void addWatcher(KDevelop::IProject* p, const QString& path); // CMakeProjectData projectData(KDevelop::IProject* project); KDevelop::ProjectFilterManager* filterManager() const; static KDevelop::IndexedString languageName(); int perProjectConfigPages() const override; KDevelop::ConfigPage* perProjectConfigPage(int number, const KDevelop::ProjectConfigOptions& options, QWidget* parent) override; void integrateData(const CMakeProjectData &data, KDevelop::IProject* project); signals: void folderRenamed(const KDevelop::Path& oldFolder, KDevelop::ProjectFolderItem* newFolder); void fileRenamed(const KDevelop::Path& oldFile, KDevelop::ProjectFileItem* newFile); private slots: // void dirtyFile(const QString& file); // // void jumpToDeclaration(); void projectClosing(KDevelop::IProject*); void dirtyFile(const QString& file); // // void directoryChanged(const QString& dir); // void filesystemBuffererTimeout(); private: CMakeFile fileInformation(KDevelop::ProjectBaseItem* item) const; void folderAdded(KDevelop::ProjectFolderItem* folder); QHash m_projects; KDevelop::ProjectFilterManager* m_filter; KDevelop::ICodeHighlighting* m_highlight; }; #endif diff --git a/projectmanagers/cmake/parser/astfactory.cpp b/projectmanagers/cmake/parser/astfactory.cpp deleted file mode 100644 index bf4c03ccca..0000000000 --- a/projectmanagers/cmake/parser/astfactory.cpp +++ /dev/null @@ -1,85 +0,0 @@ -/* KDevelop CMake Support - * - * Copyright 2006 Matt Rogers - * - * 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 "astfactory.h" -#include -#include -#include "cmakeast.h" - -class AstFactory::Private -{ -public: - CallbackMap callbacks; -}; - -AstFactory* AstFactory::self() -{ - K_GLOBAL_STATIC(AstFactory, s_self); - return s_self; -} - - -AstFactory::AstFactory() -{ - d = new Private; -} - -AstFactory::~AstFactory() -{ - delete d; -} - - -bool AstFactory::registerAst( const QString& astId, - CreateAstCallback createFn ) -{ - if ( d->callbacks.contains( astId.toLower() ) ) - return false; - - d->callbacks.insert( astId.toLower(), createFn ); - return true; -} - - -bool AstFactory::unregisterAst( const QString& astId ) -{ - return d->callbacks.remove( astId.toLower() ) == 1; -} - - -CMakeAst* AstFactory::createAst( const QString& astId ) -{ - CallbackMap::const_iterator it = d->callbacks.constFind( astId.toLower() ); - if ( it == d->callbacks.constEnd() ) - return new MacroCallAst; - - return ( it.value() )(); - -} - -QStringList AstFactory::commands() const -{ - return d->callbacks.uniqueKeys(); -} - -bool AstFactory::contains(const QString& name) const -{ - return d->callbacks.contains(name); -} diff --git a/projectmanagers/cmake/parser/astfactory.h b/projectmanagers/cmake/parser/astfactory.h deleted file mode 100644 index 7d9f90f76a..0000000000 --- a/projectmanagers/cmake/parser/astfactory.h +++ /dev/null @@ -1,61 +0,0 @@ -/* KDevelop CMake Support - * - * Copyright 2006 Matt Rogers - * - * 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. - */ - -#ifndef ASTFACTORY_H -#define ASTFACTORY_H - -#include -#include -#include "cmakecommonexport.h" - -class CMakeAst; - -class KDEVCMAKECOMMON_EXPORT AstFactory -{ -public: - //We are a singleton. Fuckin' act like it - static AstFactory* self(); - - ///Alias for the AST creation callback - typedef CMakeAst* ( *CreateAstCallback )(); - ~AstFactory(); -public: - ///Returns true if registration was successful - bool registerAst( const QString& astId, - CreateAstCallback createFn ); - - ///Returns true if the AstId was successfully found and unregistered - bool unregisterAst( const QString& astId ); - - ///Create the AST specified by @p astId - ///Return either a valid AST object or zero. - CMakeAst* createAst( const QString& astId ); - - QStringList commands() const; - - bool contains(const QString& name) const; -private: - typedef QMap CallbackMap; - AstFactory(); - class Private; - Private* d; -}; - -#endif diff --git a/projectmanagers/cmake/parser/cmakeast.cpp b/projectmanagers/cmake/parser/cmakeast.cpp deleted file mode 100644 index 5e29eb3bf0..0000000000 --- a/projectmanagers/cmake/parser/cmakeast.cpp +++ /dev/null @@ -1,3972 +0,0 @@ -/* KDevelop CMake Support - * - * Copyright 2006 Matt Rogers - * Copyright 2007-2009 Aleix Pol - * - * Some parts of this code are based on CMake - * Copyright 2002 Kitware, Inc. Insight Consortium - * - * 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 "cmakeast.h" - -#include - -#include "astfactory.h" -#include "cmakelistsparser.h" -#include "cmakeparserutils.h" -#include "../debug.h" - -#define CMAKE_REGISTER_AST( klassName, astId ) namespace { \ - CMakeAst* Create##klassName() { return new klassName; } \ - bool b_##astId = AstFactory::self()->registerAst( QLatin1String( #astId ), Create##klassName ); } - -QDebug operator<<(QDebug dbg, const CMakeFunctionDesc &func) -{ - dbg.nospace() << func.name << "(" << func.arguments << ")"; - - return dbg.space(); -} - -QDebug operator<<(QDebug dbg, const CMakeFunctionArgument &arg) -{ - dbg.nospace() << arg.value; - - return dbg.space(); -} - -CMAKE_REGISTER_AST( AddDefinitionsAst, add_definitions ) -CMAKE_REGISTER_AST( AddDependenciesAst, add_dependencies ) -CMAKE_REGISTER_AST( AddExecutableAst, add_executable ) -CMAKE_REGISTER_AST( AddLibraryAst, add_library ) -CMAKE_REGISTER_AST( AddSubdirectoryAst, add_subdirectory ) -CMAKE_REGISTER_AST( AddTestAst, add_test ) -CMAKE_REGISTER_AST( AuxSourceDirectoryAst, aux_source_directory ) -CMAKE_REGISTER_AST( BreakAst, break) -CMAKE_REGISTER_AST( BuildCommandAst, build_command ) -CMAKE_REGISTER_AST( BuildNameAst, build_name ) -CMAKE_REGISTER_AST( CMakeMinimumRequiredAst, cmake_minimum_required ) -CMAKE_REGISTER_AST( CMakePolicyAst, cmake_policy) -CMAKE_REGISTER_AST( ConfigureFileAst, configure_file ) -CMAKE_REGISTER_AST( CreateTestSourcelistAst, create_test_sourcelist ) -CMAKE_REGISTER_AST( CustomCommandAst, add_custom_command ) -CMAKE_REGISTER_AST( CustomTargetAst, add_custom_target ) -CMAKE_REGISTER_AST( EnableLanguageAst, enable_language ) -CMAKE_REGISTER_AST( EnableTestingAst, enable_testing ) -CMAKE_REGISTER_AST( ExecProgramAst, exec_program ) -CMAKE_REGISTER_AST( ExecuteProcessAst, execute_process ) -CMAKE_REGISTER_AST( ExportAst, export) -CMAKE_REGISTER_AST( ExportLibraryDepsAst, export_library_dependencies) -CMAKE_REGISTER_AST( FileAst, file ) -CMAKE_REGISTER_AST( FindFileAst, find_file ) -CMAKE_REGISTER_AST( FindLibraryAst, find_library ) -CMAKE_REGISTER_AST( FindPackageAst, find_package ) -CMAKE_REGISTER_AST( FindPathAst, find_path ) -CMAKE_REGISTER_AST( FindProgramAst, find_program ) -CMAKE_REGISTER_AST( ForeachAst, foreach ) -CMAKE_REGISTER_AST( FunctionAst, function ) -CMAKE_REGISTER_AST( GetCMakePropertyAst, get_cmake_property ) -CMAKE_REGISTER_AST( GetDirPropertyAst, get_directory_property ) -CMAKE_REGISTER_AST( GetPropertyAst, get_property ) -CMAKE_REGISTER_AST( GetSourceFilePropAst, get_source_file_property ) -CMAKE_REGISTER_AST( GetTargetPropAst, get_target_property ) -CMAKE_REGISTER_AST( GetTestPropAst, get_test_property ) -CMAKE_REGISTER_AST( GetFilenameComponentAst, get_filename_component ) -CMAKE_REGISTER_AST( IfAst, if ) -CMAKE_REGISTER_AST( IncludeAst, include ) -CMAKE_REGISTER_AST( IncludeDirectoriesAst, include_directories ) -CMAKE_REGISTER_AST( IncludeRegularExpressionAst, include_regular_expression ) -CMAKE_REGISTER_AST( InstallFilesAst, install_files ) -CMAKE_REGISTER_AST( InstallProgramsAst, install_programs ) -CMAKE_REGISTER_AST( InstallTargetsAst, install_targets ) -CMAKE_REGISTER_AST( LinkDirectoriesAst, link_directories ) -CMAKE_REGISTER_AST( LinkLibrariesAst, link_libraries ) -CMAKE_REGISTER_AST( ListAst, list ) -CMAKE_REGISTER_AST( LoadCacheAst, load_cache ) -CMAKE_REGISTER_AST( LoadCommandAst, load_command ) -CMAKE_REGISTER_AST( MacroAst, macro ) -CMAKE_REGISTER_AST( MarkAsAdvancedAst, mark_as_advanced ) -CMAKE_REGISTER_AST( MakeDirectoryAst, make_directory ) -CMAKE_REGISTER_AST( MathAst, math ) -CMAKE_REGISTER_AST( MessageAst, message ) -CMAKE_REGISTER_AST( OptionAst, option ) -CMAKE_REGISTER_AST( OutputRequiredFilesAst, output_required_files ) -CMAKE_REGISTER_AST( ProjectAst, project ) -CMAKE_REGISTER_AST( RemoveAst, remove ) -CMAKE_REGISTER_AST( ReturnAst, return ) -CMAKE_REGISTER_AST( RemoveDefinitionsAst, remove_definitions ) -CMAKE_REGISTER_AST( SetAst, set ) -CMAKE_REGISTER_AST( SetDirectoryPropsAst, set_directory_properties ) -CMAKE_REGISTER_AST( SetSourceFilesPropsAst, set_source_files_properties ) -CMAKE_REGISTER_AST( SetTargetPropsAst, set_target_properties ) -CMAKE_REGISTER_AST( SetTestsPropsAst, set_tests_properties ) -CMAKE_REGISTER_AST( SetPropertyAst, set_property ) -CMAKE_REGISTER_AST( SourceGroupAst, source_group ) -CMAKE_REGISTER_AST( SeparateArgumentsAst, separate_arguments ) -CMAKE_REGISTER_AST( SiteNameAst, site_name ) -CMAKE_REGISTER_AST( StringAst, string ) -CMAKE_REGISTER_AST( SubdirsAst, subdirs ) -CMAKE_REGISTER_AST( SubdirDependsAst, subdir_depends ) -CMAKE_REGISTER_AST( TargetIncludeDirectoriesAst, target_include_directories) -CMAKE_REGISTER_AST( TargetLinkLibrariesAst, target_link_libraries) -CMAKE_REGISTER_AST( TryCompileAst, try_compile ) -CMAKE_REGISTER_AST( TryRunAst, try_run ) -CMAKE_REGISTER_AST( UseMangledMesaAst, use_mangled_mesa ) -CMAKE_REGISTER_AST( UtilitySourceAst, utility_source ) -CMAKE_REGISTER_AST( UnsetAst, unset ) -CMAKE_REGISTER_AST( VariableRequiresAst, variable_requires ) -CMAKE_REGISTER_AST( WhileAst, while) -CMAKE_REGISTER_AST( WriteFileAst, write_file) - -#undef CMAKE_REGISTER_AST - -enum Stage {NAMES, PATHS, PATH_SUFFIXES, HINTS}; - -CustomCommandAst::CustomCommandAst() - : m_isForTarget(false) //only used here? :S - , m_buildStage(PostBuild) - , m_isVerbatim(false) - , m_append(false) -{ -} - -CustomCommandAst::~CustomCommandAst() -{ -} - -bool CustomCommandAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name.toLower() != QLatin1String( "add_custom_command" ) ) - return false; - - if (func.arguments.size() < 4) - return false; - - enum tdoing { - doing_source, - doing_command, - doing_target, - doing_depends, - doing_main_dependency, - doing_output, - doing_outputs, - doing_comment, - doing_working_directory, - doing_nothing - }; - - tdoing doing = doing_nothing; - QString currentLine; - - QList::const_iterator it, itEnd = func.arguments.end(); - for ( it = func.arguments.begin(); it != itEnd; ++it) - { - QString copy = it->value; - if(copy == "SOURCE") - doing = doing_source; - else if(copy == "COMMAND") - { - doing = doing_command; - // Save the current command before starting the next command. - if ( !currentLine.isEmpty() ) - { - m_commands.append( currentLine ); - currentLine.clear(); - } - } - else if(copy == "PRE_BUILD") - m_buildStage = PreBuild; - else if(copy == "PRE_LINK") - m_buildStage = PreLink; - else if(copy == "POST_BUILD") - m_buildStage = PostBuild; - else if(copy == "VERBATIM") - m_isVerbatim = true; - else if(copy == "APPEND") - m_append = true; - else if(copy == "TARGET") - doing = doing_target; - else if(copy == "ARGS") - // Ignore this old keyword. - ; - else if (copy == "DEPENDS") - doing = doing_depends; - else if (copy == "OUTPUTS") - doing = doing_outputs; - else if (copy == "OUTPUT") - doing = doing_output; - else if (copy == "WORKING_DIRECTORY") - doing = doing_working_directory; - else if (copy == "MAIN_DEPENDENCY") - doing = doing_main_dependency; - else if (copy == "COMMENT") - doing = doing_comment; - else - { - switch (doing) - { - case doing_working_directory: - m_workingDirectory = copy; - break; - case doing_source: - m_source = copy; - break; - case doing_main_dependency: - m_mainDependency = copy; - break; - case doing_command: - m_commands.append( copy ); - break; - case doing_target: - m_targetName = copy; - break; - case doing_depends: - m_otherDependencies.append( copy ); - break; - case doing_outputs: - case doing_output: - m_outputs.append(copy); - break; - case doing_comment: - m_comment = copy; - break; - default: - return false; - } - } - } - - // Store the last command line finished. - if ( !currentLine.isEmpty() ) - { - m_commands.append( currentLine ); - currentLine.clear(); - } - - // At this point we could complain about the lack of arguments. For - // the moment, let's say that COMMAND, TARGET are always required. - if ( m_outputs.isEmpty() && m_targetName.isEmpty() ) - return false; - - if ( m_source.isEmpty() && !m_targetName.isEmpty() && !m_outputs.isEmpty()) - return false; - - if ( m_append && m_outputs.isEmpty() ) - return false; - - return true; -} - -CustomTargetAst::CustomTargetAst() -{ - m_buildAlways = false; - m_isVerbatim = false; -} - -CustomTargetAst::~CustomTargetAst() -{ -} - -bool CustomTargetAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name.toLower() != QLatin1String( "add_custom_target" ) ) - return false; - - //make sure we have at least one argument - if ( func.arguments.size() < 1 ) - return false; - - //check and make sure the target name isn't something silly - CMakeFunctionArgument arg = func.arguments.front(); - if ( arg.value=="ALL" ) - return false; - else - m_target = arg.value; - - //check if we're part of the special "all" target - if(func.arguments.count()>1) - { - CMakeFunctionArgument arg2 = func.arguments[1]; - m_buildAlways = arg2.value == "ALL"; - } - - //what are we doing? - enum Action { - ParsingCommand, - ParsingDep, - ParsingWorkingDir, - ParsingComment, - ParsingVerbatim, - ParsingSources - }; - - //command should be first - QString currentLine; - Action act = ParsingCommand; - QList::const_iterator it, itEnd = func.arguments.end(); - it = func.arguments.begin(); - if(m_buildAlways) - it+=2; - else - ++it; - QString currCmd; - for ( ; it != itEnd; ++it ) - { - QString arg = it->value; - if ( arg == "DEPENDS" ) - act = ParsingDep; - else if ( arg == "WORKING_DIRECTORY" ) - act = ParsingWorkingDir; - else if ( arg == "VERBATIM" ) - { - m_isVerbatim = true; - act = ParsingVerbatim; - } - else if ( arg == "COMMENT" ) - act = ParsingComment; - else if ( arg == "COMMAND" ) - { - currCmd.clear(); - act = ParsingCommand; - } - else if ( arg == "SOURCES" ) - act = ParsingSources; - else - { - switch( act ) - { - case ParsingCommand: - if(m_commandArgs.contains(currCmd)) - m_commandArgs[currCmd].append(arg); - else - { - currCmd=arg; - m_commandArgs.insert(arg, QStringList()); - } - break; - case ParsingDep: - m_dependencies.append( arg ); - break; - case ParsingWorkingDir: - m_workingDir = arg; - break; - case ParsingComment: - m_comment += arg; - break; - case ParsingSources: - m_sourceLists.append( arg ); - break; - default: - return false; - } - } - } - - //check for bogus characters in the target name - if ( m_target.indexOf( QRegExp( "(#|<|>)" ) ) != -1 ) - return false; - - return true; -} - -/* Add Definitions AST */ - -AddDefinitionsAst::AddDefinitionsAst() -{ - -} - -AddDefinitionsAst::~AddDefinitionsAst() -{ -} - -bool AddDefinitionsAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "add_definitions" ) - return false; - - if ( func.arguments.isEmpty() ) - return false; - - foreach( const CMakeFunctionArgument& arg, func.arguments ) - { - m_definitions << arg.value; - } - - return true; -} - -/* Add Dependencies AST */ - -AddDependenciesAst::AddDependenciesAst() -{ -} - -AddDependenciesAst::~AddDependenciesAst() -{ -} - -bool AddDependenciesAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "add_dependencies" ) - return false; - - if ( func.arguments.size() < 2 ) - return false; - - QList args = func.arguments; - m_target = args.front().value; - - QList::const_iterator it, itEnd = args.constEnd(); - it = args.constBegin() + 1; //skip the first argument since it's the target - for ( ; it != itEnd; ++it ) - { - m_dependencies << it->value; - } - - return true; -} - -AddExecutableAst::AddExecutableAst() -{ - m_isWin32 = false; - m_isOsXBundle = false; - m_excludeFromAll = false; - m_isImported = false; -} - -AddExecutableAst::~AddExecutableAst() -{ -} - -bool AddExecutableAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "add_executable" ) - return false; - - if ( func.arguments.size() < 2 ) - return false; - - QList args = func.arguments; - QList::const_iterator it, itEnd = args.constEnd(); - it = args.constBegin(); - m_executable = it->value; - ++it; - for ( ; it != itEnd; ++it ) - { - if ( it->value == "WIN32" ) - m_isWin32 = true; - else if ( it->value == "MACOSX_BUNDLE" ) - m_isOsXBundle = true; - else if ( it->value == "EXCLUDE_FROM_ALL" ) - m_excludeFromAll = true; - else if ( it->value == "IMPORTED") - m_isImported = true; - else - m_sourceLists.append( it->value ); - } - - if(!m_isImported && m_sourceLists.isEmpty()) - return false; - - return true; - -} - -QMap AddLibraryAst::s_typeForName; -AddLibraryAst::AddLibraryAst() -{ - if(s_typeForName.isEmpty()) { - s_typeForName.insert("STATIC", Static); - s_typeForName.insert("SHARED", Shared); - s_typeForName.insert("MODULE", Module); - s_typeForName.insert("OBJECT", Object); - s_typeForName.insert("UNKNOWN", Unknown); - } - - m_type = Static; - m_isImported = false; - m_excludeFromAll = false; - m_isAlias = false; -} - -AddLibraryAst::~AddLibraryAst() -{ -} - -bool AddLibraryAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "add_library" || func.arguments.isEmpty() ) - return false; - - bool libTypeSet = false; - QList args = func.arguments; - QList::const_iterator it, itEnd = args.constEnd(); - it = args.constBegin(); - m_libraryName = it->value; - ++it; - for(; it != itEnd;) - { - if ( !libTypeSet && s_typeForName.contains(it->value) ) - { - m_type = s_typeForName.value(it->value); - libTypeSet = true; - ++it; - } - else if ( it->value == "IMPORTED") - { - m_isImported = true; - ++it; - } - else if ( it->value == "EXCLUDE_FROM_ALL" ) - { - m_excludeFromAll = true; - ++it; - } - else if ( it->value == "ALIAS") { - m_isAlias = true; - ++it; - if(it==itEnd) - return false; - m_aliasTarget = it->value; - } - else - break; - } - - if ( !m_isImported && !m_isAlias) - { - while ( it != itEnd ) - { - m_sourceLists.append( it->value ); - ++it; - } - - if ( m_sourceLists.isEmpty() ) - return false; - } - return true; - -} -AddSubdirectoryAst::AddSubdirectoryAst() -{ -} - -AddSubdirectoryAst::~AddSubdirectoryAst() -{ -} - -bool AddSubdirectoryAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "add_subdirectory" ) - return false; - if ( func.arguments.size() < 1 || func.arguments[0].value.isEmpty()) - return false; - - m_sourceDir = func.arguments[0].value; - QList::const_iterator it, itEnd = func.arguments.constEnd(); - it = ++func.arguments.constBegin(); - for ( ; it != itEnd; ++it ) - { - if ( it->value == "EXCLUDE_FROM_ALL" ) - m_excludeFromAll = true; - else if ( m_binaryDir.isEmpty() ) - m_binaryDir = it->value; - else - return false; //invalid num of args - } - - return true; -} - -AddTestAst::AddTestAst() -{ -} - -AddTestAst::~AddTestAst() -{ -} - -bool AddTestAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "add_test" ) - return false; - if ( func.arguments.size() < 2 ) - return false; - - QList::const_iterator it, itEnd = func.arguments.constEnd(); - it = func.arguments.constBegin(); - enum {Name, Command, Arg, Unsupported} state = Unsupported; - if (it->value != "NAME") - { - m_testName = (it++)->value; - m_exeName = (it++)->value; - state = Arg; - } - for ( ; it != itEnd; ++it ) - { - if ( it->value == "NAME" ) state = Name; - else if ( it->value == "COMMAND" ) state = Command; - else if ( it->value == "CONFIGURATIONS" || it->value == "WORKING_DIRECTORY" ) state = Unsupported; - else switch (state) { - case Name: - m_testName = it->value; - break; - case Command: - m_exeName = it->value; - state = Arg; - break; - case Arg: - m_testArgs << it->value; - break; - default: - break; - } - } - - return !m_exeName.isEmpty(); -} - -AuxSourceDirectoryAst::AuxSourceDirectoryAst() -{ -} - -AuxSourceDirectoryAst::~AuxSourceDirectoryAst() -{ -} - -bool AuxSourceDirectoryAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "aux_source_directory" ) - return false; - if ( func.arguments.size() != 2 ) - return false; - - m_dirName = func.arguments[0].value; - m_variableName = func.arguments[1].value; - - addOutputArgument(func.arguments[1].value); - return true; -} - -BuildCommandAst::BuildCommandAst() -{ -} - -BuildCommandAst::~BuildCommandAst() -{ -} - -bool BuildCommandAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "build_command" ) - return false; - if ( func.arguments.size() < 2 ) - return false; - - m_variableName = func.arguments[0].value; - m_makeCommand = func.arguments[1].value; - - return true; - -} - -BuildNameAst::BuildNameAst() -{ -} - -BuildNameAst::~BuildNameAst() -{ -} - -bool BuildNameAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "build_name" ) - return false; - if ( func.arguments.size() != 1 ) - return false; - - m_buildName = func.arguments[0].value; - - addOutputArgument(func.arguments[0].value); - return true; -} - -CMakeMinimumRequiredAst::CMakeMinimumRequiredAst() - : m_wrongVersionIsFatal(false) -{ -} - -CMakeMinimumRequiredAst::~CMakeMinimumRequiredAst() -{ -} - -bool CMakeMinimumRequiredAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "cmake_minimum_required" ) - return false; - if ( func.arguments.size() < 2 || func.arguments.count() > 3 || func.arguments.first().value != "VERSION") - return false; - - bool correct = false; - m_version = CMakeParserUtils::parseVersion(func.arguments[1].value, &correct); - if (!correct) - return false; - - if(func.arguments.count()==3) - { - if(func.arguments[2].value=="FATAL_ERROR") - m_wrongVersionIsFatal = true; - else - return false; - } - return true; -} - -ConfigureFileAst::ConfigureFileAst() - : m_copyOnly(false) - , m_escapeQuotes(false) - , m_atsOnly(false) - , m_immediate(false) -{ -} - -ConfigureFileAst::~ConfigureFileAst() -{ -} - - -bool ConfigureFileAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "configure_file" ) - return false; - - if ( func.arguments.size() < 2 ) - return false; - - m_inputFile = func.arguments[0].value; - m_outputFile = func.arguments[1].value; - - QList::const_iterator it, itEnd = func.arguments.constEnd(); - it = func.arguments.constBegin() + 2; - for ( ; it != itEnd; ++it ) - { - CMakeFunctionArgument arg = ( *it ); - if ( arg.value == "COPYONLY" ) - m_copyOnly = true; - else if ( arg.value == "ESCAPE_QUOTES" ) - m_escapeQuotes = true; - else if ( arg.value == "@ONLY" ) - m_atsOnly = true; - else if ( arg.value == "IMMEDIATE" ) - m_immediate = true; - } - - return true; - -} - -CreateTestSourcelistAst::CreateTestSourcelistAst() -{ -} - -CreateTestSourcelistAst::~CreateTestSourcelistAst() -{ -} - - -bool CreateTestSourcelistAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "create_test_sourcelist" ) - return false; - - if ( func.arguments.count() < 3 ) - return false; - - addOutputArgument(func.arguments[0]); - m_name=func.arguments[0].value; - m_driverName=func.arguments[1].value; - - QList::const_iterator it, itEnd = func.arguments.constEnd(); - it = func.arguments.constBegin() + 2; - enum State { Tests, ExtraInclude, Function}; - State s=Tests; - - for(; it!=itEnd; ++it) - { - if(it->value=="EXTRA_INCLUDE") s=ExtraInclude; - else if(it->value=="FUNCTION") s=Function; - else switch(s) { - case Tests: - m_tests.append(it->value); - break; - case ExtraInclude: - m_extraIncludes.append(it->value); - s=Tests; - break; - case Function: - m_function.append(it->value); - s=Tests; - break; - } - } - return !m_tests.isEmpty(); -} - -EnableLanguageAst::EnableLanguageAst() -{ -} - -EnableLanguageAst::~EnableLanguageAst() -{ -} - - -bool EnableLanguageAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "enable_language" ) - return false; - - if ( func.arguments.isEmpty() || func.arguments.count() != 1 ) - return false; - - if ( func.arguments[0].value.isEmpty() ) - return false; - - m_language = func.arguments[0].value; - return true; -} - -EnableTestingAst::EnableTestingAst() -{ -} - -EnableTestingAst::~EnableTestingAst() -{ -} - - -bool EnableTestingAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - return func.name.toLower() == "enable_testing" && func.arguments.isEmpty(); -} - -ExecProgramAst::ExecProgramAst() -{ -} - -ExecProgramAst::~ExecProgramAst() -{ -} - - -bool ExecProgramAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name != "exec_program" || func.arguments.count() == 0 ) - return false; - - m_executableName = func.arguments[0].value; - bool args=false; - - QList::const_iterator it=func.arguments.constBegin(), itEnd=func.arguments.constEnd(); - // don't re-read the first element - ++it; - for(; it!=itEnd; ++it) { - if(it->value=="OUTPUT_VARIABLE") { - ++it; - if(it!=itEnd) - { - addOutputArgument(*it); - m_outputVariable = it->value; - } - else - return false; - } else if(it->value=="RETURN_VALUE") { - ++it; - if(it!=itEnd) - { - addOutputArgument(*it); - m_returnValue = it->value; - } - else - return false; - } - else if(it->value=="ARGS") - { - args=true; - } - else if(args) - { - m_arguments += it->value; - } - else - m_workingDirectory = it->value; - } - return true; -} - -ExecuteProcessAst::ExecuteProcessAst() - : m_timeout(0.f), m_isOutputQuiet(false), m_isErrorQuiet(false), - m_isOutputStrip(false), m_isErrorStrip(false) -{ -} - -ExecuteProcessAst::~ExecuteProcessAst() -{ -} - - -bool ExecuteProcessAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name != "execute_process" || func.arguments.count()<2) - return false; - - enum Action { - None, - Cmd, - WorkDir, - Timeout, - ResultVar, - OutputVar, - ErrorVar, - InputFile, - OutputFile, - ErrorFile - }; - Action act=None; - foreach(const CMakeFunctionArgument &a, func.arguments) { - QString val=a.value.toLower(); - Action actAnt=act; - if(val=="command") { - m_commands.append(QStringList()); - act=Cmd; - } else if(val=="working_directory") - act=WorkDir; - else if(val=="timeout") - act=Timeout; - else if(val=="result_variable") - act=ResultVar; - else if(val=="output_variable") - act=OutputVar; - else if(val=="error_variable") - act=ErrorVar; - else if(val=="input_file") - act=InputFile; - else if(val=="output_file") - act=OutputFile; - else if(val=="error_file") - act=ErrorFile; - else if(val=="output_quiet") - { - m_isOutputQuiet=true; - act=None; - } - else if(val=="error_quiet") - { - m_isErrorQuiet=true; - act=None; - } - else if(val=="output_strip_trailing_whitespace") - { - m_isOutputStrip=true; - act=None; - } - else if(val=="error_strip_trailing_whitespace") - { - m_isErrorStrip=true; - act=None; - } - if(act!=actAnt) - val.clear(); - - switch(act) { - case None: - break; - case Cmd: - if(!val.isEmpty()) - m_commands.last().append(a.value); - break; - case WorkDir: - m_workingDirectory=a.value; - break; - case Timeout: - m_timeout=val.toFloat(); - break; - case ResultVar: - addOutputArgument(a); - m_resultVariable=a.value; - break; - case OutputVar: - addOutputArgument(a); - m_outputVariable=a.value; - break; - case ErrorVar: - addOutputArgument(a); - m_errorVariable=a.value; - break; - case InputFile: - m_inputFile=a.value; - break; - case OutputFile: - m_outputFile=a.value; - break; - case ErrorFile: - m_errorFile=a.value; - break; - } - } - return !m_commands.isEmpty(); -} - -ExportLibraryDepsAst::ExportLibraryDepsAst() - : m_append(false) -{ -} - -ExportLibraryDepsAst::~ExportLibraryDepsAst() -{ -} - - -bool ExportLibraryDepsAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name != "export_library_dependencies" || func.arguments.isEmpty()) - return false; - m_file=func.arguments[0].value; - if(func.arguments.count()>=2) - { - if(func.arguments[1].value=="APPEND") - { - m_append=true; - } - if(func.arguments.count()>(1+m_append)) - return false; - } - return true; -} - -FileAst::FileAst() - : m_type(Write) - , m_isFollowingSymlinks(false) - , m_newlineConsume(false) - , m_noHexConversion(false) -{ -} - -FileAst::~FileAst() -{ -} - - -bool FileAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "file" || func.arguments.count()<2) - return false; - - QString type = func.arguments.first().value; - int min_args=-1; - if(type=="WRITE") { - m_type = Write; - min_args=3; - } else if(type=="APPEND") { - m_type = Append; - min_args=3; - } else if(type=="READ") { - m_type = Read; - min_args=3; - } else if(type=="GLOB") { - m_type = Glob; - min_args=3; - } else if(type=="GLOB_RECURSE") { - m_type = GlobRecurse; - min_args = 3; - } else if(type=="REMOVE") { - m_type = Remove; - min_args=2; - } else if(type=="REMOVE_RECURSE") { - m_type = RemoveRecurse; - min_args=2; - } else if(type=="MAKE_DIRECTORY") { - m_type = MakeDirectory; - min_args=2; - } else if(type=="RELATIVE_PATH") { - m_type = RelativePath; - min_args=4; - } else if(type=="TO_CMAKE_PATH") { - m_type = ToCmakePath; - min_args=3; - } else if(type=="TO_NATIVE_PATH") { - m_type = ToNativePath; - min_args=3; - } else if(type=="STRINGS") { - m_type = Strings; - min_args=3; - } else if(type=="DOWNLOADS") { - m_type = Download; - min_args=3; - } else - return false; - - if(func.arguments.count()::const_iterator it, itEnd; - switch(m_type) { - case Write: - case Append: - m_path = func.arguments[1].value; - m_message = func.arguments[2].value; - break; - case Read: - m_path=func.arguments[1].value; - m_variable = func.arguments[2].value; - addOutputArgument(func.arguments[2]); - break; - case Glob: - addOutputArgument(func.arguments[1]); - m_variable = func.arguments[1].value; - it=func.arguments.constBegin()+2; - itEnd=func.arguments.constEnd(); - - for(; it!=itEnd; ++it) { - if(it->value=="RELATIVE") { - ++it; - if(it==itEnd) - return false; - else - m_path = it->value; - } else - m_globbingExpressions << it->value; - } - break; - case GlobRecurse: - addOutputArgument(func.arguments[1]); - m_variable = func.arguments[1].value; - m_isFollowingSymlinks = false; - it=func.arguments.constBegin()+2; - itEnd=func.arguments.constEnd(); - - for(; it!=itEnd; ++it) { - if(it->value=="RELATIVE") { - ++it; - if(it==itEnd) - return false; - else - m_path = it->value; - } else if(it->value=="FOLLOW_SYMLINKS") { - m_isFollowingSymlinks = true; - } else - m_globbingExpressions << it->value; - } - break; - case Remove: - case RemoveRecurse: - case MakeDirectory: - it=func.arguments.constBegin()+1; - itEnd=func.arguments.constEnd(); - - for(; it!=itEnd; ++it) - m_directories << it->value; - break; - case RelativePath: - addOutputArgument(func.arguments[1]); - m_variable = func.arguments[1].value; - m_directory = func.arguments[2].value; - m_path = func.arguments[3].value; - break; - case ToCmakePath: - case ToNativePath: - addOutputArgument(func.arguments[2]); - m_path = func.arguments[1].value; - m_variable = func.arguments[2].value; - break; - case Download: - m_url=func.arguments[1].value; - m_path=func.arguments[2].value; - it=func.arguments.constBegin()+3; - itEnd=func.arguments.constEnd(); - for(; it!=itEnd; ++it) - { - if(it->value=="STATUS") - { - ++it; - if(it==itEnd) break; - m_variable = it->value; - } - else if(it->value=="LOG") - { - ++it; - if(it==itEnd) break; - m_message = it->value; - } - } - break; - case Strings: - m_path=func.arguments[1].value; - m_variable=func.arguments[2].value; - it=func.arguments.constBegin()+3; - itEnd=func.arguments.constEnd(); - for(; it!=itEnd; ++it) - { - bool corr; - if(it->value=="LIMIT_COUNT") - { - ++it; - if(it==itEnd) break; - m_limitCount = it->value.toInt(&corr); - if(!corr) return false; - } - else if(it->value=="LIMIT_INPUT") - { - ++it; - if(it==itEnd) break; - m_limitInput = it->value.toInt(&corr); - if(!corr) return false; - } - else if(it->value=="LIMIT_OUTPUT") - { - ++it; - if(it==itEnd) break; - m_limitOutput = it->value.toInt(&corr); - if(!corr) return false; - } - else if(it->value=="LENGTH_MINIMUM") - { - ++it; - if(it==itEnd) break; - m_lengthMinimum = it->value.toInt(&corr); - if(!corr) return false; - } - else if(it->value=="LENGTH_MAXIMUM") - { - ++it; - if(it==itEnd) break; - m_lengthMaximum = it->value.toInt(&corr); - if(!corr) return false; - } - else if(it->value=="REGEX") - { - ++it; - if(it==itEnd) break; - m_regex = it->value; - } - else if(it->value=="NEWLINE_CONSUME") - { - m_newlineConsume=true; - } - else if(it->value=="NO_HEX_CONVERSION") - { - m_noHexConversion=true; - } - } - break; - } - return true; -} - -FindFileAst::FindFileAst() - : m_noDefaultPath(false) - , m_noCmakeEnvironmentPath(false) - , m_noCmakePath(false) - , m_noSystemEnvironmentPath(false) - , m_noCmakeSystemPath(false) -{ -} - -FindFileAst::~FindFileAst() -{ -} - - -bool FindFileAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="find_file" || func.arguments.count()<3) - return false; - - bool definedNames=false; - addOutputArgument(func.arguments.first()); - m_variableName = func.arguments.first().value; - Stage s; - QList::const_iterator it=func.arguments.constBegin()+1, itEnd=func.arguments.constEnd(); - if(it->value=="NAMES") { - definedNames = true; - s=NAMES; - } else { - m_filenames=QStringList(it->value); - s=PATHS; - definedNames = false; - } - ++it; - - for(; it!=itEnd; ++it) { - if(it->value=="NO_DEFAULT_PATH") - m_noDefaultPath = true; - else if(it->value=="NO_CMAKE_ENVIRONMENT_PATH") - m_noCmakeEnvironmentPath = true; - else if(it->value=="NO_CMAKE_PATH") - m_noSystemEnvironmentPath = true; - else if(it->value=="DOC") { - ++it; - if(it==itEnd) - return false; - m_documentation = it->value; - } else if(it->value=="PATHS") - s=PATHS; - else if(it->value=="PATH_SUFFIXES") - s=PATH_SUFFIXES; - else if(it->value=="HINTS") - s=HINTS; - else switch(s) { - case NAMES: - m_filenames << it->value; - if(!definedNames) - s=PATHS; - break; - case PATHS: - m_path << it->value; - break; - case PATH_SUFFIXES: - m_pathSuffixes << it->value; - break; - case HINTS: - m_hints << it->value; - break; - } - } - return !m_filenames.isEmpty(); -} - - -MacroCallAst::MacroCallAst() -{ -} - -MacroCallAst::~MacroCallAst() -{ -} - - -bool MacroCallAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.isEmpty()) - return false; - m_name = func.name.toLower(); - - foreach(const CMakeFunctionArgument& fa, func.arguments) - { - m_arguments += fa.value; - } - return true; -} - -FindLibraryAst::FindLibraryAst() - : m_noDefaultPath(false) - , m_noCmakeEnvironmentPath(false) - , m_noCmakePath(false) - , m_noSystemEnvironmentPath(false) - , m_noCmakeSystemPath(false) - , m_noCmakeFindRootPath(false) -{ -} - -FindLibraryAst::~FindLibraryAst() -{ -} - - -bool FindLibraryAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="find_library" || func.arguments.count()<2) - return false; - - bool definedNames=false; - addOutputArgument(func.arguments[0]); - m_variableName = func.arguments[0].value; - Stage s = NAMES; - QList::const_iterator it=func.arguments.constBegin()+1, itEnd=func.arguments.constEnd(); - if(it->value=="NAMES") { - ++it; - definedNames = true; - } else { - m_filenames=QStringList(it->value); - ++it; - s=PATHS; - definedNames = false; - } - - for(; it!=itEnd; ++it) { - if(it->value=="NO_DEFAULT_PATH") - m_noDefaultPath = true; - else if(it->value=="NO_CMAKE_ENVIRONMENT_PATH") - m_noCmakeEnvironmentPath = true; - else if(it->value=="NO_CMAKE_PATH") - m_noSystemEnvironmentPath = true; - else if(it->value=="NO_CMAKE_FIND_ROOT_PATH") - m_noCmakeFindRootPath = true; - else if(it->value=="DOC") { - ++it; - if(it==itEnd) - return false; - m_documentation = it->value; - } else if(it->value=="PATHS") - s=PATHS; - else if(it->value=="PATH_SUFFIXES") - s=PATH_SUFFIXES; - else if(it->value=="HINTS") - s=HINTS; - else switch(s) { - case NAMES: - m_filenames << it->value; - if(!definedNames) - s=PATHS; - break; - case PATHS: - m_path << it->value; - break; - case PATH_SUFFIXES: - m_pathSuffixes << it->value; - break; - case HINTS: - m_hints << it->value; - break; - } - } - return !m_filenames.isEmpty(); -} - -FindPackageAst::FindPackageAst() - : m_isQuiet(false) - , m_noModule(false) - , m_isRequired(false) -{ -} - -FindPackageAst::~FindPackageAst() -{ -} - - -bool FindPackageAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - m_isQuiet=false; - m_noModule=false; - m_isRequired=false; - if ( func.name != "find_package" ) - return false; - - if ( func.arguments.isEmpty() ) - return false; - - m_name = func.arguments[0].value; - QList::const_iterator it=func.arguments.constBegin()+1; - QList::const_iterator itEnd=func.arguments.constEnd(); - - bool ret=true; - enum State { None, Components, Paths }; - State s=None; - for(; it!=itEnd; ++it) - { - if(it->value.isEmpty()) - {} - else if(it->value[0].isNumber()) m_version=it->value; - else if(it->value=="QUIET") m_isQuiet=true; - else if(it->value=="NO_MODULE" || it->value=="CONFIG") m_noModule=true; - else if(it->value=="REQUIRED") { m_isRequired=true; s=Components; } - else if(it->value=="COMPONENTS") s=Components; - else if(it->value=="PATHS") s=Paths; - else if(s==Components) - m_components.append(it->value); - else if(s==Paths) - m_paths.append(it->value); - else { - qWarning() << "found error" << it->value; - ret=false; - } - } - return ret; -} - -FindPathAst::FindPathAst() - : m_noDefaultPath(false) - , m_noCmakeEnvironmentPath(false) - , m_noCmakePath(false) - , m_noSystemEnvironmentPath(false) - , m_noCmakeSystemPath(false) -{ -} - -FindPathAst::~FindPathAst() -{ -} - - -bool FindPathAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="find_path" || func.arguments.count()<2) - return false; - - //FIXME: FIND_PATH(KDE4_DATA_DIR cmake/modules/FindKDE4Internal.cmake ${_data_DIR}) - bool definedNames=false; - addOutputArgument(func.arguments[0]); - m_variableName = func.arguments[0].value; - Stage s = NAMES; - QList::const_iterator it=func.arguments.constBegin()+1, itEnd=func.arguments.constEnd(); - if(it->value=="NAMES") { - ++it; - definedNames = true; - } else { - m_filenames=QStringList(it->value); - ++it; - s=PATHS; - definedNames = false; - } - - for(; it!=itEnd; ++it) { - if(it->value=="NO_DEFAULT_PATH") - m_noDefaultPath = true; - else if(it->value=="NO_CMAKE_ENVIRONMENT_PATH") - m_noCmakeEnvironmentPath = true; - else if(it->value=="NO_CMAKE_PATH") - m_noCmakePath = true; - else if(it->value=="NO_CMAKE_SYSTEM_PATH") - m_noCmakeSystemPath = true; - else if(it->value=="NO_SYSTEM_ENVIRONMENT_PATH") - m_noSystemEnvironmentPath = true; - else if(it->value=="DOC") { - ++it; - if(it==itEnd) - return false; - m_documentation = it->value; - } else if(it->value=="PATHS") - s=PATHS; - else if(it->value=="PATH_SUFFIXES") - s=PATH_SUFFIXES; - else if(it->value=="HINTS") - s=HINTS; - else switch(s) { - case NAMES: - m_filenames << it->value; - if(!definedNames) - s=PATHS; - break; - case PATHS: - m_path << it->value; - break; - case PATH_SUFFIXES: - m_pathSuffixes << it->value; - break; - case HINTS: - m_hints << it->value; - break; - } - } - return !m_filenames.isEmpty(); -} - -FindProgramAst::FindProgramAst() - : m_noDefaultPath(false) - , m_noCmakeEnvironmentPath(false) - , m_noCmakePath(false) - , m_noSystemEnvironmentPath(false) - , m_noCmakeSystemPath(false) - , m_noCMakeFindRootPath(false) -{ -} - -FindProgramAst::~FindProgramAst() -{ -} - - -bool FindProgramAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="find_program" || func.arguments.count()<2) - return false; - - addOutputArgument(func.arguments[0]); - m_variableName = func.arguments[0].value; - Stage s = NAMES; - QList::const_iterator it=func.arguments.constBegin()+1, itEnd=func.arguments.constEnd(); - if(it->value=="NAMES") - ++it; - else { - m_filenames=QStringList(it->value); - s=PATHS; - ++it; - } - - for(; it!=itEnd; ++it) { - if(it->value=="NO_DEFAULT_PATH") - m_noDefaultPath = true; - else if(it->value=="NO_CMAKE_ENVIRONMENT_PATH") - m_noCmakeEnvironmentPath = true; - else if(it->value=="NO_CMAKE_PATH") - m_noCmakePath=true; - else if(it->value=="NO_SYSTEM_ENVIRONMENT_PATH") - m_noSystemEnvironmentPath = true; - else if(it->value=="NO_CMAKE_FIND_ROOT_PATH") - m_noCMakeFindRootPath = true; - else if(it->value=="DOC") { - ++it; - if(it==itEnd) - return false; - m_documentation = it->value; - } else if(it->value=="PATHS") - s=PATHS; - else if(it->value=="PATH_SUFFIXES") - s=PATH_SUFFIXES; - else if(it->value=="HINTS") - s=HINTS; - else switch(s) { - case NAMES: - m_filenames << it->value; - break; - case PATHS: - m_path << it->value; - break; - case PATH_SUFFIXES: - m_pathSuffixes << it->value; - break; - case HINTS: - m_hints << it->value; - break; - } - } - return !m_filenames.isEmpty(); -} - -FltkWrapUiAst::FltkWrapUiAst() -{ -} - -FltkWrapUiAst::~FltkWrapUiAst() -{ -} - - -bool FltkWrapUiAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - Q_UNUSED(func); - return false; -} - -ForeachAst::ForeachAst() - : m_ranges{} - , m_type(Range) -{ -} - -ForeachAst::~ForeachAst() -{ -} - - -bool ForeachAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="foreach" || func.arguments.count()<1) - return false; - addOutputArgument(func.arguments.first()); - m_loopVar=func.arguments.first().value; - if(func.arguments.count()>1 && func.arguments[1].value=="RANGE") { - bool correctStart = true, correctStop = true, correctRange = true; - m_type=Range; - if(func.arguments.count()<3) - return false; - m_ranges.step = 1; - m_ranges.start = 0; - if( func.arguments.count() == 3 ) - { - m_ranges.stop = func.arguments[2].value.toInt(&correctStop); - }else - { - m_ranges.start = func.arguments[2].value.toInt(&correctStart); - m_ranges.stop = func.arguments[3].value.toInt(&correctStop); - } - if(func.arguments.count()==5) - m_ranges.step = func.arguments[4].value.toInt(&correctRange); - if(!correctStart || !correctStop || !correctRange) - return false; - } else { - int incr; - if(func.arguments.count()>1 && func.arguments[1].value=="IN") { - if(func.arguments[2].value=="LISTS") { - m_type = InLists; - } else if(func.arguments[2].value=="ITEMS") { - m_type = InItems; - } else - return false; - incr=3; - } else { - m_type=InItems; - incr=1; - } - QList::const_iterator it=func.arguments.constBegin()+incr, itEnd=func.arguments.constEnd(); - for(; it!=itEnd; ++it) { - m_arguments += it->value; - } - } - return true; -} - -GetCMakePropertyAst::GetCMakePropertyAst() - : m_type(Variables) -{ -} - -GetCMakePropertyAst::~GetCMakePropertyAst() -{ -} - - -bool GetCMakePropertyAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="get_cmake_property" || func.arguments.count()!=2) - return false; - addOutputArgument(func.arguments[0]); - m_variableName = func.arguments[0].value; - - QString type=func.arguments[1].value; - if(type=="VARIABLES") - m_type=Variables; - else if(type=="CACHE_VARIABLES") - m_type=CacheVariables; - else if(type=="COMMANDS") - m_type=Commands; - else if(type=="MACROS") - m_type=Macros; - else if(type=="COMPONENTS") - m_type=Components; - else - return false; - return true; -} - -GetDirPropertyAst::GetDirPropertyAst() -{ -} - -GetDirPropertyAst::~GetDirPropertyAst() -{ -} - - -bool GetDirPropertyAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="get_directory_property" || (func.arguments.count()!=2 && func.arguments.count()!=4)) - return false; - - addOutputArgument(func.arguments[0]); - m_outputVariable = func.arguments[0].value; - int next=1; - if(func.arguments.count()==4) { - if(func.arguments[1].value!="DIRECTORY") - return false; - m_directory=func.arguments[2].value; - next=3; - } - m_propName=func.arguments[next].value; - return true; -} - -GetFilenameComponentAst::GetFilenameComponentAst() - : m_type(Path) - , m_cache(false) -{ -} - -GetFilenameComponentAst::~GetFilenameComponentAst() -{ -} - - -bool GetFilenameComponentAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="get_filename_component" || func.arguments.count()<3) - return false; - addOutputArgument(func.arguments[0]); - m_variableName = func.arguments[0].value; - m_fileName = func.arguments[1].value; - QString t = func.arguments[2].value; - - if(t=="PATH") m_type=Path; - else if(t=="REALPATH") m_type=RealPath; - else if(t=="ABSOLUTE") m_type=Absolute; - else if(t=="NAME") m_type=Name; - else if(t=="EXT") m_type=Ext; - else if(t=="NAME_WE") m_type=NameWe; - else if(t=="PROGRAM") m_type=Program; - else - return false; - - if(m_type==Program) { - //TODO: Did not understand this option - } - - m_cache = func.arguments.last().value=="CACHE"; - return true; -} - -GetSourceFilePropAst::GetSourceFilePropAst() -{ -} - -GetSourceFilePropAst::~GetSourceFilePropAst() -{ -} - - -bool GetSourceFilePropAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="get_source_file_property" || func.arguments.count()!=3) - return false; - addOutputArgument(func.arguments[0]); - m_variableName=func.arguments[0].value; - m_filename=func.arguments[1].value; - m_property=func.arguments[2].value; - return true; -} - -GetTargetPropAst::GetTargetPropAst() -{ -} - -GetTargetPropAst::~GetTargetPropAst() -{ -} - - -bool GetTargetPropAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="get_target_property" || func.arguments.count()!=3) - return false; - addOutputArgument(func.arguments[0]); - m_variableName=func.arguments[0].value; - m_target=func.arguments[1].value; - m_property=func.arguments[2].value; - return true; -} - -GetTestPropAst::GetTestPropAst() -{ -} - -GetTestPropAst::~GetTestPropAst() -{ -} - - -bool GetTestPropAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="get_target_property" || func.arguments.count()!=3) - return false; - addOutputArgument(func.arguments[1]); - m_test=func.arguments[0].value; - m_variableName=func.arguments[1].value; - m_property=func.arguments[2].value; - return true; -} - -IfAst::IfAst() -{ -} - -IfAst::~IfAst() -{ -} - -bool IfAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="if" && func.name.toLower()!="elseif" && func.name.toLower()!="else") - return false; - if(func.name.toLower()=="else" && !func.arguments.isEmpty()) - return false; - - m_kind = func.name; - m_condition.clear(); - foreach(const CMakeFunctionArgument& fa, func.arguments) - { - m_condition += fa.value; - } - return true; -} - -IncludeAst::IncludeAst() - : m_optional(false) -{ -} - -IncludeAst::~IncludeAst() -{ -} - - -bool IncludeAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "include" || (func.arguments.isEmpty() || func.arguments.size() > 4)) - return false; - - m_includeFile = func.arguments[0].value; - - QList::const_iterator it, itEnd; - it=func.arguments.constBegin() + 1; - itEnd = func.arguments.constEnd(); - - bool nextIsResult=false; - for ( ; it != itEnd; ++it ) { - if(nextIsResult) - { - m_resultVariable=it->value; - addOutputArgument( *it ); - nextIsResult=false; - } - else if ( it->value == "OPTIONAL" ) - m_optional = true; - else if( it->value == "RESULT_VARIABLE" ) - nextIsResult=true; - } - - return !m_includeFile.isEmpty(); -} - -IncludeDirectoriesAst::IncludeDirectoriesAst() - : m_includeType(Default) - , m_isSystem(false) -{ -} - -IncludeDirectoriesAst::~IncludeDirectoriesAst() -{ -} - - -bool IncludeDirectoriesAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "include_directories" || func.arguments.isEmpty() ) - return false; - - int i=0; - m_includeType = Default; - m_isSystem = false; - - if(func.arguments.first().value=="AFTER") { - m_includeType = After; - i++; - } else if(func.arguments.first().value=="BEFORE") { - m_includeType = Before; - i++; - } - - if(i::const_iterator it=func.arguments.constBegin() + i; - QList::const_iterator itEnd = func.arguments.constEnd(); - - for ( ; it != itEnd; ++it ) - m_includedDirectories.append(it->value); - - return true; -} - -IncludeExternalMsProjectAst::IncludeExternalMsProjectAst() -{ -} - -IncludeExternalMsProjectAst::~IncludeExternalMsProjectAst() -{ -} - - -bool IncludeExternalMsProjectAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - Q_UNUSED(func); - return false; -} - -IncludeRegularExpressionAst::IncludeRegularExpressionAst() -{ -} - -IncludeRegularExpressionAst::~IncludeRegularExpressionAst() -{ -} - - -bool IncludeRegularExpressionAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "include_regular_expression" || func.arguments.isEmpty() || func.arguments.count()>2 ) - return false; - m_match=func.arguments[0].value; - if(func.arguments.count()==2) - m_complain=func.arguments[1].value; - return true; -} - -InstallAst::InstallAst() -{ -} - -InstallAst::~InstallAst() -{ -} - - -bool InstallAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - Q_UNUSED(func); - return false; -} - -InstallFilesAst::InstallFilesAst() -{ -} - -InstallFilesAst::~InstallFilesAst() -{ -} - - -bool InstallFilesAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()=="install_files" || func.arguments.count()<2) - return false; - m_directory=func.arguments[0].value; - if(func.arguments.count()==2) - { - m_regex=func.arguments[1].value; - } - else - { - QList::const_iterator it, itEnd=func.arguments.constEnd(); - if(func.arguments[1].value!="FILES") - m_extension=func.arguments[1].value; - for(it=func.arguments.constBegin()+2; it!=itEnd; ++it) - { - m_files.append(it->value); - } - } - return !m_files.isEmpty() || !m_regex.isEmpty(); -} - -InstallProgramsAst::InstallProgramsAst() -{ -} - -InstallProgramsAst::~InstallProgramsAst() -{ -} - - -bool InstallProgramsAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()=="install_programs" || func.arguments.count()<2) - return false; - m_directory=func.arguments[0].value; - if(func.arguments.count()==2) - { - m_regex=func.arguments[1].value; - } - else - { - QList::const_iterator it, itEnd=func.arguments.constEnd(); - int firstpos=1; - if(func.arguments[1].value!="FILES") - firstpos++; - for(it=func.arguments.constBegin()+firstpos; it!=itEnd; ++it) - { - m_files.append(it->value); - } - } - return !m_files.isEmpty() || !m_regex.isEmpty(); -} - -InstallTargetsAst::InstallTargetsAst() -{ -} - -InstallTargetsAst::~InstallTargetsAst() -{ -} - - -bool InstallTargetsAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()=="install_targets" || func.arguments.count()<2) - return false; - m_directory=func.arguments[0].value; - QList::const_iterator it, itEnd=func.arguments.constEnd(); - int firstpos=1; - if(func.arguments[1].value=="RUNTIME_DIRECTORY") - { - firstpos+=2; - if(func.arguments.count()<3) - return false; - m_runtimeDir=func.arguments[2].value; - } - for(it=func.arguments.constBegin()+firstpos; it!=itEnd; ++it) - { - m_targets.append(it->value); - } - return !m_targets.isEmpty(); -} - -LinkDirectoriesAst::LinkDirectoriesAst() -{ -} - -LinkDirectoriesAst::~LinkDirectoriesAst() -{ -} - - -bool LinkDirectoriesAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "link_directories" || func.arguments.isEmpty() ) - return false; - - foreach(const CMakeFunctionArgument &arg, func.arguments) - m_directories.append(arg.value); - return true; -} - -LinkLibrariesAst::LinkLibrariesAst() -{ -} - -LinkLibrariesAst::~LinkLibrariesAst() -{ -} - - -bool LinkLibrariesAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "link_libraries" || func.arguments.isEmpty() ) - return false; - - QString lastLib; - foreach(const CMakeFunctionArgument &arg, func.arguments) - { - BuildType current=None; - if(arg.value=="debug") - current=Debug; - else if(arg.value=="optimized") - current=Optimized; - else - { - if(!lastLib.isEmpty()) - m_libraries.append(LibraryType(lastLib, None)); - lastLib=arg.value; - } - if(current!=None) - m_libraries.append(LibraryType(lastLib, current)); - } - return true; -} - -ListAst::ListAst() - : m_type(Length) -{ -} - -ListAst::~ListAst() -{ -} - - -bool ListAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "list" ) - return false; - if ( func.arguments.size() < 2) - return false; - - QString argName = func.arguments.first().value; - if(argName=="LENGTH") - m_type = Length; - else if(argName=="GET") - m_type=Get; - else if(argName=="APPEND") - m_type = Append; - else if(argName=="FIND") - m_type = Find; - else if(argName=="INSERT") - m_type = Insert; - else if(argName=="REMOVE_ITEM") - m_type = RemoveItem; - else if(argName=="REMOVE_AT") - m_type = RemoveAt; - else if(argName=="SORT") - m_type = Sort; - else if(argName=="REVERSE") - m_type = Reverse; - else if(argName=="REMOVE_DUPLICATES") - m_type = RemoveDuplicates; - else - return false; - - m_list = func.arguments[1].value; - switch(m_type) - { - case Length: - if(func.arguments.count()!=3) - return false; - m_output = func.arguments[2].value; - addOutputArgument(func.arguments[2]); - break; - case Get: { - if(func.arguments.count()<3) - return false; - - addOutputArgument(func.arguments[1]); - addOutputArgument(func.arguments.last()); - - m_output = func.arguments.last().value; - - QList::const_iterator it=func.arguments.constBegin()+2, itEnd=func.arguments.constEnd(); - int i=2; - bool correct; - for(; it!=itEnd; ++it) - { - if(i!=func.arguments.size()-1) { - m_index.append(it->value.toInt(&correct)); - if(!correct) - return false; - } - i++; - } - } break; - case Append: { - if(func.arguments.count()<2) - return false; - - addOutputArgument(func.arguments[1]); - m_output = func.arguments[1].value; - int i=0; - foreach(const CMakeFunctionArgument& arg, func.arguments) - { - if(i>1) - m_elements.append(arg.value); - i++; - } - } break; - case Find: { - if(func.arguments.count()!=4) - return false; - m_elements.append(func.arguments[2].value); - m_output=func.arguments[3].value; - - addOutputArgument(func.arguments[3]); - } break; - case Insert: { - bool correct; - if(func.arguments.count()<4) - return false; - int i=0; - addOutputArgument(func.arguments[1]); - m_index.append(func.arguments[2].value.toInt(&correct)); - if(!correct) - return false; - foreach(const CMakeFunctionArgument& arg, func.arguments) - { - if(i>2) - m_elements.append(arg.value); - i++; - } - } break; - case RemoveItem: { - if(func.arguments.count()<3) - return false; - addOutputArgument(func.arguments[1]); - m_output = func.arguments[1].value; - - QList::const_iterator it=func.arguments.constBegin()+2, itEnd=func.arguments.constEnd(); - for(; it!=itEnd; ++it) - { - m_elements.append(it->value); - } - } break; - case RemoveAt: { - if(func.arguments.count()<3) - return false; - addOutputArgument(func.arguments[1]); - m_output = func.arguments[1].value; - int i=0; - foreach(const CMakeFunctionArgument& arg, func.arguments) - { - if(i>1) - { - bool correct; - m_index.append(arg.value.toInt(&correct)); - qCDebug(CMAKE) << "???" << arg.value; - if(!correct) return false; - } - i++; - } - } break; - case Sort: - case Reverse: - case RemoveDuplicates: - addOutputArgument(func.arguments[1]); - m_output = func.arguments[1].value; - if(func.arguments.count()>2) - return false; - break; - } - return true; -} - -LoadCacheAst::LoadCacheAst() -{ -} - -LoadCacheAst::~LoadCacheAst() -{ -} - - -bool LoadCacheAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "load_cache" || func.arguments.count()<4) - return false; - m_cachePath=func.arguments[0].value; - if(func.arguments[1].value=="READ_WITH_PREFIX") - { - QString prefix; - QList::const_iterator it, itEnd = func.arguments.constEnd(); - for ( it = func.arguments.constBegin() + 2; it != itEnd; ++it ) - { - if(prefix.isEmpty()) - { - prefix=it->value; - } - else - { - m_prefixes=PrefixEntry(prefix, it->value); - prefix.clear(); - } - } - return prefix.isEmpty(); - } - else - { - bool exclude=false; - QList::const_iterator it, itEnd = func.arguments.constEnd(); - for ( it = func.arguments.constBegin() + 2; it != itEnd; ++it ) - { - if(it->value=="EXCLUDE") - exclude=true; - else if(it->value=="INCLUDE_INTERNALS") - exclude=false; - else - { - if(exclude) - m_exclude.append(it->value); - else - m_includeInternals.append(it->value); - } - } - return true; - } - return false; -} - -LoadCommandAst::LoadCommandAst() -{ -} - -LoadCommandAst::~LoadCommandAst() -{ -} - - -bool LoadCommandAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "load_command" || func.arguments.count()<4) - return false; - m_cmdName=func.arguments[0].value; - - QList::const_iterator it, itEnd = func.arguments.constEnd(); - for ( it = func.arguments.constBegin() + 1; it != itEnd; ++it ) - m_location.append( it->value ); - return !m_location.isEmpty(); -} - -MacroAst::MacroAst() -{ -} - -MacroAst::~MacroAst() -{ -} - - -bool MacroAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "macro" || func.arguments.isEmpty()) - return false; - - m_macroName = func.arguments.first().value.toLower(); - QList::const_iterator it, itEnd = func.arguments.end(); - for ( it = func.arguments.begin() + 1; it != itEnd; ++it ) - m_knownArgs.append( it->value ); - - return !m_macroName.isEmpty(); -} - -FunctionAst::FunctionAst() -{ -} - -FunctionAst::~FunctionAst() -{ -} - - -bool FunctionAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "function" || func.arguments.isEmpty()) - return false; - - m_name = func.arguments.first().value.toLower(); - QList::const_iterator it, itEnd = func.arguments.end(); - for ( it = func.arguments.begin() + 1; it != itEnd; ++it ) - m_knownArgs.append( it->value ); - - return true; -} - -MakeDirectoryAst::MakeDirectoryAst() -{ -} - -MakeDirectoryAst::~MakeDirectoryAst() -{ -} - - -bool MakeDirectoryAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "make_directory" || func.arguments.isEmpty() || func.arguments.size()>1) - return false; - m_directory=func.arguments.first().value; - return true; -} - -MarkAsAdvancedAst::MarkAsAdvancedAst() - : m_isClear(false) - , m_isForce(false) -{ -} - -MarkAsAdvancedAst::~MarkAsAdvancedAst() -{ -} - - - -bool MarkAsAdvancedAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "mark_as_advanced" || func.arguments.isEmpty() ) - return false; - - m_isClear = func.arguments[0].value == "CLEAR"; - m_isForce = func.arguments[0].value == "FORCE"; - - if ( (m_isClear || m_isForce) && func.arguments.size() < 2 ) - return false; - - QList::const_iterator it, itEnd; - it=func.arguments.begin(); - itEnd = func.arguments.end(); - - if(m_isClear || m_isForce) - ++it; - - for ( ; it != itEnd; ++it ) - { - m_advancedVars.append(it->value); - } - - return true; -} - -MathAst::MathAst() -{ -} - -MathAst::~MathAst() -{ -} - - -bool MathAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="math" || func.arguments.count()!=3 || func.arguments.first().value!="EXPR") - return false; - - addOutputArgument(func.arguments[1]); - m_outputVariable = func.arguments[1].value; - m_expression = func.arguments.last().value; - return true; -} - -MessageAst::MessageAst() - : m_type(SendError) -{ -} - -MessageAst::~MessageAst() -{ -} - - -bool MessageAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="message" || func.arguments.isEmpty()) - return false; - if(func.arguments.count()>1) { - QString type=func.arguments.first().value; - if(type=="SEND_ERROR") - m_type=SendError; - else if(type=="STATUS") - m_type=Status; - else if(type=="FATAL_ERROR") - m_type=FatalError; - } - - m_message.append(func.arguments.last().value); //Maybe should do a foreach - return true; -} - -OptionAst::OptionAst() -{ -} - -OptionAst::~OptionAst() -{ -} - - -bool OptionAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="option" || func.arguments.count()<2 || func.arguments.count()>3) - return false; - m_variableName = func.arguments[0].value; - m_description = func.arguments[1].value; - m_defaultValue = "OFF"; - if(func.arguments.count() ==3) - m_defaultValue = func.arguments[2].value; - return true; -} - -OutputRequiredFilesAst::OutputRequiredFilesAst() -{ -} - -OutputRequiredFilesAst::~OutputRequiredFilesAst() -{ -} - - -bool OutputRequiredFilesAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="output_required_files" || func.arguments.count()!=2) - return false; - m_srcFile=func.arguments[0].value; - m_outputFile=func.arguments[1].value; - return true; -} - -ProjectAst::ProjectAst() - : m_useCpp(false) - , m_useC(false) - , m_useJava(false) -{ -} - -ProjectAst::~ProjectAst() -{ -} - - -bool ProjectAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "project" ) - return false; - - if ( func.arguments.size() < 1 ) - return false; - - m_projectName = func.arguments[0].value; - - QList::const_iterator it, itEnd = func.arguments.end(); - for ( it = func.arguments.begin()+1; it != itEnd; ++it ) - { - CMakeFunctionArgument arg = ( *it ); - if ( arg.value == "CXX" ) - m_useCpp = true; - else if ( arg.value == "C" ) - m_useC = true; - else if ( arg.value == "Java" ) - m_useJava = true; - else - return false; - } - - return true; -} - -QtWrapCppAst::QtWrapCppAst() -{ -} - -QtWrapCppAst::~QtWrapCppAst() -{ -} - - -bool QtWrapCppAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - Q_UNUSED(func); - return false; -} - -QtWrapUiAst::QtWrapUiAst() -{ -} - -QtWrapUiAst::~QtWrapUiAst() -{ -} - - -bool QtWrapUiAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - Q_UNUSED(func); - return false; -} - -RemoveAst::RemoveAst() -{ -} - -RemoveAst::~RemoveAst() -{ -} - - -bool RemoveAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "remove" || func.arguments.isEmpty()) - return false; - - m_variableName = func.arguments[0].value; - - QList::const_iterator it, itEnd = func.arguments.end(); - for ( it = func.arguments.begin()+1; it != itEnd; ++it ) - { - m_values.append(it->value); - } - return !m_values.isEmpty(); -} - -RemoveDefinitionsAst::RemoveDefinitionsAst() -{ -} - -RemoveDefinitionsAst::~RemoveDefinitionsAst() -{ -} - - -bool RemoveDefinitionsAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "remove_definitions") - return false; - - QList::const_iterator it, itEnd = func.arguments.end(); - for ( it = func.arguments.begin(); it != itEnd; ++it ) - { - m_definitions.append(it->value); - } - return !m_definitions.isEmpty(); -} - -SeparateArgumentsAst::SeparateArgumentsAst() -{ -} - -SeparateArgumentsAst::~SeparateArgumentsAst() -{ -} - -/// @todo Parse the UNIX_COMMAND and WINDOWS_COMMAND keywords -/// introduced in CMake 2.8. -bool SeparateArgumentsAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "separate_arguments" || func.arguments.count()!=1) - return false; - - addOutputArgument(func.arguments.first()); - m_variableName=func.arguments.first().value; - return true; -} - -SetAst::SetAst() - : m_storeInCache(false) - , m_forceStoring(false) - , m_parentScope(false) -{ -} - -SetAst::~SetAst() -{ -} - - -bool SetAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "set" || func.arguments.isEmpty() ) - return false; - - m_variableName = func.arguments.first().value; - addOutputArgument(func.arguments.first()); - - int argSize = func.arguments.size(); - - //look for the FORCE argument. Thanks to the CMake folks for letting - //me read their code - m_forceStoring = ( argSize > 4 && func.arguments.last().value == "FORCE" ); - m_parentScope = ( argSize > 1 && func.arguments.last().value == "PARENT_SCOPE" ); - m_storeInCache = ( argSize > 3 && - func.arguments[argSize - 3 - ( m_forceStoring || m_parentScope ? 1 : 0 )].value == "CACHE" ); - - int numCacheArgs = ( m_storeInCache ? 3 : 0 ); - int numForceArgs = ( m_forceStoring ? 1 : 0 ); - int numParentScope = ( m_parentScope ? 1 : 0 ); - if ( argSize > 1 + numCacheArgs + numForceArgs + numParentScope ) - { - QList args = func.arguments; - QList::const_iterator it, itEnd; - it = args.constBegin() + 1; - itEnd = args.constEnd() - numCacheArgs - numForceArgs - numParentScope; - for ( ; it != itEnd; ++it ) - m_values.append( it->value ); - } - - //catch some simple things. if CACHE is the last or next to last arg or if - //FORCE was used without CACHE, then there's a problem. - if ( func.arguments.last().value == "CACHE" || - ( argSize > 1 && func.arguments[argSize - 2].value == "CACHE" ) || - (m_forceStoring && !m_storeInCache) ) - { - return false; - } - if((m_storeInCache || m_forceStoring) && m_parentScope) - return false; - if(func.arguments.last().value=="FORCE" && !m_forceStoring) - return false; - - return true; -} - -SetDirectoryPropsAst::SetDirectoryPropsAst() -{ -} - -SetDirectoryPropsAst::~SetDirectoryPropsAst() -{ -} - - -bool SetDirectoryPropsAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="set_directory_properties" || func.arguments.count()<3) - return false; - if(func.arguments.first().value!="PROPERTIES") - return false; - - QList::const_iterator it=func.arguments.begin()+1; - QList::const_iterator itEnd=func.arguments.end(); - - for(; it!=itEnd; ++it) - { - QString prop=it->value; - ++it; - - if(it==itEnd) - return false; - - m_properties.append(PropPair(prop, it->value)); - } - return !m_properties.isEmpty(); -} - -SetSourceFilesPropsAst::SetSourceFilesPropsAst() -{ -} - -SetSourceFilesPropsAst::~SetSourceFilesPropsAst() -{ -} - - -bool SetSourceFilesPropsAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="set_source_files_properties" || func.arguments.count()<4) - return false; - bool props=false; - - QList::const_iterator it=func.arguments.begin(); - QList::const_iterator itEnd=func.arguments.end(); - QString prop; - for(; it!=itEnd; ++it) - { - if(it->value=="PROPERTIES") - { - props=true; - continue; - } - if(!props) - { - m_files.append(it->value); - } - else - { - if(prop.isEmpty()) - prop=it->value; - else - { - m_properties.append(PropPair(prop, it->value)); - prop.clear(); - } - } - } - return prop.isEmpty(); -} - -SetTargetPropsAst::SetTargetPropsAst() -{ -} - -SetTargetPropsAst::~SetTargetPropsAst() -{ -} - - -bool SetTargetPropsAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="set_target_properties" || func.arguments.count()<4) - return false; - bool props=false; - - QList::const_iterator it=func.arguments.begin(); - QList::const_iterator itEnd=func.arguments.end(); - QString prop; - for(; it!=itEnd; ++it) - { - if(it->value=="PROPERTIES") - { - props=true; - continue; - } - if(!props) - { - m_targets.append(it->value); - } - else - { - if(prop.isEmpty()) - prop=it->value; - else - { - m_properties.append(PropPair(prop, it->value)); - prop.clear(); - } - } - } - return prop.isEmpty(); -} - -SetTestsPropsAst::SetTestsPropsAst() -{ -} - -SetTestsPropsAst::~SetTestsPropsAst() -{ -} - - -bool SetTestsPropsAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="set_tests_properties" || func.arguments.count()<4) - return false; - bool props=false; - - QList::const_iterator it=func.arguments.begin(); - QList::const_iterator itEnd=func.arguments.end(); - QString prop; - for(; it!=itEnd; ++it) - { - if(it->value=="PROPERTIES") - { - props=true; - continue; - } - if(!props) - { - m_tests.append(it->value); - } - else - { - if(prop.isEmpty()) - prop=it->value; - else - { - m_properties.append(PropPair(prop, it->value)); - prop.clear(); - } - } - } - return prop.isEmpty(); -} - -SiteNameAst::SiteNameAst() -{ -} - -SiteNameAst::~SiteNameAst() -{ -} - - -bool SiteNameAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="site_name" || func.arguments.count()!=1) - return false; - addOutputArgument(func.arguments.first()); - m_variableName = func.arguments.first().value; - return true; -} - -SourceGroupAst::SourceGroupAst() -{ -} - -SourceGroupAst::~SourceGroupAst() -{ -} - - -bool SourceGroupAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="source_group" || func.arguments.count()>1) - return false; - - m_name=func.arguments[0].value; - QList::const_iterator it=func.arguments.begin()+1; - QList::const_iterator itEnd=func.arguments.end(); - enum Param { None, Regex, Files }; - Param current=None; - for(; it!=itEnd; ++it) - { - if(it->value=="REGULAR_EXPRESSION") - current=Regex; - else if(it->value=="FILES") - current=Files; - else switch(current) - { - case Regex: - m_regex=it->value; - case Files: - m_files.append(it->value); - break; - case None: - return false; - } - } - return !m_regex.isEmpty() || !m_files.isEmpty(); -} - -StringAst::StringAst() - : m_type(Regex) - , m_cmdType(Match) - , m_only(false) - , m_escapeQuotes(false) - , m_begin(0) - , m_length(0) -{ -} - -StringAst::~StringAst() -{ -} - - -bool StringAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="string" || func.arguments.count()<2) - return false; - QString stringType=func.arguments[0].value; - if(stringType=="REGEX") - { - if(func.arguments.count()<5) - return false; - m_type=Regex; - QString regexType = func.arguments[1].value; - - int outpos=3; - if(regexType=="MATCH") m_cmdType=Match; - else if(regexType=="MATCHALL") m_cmdType=MatchAll; - else if(regexType=="REPLACE") { - m_cmdType=RegexReplace; - m_replace=func.arguments[3].value; - outpos=4; - } - - m_regex = func.arguments[2].value; - addOutputArgument(func.arguments[outpos]); - m_outputVariable = func.arguments[outpos].value; - - QList::const_iterator it=func.arguments.begin()+outpos+1; - QList::const_iterator itEnd=func.arguments.end(); - for(; it!=itEnd; ++it) - { - m_input += it->value; - } - qCDebug(CMAKE) << "performing REGEX" << regexType << " : " << m_regex << " > "<< m_outputVariable << "result: "; - } - else if(stringType=="REPLACE") - { - if(func.arguments.count()<4) - return false; - - m_type=Replace; - m_regex = func.arguments[1].value; - m_replace=func.arguments[2].value; - m_outputVariable = func.arguments[3].value; - addOutputArgument(func.arguments[3]); - - QList::const_iterator it=func.arguments.begin()+4, itEnd=func.arguments.end(); - for(; it!=itEnd; ++it) - { - m_input += it->value; - } - } - else if(stringType=="COMPARE") - { - if(func.arguments.count()!=5) - return false; - m_type=Compare; - QString argumentType=func.arguments[1].value; - if(argumentType=="EQUAL") m_cmdType=Equal; - else if(argumentType=="NOTEQUAL") m_cmdType=NotEqual; - else if(argumentType=="LESS") m_cmdType=Less; - else if(argumentType=="GREATER") m_cmdType=Greater; - - m_input.append(func.arguments[2].value); - m_input.append(func.arguments[3].value); - m_outputVariable = func.arguments[4].value; - addOutputArgument(func.arguments[4]); - } - else if(stringType=="ASCII") - { - m_type=Ascii; - QList::const_iterator it=func.arguments.begin()+1; - QList::const_iterator itEnd=func.arguments.end(); - for(; it!=itEnd; ++it) - { - m_input += it->value; - } - m_input.pop_back(); //We remove the output var - m_outputVariable = func.arguments.last().value; - addOutputArgument(func.arguments.last()); - } - else if(stringType=="CONFIGURE") - { - m_type=Configure; - if(func.arguments.isEmpty()) - return false; - m_input += func.arguments[1].value; - m_outputVariable=func.arguments[2].value; - addOutputArgument(func.arguments[2]); - - int i=3; - if(func.arguments.count()>i) m_only = func.arguments[i].value=="@ONLY"; - if(m_only) i++; - if(func.arguments.count()>i) m_escapeQuotes = func.arguments[i].value=="ESCAPE_QUOTES"; - } - else if(stringType=="TOUPPER" && func.arguments.count()==3) - { - m_type=ToUpper; - m_input.append(func.arguments[1].value); - m_outputVariable = func.arguments[2].value; - addOutputArgument(func.arguments[2]); - } - else if(stringType=="TOLOWER" && func.arguments.count()==3) - { - m_type=ToLower; - m_input.append(func.arguments[1].value); - m_outputVariable = func.arguments[2].value; - addOutputArgument(func.arguments[2]); - } - else if(stringType=="LENGTH" && func.arguments.count()==3) - { - m_type=Length; - m_input.append(func.arguments[1].value); - m_outputVariable = func.arguments[2].value; - addOutputArgument(func.arguments[2]); - } - else if(stringType=="SUBSTRING") - { - if(func.arguments.count()<5) - return false; - bool correctBegin, correctLength; - m_type=Substring; - m_input.append(func.arguments[1].value); - m_begin = func.arguments[2].value.toInt(&correctBegin); - m_length = func.arguments[3].value.toInt(&correctLength); - m_outputVariable = func.arguments[4].value; - addOutputArgument(func.arguments[4]); - if(!correctBegin || !correctLength) - return false; - } - else if(stringType=="STRIP") - { - m_type=Strip; - if(func.arguments.count()!=3) - return false; - m_string = func.arguments[1].value; - m_outputVariable = func.arguments.last().value; - addOutputArgument(func.arguments.last()); - } - else if(stringType=="RANDOM") - { - if(func.arguments.count()>6 || func.arguments.count()<2) - return false; - m_type=Random; - enum State { Alphabet, Length, None }; - State s = None; - m_length=5; - m_string="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; - bool first=true; - - foreach(const CMakeFunctionArgument& arg, func.arguments) - { - if(first) { first=false; continue; } - - bool correct=true; - switch(s) { - case Alphabet: - m_regex=arg.value; - s=None; - continue; - case Length: - m_length = arg.value.toInt(&correct); - if(!correct) return false; - s=None; - continue; - case None: - break; - } - - if(arg.value=="LENGTH") - s = Length; - else if(arg.value=="ALPHABET") - s = Alphabet; - else - { - s=None; - if(!m_outputVariable.isEmpty()) - { - return false; - } - m_outputVariable = arg.value; - addOutputArgument(arg); - } - } - } - else - return false; - return true; -} - -SubdirDependsAst::SubdirDependsAst() -{ -} - -SubdirDependsAst::~SubdirDependsAst() -{ -} - - -bool SubdirDependsAst::parseFunctionInfo( const CMakeFunctionDesc& func) -{ - if ( func.name != "subdir_depends" || func.arguments.isEmpty()) - return false; - - return true; -} - -SubdirsAst::SubdirsAst() : m_preorder(false) -{ -} - -SubdirsAst::~SubdirsAst() -{ -} - - -bool SubdirsAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "subdirs" ) - return false; - - if ( func.arguments.isEmpty() ) - return false; - - bool excludeFromAll=false; - foreach(const CMakeFunctionArgument& arg, func.arguments) - { - if(arg.value.toLower()=="exclude_from_all") - excludeFromAll=true; - else if(arg.value.toLower()=="preorder") - m_preorder=true; - else { - if(excludeFromAll) - m_exluceFromAll.append(arg.value); - else - m_directories.append(arg.value); - } - } - return true; -} - -TargetIncludeDirectoriesAst::TargetIncludeDirectoriesAst() - : m_before(false) -{} - -TargetIncludeDirectoriesAst::~TargetIncludeDirectoriesAst() -{} - -bool TargetIncludeDirectoriesAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "target_include_directories" ) - return false; - - //we don't do variable expansion when parsing like CMake does, so we - //need to have at least two arguments for target_link_libraries - if ( func.arguments.size() < 2 ) - return false; - - m_target = func.arguments[0].value; - - QList::const_iterator it = func.arguments.constBegin() + 1; - QList::const_iterator itEnd = func.arguments.constEnd(); - - m_before = func.arguments[1].value == "BEFORE"; - if(m_before) { - ++it; - } - - Item currentItem; - for ( ; it != itEnd; ++it ) - { - QString visibility = it->value; - if(visibility == "INTERFACE") - currentItem.visibility = Interface; - else if(visibility == "PUBLIC") - currentItem.visibility = Public; - else if(visibility == "PRIVATE") - currentItem.visibility = Private; - else - return false; - ++it; - if(it==itEnd) - return false; - - currentItem.item = it->value; - m_items.append(currentItem); - } - - return !m_items.isEmpty(); -} - -TargetLinkLibrariesAst::TargetLinkLibrariesAst() -{ -} - -TargetLinkLibrariesAst::~TargetLinkLibrariesAst() -{ -} - - -bool TargetLinkLibrariesAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "target_link_libraries" ) - return false; - - //we don't do variable expansion when parsing like CMake does, so we - //need to have at least two arguments for target_link_libraries - if ( func.arguments.size() < 2 ) - return false; - - m_target = func.arguments[0].value; - - Dependencies* current = &m_publicDependencies; - - QList::const_iterator it, itEnd; - for (it = func.arguments.begin() + 1, itEnd = func.arguments.end(); it != itEnd; ++it ) - { - CMakeFunctionArgument arg = ( *it ); - if ( arg.value == "LINK_PUBLIC" || arg.value == "PUBLIC" ) - { - current = &m_publicDependencies; - continue; - } - else if ( arg.value == "LINK_PRIVATE" || arg.value == "PRIVATE" ) - { - current = &m_privateDependencies; - continue; - } - else if ( arg.value == "LINK_INTERFACE_LIBRARIES") - { - current = &m_interfaceOnlyDependencies; - continue; - } - else if ( arg.value == "debug" ) - { - ++it; - if ( it == itEnd ) - return false; - else - current->debug.append( it->value ); - } - else if ( arg.value == "optimized" ) - { - ++it; - if ( it == itEnd ) - return false; - else - current->optimized.append( it->value ); - } - else - current->other.append( arg.value ); - } - - return true; -} - -QStringList TargetLinkLibrariesAst::Dependencies::retrieveTargets() const -{ - return debug + optimized + other; -} - -TryCompileAst::TryCompileAst() -{ -} - -TryCompileAst::~TryCompileAst() -{ -} - - -bool TryCompileAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if ( func.name != "try_compile" || func.arguments.size() < 3) - return false; - m_resultName=func.arguments[0].value; - m_binDir=func.arguments[1].value; - m_source=func.arguments[2].value; - - enum Param { None, CMakeFlags, CompileDefinitions, OutputVariable, CopyFile }; - - Param current=None; - QList::const_iterator it, itEnd; - it = func.arguments.begin() + 3; - itEnd = func.arguments.end(); - - //FIXME: Should look for errors - for ( ; it != itEnd; ++it ) - { - if(it->value=="CMAKE_FLAGS") current=CMakeFlags; - else if(it->value=="COMPILE_DEFINITIONS") current=CompileDefinitions; - else if(it->value=="OUTPUT_VARIABLE") current=OutputVariable; - else if(it->value=="COPY_FILE") current=OutputVariable; - else switch(current) - { - case None: - if(m_projectName.isEmpty()) - m_projectName=it->value; - else - m_targetName=it->value; - current=None; - break; - case CMakeFlags: - m_cmakeFlags.append(it->value); - break; - case CompileDefinitions: - m_compileDefinitions.append(it->value); - break; - case OutputVariable: - m_outputName=it->value; - addOutputArgument(*it); - current=None; - break; - case CopyFile: - m_copyFile=it->value; - current=None; - break; - } - } - - return true; -} - -TryRunAst::TryRunAst() -{ -} - -TryRunAst::~TryRunAst() -{ -} - - -bool TryRunAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="try_run" || func.arguments.count()<4) - return false; - - enum Actions { None, CMakeFlags, CompileDefs, OutputVariable, Args }; - Actions act = None; - unsigned int i=0; - foreach(const CMakeFunctionArgument& arg, func.arguments) { - QString val=arg.value.toLower(); - if(i<4) - act=None; - - if(i==0) - m_runResultVar=arg.value; - else if(i==1) - { - addOutputArgument(arg); - m_compileResultVar=arg.value; - } - else if(i==2) - m_binDir=arg.value; - else if(i==3) - m_srcFile=arg.value; - else if(val=="cmake_flags") - act=CMakeFlags; - else if(val=="compile_definitions") - act=CompileDefs; - else if(val=="output_variable") - act=OutputVariable; - else if(val=="args") - act=Args; - else switch(act) { - case None: - return false; - case CMakeFlags: - m_cmakeFlags.append(arg.value); - break; - case CompileDefs: - m_compileDefs.append(arg.value); - case OutputVariable: - m_outputVar=arg.value; - break; - case Args: - m_args.append(arg.value); - break; - } - i++; - } - return true; -} - -UseMangledMesaAst::UseMangledMesaAst() -{ -} - -UseMangledMesaAst::~UseMangledMesaAst() -{ -} - - -bool UseMangledMesaAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="path_to_mesa" || func.arguments.count()!=2) - return false; - m_pathToMesa=func.arguments[0].value; - m_outputDir=func.arguments[1].value; - return true; -} - -UtilitySourceAst::UtilitySourceAst() -{ -} - -UtilitySourceAst::~UtilitySourceAst() -{ -} - - -bool UtilitySourceAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="utility_source" || func.arguments.count()<3) - return false; - unsigned int i=0; - foreach(const CMakeFunctionArgument& arg, func.arguments) { - if(i==0) - m_cacheEntry=arg.value; - else if(i==1) - m_executableName=arg.value; - else if(i==2) - m_pathToSource=arg.value; - else - m_fileList.append(arg.value); - } - return true; -} - -UnsetAst::UnsetAst() - : m_cache(false) - , m_env(false) -{ -} - -UnsetAst::~UnsetAst() -{ -} - - -bool UnsetAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="unset" || func.arguments.count()<1 || func.arguments.count()>2) - return false; - m_variableName = func.arguments.first().value; - addOutputArgument(func.arguments.first()); - m_cache = func.arguments.count()==2 && func.arguments.last().value=="CACHE"; - m_env = m_variableName.startsWith("ENV{"); - if(m_env) { - m_variableName = m_variableName.mid(4, -2); - } - return func.arguments.count()==1 || (m_cache && !m_env); -} - -VariableRequiresAst::VariableRequiresAst() -{ -} - -VariableRequiresAst::~VariableRequiresAst() -{ -} - - -bool VariableRequiresAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="variable_requires" || func.arguments.count()<2) - return false; - unsigned int i=0; - foreach(const CMakeFunctionArgument& arg, func.arguments) { - if(i==0) - m_testVariable=arg.value; - else if(i==1) - { - addOutputArgument(arg); - m_resultVariable=arg.value; - } - else - m_requiredVariables.append(arg.value); - i++; - } - return true; -} - -VtkMakeInstantiatorAst::VtkMakeInstantiatorAst() -{ -} - -VtkMakeInstantiatorAst::~VtkMakeInstantiatorAst() -{ -} - - -bool VtkMakeInstantiatorAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - Q_UNUSED(func); - return false; -} - -VtkWrapJavaAst::VtkWrapJavaAst() -{ -} - -VtkWrapJavaAst::~VtkWrapJavaAst() -{ -} - - -bool VtkWrapJavaAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - Q_UNUSED(func); - return false; -} - -VtkWrapPythonAst::VtkWrapPythonAst() -{ -} - -VtkWrapPythonAst::~VtkWrapPythonAst() -{ -} - - -bool VtkWrapPythonAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - Q_UNUSED(func); - return false; -} - -VtkWrapTclAst::VtkWrapTclAst() -{ -} - -VtkWrapTclAst::~VtkWrapTclAst() -{ -} - - -bool VtkWrapTclAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - Q_UNUSED(func); - return false; -} - -WhileAst::WhileAst() -{ -} - -WhileAst::~WhileAst() -{ -} - - -bool WhileAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="while" || func.arguments.isEmpty()) - return false; - foreach(const CMakeFunctionArgument& arg, func.arguments) - { - m_condition.append(arg.value); - } - return true; -} - -WriteFileAst::WriteFileAst() - : m_append(false) -{ -} - -WriteFileAst::~WriteFileAst() -{ -} - - -bool WriteFileAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="write_file" || func.arguments.count()<2) - return false; - m_filename=func.arguments[0].value; - m_message=func.arguments[1].value; - - if(func.arguments.count()>2) - { - if(func.arguments[2].value=="APPEND") - { - m_append=true; - } - if(func.arguments.count()>(2+m_append)) - return false; - } - return true; -} - -CustomInvokationAst::CustomInvokationAst() -{ -} - -CustomInvokationAst::~CustomInvokationAst() -{ -} - - -bool CustomInvokationAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - m_function = func; - m_arguments = func.arguments; - return true; -} - -BreakAst::BreakAst() -{ -} - -BreakAst::~BreakAst() -{ -} - - -bool BreakAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - return func.name.toLower()=="break"; -} - -CMakePolicyAst::CMakePolicyAst() - : m_action(Version) - , m_policyNum(0) - , m_isNew(false) -{ -} - -CMakePolicyAst::~CMakePolicyAst() -{ -} - - -bool CMakePolicyAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="cmake_policy" || func.arguments.isEmpty()) - return false; - const QString &first=func.arguments[0].value; - - if(first=="VERSION") - { - bool ok = false; - m_version = CMakeParserUtils::parseVersion(func.arguments[1].value, &ok); - return ok; - } - else if(first=="SET" && func.arguments.count()==3) - { - QRegExp rx("CMP([1-9]*)"); - rx.indexIn(func.arguments[1].value); - - QStringList cmpValue=rx.capturedTexts(); - cmpValue.erase(cmpValue.begin()); - if(cmpValue.count()==1) - { - m_policyNum=cmpValue[0].toInt(); - } - else - return false; - - if(func.arguments[2].value=="OLD") - m_isNew=false; - else if(func.arguments[2].value=="NEW") - m_isNew=true; - else - return false; - return true; - } else if(first=="PUSH") { - m_action=Push; - return func.arguments.count()==1; - } else if(first=="POP") { - m_action=Pop; - return func.arguments.count()==1; - } - return false; -} - -ExportAst::ExportAst() - : m_append(false) -{ -} - -ExportAst::~ExportAst() -{ -} - - -/// @todo Implement EXPORT(PACKAGE name), introduced in CMake 2.8 -bool ExportAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="export" || func.arguments.count() < 2 || func.arguments[0].value!="TARGETS") - return false; - - enum Option { TARGETS, NAMESPACE, FILE }; - Option opt=TARGETS; - foreach(const CMakeFunctionArgument& arg, func.arguments) - { - if(arg.value=="TARGETS") - { - if(opt!=TARGETS) - return false; - } - else if(arg.value=="NAMESPACE") - { - opt=NAMESPACE; - } - else if(arg.value=="FILE") - { - opt=FILE; - } - else if(arg.value=="APPEND") - { - m_append=true; - } - else - { - switch(opt) - { - case TARGETS: - m_targets.append(arg.value); - break; - case NAMESPACE: - m_targetNamespace=arg.value; - break; - case FILE: - m_filename=arg.value; - break; - } - opt=TARGETS; - } - } - return !m_filename.isEmpty(); -} - -ReturnAst::ReturnAst() -{ -} - -ReturnAst::~ReturnAst() -{ -} - - -bool ReturnAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - return func.arguments.isEmpty() && func.name.toLower()=="return"; -} - -SetPropertyAst::SetPropertyAst() - : m_type(GlobalProperty) - , m_append(false) -{ -} - -SetPropertyAst::~SetPropertyAst() -{ -} - - -bool SetPropertyAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="set_property" || func.arguments.count() < 3) - return false; - - QString propName=func.arguments.first().value; - if(propName=="GLOBAL") m_type=GlobalProperty; - else if(propName=="DIRECTORY") m_type=DirectoryProperty; - else if(propName=="TARGET") m_type=TargetProperty; - else if(propName=="CACHE") m_type=CacheProperty; - else if(propName=="SOURCE") m_type=SourceProperty; - else if(propName=="TEST") m_type=TestProperty; - else - return false; - - QList::const_iterator it=func.arguments.constBegin()+1, itEnd=func.arguments.constEnd(); - for(; it!=itEnd && it->value!="PROPERTY" && it->value!="APPEND" && it->value!="APPEND_STRING"; ++it) - { - m_args.append(it->value); - } - - m_append=it!=itEnd && it->value=="APPEND"; - if(m_append) - ++it; - - m_appendString=it!=itEnd && it->value=="APPEND_STRING"; - if(m_appendString) - ++it; - - if(it!=itEnd) - ++it; //PROPERTY - else - return false; - - m_name=it->value; - ++it; - for(; it!=itEnd && it->value!="PROPERTY" && it->value!="APPEND"; ++it) - { - m_values.append(it->value); - } - - return !m_name.isEmpty(); -} - -GetPropertyAst::GetPropertyAst() - : m_type(GlobalProperty) -{} - -GetPropertyAst::~GetPropertyAst() -{} - -bool GetPropertyAst::parseFunctionInfo( const CMakeFunctionDesc& func ) -{ - if(func.name.toLower()!="get_property" || func.arguments.count() < 4 || func.arguments.count() > 6) - return false; - QList::const_iterator it=func.arguments.constBegin(), itEnd=func.arguments.constEnd(); - m_outputVariable=it->value; - addOutputArgument(*it); - ++it; - - PropertyType t; - QString propName=it->value; - if(propName=="GLOBAL") t=GlobalProperty; - else if(propName=="DIRECTORY") t=DirectoryProperty; - else if(propName=="TARGET") t=TargetProperty; - else if(propName=="SOURCE") t=SourceProperty; - else if(propName=="CACHE") t=CacheProperty; - else if(propName=="TEST") t=TestProperty; - else if(propName=="VARIABLE") t=VariableProperty; - else - return false; - m_type=t; - ++it; - if(it->value!="PROPERTY") { - m_typeName=it->value; - ++it; - } - if(it->value!="PROPERTY") return false; - ++it; - m_name=it->value; - ++it; - m_behaviour=None; - if(it!=itEnd) { - QString ee=it->value; - if(ee=="SET") m_behaviour=Set; - else if(ee=="DEFINED") m_behaviour=Defined; - else if(ee=="BRIEF_DOCS") m_behaviour=BriefDocs; - else if(ee=="FULL_DOCS") m_behaviour=FullDocs; - } - - return !m_name.isEmpty(); -} diff --git a/projectmanagers/cmake/parser/cmakeast.h b/projectmanagers/cmake/parser/cmakeast.h deleted file mode 100644 index b9ea07acb2..0000000000 --- a/projectmanagers/cmake/parser/cmakeast.h +++ /dev/null @@ -1,863 +0,0 @@ -/* KDevelop CMake Support - * - * Copyright 2006 Matt Rogers - * Copyright 2007 Aleix Pol - * - * 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. - */ - -#ifndef CMAKEAST_H -#define CMAKEAST_H - -#include -#include -#include - -#include "cmakecommonexport.h" -#include "cmakelistsparser.h" -#include "cmakeastvisitor.h" -#include "cmaketypes.h" - -class KDEVCMAKECOMMON_EXPORT CMakeAst /*Should consider making it abstract. */ -{ - public: - CMakeAst() : m_line(-1) { } - virtual ~CMakeAst() { /*qDeleteAll( m_children );*/ } - - virtual int accept(CMakeAstVisitor * v) const { return v->visit(this); } - - /** - * Returns \c true if this command is deprecated. - */ - virtual bool isDeprecated() const { return false; } - - virtual bool parseFunctionInfo( const CMakeFunctionDesc& func )=0; - - int line() const { return m_line; } - const CMakeFileContent & content() const { return m_content; } - void setContent(const CMakeFileContent &cont, int nline=0) { m_content=cont; m_line=nline; } - const QList & outputArguments() const { return m_outputArguments; } - private: - CMakeAst( const CMakeAst& ) {} - - QList m_outputArguments; - CMakeFileContent m_content; - - int m_line; - protected: - void addOutputArgument(const CMakeFunctionArgument& arg) { m_outputArguments.append(arg); } -}; - -#define CMAKE_BEGIN_AST_CLASS( klassName ) class klassName : public CMakeAst { \ - public: \ - klassName(); \ - ~klassName(); \ - \ - virtual int accept(CMakeAstVisitor * visitor) const { return visitor->visit(this); } \ - virtual bool parseFunctionInfo( const CMakeFunctionDesc& func ); - -#define CMAKE_ADD_AST_MEMBER( returnType, returnName ) \ - public: \ - returnType returnName() const { return m_##returnName; } \ - private: \ - returnType m_##returnName; - -#define CMAKE_MARK_AS_DEPRECATED() virtual bool isDeprecated() const { return true; } - -#define CMAKE_END_AST_CLASS( klassName ) }; - -CMAKE_BEGIN_AST_CLASS( CustomCommandAst ) - enum BuildStage { - PreBuild, - PreLink, - PostBuild }; - - CMAKE_ADD_AST_MEMBER( bool, isForTarget ) - CMAKE_ADD_AST_MEMBER( QString, targetName ) - CMAKE_ADD_AST_MEMBER( BuildStage, buildStage ) - CMAKE_ADD_AST_MEMBER( QStringList, outputs ) - CMAKE_ADD_AST_MEMBER( QStringList, commands ) - CMAKE_ADD_AST_MEMBER( QString, mainDependency ) - CMAKE_ADD_AST_MEMBER( QStringList, otherDependencies ) - CMAKE_ADD_AST_MEMBER( QString, workingDirectory ) - CMAKE_ADD_AST_MEMBER( QString, comment ) - CMAKE_ADD_AST_MEMBER( QString, source ) - CMAKE_ADD_AST_MEMBER( bool, isVerbatim ) - CMAKE_ADD_AST_MEMBER( bool, append ) -CMAKE_END_AST_CLASS( CustomCommandAst ) - -CMAKE_BEGIN_AST_CLASS( MacroCallAst ) -CMAKE_ADD_AST_MEMBER( QString, name ) -CMAKE_ADD_AST_MEMBER( QStringList, arguments ) -CMAKE_END_AST_CLASS( MacroCallAst ) - -CMAKE_BEGIN_AST_CLASS( CustomTargetAst ) -typedef QMap cmdAndArgs; //Just to make preprocessor not cry -CMAKE_ADD_AST_MEMBER( QString, target ) -CMAKE_ADD_AST_MEMBER( bool, buildAlways ) -CMAKE_ADD_AST_MEMBER( cmdAndArgs, commandArgs ) -CMAKE_ADD_AST_MEMBER( QStringList, dependencies ) -CMAKE_ADD_AST_MEMBER( QString, workingDir ) -CMAKE_ADD_AST_MEMBER( QString, comment ) -CMAKE_ADD_AST_MEMBER( bool, isVerbatim ) -CMAKE_ADD_AST_MEMBER( QStringList, sourceLists ) -CMAKE_END_AST_CLASS( CustomTargetAst ) - -CMAKE_BEGIN_AST_CLASS( AddDefinitionsAst ) -CMAKE_ADD_AST_MEMBER( QStringList, definitions ) -CMAKE_END_AST_CLASS( AddDefinitionsAst ) - -CMAKE_BEGIN_AST_CLASS( AddDependenciesAst ) -CMAKE_ADD_AST_MEMBER( QString, target ) -CMAKE_ADD_AST_MEMBER( QStringList, dependencies ) -CMAKE_END_AST_CLASS( AddDependenciesAst ) - -CMAKE_BEGIN_AST_CLASS( AddExecutableAst ) -CMAKE_ADD_AST_MEMBER( QString, executable ) -CMAKE_ADD_AST_MEMBER( bool, isWin32 ) -CMAKE_ADD_AST_MEMBER( bool, isOsXBundle ) -CMAKE_ADD_AST_MEMBER( bool, excludeFromAll ) -CMAKE_ADD_AST_MEMBER( bool, isImported ) -CMAKE_ADD_AST_MEMBER( QStringList, sourceLists ) -CMAKE_END_AST_CLASS( AddExecutableAst ) - -CMAKE_BEGIN_AST_CLASS( AddLibraryAst ) -enum LibraryType {Shared, Static, Module, Object, Unknown}; -CMAKE_ADD_AST_MEMBER( QString, libraryName ) -CMAKE_ADD_AST_MEMBER( LibraryType, type ) -CMAKE_ADD_AST_MEMBER( bool, isImported ) -CMAKE_ADD_AST_MEMBER( bool, isAlias ) -CMAKE_ADD_AST_MEMBER( QString, aliasTarget ) -CMAKE_ADD_AST_MEMBER( bool, excludeFromAll ) -CMAKE_ADD_AST_MEMBER( QStringList, sourceLists ) -static QMap s_typeForName; -CMAKE_END_AST_CLASS( AddLibraryAst ) - -CMAKE_BEGIN_AST_CLASS( AddSubdirectoryAst ) -CMAKE_ADD_AST_MEMBER( QString, sourceDir ) -CMAKE_ADD_AST_MEMBER( QString, binaryDir ) -CMAKE_ADD_AST_MEMBER( bool, excludeFromAll ) -CMAKE_END_AST_CLASS( AddSubdirectoryAst ) - - -CMAKE_BEGIN_AST_CLASS( AddTestAst ) -CMAKE_ADD_AST_MEMBER( QString, testName ) -CMAKE_ADD_AST_MEMBER( QString, exeName ) -CMAKE_ADD_AST_MEMBER( QStringList, testArgs ) -CMAKE_END_AST_CLASS( AddTestAst ) - - -CMAKE_BEGIN_AST_CLASS( AuxSourceDirectoryAst ) -CMAKE_ADD_AST_MEMBER( QString, dirName ) -CMAKE_ADD_AST_MEMBER( QString, variableName ) -CMAKE_END_AST_CLASS( AuxSourceDirectoryAst ) - - -CMAKE_BEGIN_AST_CLASS( BuildCommandAst ) -CMAKE_ADD_AST_MEMBER( QString, variableName ) -CMAKE_ADD_AST_MEMBER( QString, makeCommand ) -CMAKE_END_AST_CLASS( BuildCommandAst ) - - -CMAKE_BEGIN_AST_CLASS( BuildNameAst ) -CMAKE_MARK_AS_DEPRECATED() -CMAKE_ADD_AST_MEMBER( QString, buildName ) -CMAKE_END_AST_CLASS( BuildNameAst ) - - -CMAKE_BEGIN_AST_CLASS( CMakeMinimumRequiredAst ) -CMAKE_ADD_AST_MEMBER( QList, version ) -CMAKE_ADD_AST_MEMBER( bool, wrongVersionIsFatal ) -CMAKE_END_AST_CLASS( CMakeMinimumRequiredAst ) - - -CMAKE_BEGIN_AST_CLASS( ConfigureFileAst ) -CMAKE_ADD_AST_MEMBER( QString, inputFile ) -CMAKE_ADD_AST_MEMBER( QString, outputFile ) -CMAKE_ADD_AST_MEMBER( bool, copyOnly ) -CMAKE_ADD_AST_MEMBER( bool, escapeQuotes ) -CMAKE_ADD_AST_MEMBER( bool, atsOnly ) -CMAKE_ADD_AST_MEMBER( bool, immediate ) -CMAKE_END_AST_CLASS( ConfigureFileAst ) - - -CMAKE_BEGIN_AST_CLASS( CreateTestSourcelistAst ) -CMAKE_ADD_AST_MEMBER( QString, name ) -CMAKE_ADD_AST_MEMBER( QString, driverName ) -CMAKE_ADD_AST_MEMBER( QStringList, tests ) -CMAKE_ADD_AST_MEMBER( QStringList, extraIncludes ) -CMAKE_ADD_AST_MEMBER( QString, function ) -CMAKE_END_AST_CLASS( CreateTestSourcelistAst ) - - -CMAKE_BEGIN_AST_CLASS( EnableLanguageAst ) -CMAKE_ADD_AST_MEMBER( QString, language ) -CMAKE_END_AST_CLASS( EnableLanguageAst ) - - -CMAKE_BEGIN_AST_CLASS( EnableTestingAst ) -CMAKE_END_AST_CLASS( EnableTestingAst ) - - -CMAKE_BEGIN_AST_CLASS( ExecProgramAst ) -CMAKE_MARK_AS_DEPRECATED() -CMAKE_ADD_AST_MEMBER( QString, executableName ) -CMAKE_ADD_AST_MEMBER( QString, workingDirectory ) -CMAKE_ADD_AST_MEMBER( QStringList, arguments ) -CMAKE_ADD_AST_MEMBER( QString, outputVariable ) -CMAKE_ADD_AST_MEMBER( QString, returnValue ) -CMAKE_END_AST_CLASS( ExecProgramAst ) - - -CMAKE_BEGIN_AST_CLASS( ExecuteProcessAst ) -CMAKE_ADD_AST_MEMBER( QList, commands ) -CMAKE_ADD_AST_MEMBER( QString, resultVariable ) -CMAKE_ADD_AST_MEMBER( QString, outputVariable ) -CMAKE_ADD_AST_MEMBER( QString, errorVariable ) -CMAKE_ADD_AST_MEMBER( QString, inputFile ) -CMAKE_ADD_AST_MEMBER( QString, outputFile ) -CMAKE_ADD_AST_MEMBER( QString, errorFile ) -CMAKE_ADD_AST_MEMBER( QString, workingDirectory ) -CMAKE_ADD_AST_MEMBER( float, timeout ) -CMAKE_ADD_AST_MEMBER( bool, isOutputQuiet ) -CMAKE_ADD_AST_MEMBER( bool, isErrorQuiet ) -CMAKE_ADD_AST_MEMBER( bool, isOutputStrip ) -CMAKE_ADD_AST_MEMBER( bool, isErrorStrip ) -CMAKE_END_AST_CLASS( ExecuteProcessAst ) - - -CMAKE_BEGIN_AST_CLASS( ExportLibraryDepsAst ) -CMAKE_MARK_AS_DEPRECATED() -CMAKE_ADD_AST_MEMBER( QString, file ) -CMAKE_ADD_AST_MEMBER( bool, append ) -CMAKE_END_AST_CLASS( ExportLibraryDepsAst ) - - -CMAKE_BEGIN_AST_CLASS( FileAst ) -enum TypeFile { Write, Append, Read, Glob, GlobRecurse, Remove, RemoveRecurse, - MakeDirectory, RelativePath, ToCmakePath, ToNativePath, Strings, Download }; -CMAKE_ADD_AST_MEMBER( TypeFile, type ) -CMAKE_ADD_AST_MEMBER( QString, path ) -CMAKE_ADD_AST_MEMBER( QString, variable ) -CMAKE_ADD_AST_MEMBER( QString, directory ) -CMAKE_ADD_AST_MEMBER( QString, message ) -CMAKE_ADD_AST_MEMBER( QStringList, globbingExpressions ) -CMAKE_ADD_AST_MEMBER( bool, isFollowingSymlinks ) -CMAKE_ADD_AST_MEMBER( QStringList, directories ) - -CMAKE_ADD_AST_MEMBER( QUrl, url ) -CMAKE_ADD_AST_MEMBER( int, timeout ) - -CMAKE_ADD_AST_MEMBER( int, limitCount ) -CMAKE_ADD_AST_MEMBER( int, limitInput ) -CMAKE_ADD_AST_MEMBER( int, limitOutput ) -CMAKE_ADD_AST_MEMBER( int, lengthMinimum ) -CMAKE_ADD_AST_MEMBER( int, lengthMaximum ) -CMAKE_ADD_AST_MEMBER( bool, newlineConsume ) -CMAKE_ADD_AST_MEMBER( bool, noHexConversion ) -CMAKE_ADD_AST_MEMBER( QString, regex ) -CMAKE_END_AST_CLASS( FileAst ) - - -CMAKE_BEGIN_AST_CLASS( FindFileAst ) -CMAKE_ADD_AST_MEMBER( QString, variableName ) -CMAKE_ADD_AST_MEMBER( QStringList, filenames ) -CMAKE_ADD_AST_MEMBER( QStringList, path ) -CMAKE_ADD_AST_MEMBER( QStringList, hints ) -CMAKE_ADD_AST_MEMBER( QStringList, pathSuffixes ) -CMAKE_ADD_AST_MEMBER( QString, documentation ) - -CMAKE_ADD_AST_MEMBER( bool, noDefaultPath ) -CMAKE_ADD_AST_MEMBER( bool, noCmakeEnvironmentPath ) -CMAKE_ADD_AST_MEMBER( bool, noCmakePath ) -CMAKE_ADD_AST_MEMBER( bool, noSystemEnvironmentPath ) -CMAKE_ADD_AST_MEMBER( bool, noCmakeSystemPath ) -CMAKE_END_AST_CLASS( FindFileAst ) - - -CMAKE_BEGIN_AST_CLASS( FindLibraryAst ) -CMAKE_ADD_AST_MEMBER( QString, variableName ) -CMAKE_ADD_AST_MEMBER( QStringList, filenames ) -CMAKE_ADD_AST_MEMBER( QStringList, path ) -CMAKE_ADD_AST_MEMBER( QStringList, hints ) -CMAKE_ADD_AST_MEMBER( QStringList, pathSuffixes ) -CMAKE_ADD_AST_MEMBER( QString, documentation ) - -CMAKE_ADD_AST_MEMBER( bool, noDefaultPath ) -CMAKE_ADD_AST_MEMBER( bool, noCmakeEnvironmentPath ) -CMAKE_ADD_AST_MEMBER( bool, noCmakePath ) -CMAKE_ADD_AST_MEMBER( bool, noSystemEnvironmentPath ) -CMAKE_ADD_AST_MEMBER( bool, noCmakeSystemPath ) -CMAKE_ADD_AST_MEMBER( bool, noCmakeFindRootPath ) -CMAKE_END_AST_CLASS( FindLibraryAst ) - - -CMAKE_BEGIN_AST_CLASS( FindPackageAst ) //FIXME: there are things that I don't understand -CMAKE_ADD_AST_MEMBER( QString, name ) -CMAKE_ADD_AST_MEMBER( QString, version ) -CMAKE_ADD_AST_MEMBER( QStringList, components ) -CMAKE_ADD_AST_MEMBER( QStringList, paths ) -CMAKE_ADD_AST_MEMBER( bool, isQuiet ) -CMAKE_ADD_AST_MEMBER( bool, noModule ) -CMAKE_ADD_AST_MEMBER( bool, isRequired ) -CMAKE_END_AST_CLASS( FindPackageAst ) - - -CMAKE_BEGIN_AST_CLASS( FindPathAst ) -CMAKE_ADD_AST_MEMBER( QString, variableName ) -CMAKE_ADD_AST_MEMBER( QStringList, filenames ) -CMAKE_ADD_AST_MEMBER( QStringList, path ) -CMAKE_ADD_AST_MEMBER( QStringList, hints ) -CMAKE_ADD_AST_MEMBER( QStringList, pathSuffixes ) -CMAKE_ADD_AST_MEMBER( QString, documentation ) - -CMAKE_ADD_AST_MEMBER( bool, noDefaultPath ) -CMAKE_ADD_AST_MEMBER( bool, noCmakeEnvironmentPath ) -CMAKE_ADD_AST_MEMBER( bool, noCmakePath ) -CMAKE_ADD_AST_MEMBER( bool, noSystemEnvironmentPath ) -CMAKE_ADD_AST_MEMBER( bool, noCmakeSystemPath ) -CMAKE_END_AST_CLASS( FindPathAst ) - - -CMAKE_BEGIN_AST_CLASS( FindProgramAst ) -CMAKE_ADD_AST_MEMBER( QString, variableName ) -CMAKE_ADD_AST_MEMBER( QStringList, filenames ) -CMAKE_ADD_AST_MEMBER( QStringList, path ) -CMAKE_ADD_AST_MEMBER( QStringList, hints ) -CMAKE_ADD_AST_MEMBER( QStringList, pathSuffixes ) -CMAKE_ADD_AST_MEMBER( QString, documentation ) - -CMAKE_ADD_AST_MEMBER( bool, noDefaultPath ) -CMAKE_ADD_AST_MEMBER( bool, noCmakeEnvironmentPath ) -CMAKE_ADD_AST_MEMBER( bool, noCmakePath ) -CMAKE_ADD_AST_MEMBER( bool, noSystemEnvironmentPath ) -CMAKE_ADD_AST_MEMBER( bool, noCmakeSystemPath ) -CMAKE_ADD_AST_MEMBER( bool, noCMakeFindRootPath ) -CMAKE_END_AST_CLASS( FindProgramAst ) - - -CMAKE_BEGIN_AST_CLASS( FltkWrapUiAst ) -CMAKE_END_AST_CLASS( FltkWrapUiAst ) - - -CMAKE_BEGIN_AST_CLASS( ForeachAst ) - enum ForeachType { Range, InItems, InLists }; - struct rangeValues { int start, stop, step; }; -CMAKE_ADD_AST_MEMBER( QString, loopVar ) -CMAKE_ADD_AST_MEMBER( rangeValues, ranges ) -CMAKE_ADD_AST_MEMBER( QStringList, arguments ) -CMAKE_ADD_AST_MEMBER( ForeachType, type ) -CMAKE_END_AST_CLASS( ForeachAst ) - - -CMAKE_BEGIN_AST_CLASS( GetCMakePropertyAst ) - enum PropertyType { Variables, CacheVariables, Commands, Macros, Components }; -CMAKE_ADD_AST_MEMBER( PropertyType, type ) -CMAKE_ADD_AST_MEMBER( QString, variableName ) -CMAKE_END_AST_CLASS( GetCMakePropertyAst ) - - -CMAKE_BEGIN_AST_CLASS( SetPropertyAst ) -CMAKE_ADD_AST_MEMBER( PropertyType, type ) -CMAKE_ADD_AST_MEMBER( bool, append ) -CMAKE_ADD_AST_MEMBER( bool, appendString ) -CMAKE_ADD_AST_MEMBER( QStringList, args ) -CMAKE_ADD_AST_MEMBER( QString, name ) -CMAKE_ADD_AST_MEMBER( QStringList, values ) -CMAKE_END_AST_CLASS( SetPropertyAst ) - - -CMAKE_BEGIN_AST_CLASS( GetPropertyAst ) -CMAKE_ADD_AST_MEMBER( PropertyType, type ) -CMAKE_ADD_AST_MEMBER( QString, outputVariable ) -CMAKE_ADD_AST_MEMBER( QString, typeName ) -CMAKE_ADD_AST_MEMBER( QString, name ) - -enum Behaviour { None, Set, Defined, BriefDocs, FullDocs }; -CMAKE_ADD_AST_MEMBER( Behaviour, behaviour ) -CMAKE_END_AST_CLASS( GetPropertyAst ) - - -CMAKE_BEGIN_AST_CLASS( GetDirPropertyAst ) -CMAKE_ADD_AST_MEMBER( QString, propName ) -CMAKE_ADD_AST_MEMBER( QString, outputVariable ) -CMAKE_ADD_AST_MEMBER( QString, directory ) -CMAKE_END_AST_CLASS( GetDirPropertyAst ) - - -CMAKE_BEGIN_AST_CLASS( GetFilenameComponentAst ) - enum ComponentType { Path, RealPath, Absolute, Name, Ext, NameWe, Program }; -CMAKE_ADD_AST_MEMBER( QString, variableName ) -CMAKE_ADD_AST_MEMBER( QString, fileName ) -CMAKE_ADD_AST_MEMBER( ComponentType, type ) -CMAKE_ADD_AST_MEMBER( QStringList, programArgs ) -CMAKE_ADD_AST_MEMBER( bool, cache ) -CMAKE_END_AST_CLASS( GetFilenameComponentAst ) - - -CMAKE_BEGIN_AST_CLASS( GetSourceFilePropAst ) -CMAKE_ADD_AST_MEMBER( QString, variableName ) -CMAKE_ADD_AST_MEMBER( QString, filename ) -CMAKE_ADD_AST_MEMBER( QString, property ) -CMAKE_END_AST_CLASS( GetSourceFilePropAst ) - - -CMAKE_BEGIN_AST_CLASS( GetTargetPropAst ) -CMAKE_ADD_AST_MEMBER( QString, variableName ) -CMAKE_ADD_AST_MEMBER( QString, target ) -CMAKE_ADD_AST_MEMBER( QString, property ) -CMAKE_END_AST_CLASS( GetTargetPropAst ) - - -CMAKE_BEGIN_AST_CLASS( GetTestPropAst ) -CMAKE_ADD_AST_MEMBER( QString, test ) -CMAKE_ADD_AST_MEMBER( QString, variableName ) -CMAKE_ADD_AST_MEMBER( QString, property ) -CMAKE_END_AST_CLASS( GetTestPropAst ) - - -CMAKE_BEGIN_AST_CLASS( IfAst ) -CMAKE_ADD_AST_MEMBER( QStringList, condition ) -CMAKE_ADD_AST_MEMBER( QString, kind ) -CMAKE_END_AST_CLASS( IfAst ) - - -CMAKE_BEGIN_AST_CLASS( IncludeAst ) -CMAKE_ADD_AST_MEMBER( QString, includeFile ) -CMAKE_ADD_AST_MEMBER( bool, optional ) -CMAKE_ADD_AST_MEMBER( QString, resultVariable ) -CMAKE_END_AST_CLASS( IncludeAst ) - - -CMAKE_BEGIN_AST_CLASS( IncludeDirectoriesAst ) - enum IncludeType { Default=0, After, Before }; -CMAKE_ADD_AST_MEMBER( IncludeType, includeType ) -CMAKE_ADD_AST_MEMBER( bool, isSystem ) -CMAKE_ADD_AST_MEMBER( QStringList, includedDirectories ) -CMAKE_END_AST_CLASS( IncludeDirectoriesAst ) - - -CMAKE_BEGIN_AST_CLASS( IncludeExternalMsProjectAst ) -CMAKE_END_AST_CLASS( IncludeExternalMsProjectAst ) - - -CMAKE_BEGIN_AST_CLASS( IncludeRegularExpressionAst ) -CMAKE_ADD_AST_MEMBER( QString, match ) -CMAKE_ADD_AST_MEMBER( QString, complain ) -CMAKE_END_AST_CLASS( IncludeRegularExpressionAst ) - - -CMAKE_BEGIN_AST_CLASS( InstallAst ) -struct InstallTargetForm { //Targets - enum DestType { }; - QStringList targets; - QString destination; - QString permissions; - QString configuration; - QString component; - QString optional; -}; - -struct InstallFileForm { - QStringList files; - -}; - -CMAKE_ADD_AST_MEMBER( QList, targets ) -CMAKE_END_AST_CLASS( InstallAst ) - - -CMAKE_BEGIN_AST_CLASS( InstallFilesAst ) -CMAKE_MARK_AS_DEPRECATED() -CMAKE_ADD_AST_MEMBER( QString, directory ) -CMAKE_ADD_AST_MEMBER( QString, extension ) -CMAKE_ADD_AST_MEMBER( QStringList, files ) -CMAKE_ADD_AST_MEMBER( QString, regex ) -CMAKE_END_AST_CLASS( InstallFilesAst ) - - -CMAKE_BEGIN_AST_CLASS( InstallProgramsAst ) -CMAKE_MARK_AS_DEPRECATED() -CMAKE_ADD_AST_MEMBER( QString, directory ) -CMAKE_ADD_AST_MEMBER( QStringList, files ) -CMAKE_ADD_AST_MEMBER( QString, regex ) -CMAKE_END_AST_CLASS( InstallProgramsAst ) - - -CMAKE_BEGIN_AST_CLASS( InstallTargetsAst ) -CMAKE_MARK_AS_DEPRECATED() -CMAKE_ADD_AST_MEMBER( QString, directory ) -CMAKE_ADD_AST_MEMBER( QStringList, targets ) -CMAKE_ADD_AST_MEMBER( QString, runtimeDir ) -CMAKE_END_AST_CLASS( InstallTargetsAst ) - - -CMAKE_BEGIN_AST_CLASS( LinkDirectoriesAst ) - CMAKE_ADD_AST_MEMBER( QStringList, directories ) -CMAKE_END_AST_CLASS( LinkDirectoriesAst ) - - -CMAKE_BEGIN_AST_CLASS( LinkLibrariesAst ) - CMAKE_MARK_AS_DEPRECATED() - enum BuildType { Optimized, Debug, None }; - typedef QPair LibraryType; - CMAKE_ADD_AST_MEMBER( QList, libraries ) -CMAKE_END_AST_CLASS( LinkLibrariesAst ) - - -CMAKE_BEGIN_AST_CLASS( ListAst ) - enum ListType { Length, Get, Append, Find, Insert, RemoveItem, RemoveAt, Sort, Reverse, RemoveDuplicates }; - CMAKE_ADD_AST_MEMBER( ListType, type ) - CMAKE_ADD_AST_MEMBER( QString, list ) - CMAKE_ADD_AST_MEMBER( QString, output ) - CMAKE_ADD_AST_MEMBER( QList, index ) - CMAKE_ADD_AST_MEMBER( QStringList, elements ) -CMAKE_END_AST_CLASS( ListAst ) - - -CMAKE_BEGIN_AST_CLASS( LoadCacheAst ) - typedef QPair PrefixEntry; - CMAKE_ADD_AST_MEMBER( QString, cachePath ) - CMAKE_ADD_AST_MEMBER( PrefixEntry, prefixes ) - - CMAKE_ADD_AST_MEMBER( QStringList, exclude ) - CMAKE_ADD_AST_MEMBER( QStringList, includeInternals ) -CMAKE_END_AST_CLASS( LoadCacheAst ) - - -CMAKE_BEGIN_AST_CLASS( LoadCommandAst ) - CMAKE_ADD_AST_MEMBER( QString, cmdName ) - CMAKE_ADD_AST_MEMBER( QStringList, location ) -CMAKE_END_AST_CLASS( LoadCommandAst ) - - -CMAKE_BEGIN_AST_CLASS( MacroAst ) -CMAKE_ADD_AST_MEMBER( QString, macroName ) -CMAKE_ADD_AST_MEMBER( QStringList, knownArgs ) -CMAKE_END_AST_CLASS( MacroAst ) - - -CMAKE_BEGIN_AST_CLASS( MakeDirectoryAst ) -CMAKE_MARK_AS_DEPRECATED() -CMAKE_ADD_AST_MEMBER( QString, directory ) -CMAKE_END_AST_CLASS( MakeDirectoryAst ) - - -CMAKE_BEGIN_AST_CLASS( MarkAsAdvancedAst ) -CMAKE_ADD_AST_MEMBER( QStringList, advancedVars ) -CMAKE_ADD_AST_MEMBER( bool, isClear ) -CMAKE_ADD_AST_MEMBER( bool, isForce ) -CMAKE_END_AST_CLASS( MarkAsAdvancedAst ) - - -CMAKE_BEGIN_AST_CLASS( MathAst ) -CMAKE_ADD_AST_MEMBER( QString, outputVariable ) -CMAKE_ADD_AST_MEMBER( QString, expression ) -CMAKE_END_AST_CLASS( MathAst ) - - -CMAKE_BEGIN_AST_CLASS( MessageAst ) -enum MessageType { SendError, Status, FatalError }; -CMAKE_ADD_AST_MEMBER( MessageType, type ) -CMAKE_ADD_AST_MEMBER( QStringList, message ) -CMAKE_END_AST_CLASS( MessageAst ) - - -CMAKE_BEGIN_AST_CLASS( OptionAst ) -CMAKE_ADD_AST_MEMBER( QString, variableName ) -CMAKE_ADD_AST_MEMBER( QString, description ) -CMAKE_ADD_AST_MEMBER( QString, defaultValue ) -CMAKE_END_AST_CLASS( OptionAst ) - - -CMAKE_BEGIN_AST_CLASS( OutputRequiredFilesAst ) - CMAKE_ADD_AST_MEMBER( QString, srcFile ) - CMAKE_ADD_AST_MEMBER( QString, outputFile ) -CMAKE_END_AST_CLASS( OutputRequiredFilesAst ) - - -CMAKE_BEGIN_AST_CLASS( ProjectAst ) -CMAKE_ADD_AST_MEMBER( QString, projectName ) -CMAKE_ADD_AST_MEMBER( bool, useCpp ) -CMAKE_ADD_AST_MEMBER( bool, useC ) -CMAKE_ADD_AST_MEMBER( bool, useJava ) -CMAKE_END_AST_CLASS( ProjectAst ) - - -CMAKE_BEGIN_AST_CLASS( QtWrapCppAst ) -CMAKE_END_AST_CLASS( QtWrapCppAst ) - - -CMAKE_BEGIN_AST_CLASS( QtWrapUiAst ) -CMAKE_END_AST_CLASS( QtWrapUiAst ) - - -CMAKE_BEGIN_AST_CLASS( RemoveAst ) - CMAKE_MARK_AS_DEPRECATED() - CMAKE_ADD_AST_MEMBER( QString, variableName ) - CMAKE_ADD_AST_MEMBER( QStringList, values ) -CMAKE_END_AST_CLASS( RemoveAst ) - - -CMAKE_BEGIN_AST_CLASS( RemoveDefinitionsAst ) - CMAKE_ADD_AST_MEMBER( QStringList, definitions ) -CMAKE_END_AST_CLASS( RemoveDefinitionsAst ) - - -CMAKE_BEGIN_AST_CLASS( SeparateArgumentsAst ) - CMAKE_ADD_AST_MEMBER( QString, variableName ) -CMAKE_END_AST_CLASS( SeparateArgumentsAst ) - - -CMAKE_BEGIN_AST_CLASS( SetAst ) -CMAKE_ADD_AST_MEMBER( QString, variableName ) -CMAKE_ADD_AST_MEMBER( QStringList, values ) -CMAKE_ADD_AST_MEMBER( bool, storeInCache ) -CMAKE_ADD_AST_MEMBER( bool, forceStoring ) -CMAKE_ADD_AST_MEMBER( QString, entryType ) -CMAKE_ADD_AST_MEMBER( QString, documentation ) -CMAKE_ADD_AST_MEMBER( bool, parentScope ) -CMAKE_END_AST_CLASS( SetAst ) - -CMAKE_BEGIN_AST_CLASS( UnsetAst ) -CMAKE_ADD_AST_MEMBER( QString, variableName ) -CMAKE_ADD_AST_MEMBER( bool, cache ) -CMAKE_ADD_AST_MEMBER( bool, env ) -CMAKE_END_AST_CLASS( SetAst ) - -CMAKE_BEGIN_AST_CLASS( SetDirectoryPropsAst ) - typedef QPair PropPair; -CMAKE_ADD_AST_MEMBER( QList, properties ) -CMAKE_END_AST_CLASS( SetDirectoryPropsAst ) - - -CMAKE_BEGIN_AST_CLASS( SetSourceFilesPropsAst ) - typedef QPair PropPair; -CMAKE_ADD_AST_MEMBER( QStringList, files ) -CMAKE_ADD_AST_MEMBER( QList, properties ) -CMAKE_END_AST_CLASS( SetSourceFilesPropsAst ) - - -CMAKE_BEGIN_AST_CLASS( SetTargetPropsAst ) - typedef QPair PropPair; -CMAKE_ADD_AST_MEMBER( QStringList, targets ) -CMAKE_ADD_AST_MEMBER( QList, properties ) -CMAKE_END_AST_CLASS( SetTargetPropsAst ) - - -CMAKE_BEGIN_AST_CLASS( SetTestsPropsAst ) - typedef QPair PropPair; -CMAKE_ADD_AST_MEMBER( QStringList, tests ) -CMAKE_ADD_AST_MEMBER( QList, properties ) -CMAKE_END_AST_CLASS( SetTestsPropsAst ) - - -CMAKE_BEGIN_AST_CLASS( SiteNameAst ) -CMAKE_ADD_AST_MEMBER( QString, variableName ) -CMAKE_END_AST_CLASS( SiteNameAst ) - - -CMAKE_BEGIN_AST_CLASS( SourceGroupAst ) -CMAKE_ADD_AST_MEMBER( QString, name ) -CMAKE_ADD_AST_MEMBER( QString, regex ) -CMAKE_ADD_AST_MEMBER( QStringList, files ) -CMAKE_END_AST_CLASS( SourceGroupAst ) - - -CMAKE_BEGIN_AST_CLASS( StringAst ) -enum StringAstType { Regex, Replace, Compare, Ascii, Configure, - ToUpper, ToLower, Length, Substring, Strip, Random }; -enum CommandType { Match, MatchAll, RegexReplace, Equal, NotEqual, Less, Greater }; -CMAKE_ADD_AST_MEMBER( StringAstType, type ) -CMAKE_ADD_AST_MEMBER( CommandType, cmdType ) -CMAKE_ADD_AST_MEMBER( QString, outputVariable ) -CMAKE_ADD_AST_MEMBER( QString, regex ) -CMAKE_ADD_AST_MEMBER( QString, string ) -CMAKE_ADD_AST_MEMBER( QString, replace ) -CMAKE_ADD_AST_MEMBER( QStringList, input ) -CMAKE_ADD_AST_MEMBER( bool, only ) -CMAKE_ADD_AST_MEMBER( bool, escapeQuotes ) -CMAKE_ADD_AST_MEMBER( int, begin ) -CMAKE_ADD_AST_MEMBER( int, length ) -CMAKE_END_AST_CLASS( StringAst ) - - -CMAKE_BEGIN_AST_CLASS( SubdirDependsAst ) -CMAKE_MARK_AS_DEPRECATED() -CMAKE_ADD_AST_MEMBER( QString, subdir ) -CMAKE_ADD_AST_MEMBER( QStringList, directories ) -CMAKE_END_AST_CLASS( SubdirDependsAst ) - - -CMAKE_BEGIN_AST_CLASS( SubdirsAst ) -CMAKE_MARK_AS_DEPRECATED() -CMAKE_ADD_AST_MEMBER( QStringList, directories ) -CMAKE_ADD_AST_MEMBER( QStringList, exluceFromAll ) -CMAKE_ADD_AST_MEMBER( bool, preorder ) -CMAKE_END_AST_CLASS( SubdirsAst ) - -CMAKE_BEGIN_AST_CLASS( TargetIncludeDirectoriesAst ) -enum Visibility { Interface, Public, Private }; -struct Item { - Visibility visibility; - QString item; -}; - -CMAKE_ADD_AST_MEMBER( QString, target ) -CMAKE_ADD_AST_MEMBER( bool, before ) -CMAKE_ADD_AST_MEMBER( QList, items ) -CMAKE_END_AST_CLASS( TargetLinkLibrariesAst ) - -CMAKE_BEGIN_AST_CLASS( TargetLinkLibrariesAst ) -struct Dependencies { - QStringList other; - QStringList debug; - QStringList optimized; - QStringList retrieveTargets() const; -}; -CMAKE_ADD_AST_MEMBER( QString, target ) -CMAKE_ADD_AST_MEMBER( Dependencies, publicDependencies ) -CMAKE_ADD_AST_MEMBER( Dependencies, privateDependencies ) -CMAKE_ADD_AST_MEMBER( Dependencies, interfaceOnlyDependencies ) -CMAKE_END_AST_CLASS( TargetLinkLibrariesAst ) - - -CMAKE_BEGIN_AST_CLASS( TryCompileAst ) -CMAKE_ADD_AST_MEMBER( QString, resultName ) -CMAKE_ADD_AST_MEMBER( QString, binDir ) -CMAKE_ADD_AST_MEMBER( QString, source ) -CMAKE_ADD_AST_MEMBER( QString, projectName ) -CMAKE_ADD_AST_MEMBER( QString, targetName ) -CMAKE_ADD_AST_MEMBER( QStringList, cmakeFlags ) -CMAKE_ADD_AST_MEMBER( QStringList, compileDefinitions ) -CMAKE_ADD_AST_MEMBER( QString, outputName ) -CMAKE_ADD_AST_MEMBER( QString, copyFile ) -CMAKE_END_AST_CLASS( TryCompileAst ) - - -CMAKE_BEGIN_AST_CLASS( TryRunAst ) -CMAKE_ADD_AST_MEMBER( QString, runResultVar ) -CMAKE_ADD_AST_MEMBER( QString, compileResultVar ) -CMAKE_ADD_AST_MEMBER( QString, binDir ) -CMAKE_ADD_AST_MEMBER( QString, srcFile ) -CMAKE_ADD_AST_MEMBER( QStringList, cmakeFlags ) -CMAKE_ADD_AST_MEMBER( QStringList, compileDefs ) -CMAKE_ADD_AST_MEMBER( QString, outputVar ) -CMAKE_ADD_AST_MEMBER( QStringList, args ) -CMAKE_END_AST_CLASS( TryRunAst ) - - -CMAKE_BEGIN_AST_CLASS( UseMangledMesaAst ) -CMAKE_MARK_AS_DEPRECATED() -CMAKE_ADD_AST_MEMBER( QString, pathToMesa ) -CMAKE_ADD_AST_MEMBER( QString, outputDir ) -CMAKE_END_AST_CLASS( UseMangledMesaAst ) - - -CMAKE_BEGIN_AST_CLASS( UtilitySourceAst ) -CMAKE_MARK_AS_DEPRECATED() -CMAKE_ADD_AST_MEMBER( QString, cacheEntry ) -CMAKE_ADD_AST_MEMBER( QString, executableName ) -CMAKE_ADD_AST_MEMBER( QString, pathToSource ) -CMAKE_ADD_AST_MEMBER( QStringList, fileList ) -CMAKE_END_AST_CLASS( UtilitySourceAst ) - - -CMAKE_BEGIN_AST_CLASS( VariableRequiresAst ) -CMAKE_MARK_AS_DEPRECATED() -CMAKE_ADD_AST_MEMBER( QString, testVariable ) -CMAKE_ADD_AST_MEMBER( QString, resultVariable ) -CMAKE_ADD_AST_MEMBER( QStringList, requiredVariables ) -CMAKE_END_AST_CLASS( VariableRequiresAst ) - - -CMAKE_BEGIN_AST_CLASS( VtkMakeInstantiatorAst ) -CMAKE_MARK_AS_DEPRECATED() -CMAKE_END_AST_CLASS( VtkMakeInstantiatorAst ) - - -CMAKE_BEGIN_AST_CLASS( VtkWrapJavaAst ) -CMAKE_MARK_AS_DEPRECATED() -CMAKE_END_AST_CLASS( VtkWrapJavaAst ) - - -CMAKE_BEGIN_AST_CLASS( VtkWrapPythonAst ) -CMAKE_MARK_AS_DEPRECATED() -CMAKE_END_AST_CLASS( VtkWrapPythonAst ) - - -CMAKE_BEGIN_AST_CLASS( VtkWrapTclAst ) -CMAKE_MARK_AS_DEPRECATED() -CMAKE_END_AST_CLASS( VtkWrapTclAst ) - - -CMAKE_BEGIN_AST_CLASS( WhileAst ) -CMAKE_ADD_AST_MEMBER( QStringList, condition ) -CMAKE_END_AST_CLASS( WhileAst ) - - -CMAKE_BEGIN_AST_CLASS( WriteFileAst ) -CMAKE_MARK_AS_DEPRECATED() -CMAKE_ADD_AST_MEMBER( QString, filename ) -CMAKE_ADD_AST_MEMBER( QString, message ) -CMAKE_ADD_AST_MEMBER( bool, append ) -CMAKE_END_AST_CLASS( WriteFileAst ) - -CMAKE_BEGIN_AST_CLASS( CustomInvokationAst ) -CMAKE_ADD_AST_MEMBER( CMakeFunctionDesc, function ) -CMAKE_ADD_AST_MEMBER( QList, arguments ) -CMAKE_END_AST_CLASS( CustomInvokationAst ) - -//CMake 2.6 -CMAKE_BEGIN_AST_CLASS( BreakAst ) -CMAKE_END_AST_CLASS( BreakAst ) - -CMAKE_BEGIN_AST_CLASS( CMakePolicyAst ) -enum Action { Version, Set, Push, Pop }; -CMAKE_ADD_AST_MEMBER( Action, action ) -CMAKE_ADD_AST_MEMBER( QList, version ) -CMAKE_ADD_AST_MEMBER( int, policyNum ) -CMAKE_ADD_AST_MEMBER( bool, isNew ) -CMAKE_END_AST_CLASS( CMakePolicyAst ) - - -CMAKE_BEGIN_AST_CLASS( ExportAst ) -CMAKE_ADD_AST_MEMBER( QStringList, targets ) -CMAKE_ADD_AST_MEMBER( QString, targetNamespace ) -CMAKE_ADD_AST_MEMBER( bool, append ) -CMAKE_ADD_AST_MEMBER( QString, filename ) -CMAKE_END_AST_CLASS( ExportAst ) - -CMAKE_BEGIN_AST_CLASS( FunctionAst ) -CMAKE_ADD_AST_MEMBER( QString, name ) -CMAKE_ADD_AST_MEMBER( QStringList, knownArgs ) -CMAKE_END_AST_CLASS( FunctionAst ) - -CMAKE_BEGIN_AST_CLASS( ReturnAst ) -CMAKE_END_AST_CLASS( ReturnAst ) - -#undef CMAKE_END_AST_CLASS - -#undef CMAKE_MARK_AS_DEPRECATED - -#undef CMAKE_ADD_AST_MEMBER - -#undef CMAKE_BEGIN_AST_CLASS - -#endif - - -struct D; diff --git a/projectmanagers/cmake/parser/cmakeastvisitor.h b/projectmanagers/cmake/parser/cmakeastvisitor.h deleted file mode 100644 index 3fb0b6556d..0000000000 --- a/projectmanagers/cmake/parser/cmakeastvisitor.h +++ /dev/null @@ -1,137 +0,0 @@ - -/* KDevelop CMake Support - * - * Copyright 2007 Aleix Pol - * - * 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. - */ - -#ifndef CMAKEASTVISITOR_H -#define CMAKEASTVISITOR_H - -class AddDefinitionsAst; -class AddDependenciesAst; -class AddExecutableAst; -class AddLibraryAst; -class AddSubdirectoryAst; -class AddTestAst; -class AuxSourceDirectoryAst; -class BuildCommandAst; -class BuildNameAst; -class CMakeAst; -class CMakeMinimumRequiredAst; -class ConfigureFileAst; -class CustomCommandAst; -class CustomTargetAst; -class ExecProgramAst; -class ExecuteProcessAst; -class FileAst; -class FindFileAst; -class FindLibraryAst; -class FindPackageAst; -class FindPathAst; -class FindProgramAst; -class ForeachAst; -class FunctionAst; -class GetCMakePropertyAst; -class GetDirPropertyAst; -class GetFilenameComponentAst; -class GetPropertyAst; -class GetSourceFilePropAst; -class GetTargetPropAst; -class IfAst; -class IncludeAst; -class IncludeDirectoriesAst; -class ListAst; -class MacroAst; -class MacroCallAst; -class MarkAsAdvancedAst; -class MathAst; -class MessageAst; -class OptionAst; -class ProjectAst; -class RemoveDefinitionsAst; -class SetAst; -class SetTargetPropsAst; -class SeparateArgumentsAst; -class SetPropertyAst; -class StringAst; -class SubdirsAst; -class SetTestsPropsAst; -class SetDirectoryPropsAst; -class TargetIncludeDirectoriesAst; -class TargetLinkLibrariesAst; -class TryCompileAst; -class UnsetAst; -class WhileAst; - -class CMakeAstVisitor { - public: //maybe protected? - virtual ~CMakeAstVisitor() {} - - virtual int visit( const AddDefinitionsAst * ) = 0; - virtual int visit( const AddExecutableAst * ) = 0; - virtual int visit( const AddLibraryAst * ) = 0; - virtual int visit( const AddSubdirectoryAst * ) = 0; - virtual int visit( const AddTestAst * ) = 0; - virtual int visit( const CustomCommandAst * ) = 0; - virtual int visit( const CustomTargetAst * ) = 0; - virtual int visit( const ExecProgramAst * ) = 0; - virtual int visit( const ExecuteProcessAst * ) = 0; - virtual int visit( const FileAst * ) = 0; - virtual int visit( const FindFileAst * ) = 0; - virtual int visit( const FindLibraryAst * ) = 0; - virtual int visit( const FindPackageAst * ) = 0; - virtual int visit( const FindPathAst * ) = 0; - virtual int visit( const FindProgramAst * ) = 0; - virtual int visit( const ForeachAst * ) = 0; - virtual int visit( const FunctionAst * ) = 0; - virtual int visit( const GetCMakePropertyAst * ) = 0; - virtual int visit( const GetDirPropertyAst * ) = 0; - virtual int visit( const GetFilenameComponentAst * ) = 0; - virtual int visit( const GetPropertyAst * ) = 0; - virtual int visit( const GetTargetPropAst * ) = 0; - virtual int visit( const GetSourceFilePropAst * )=0; - virtual int visit( const IfAst * ) = 0; - virtual int visit( const IncludeAst * ) = 0; - virtual int visit( const IncludeDirectoriesAst * ) = 0; - virtual int visit( const ListAst * ) = 0; - virtual int visit( const MacroAst * ) = 0; - virtual int visit( const MacroCallAst * ) = 0; - virtual int visit( const MarkAsAdvancedAst * ) = 0; - virtual int visit( const MathAst * ) = 0; - virtual int visit( const MessageAst * ) = 0; - virtual int visit( const OptionAst * ) = 0; - virtual int visit( const ProjectAst * ) = 0; - virtual int visit( const RemoveDefinitionsAst * ) = 0; - virtual int visit( const SetAst * ) = 0; - virtual int visit( const SetTargetPropsAst * ) = 0; - virtual int visit( const SetDirectoryPropsAst * ) = 0; - virtual int visit( const SetPropertyAst * ) = 0; - virtual int visit( const SetTestsPropsAst * ) = 0; - virtual int visit( const StringAst * ) = 0; - virtual int visit( const SubdirsAst * ) = 0; - virtual int visit( const TryCompileAst * ) = 0; - virtual int visit( const TargetLinkLibrariesAst * ) = 0; - virtual int visit( const TargetIncludeDirectoriesAst* ) = 0; - virtual int visit( const SeparateArgumentsAst * ) = 0; - virtual int visit( const UnsetAst * ) = 0; - virtual int visit( const WhileAst * ) = 0; - - virtual int visit( const CMakeAst * ) = 0; -}; - -#endif diff --git a/projectmanagers/cmake/parser/cmakelistsparser.cpp b/projectmanagers/cmake/parser/cmakelistsparser.cpp index 3ea0e6f362..783624d9d7 100644 --- a/projectmanagers/cmake/parser/cmakelistsparser.cpp +++ b/projectmanagers/cmake/parser/cmakelistsparser.cpp @@ -1,255 +1,253 @@ /* KDevelop CMake Support * * Copyright 2006 Matt Rogers * Copyright 2008 Aleix Pol * * 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 "cmakelistsparser.h" -// #include "cmakeprojectvisitor.h" -#include "astfactory.h" #include "../debug.h" #include #include QMap whatToScape() { //Only add those where we're not scaping the next character QMap ret; ret['n']='\n'; ret['r']='\r'; ret['t']='\t'; return ret; } const QMap CMakeFunctionArgument::scapings=whatToScape(); static const QChar scapingChar='\\'; QString CMakeFunctionArgument::unescapeValue(const QString& value) { int firstScape=value.indexOf(scapingChar); if (firstScape<0) { return value; } QString newValue; int last=0; QMap::const_iterator itEnd = scapings.constEnd(); for(int i=firstScape; i=0; i=value.indexOf(scapingChar, i+2)) { newValue+=value.mid(last, i-last); const QChar current=value[i+1]; QMap::const_iterator it = scapings.constFind(current); if(it!=itEnd) newValue += *it; else newValue += current; last=i+2; } newValue+=value.mid(last, value.size()); // qCDebug(CMAKE) << "escapiiiiiiiiing" << value << newValue; return newValue; } void CMakeFunctionDesc::addArguments( const QStringList& args, bool addEvenIfEmpty ) { if(addEvenIfEmpty && args.isEmpty()) arguments += CMakeFunctionArgument(); else foreach( const QString& arg, args ) { CMakeFunctionArgument cmakeArg( arg ); arguments.append( cmakeArg ); } } QString CMakeFunctionDesc::writeBack() const { QString output=name+"( "; foreach(const CMakeFunctionArgument& arg, arguments) { QString o = arg.value; if(arg.quoted) o='"'+o+'"'; output += o+' '; } output += ')'; return output; } namespace CMakeListsParser { static bool readCMakeFunction( cmListFileLexer* lexer, CMakeFunctionDesc& func); CMakeFileContent readCMakeFile(const QString & _fileName) { cmListFileLexer* lexer = cmListFileLexer_New(); if ( !lexer ) return CMakeFileContent(); if ( !cmListFileLexer_SetFileName( lexer, qPrintable( _fileName ), nullptr ) ) { qCDebug(CMAKE) << "cmake read error. could not read " << _fileName; cmListFileLexer_Delete(lexer); return CMakeFileContent(); } CMakeFileContent ret; QString fileName = QDir::cleanPath(_fileName); bool readError = false, haveNewline = true; cmListFileLexer_Token* token; while(!readError && (token = cmListFileLexer_Scan(lexer))) { readError=false; if(token->type == cmListFileLexer_Token_Newline) { readError=false; haveNewline = true; } else if(token->type == cmListFileLexer_Token_Identifier) { if(haveNewline) { haveNewline = false; CMakeFunctionDesc function; function.name = QString::fromLocal8Bit(token->text).toLower(); function.filePath = fileName; function.line = token->line; function.column = token->column; readError = !readCMakeFunction( lexer, function); ret.append(function); if(readError) { qCDebug(CMAKE) << "Error while parsing:" << function.name << "at" << function.line; } } } } cmListFileLexer_Delete(lexer); return ret; } } bool CMakeListsParser::readCMakeFunction(cmListFileLexer *lexer, CMakeFunctionDesc &func) { // Command name has already been parsed. Read the left paren. cmListFileLexer_Token* token; if(!(token = cmListFileLexer_Scan(lexer))) { return false; } if(token->type != cmListFileLexer_Token_ParenLeft) { return false; } // Arguments. int parenthesis=1; while((token = cmListFileLexer_Scan(lexer))) { switch(token->type) { case cmListFileLexer_Token_ParenRight: parenthesis--; if(parenthesis==0) { func.endLine=token->line; func.endColumn=token->column; return true; } else if(parenthesis<0) return false; else func.arguments << CMakeFunctionArgument( QString::fromLocal8Bit(token->text), false, token->line, token->column ); break; case cmListFileLexer_Token_ParenLeft: parenthesis++; func.arguments << CMakeFunctionArgument( QString::fromLocal8Bit(token->text), false, token->line, token->column ); break; case cmListFileLexer_Token_Identifier: case cmListFileLexer_Token_ArgumentUnquoted: func.arguments << CMakeFunctionArgument( QString::fromLocal8Bit(token->text), false, token->line, token->column ); break; case cmListFileLexer_Token_ArgumentQuoted: func.arguments << CMakeFunctionArgument( QString::fromLocal8Bit(token->text), true, token->line, token->column+1 ); break; case cmListFileLexer_Token_Newline: break; default: return false; } } return false; } CMakeFunctionDesc::CMakeFunctionDesc(const QString& name, const QStringList& args) : name(name) , line(0) , column(0) , endLine(0) , endColumn(0) { addArguments(args); } CMakeFunctionDesc::CMakeFunctionDesc() : line(0) , column(0) , endLine(0) , endColumn(0) {} bool CMakeFunctionDesc::operator==(const CMakeFunctionDesc & other) const { if(other.arguments.count()!=arguments.count() || name!=other.name) return false; QList::const_iterator it=arguments.constBegin(); QList::const_iterator itOther=other.arguments.constBegin(); for(;it!=arguments.constEnd(); ++it, ++itOther) { if(*it!=*itOther) return false; } return true; } /*CMakeFunctionArgument::CMakeFunctionArgument(const CMakeFunctionArgument & r) : value(r.value), quoted(r.quoted), filePath(r.filePath), line(r.line), column(r.column) { value=unescapeValue(value); }*/ CMakeFunctionArgument::CMakeFunctionArgument(const QString& v, bool q, quint32 l, quint32 c) : value(unescapeValue(v)), quoted(q), line(l), column(c) { } CMakeFunctionArgument::CMakeFunctionArgument(const QString& v) : value(v), quoted(false), line(0), column(0) { } diff --git a/projectmanagers/cmake/parser/cmakeparserutils.cpp b/projectmanagers/cmake/parser/cmakeparserutils.cpp deleted file mode 100644 index 8eccff8650..0000000000 --- a/projectmanagers/cmake/parser/cmakeparserutils.cpp +++ /dev/null @@ -1,282 +0,0 @@ -/* KDevelop CMake Support - * - * Copyright 2008 Matt Rogers - * - * 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 "cmakeparserutils.h" - -#include -#include -#include -#include -#include "variablemap.h" -#include -#include "cmakeprojectvisitor.h" -#include "cmakeprojectdata.h" -#include "cmakecachereader.h" -#include "../debug.h" -#include -#include - -namespace CMakeParserUtils -{ - QList parseVersion(const QString& version, bool* ok) - { - QList versionNumList; - *ok = false; - QStringList versionStringList = version.split('.', QString::SkipEmptyParts); - - foreach(const QString& part, versionStringList) - { - int i = part.toInt(ok); - if (!*ok) - { - versionNumList.clear(); - return versionNumList; - } - else - versionNumList.append(i); - } - return versionNumList; - } - - QString valueFromSystemInfo(const QString& variable, const QString& systeminfo) - { - int idx = systeminfo.indexOf( variable ); - if( idx != -1 ) { - // 2 == ' "' - idx += variable.count() + 2; - int end = systeminfo.indexOf( "\"", idx ); - if( end != -1 ) { - return systeminfo.mid( idx, end-idx ); - } - } - return QString(); - } - - - QPair initialVariables() - { - static QPair ret; - if (!ret.first.isEmpty()) { - return ret; - } - QString cmakeCmd=QStandardPaths::findExecutable("cmake"); - - QString systeminfo=executeProcess(cmakeCmd, QStringList("--system-information")); - - VariableMap varsDef; - QStringList modulePathDef=QStringList(CMakeParserUtils::valueFromSystemInfo( "CMAKE_ROOT", systeminfo ) + "/Modules"); - qCDebug(CMAKE) << "found module path is" << modulePathDef; - varsDef.insertGlobal("CMAKE_BINARY_DIR", QStringList("#[bin_dir]")); - varsDef.insertGlobal("CMAKE_INSTALL_PREFIX", QStringList("#[install_dir]")); - varsDef.insertGlobal("CMAKE_COMMAND", QStringList(cmakeCmd)); - varsDef.insertGlobal("CMAKE_MAJOR_VERSION", QStringList(CMakeParserUtils::valueFromSystemInfo("CMAKE_MAJOR_VERSION", systeminfo))); - varsDef.insertGlobal("CMAKE_MINOR_VERSION", QStringList(CMakeParserUtils::valueFromSystemInfo("CMAKE_MINOR_VERSION", systeminfo))); - varsDef.insertGlobal("CMAKE_PATCH_VERSION", QStringList(CMakeParserUtils::valueFromSystemInfo("CMAKE_PATCH_VERSION", systeminfo))); - varsDef.insertGlobal("CMAKE_VERSION", QStringList(CMakeParserUtils::valueFromSystemInfo("CMAKE_VERSION", systeminfo))); - varsDef.insertGlobal("CMAKE_INCLUDE_CURRENT_DIR", QStringList("OFF")); - - QStringList cmakeInitScripts; - #ifdef Q_OS_WIN - cmakeInitScripts << "CMakeMinGWFindMake.cmake"; - cmakeInitScripts << "CMakeMSYSFindMake.cmake"; - cmakeInitScripts << "CMakeNMakeFindMake.cmake"; - cmakeInitScripts << "CMakeVS8FindMake.cmake"; - #else - cmakeInitScripts << "CMakeUnixFindMake.cmake"; - #endif - cmakeInitScripts << "CMakeDetermineSystem.cmake"; - cmakeInitScripts << "CMakeSystemSpecificInformation.cmake"; - cmakeInitScripts << "CMakeDetermineCCompiler.cmake"; - cmakeInitScripts << "CMakeDetermineCXXCompiler.cmake"; - - varsDef.insertGlobal("CMAKE_MODULE_PATH", modulePathDef); - varsDef.insertGlobal("CMAKE_ROOT", QStringList(CMakeParserUtils::valueFromSystemInfo("CMAKE_ROOT", systeminfo))); - - //Defines the behaviour that can't be identified on initialization scripts - #ifdef Q_OS_WIN32 - varsDef.insertGlobal("WIN32", QStringList("1")); - varsDef.insertGlobal("CMAKE_HOST_WIN32", QStringList("1")); - #else - varsDef.insertGlobal("UNIX", QStringList("1")); - varsDef.insertGlobal("CMAKE_HOST_UNIX", QStringList("1")); - #endif - #ifdef Q_OS_MAC - varsDef.insertGlobal("APPLE", QStringList("1")); - varsDef.insertGlobal("CMAKE_HOST_APPLE", QStringList("1")); - #endif - - ret = qMakePair(varsDef, cmakeInitScripts); - return ret; - } - - void printSubdirectories(const QList& subs) - { - Q_FOREACH(const Subdirectory& s, subs) { - qCDebug(CMAKE) << "lala " << s.name; - } - } - - QString binaryPath(const QString& sourcedir, const QString& projectSourceDir, const QString projectBinDir) - { - QString binDir = projectBinDir; - // CURRENT_BINARY_DIR must point to the subfolder if any" - if (sourcedir.startsWith(projectSourceDir)) { - Q_ASSERT(projectSourceDir.size()==sourcedir.size() || sourcedir.at(projectSourceDir.size()) == '/'); - binDir += sourcedir.mid(projectSourceDir.size()); - } - return binDir; - } - - KDevelop::ReferencedTopDUContext includeScript(const QString& file, const KDevelop::ReferencedTopDUContext& parent, CMakeProjectData* data, const QString& sourcedir, const QMap& env) - { - qCDebug(CMAKE) << "Running cmake script: " << file; - - CMakeFileContent f = CMakeListsParser::readCMakeFile(file); - data->vm.insertGlobal("CMAKE_CURRENT_LIST_FILE", QStringList(file)); - data->vm.insertGlobal("CMAKE_CURRENT_LIST_DIR", QStringList(QFileInfo(file).dir().absolutePath())); - - const QString projectSourceDir = data->vm.value("CMAKE_SOURCE_DIR").first(); - const QString projectBinDir = data->vm.value("CMAKE_BINARY_DIR").join(QString()); - - data->vm.insertGlobal("CMAKE_CURRENT_BINARY_DIR", QStringList(binaryPath(sourcedir, projectSourceDir, projectBinDir))); - data->vm.insertGlobal("CMAKE_CURRENT_SOURCE_DIR", QStringList(sourcedir)); - - CMakeProjectVisitor v(file, parent); - v.setCacheValues(&data->cache); - v.setVariableMap(&data->vm); - v.setMacroMap(&data->mm); - v.setModulePath(data->modulePath); - v.setEnvironmentProfile(env); - v.setProperties(data->properties); - v.setDefinitions(data->definitions); - v.walk(f, 0, true); - - data->projectName=v.projectName(); - data->subdirectories=v.subdirectories(); - data->targets=v.targets(); - data->properties=v.properties(); - data->testSuites=v.testSuites(); - data->targetAlias=v.targetAlias(); - data->definitions=v.definitions(); - - //printSubdirectories(data->subdirectories); - - data->vm.remove("CMAKE_CURRENT_LIST_FILE"); - data->vm.remove("CMAKE_CURRENT_LIST_DIR"); - data->vm.remove("CMAKE_CURRENT_SOURCE_DIR"); - data->vm.remove("CMAKE_CURRENT_BINARY_DIR"); - - return v.context(); - } - - CacheValues readCache(const KDevelop::Path &path) - { - QFile file(path.toLocalFile()); - if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) - { - qCDebug(CMAKE) << "error. Could not find the file" << path; - return CacheValues(); - } - - CacheValues ret; - QTextStream in(&file); - qCDebug(CMAKE) << "Reading cache:" << path; - QStringList currentComment; - while (!in.atEnd()) - { - QString line = in.readLine().trimmed(); - if(!line.isEmpty() && line[0].isLetter()) //it is a variable - { - CacheLine c; - c.readLine(line); - if(c.flag().isEmpty()) { - ret[c.name()]=CacheEntry(c.value(), currentComment.join("\n")); - currentComment.clear(); - } - // qCDebug(CMAKE) << "Cache line" << line << c.name(); - } - else if(line.startsWith("//")) - currentComment += line.right(line.count()-2); - } - return ret; - } - - /** - * Parse a string which contains definition(s), the thing is that in CMake you can do funky things: - * - * add_definitions(-DFOO -DBAR) - * add_definitions("-DLA=LU -DA=B") - * set_property( DIRECTORY PROPERTY COMPILE_DEFINITIONS A AV=1 ) - * ... - * - * TODO: this probably fails with defines containing spaces... - */ - static void parseDefinition(const QString& param, const bool expectDashD, const bool remove, CMakeDefinitions* defs) - { - int pos = 0; - - while (pos != -1 && pos < param.size()) { - if (param.at(pos).isSpace()) { - ++pos; - continue; - } else if (expectDashD) { - if (param.midRef(pos, 2) != QLatin1String("-D")) { - pos = param.indexOf(' ', pos); - continue; - } - pos += 2; - } - const int eq = param.indexOf('=', pos); - const int space = param.indexOf(' ', pos); - QString key; - QString value; - if (eq != -1 && (eq < space || space == -1)) { - key = param.mid(pos, eq - pos); - if (!remove) { - value = param.mid(eq + 1, space - (eq + 1)); - } - } else { - key = param.mid(pos, space - pos); - } - if (remove) { - defs->remove(key); - } else { - defs->insert(key, value); - } - pos = space; - } - } - - void addDefinitions(const QStringList& definitions, CMakeDefinitions* to, const bool expectDashD) - { - Q_ASSERT(to); - foreach(const QString& v, definitions) { - parseDefinition(v, expectDashD, false, to); - } - } - - void removeDefinitions(const QStringList& definitions, CMakeDefinitions* from, const bool expectDashD) - { - Q_ASSERT(from); - foreach(const QString& v, definitions) { - parseDefinition(v, expectDashD, true, from); - } - } -} diff --git a/projectmanagers/cmake/parser/cmakeparserutils.h b/projectmanagers/cmake/parser/cmakeparserutils.h deleted file mode 100644 index 371769ca22..0000000000 --- a/projectmanagers/cmake/parser/cmakeparserutils.h +++ /dev/null @@ -1,70 +0,0 @@ -/* KDevelop CMake Support - * - * Copyright 2008 Matt Rogers - * - * 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. - */ -#ifndef CMAKEPARSERUTILS_H -#define CMAKEPARSERUTILS_H - -#include "cmakecommonexport.h" - -#include -#include -#include -#include -#include "cmaketypes.h" -#include - -struct CMakeProjectData; -class VariableMap; - -namespace KDevelop { - class IProject; - class Path; -} - -namespace CMakeParserUtils -{ - /** - * Parse a string in the form of "x.y.z" that could possibly - * be a version number. - */ - KDEVCMAKECOMMON_EXPORT QList parseVersion(const QString &version, bool *ok); - /** - * extracts the value of a variable from the --system-information output from CMake - */ - KDEVCMAKECOMMON_EXPORT QString valueFromSystemInfo( const QString& variable, const QString& systeminfo ); - - /** - * produces a map of initially set variables and scripts to include. - * This is based on the CMake output from --system-information - * and on reading the CMake sources. - */ - KDEVCMAKECOMMON_EXPORT QPair initialVariables( ); - - KDEVCMAKECOMMON_EXPORT KDevelop::ReferencedTopDUContext includeScript( const QString& file, const KDevelop::ReferencedTopDUContext& parent, CMakeProjectData* data, const QString& sourcedir, const QMap< QString, QString >& env); - - KDEVCMAKECOMMON_EXPORT CacheValues readCache(const KDevelop::Path& path); - - KDEVCMAKECOMMON_EXPORT QString binaryPath(const QString& sourcedir, const QString& projectSourceDir, const QString projectBinDir); - - KDEVCMAKECOMMON_EXPORT void addDefinitions(const QStringList& definitions, CMakeDefinitions* to, const bool expectDashD = false); - KDEVCMAKECOMMON_EXPORT void removeDefinitions(const QStringList& definitions, CMakeDefinitions* from, const bool expectDashD = false); -} - -#endif - diff --git a/projectmanagers/cmake/parser/cmakeprojectvisitor.h b/projectmanagers/cmake/parser/cmakeprojectvisitor.h index 7e8387b339..24b831090b 100644 --- a/projectmanagers/cmake/parser/cmakeprojectvisitor.h +++ b/projectmanagers/cmake/parser/cmakeprojectvisitor.h @@ -1,212 +1,211 @@ /* KDevelop CMake Support * * Copyright 2007 Aleix Pol * * 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. */ #ifndef CMAKEPROJECTVISITOR_H #define CMAKEPROJECTVISITOR_H #include #include #include #include -#include "cmakeastvisitor.h" #include "cmaketypes.h" #include class CMakeFunctionDesc; namespace KDevelop { class TopDUContext; class Declaration; class ITestController; } class KDEVCMAKECOMMON_EXPORT CMakeProjectVisitor : CMakeAstVisitor { public: typedef void (*message_callback)(const QString& message); explicit CMakeProjectVisitor(const QString& root, KDevelop::ReferencedTopDUContext parent); virtual ~CMakeProjectVisitor() {} int visit( const CustomCommandAst * ) override; int visit( const CustomTargetAst * ) override; int visit( const AddDefinitionsAst * ) override; int visit( const AddTestAst * ) override; int visit( const AddExecutableAst * ) override; int visit( const AddLibraryAst * ) override; int visit( const AddSubdirectoryAst * ) override; int visit( const IncludeDirectoriesAst * ) override; int visit( const IncludeAst * ) override; int visit( const MacroCallAst * call) override; int visit( const FindPackageAst * ) override; int visit( const MarkAsAdvancedAst * ) override; int visit( const FindProgramAst * ) override; int visit( const FunctionAst * ) override; int visit( const FindPathAst * ) override; int visit( const FindLibraryAst * ) override; int visit( const FindFileAst * ) override; int visit( const IfAst * ) override; int visit( const ExecProgramAst * ) override; int visit( const ExecuteProcessAst * ) override; int visit( const FileAst * ) override; int visit( const MessageAst * ) override; int visit( const MathAst * ) override; int visit( const MacroAst * ) override; int visit( const ListAst * ) override; int visit( const GetDirPropertyAst * ) override; int visit( const GetFilenameComponentAst * ) override; int visit( const GetSourceFilePropAst * ) override; int visit( const GetTargetPropAst * ) override; int visit( const OptionAst * ) override; int visit( const SetAst * ) override; int visit( const ForeachAst * ) override; int visit( const ProjectAst * ) override; int visit( const SetPropertyAst* ) override; int visit( const SetTargetPropsAst * ) override; int visit( const SetDirectoryPropsAst * ) override; int visit( const StringAst * ) override; int visit( const SubdirsAst * ) override; int visit( const SetTestsPropsAst* ) override; int visit( const TargetLinkLibrariesAst * ) override; int visit( const TargetIncludeDirectoriesAst* ) override; int visit( const TryCompileAst * ) override; int visit( const GetCMakePropertyAst * ) override; int visit( const GetPropertyAst* ) override; int visit( const RemoveDefinitionsAst * ) override; int visit( const SeparateArgumentsAst * ) override; int visit( const UnsetAst * ) override; int visit( const WhileAst * ) override; int visit( const CMakeAst * ) override; void setCacheValues( CacheValues* cache); void setVariableMap( VariableMap* vars ); void setMacroMap( MacroMap* macros ) { m_macros=macros; } void setModulePath(const QStringList& mp) { m_modulePath=mp; } void setDefinitions(const CMakeDefinitions& defs) { m_defs=defs; } /** sets the @p profile env variables that will be used to override those in the current system */ void setEnvironmentProfile(const QMap& profile) { m_environmentProfile = profile; } const VariableMap* variables() const { return m_vars; } const CacheValues* cache() const { return m_cache; } CMakeDefinitions definitions() const { return m_defs; } QString projectName() const { return m_projectName; } QVector subdirectories() const { return m_subdirectories; } QVector targets() const { return m_targetForId.values().toVector(); } QStringList resolveDependencies(const QStringList& target) const; QVector testSuites() const { return m_testSuites; } int walk(const CMakeFileContent& fc, int line, bool isClean=false); // enum FileType { Location, File, Executable, Library }; static QString findFile(const QString& files, const QStringList &folders, const QStringList& suffixes=QStringList(), bool location=false); QString findExecutable(const QString& filenames, const QStringList& dirs, const QStringList& pathSuffixes=QStringList()) const; KDevelop::ReferencedTopDUContext context() const { return m_topctx; } QStringList resolveVariable(const CMakeFunctionArgument &exp); bool hasMacro(const QString& name) const; struct VisitorState { const CMakeFileContent* code; int line; KDevelop::ReferencedTopDUContext context; }; CMakeProperties properties() { return m_props; } static void setMessageCallback(message_callback f) { s_msgcallback=f; } QStringList variableValue(const QString& var) const; void setProperties(const CMakeProperties& properties) { m_props = properties; } QHash targetAlias() { return m_targetAlias; } protected: struct IntPair { IntPair(int f, int s, int l) : first(f), second(s), level(l) {} int first, second, level; QString print() const { return QString("(%1, %2 : %3)").arg(first).arg(second).arg(level); } static QStringList printList(const QList& l) { QStringList r; foreach(const IntPair& i, l) r+= i.print(); return r; } }; static QList parseArgument(const QString &exp); private: QStringList envVarDirectories(const QString &varName) const; static message_callback s_msgcallback; static KDevelop::ReferencedTopDUContext createContext(const KDevelop::IndexedString& path, KDevelop::ReferencedTopDUContext aux, int endl ,int endc, bool isClean); void macroDeclaration(const CMakeFunctionDesc& def, const CMakeFunctionDesc& end, const QStringList& args); CMakeFunctionDesc resolveVariables(const CMakeFunctionDesc &exp); QStringList value(const QString& exp, const QList& poss, int& desired) const; QStringList theValue(const QString& exp, const IntPair& p) const; void defineTarget(const QString& id, const QStringList& sources, Target::Type t); bool haveToFind(const QString &varName); void createDefinitions(const CMakeAst* ast); void createUses(const CMakeFunctionDesc& ast); void printBacktrace(const KDevelop::Stack &backtrace); VisitorState stackTop() const; QStringList dependees(const QString& s) const; int declareFunction(Macro m, const CMakeFileContent& content, int initial, const QString& end); QStringList traverseGlob(const QString& startPath, const QString& expression, bool recursive = false, bool followSymlinks = false); CMakeProperties m_props; QStringList m_modulePath; QString m_projectName; QVector m_subdirectories; QHash m_generatedFiles; QHash m_targetForId; KDevelop::Stack m_backtrace; QString m_root; VariableMap *m_vars; MacroMap *m_macros; const CacheValues* m_cache; CMakeDefinitions m_defs; KDevelop::ReferencedTopDUContext m_topctx; KDevelop::ReferencedTopDUContext m_parentCtx; bool m_hitBreak; bool m_hitReturn; QMap m_environmentProfile; QHash m_targetAlias; QVector m_testSuites; }; #endif diff --git a/projectmanagers/cmake/parser/cmaketypes.h b/projectmanagers/cmake/parser/cmaketypes.h index 23986c6785..2eb9a6ed65 100644 --- a/projectmanagers/cmake/parser/cmaketypes.h +++ b/projectmanagers/cmake/parser/cmaketypes.h @@ -1,88 +1,87 @@ /* Copyright 2009 Aleix Pol Gonzalez This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License version 2 as published by the Free Software Foundation. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #ifndef CMAKETYPES_H #define CMAKETYPES_H #include "cmakelistsparser.h" -#include "variablemap.h" #include #include struct Macro { QString name; QStringList knownArgs; CMakeFileContent code; bool isFunction; }; struct CacheEntry { explicit CacheEntry(const QString& value=QString(), const QString &doc=QString()) : value(value), doc(doc) {} QString value; QString doc; }; struct Target { typedef QMap Properties; enum Type { Library, Executable, Custom }; KDevelop::IndexedDeclaration declaration; QStringList files; Type type; CMakeFunctionDesc desc; QString name; }; typedef Target CMakeTarget; //Workaround for namespacing. fix me! struct Subdirectory { QString name; CMakeFunctionDesc desc; QString build_dir; }; struct Test { Test() {} QString name; KDevelop::Path executable; QStringList arguments; QHash properties; }; Q_DECLARE_TYPEINFO(Test, Q_MOVABLE_TYPE); Q_DECLARE_TYPEINFO(Subdirectory, Q_MOVABLE_TYPE); Q_DECLARE_TYPEINFO(Target, Q_MOVABLE_TYPE); Q_DECLARE_TYPEINFO(CacheEntry, Q_MOVABLE_TYPE); Q_DECLARE_TYPEINFO(Macro, Q_MOVABLE_TYPE); enum PropertyType { GlobalProperty, DirectoryProperty, TargetProperty, SourceProperty, TestProperty, CacheProperty, VariableProperty }; typedef QHash > CategoryType; typedef QMap CMakeProperties; typedef QHash MacroMap; typedef QHash CMakeDefinitions; typedef QHash CacheValues; Q_DECLARE_METATYPE(QList) Q_DECLARE_METATYPE(PropertyType); #endif diff --git a/projectmanagers/cmake/parser/generationexpressionsolver.cpp b/projectmanagers/cmake/parser/generationexpressionsolver.cpp deleted file mode 100644 index 54fc05800c..0000000000 --- a/projectmanagers/cmake/parser/generationexpressionsolver.cpp +++ /dev/null @@ -1,153 +0,0 @@ -/* KDevelop CMake Support - * - * Copyright 2013 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 "generationexpressionsolver.h" -#include "../debug.h" -#include -#include - -QHash GenerationExpressionSolver::s_vars; -QSet GenerationExpressionSolver::s_neededValues; - -GenerationExpressionSolver::GenerationExpressionSolver(const CMakeProperties& properties, const QHash& alias) - : m_alias(alias) - , m_props(properties) -{ - if(s_vars.isEmpty()) { - s_vars["ANGLE-R"] = QChar('>'); - s_vars["COMMA"] = QChar(','); - s_vars["SEMICOLON"] = QChar(';'); - - s_neededValues.insert("BUILD_INTERFACE"); - s_neededValues.insert("INSTALL_INTERFACE"); - } -} - -void GenerationExpressionSolver::defineVariable(const QString& key, const QString& value) -{ - m_values.insert(key, value); -} - -QString GenerationExpressionSolver::run(const QString& op) -{ - if(!op.startsWith("$<")) - return op; - - return process(op); -} - -QString GenerationExpressionSolver::process(const QString& op) -{ - QString ret; - int i = op.indexOf("$<"), last = 0; - for(; i>=0 && i') { - if(depth==0) { - if(split<0) - split = i; - - ret += calculate(op.mid(j, split-j), op.mid(split+1, i-split-1)); - last = i+1; - break; - } else - --depth; - } else if(op.mid(i, 2)=="$<") { - ++depth; - } else if(op[i]==':') { - split = i; - } - } - Q_ASSERT(depth==0); - i = op.indexOf("$<", i+1); - } - ret += op.mid(last); - return ret; -} - -QString GenerationExpressionSolver::calculate(const QString& pre, const QString& post) -{ - if(pre == "0") - return QString(); - else if(pre == "1") { - return process(post); - } else if(pre == "BOOL") { - static QSet s_trueDefinitions=QSet() << "1" << "on" << "yes" << "true" << "y"; - bool ret = s_trueDefinitions.contains(post.toLower()); - return ret ? "1" : "0"; - } else if(pre == "AND") { - QStringList vals = post.split(','); - bool ret = true; - foreach(const QString& op, vals) { - ret &= (process(op) == "1"); - } - return ret ? "1" : "0"; - } else if(pre == "OR") { - QStringList vals = post.split(','); - bool ret = false; - foreach(const QString& op, vals) { - ret |= (process(op) == "1"); - } - return ret ? "1" : "0"; - } else if(pre == "STREQUAL") { - QStringList vals = post.split(','); - bool ret = false; - if(!vals.isEmpty()) { - QString first = vals.first(); - for(QStringList::const_iterator it=vals.constBegin()+1, itEnd=vals.constEnd(); it!=itEnd; ++it) { - ret |= (process(*it) == first); - } - } - return ret ? "1" : "0"; - } else if(pre == "NOT") { - bool val = process(post) == "1"; - return !val ? "1" : "0"; - } else if(pre == "TARGET_PROPERTY") { - int idx = post.indexOf(','); - QString targetName, propName; - if(idx>0) { - targetName = post.left(idx); - propName = post.mid(idx+1); - targetName = m_alias.value(targetName, targetName); - } else { - targetName = m_name; - propName = post; - } - return m_props[TargetProperty][targetName][propName].join(":"); - } else if(s_neededValues.contains(pre)) { - return process(post); - } else if(m_values.contains(pre)) { - return m_values.value(pre); - } else { - QString ret = s_vars.value(pre); - if(ret.isEmpty()) { - qCDebug(CMAKE) << "unknown expression" << pre << post; - } - return ret; - } -} - -void GenerationExpressionSolver::setTargetName(const QString& name) -{ - m_name = m_alias.value(name, name); -} diff --git a/projectmanagers/cmake/parser/generationexpressionsolver.h b/projectmanagers/cmake/parser/generationexpressionsolver.h deleted file mode 100644 index 31165a4d0b..0000000000 --- a/projectmanagers/cmake/parser/generationexpressionsolver.h +++ /dev/null @@ -1,48 +0,0 @@ -/* KDevelop CMake Support - * - * Copyright 2013 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. - */ - -#ifndef GENERATIONEXPRESSIONSOLVER_H -#define GENERATIONEXPRESSIONSOLVER_H - -#include "cmakecommonexport.h" -#include "cmaketypes.h" - -class KDEVCMAKECOMMON_EXPORT GenerationExpressionSolver -{ - public: - GenerationExpressionSolver(const CMakeProperties& properties, const QHash& alias); - void setTargetName(const QString& name); - - void defineVariable(const QString& key, const QString& value); - QString run(const QString& op); - - private: - QString process(const QString& op); - QString calculate(const QString& pre, const QString& post); - - static QHash s_vars; - static QSet s_neededValues; - QHash m_values; - const QHash m_alias; - const CMakeProperties m_props; - QString m_name; -}; - -#endif // GENERATIONEXPRESSIONSOLVER_H diff --git a/projectmanagers/cmake/parser/variablemap.cpp b/projectmanagers/cmake/parser/variablemap.cpp deleted file mode 100644 index 2d54757c7b..0000000000 --- a/projectmanagers/cmake/parser/variablemap.cpp +++ /dev/null @@ -1,98 +0,0 @@ -/* KDevelop CMake Support - * - * Copyright 2007 Aleix Pol - * - * 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 "variablemap.h" -#include "../debug.h" - -VariableMap::VariableMap() -{ - m_scopes.push(QSet()); -} - -QStringList splitVariable(const QStringList& input) -{ - QStringList ret; - foreach(const QString& v, input) - { - if(v.isEmpty()) - continue; - - ret += v.split(';'); - } - return ret; -} - -void VariableMap::insert(const QString& varName, const QStringList& value, bool parentScope) -{ - QSet< QString >* current; -// qCDebug(CMAKE) << "leeeeeeeeeeeeE" << varName << value << parentScope; - if(parentScope && m_scopes.size()>1) { //TODO: provide error? - current = &m_scopes[m_scopes.size()-2]; - m_scopes.top().remove(varName); - } else - current = &m_scopes.top(); - - QStringList ret = splitVariable(value); - - if(current->contains(varName)) - (*this)[varName]=ret; - else { - current->insert(varName); - QHash::insertMulti(varName, ret); - } - -// QHash::insert(varName, ret); -// qCDebug(CMAKE) << "++++++++" << varName << QHash::value(varName); -} - -QHash::iterator VariableMap::insertMulti(const QString & varName, const QStringList & value) -{ - return QHash::insertMulti(varName, splitVariable(value)); -} - -void VariableMap::insertGlobal(const QString& varName, const QStringList& value) -{ - QHash::insert(varName, value); -} - -void VariableMap::pushScope() -{ - m_scopes.push(QSet()); -} - -void VariableMap::popScope() -{ - QSet t=m_scopes.pop(); - foreach(const QString& var, t) { -// qCDebug(CMAKE) << "removing........" << var << QHash::value(var); - take(var); - } -} - -int VariableMap::removeMulti(const QString& varName) -{ - iterator it = find(varName); - if(it==end()) - return 0; - else { - erase(it); - return 1; - } -} diff --git a/projectmanagers/cmake/parser/variablemap.h b/projectmanagers/cmake/parser/variablemap.h deleted file mode 100644 index d5ccf94c33..0000000000 --- a/projectmanagers/cmake/parser/variablemap.h +++ /dev/null @@ -1,62 +0,0 @@ -/* KDevelop CMake Support - * - * Copyright 2007 Aleix Pol - * - * 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. - */ - -#ifndef CMAKE_VARIABLEMAP_H -#define CMAKE_VARIABLEMAP_H - -#include -#include -#include "cmakecommonexport.h" -#include -#include - -class KDEVCMAKECOMMON_EXPORT VariableMap : public QHash -{ - public: - VariableMap(); -// bool contains(const QString& varName) const; - void insert(const QString& varName, const QStringList& value, bool parentScope = false); - - ///only for very special cases, usually should use insert. bypasses scopes - iterator insertMulti(const QString& varName, const QStringList& value); - -// QStringList value(const QString& varName) const; -// QStringList take(const QString& varName); -// int remove(const QString& varName); - int removeMulti(const QString& varName); -// -// int size() const { return QHash::size(); } -// QStringList keys() const { return QHash::keys(); } - static QString regexVar() { return "\\$\\{[A-z0-9\\-._:]+\\}"; } -#ifdef Q_OS_WIN - static QString regexEnvVar() { return "\\$ENV\\{[A-z0-9\\-._:]+\\}"; } -#else - static QString regexEnvVar() { return "\\$ENV\\{[A-z0-9\\-._]+\\}"; } -#endif - void pushScope(); - void popScope(); - - /** will create a variable without adding a scope on it */ - void insertGlobal(const QString& key, const QStringList& value); - private: - KDevelop::Stack > m_scopes; -}; - -#endif