File Manager

003 File Manager

Current Path: /usr/src/contrib/llvm-project/clang/lib/Tooling

usr / src / contrib / llvm-project / clang / lib / Tooling /

📁 ..
📁 ASTDiff
📄 AllTUsExecution.cpp(6.2 KB)
📄 ArgumentsAdjusters.cpp(5.64 KB)
📄 CommonOptionsParser.cpp(7.12 KB)
📄 CompilationDatabase.cpp(15.17 KB)
📁 Core
📁 DependencyScanning
📄 Execution.cpp(3.9 KB)
📄 ExpandResponseFilesCompilationDatabase.cpp(3.05 KB)
📄 FileMatchTrie.cpp(6.96 KB)
📄 FixIt.cpp(1 KB)
📄 GuessTargetAndModeCompilationDatabase.cpp(1.67 KB)
📁 Inclusions
📄 InterpolatingCompilationDatabase.cpp(21.22 KB)
📄 JSONCompilationDatabase.cpp(14.9 KB)
📁 Refactoring
📄 Refactoring.cpp(3.56 KB)
📄 RefactoringCallbacks.cpp(8.84 KB)
📄 StandaloneExecution.cpp(3.4 KB)
📁 Syntax
📄 Tooling.cpp(25.65 KB)
📁 Transformer

Editing: Execution.cpp

//===- lib/Tooling/Execution.cpp - Implements tool execution framework. ---===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "clang/Tooling/Execution.h"
#include "clang/Tooling/ToolExecutorPluginRegistry.h"
#include "clang/Tooling/Tooling.h"

LLVM_INSTANTIATE_REGISTRY(clang::tooling::ToolExecutorPluginRegistry)

namespace clang {
namespace tooling {

llvm::cl::opt<std::string>
    ExecutorName("executor", llvm::cl::desc("The name of the executor to use."),
                 llvm::cl::init("standalone"));

void InMemoryToolResults::addResult(StringRef Key, StringRef Value) {
  KVResults.push_back({Strings.save(Key), Strings.save(Value)});
}

std::vector<std::pair<llvm::StringRef, llvm::StringRef>>
InMemoryToolResults::AllKVResults() {
  return KVResults;
}

void InMemoryToolResults::forEachResult(
    llvm::function_ref<void(StringRef Key, StringRef Value)> Callback) {
  for (const auto &KV : KVResults) {
    Callback(KV.first, KV.second);
  }
}

void ExecutionContext::reportResult(StringRef Key, StringRef Value) {
  Results->addResult(Key, Value);
}

llvm::Error
ToolExecutor::execute(std::unique_ptr<FrontendActionFactory> Action) {
  return execute(std::move(Action), ArgumentsAdjuster());
}

llvm::Error ToolExecutor::execute(std::unique_ptr<FrontendActionFactory> Action,
                                  ArgumentsAdjuster Adjuster) {
  std::vector<
      std::pair<std::unique_ptr<FrontendActionFactory>, ArgumentsAdjuster>>
      Actions;
  Actions.emplace_back(std::move(Action), std::move(Adjuster));
  return execute(Actions);
}

namespace internal {
llvm::Expected<std::unique_ptr<ToolExecutor>>
createExecutorFromCommandLineArgsImpl(int &argc, const char **argv,
                                      llvm::cl::OptionCategory &Category,
                                      const char *Overview) {
  auto OptionsParser =
      CommonOptionsParser::create(argc, argv, Category, llvm::cl::ZeroOrMore,
                                  /*Overview=*/Overview);
  if (!OptionsParser)
    return OptionsParser.takeError();
  for (const auto &TEPlugin : ToolExecutorPluginRegistry::entries()) {
    if (TEPlugin.getName() != ExecutorName) {
      continue;
    }
    std::unique_ptr<ToolExecutorPlugin> Plugin(TEPlugin.instantiate());
    llvm::Expected<std::unique_ptr<ToolExecutor>> Executor =
        Plugin->create(*OptionsParser);
    if (!Executor) {
      return llvm::make_error<llvm::StringError>(
          llvm::Twine("Failed to create '") + TEPlugin.getName() +
              "': " + llvm::toString(Executor.takeError()) + "\n",
          llvm::inconvertibleErrorCode());
    }
    return std::move(*Executor);
  }
  return llvm::make_error<llvm::StringError>(
      llvm::Twine("Executor \"") + ExecutorName + "\" is not registered.",
      llvm::inconvertibleErrorCode());
}
} // end namespace internal

llvm::Expected<std::unique_ptr<ToolExecutor>>
createExecutorFromCommandLineArgs(int &argc, const char **argv,
                                  llvm::cl::OptionCategory &Category,
                                  const char *Overview) {
  return internal::createExecutorFromCommandLineArgsImpl(argc, argv, Category,
                                                         Overview);
}

// This anchor is used to force the linker to link in the generated object file
// and thus register the StandaloneToolExecutorPlugin etc.
extern volatile int StandaloneToolExecutorAnchorSource;
extern volatile int AllTUsToolExecutorAnchorSource;
static int LLVM_ATTRIBUTE_UNUSED StandaloneToolExecutorAnchorDest =
    StandaloneToolExecutorAnchorSource;
static int LLVM_ATTRIBUTE_UNUSED AllTUsToolExecutorAnchorDest =
    AllTUsToolExecutorAnchorSource;

} // end namespace tooling
} // end namespace clang

003 File Manager

Editing: Execution.cpp

Upload File

Create Folder