parser_options.h

/*
 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
 * Copyright 2013-present Barefoot Networks, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
/* -*-C++-*- */
 
#ifndef FRONTENDS_COMMON_PARSER_OPTIONS_H_
#define FRONTENDS_COMMON_PARSER_OPTIONS_H_
 
#include <cstdio>
#include <filesystem>
#include <set>
 
#include "../p4/metrics/metricsStructure.h"
#include "ir/configuration.h"
#include "ir/pass_manager.h"
#include "lib/compile_context.h"
#include "lib/cstring.h"
#include "lib/options.h"
 
namespace P4 {
 
class ToP4;

extern std::filesystem::path p4includePath;
extern std::filesystem::path p4_14includePath;

bool isSystemFile(cstring filename);
bool isSystemFile(const std::filesystem::path &filename);

class ParserOptions : public Util::Options {
    std::set<cstring> disabledAnnotations;

    mutable size_t dump_uid = 0;
 
 protected:
    void dumpPass(const char *manager, unsigned seq, const char *pass, const IR::Node *node) const;

    virtual std::unique_ptr<ToP4> getToP4(std::ostream *, bool, std::filesystem::path) const;
 
 public:
    explicit ParserOptions(std::string_view defaultMessage = "Parse a P4 program");
 
    std::vector<const char *> *process(int argc, char *const argv[]) override;
    enum class FrontendVersion { P4_14, P4_16 };

    static void closeFile(FILE *file);
    using PreprocessorResult = std::unique_ptr<FILE, decltype(&closeFile)>;

    cstring exe_name;
    FrontendVersion langVersion = FrontendVersion::P4_16;
    cstring preprocessor_options = cstring::empty;
    std::filesystem::path file;
    bool doNotCompile = false;
    cstring compilerVersion;
    bool doNotPreprocess = false;
    std::vector<cstring> top4;
    std::filesystem::path dumpFolder = ".";
    bool optimizeParserInlining = false;
    void setInputFile();
    const char *getIncludePath() const override;
    std::optional<ParserOptions::PreprocessorResult> preprocess() const;
    bool isv1() const;
    DebugHook getDebugHook() const;
    bool isAnnotationDisabled(const IR::Annotation *a) const;
    static bool searchForIncludePath(std::filesystem::path &includePathOut,
                                     const std::vector<cstring> &userSpecifiedPaths,
                                     const std::filesystem::path &exename);
    bool noIncludes = false;
    Metrics metrics;
};

class P4CContext : public BaseCompileContext {
 public:
    static P4CContext &get();

    static const P4CConfiguration &getConfig();
 
    P4CContext() {}

    virtual ParserOptions &options() = 0;

    DiagnosticAction getDefaultInfoDiagnosticAction() final {
        return errorReporter().getDefaultInfoDiagnosticAction();
    }

    void setDefaultInfoDiagnosticAction(DiagnosticAction action) {
        errorReporter().setDefaultInfoDiagnosticAction(action);
    }

    DiagnosticAction getDefaultWarningDiagnosticAction() final {
        return errorReporter().getDefaultWarningDiagnosticAction();
    }

    void setDefaultWarningDiagnosticAction(DiagnosticAction action) {
        errorReporter().setDefaultWarningDiagnosticAction(action);
    }

    void setDiagnosticAction(std::string_view diagnostic, DiagnosticAction action) {
        errorReporter().setDiagnosticAction(diagnostic, action);
    }
 
 protected:
    virtual bool isRecognizedDiagnostic(cstring diagnostic);

    virtual const P4CConfiguration &getConfigImpl();
};

template <typename OptionsType>
class P4CContextWithOptions final : public P4CContext {
 public:
    static P4CContextWithOptions &get() {
        return CompileContextStack::top<P4CContextWithOptions>();
    }
 
    P4CContextWithOptions() {}
 
    template <typename OptionsDerivedType>
    P4CContextWithOptions(P4CContextWithOptions<OptionsDerivedType> &context) {
        optionsInstance = context.options();
    }
 
    template <typename OptionsDerivedType>
    P4CContextWithOptions &operator=(P4CContextWithOptions<OptionsDerivedType> &context) {
        optionsInstance = context.options();
    }

    OptionsType &options() override { return optionsInstance; }
 
 private:
    OptionsType optionsInstance;
};
 
}  // namespace P4
 
#endif /* FRONTENDS_COMMON_PARSER_OPTIONS_H_*/