p4ctool.h

/*
 * SPDX-FileCopyrightText: 2022 The P4 Language Consortium
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef BACKENDS_P4TOOLS_COMMON_P4CTOOL_H_
#define BACKENDS_P4TOOLS_COMMON_P4CTOOL_H_
 
#include <cstdlib>
#include <type_traits>
#include <vector>
 
#include "backends/p4tools/common/compiler/compiler_target.h"
#include "backends/p4tools/common/compiler/context.h"
#include "backends/p4tools/common/lib/logging.h"
#include "backends/p4tools/common/options.h"
#include "frontends/common/options.h"
 
namespace P4::P4Tools {

//
// Because of limitations of templates, method implementations must be inlined here.
template <class Options,
          typename = std::enable_if_t<std::is_base_of_v<AbstractP4cToolOptions, Options>>>
class AbstractP4cTool {
 protected:
    virtual int mainImpl(const CompilerResult &compilerResult) = 0;
 
    virtual void registerTarget() = 0;
 
 public:
    int main(std::string_view toolName, const std::vector<const char *> &args) {
        // Register supported compiler targets.
        registerTarget();
 
        // Initialize the target and the context.
        auto context = Target::initializeTarget(toolName, args);
        if (!context.has_value()) {
            return EXIT_FAILURE;
        }
        AutoCompileContext autoContext(context.value().get());
        Options &toolOptions =
            dynamic_cast<CompileContext<Options> *>(context.value().get())->options();
 
        // Process command-line options.
        auto result = toolOptions.process(args);
        if (result != EXIT_SUCCESS) {
            return EXIT_FAILURE;
        }
 
        // Set up the compilation context.
        // If not explicitly disabled, print basic information to standard output.
        if (!toolOptions.disableInformationLogging) {
            enableInformationLogging();
        }
 
        // Print the seed if it has been set.
        if (toolOptions.seed) {
            printInfo("============ Program seed %1% =============\n", *toolOptions.seed);
        }
 
        // Run the compiler to get an IR and invoke the tool.
        const auto compilerResult = P4Tools::CompilerTarget::runCompiler(toolOptions, toolName);
        if (!compilerResult.has_value()) {
            return EXIT_FAILURE;
        }
        return mainImpl(compilerResult.value());
    }
};
 
}  // namespace P4::P4Tools
 
#endif /* BACKENDS_P4TOOLS_COMMON_P4CTOOL_H_ */