parser_options.h

/*
Copyright 2013-present Barefoot Networks, Inc.
 
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
 
    http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
 
/* -*-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_*/