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 <set>
#include <unordered_map>
 
#include "ir/configuration.h"
#include "ir/pass_manager.h"
#include "lib/compile_context.h"
#include "lib/cstring.h"
#include "lib/options.h"
 
// Standard include paths for .p4 header files. The values are determined by
// `configure`.
extern const char *p4includePath;
extern const char *p4_14includePath;
 
// Base class for compiler options.
// This class contains the options for the front-ends.
// Each back-end should subclass this file.
class ParserOptions : public Util::Options {
    bool close_input = false;
    static const char *defaultMessage;
 
    // annotation names that are to be ignored by the compiler
    std::set<cstring> disabledAnnotations;
 
    // used to generate dump file names
    mutable size_t dump_uid = 0;
 
 protected:
    // Function that is returned by getDebugHook.
    void dumpPass(const char *manager, unsigned seq, const char *pass, const IR::Node *node) const;
    // Checks if parsed options make sense with respect to each-other.
    virtual void validateOptions() const;
 
 public:
    ParserOptions();
    std::vector<const char *> *process(int argc, char *const argv[]) override;
    enum class FrontendVersion { P4_14, P4_16 };
    // Name of executable that is being run.
    cstring exe_name;
    // Which language to compile
    FrontendVersion langVersion = FrontendVersion::P4_16;
    // options to pass to preprocessor
    cstring preprocessor_options = "";
    // file to compile (- for stdin)
    cstring file = nullptr;
    // if true preprocess only
    bool doNotCompile = false;
    // Compiler version.
    cstring compilerVersion;
    // if true skip preprocess
    bool doNotPreprocess = false;
    // substrings matched against pass names
    std::vector<cstring> top4;
    // debugging dumps of programs written in this folder
    cstring dumpFolder = ".";
    // If false, optimization of callee parsers (subparsers) inlining is disabled.
    bool optimizeParserInlining = false;
    // Expect that the only remaining argument is the input file.
    void setInputFile();
    // Return target specific include path.
    const char *getIncludePath() override;
    // Returns the output of the preprocessor.
    FILE *preprocess();
    // Closes the input stream returned by preprocess.
    void closePreprocessedInput(FILE *input) const;
    // True if we are compiling a P4 v1.0 or v1.1 program
    bool isv1() const;
    // Get a debug hook function suitable for insertion
    // in the pass managers that are executed.
    DebugHook getDebugHook() const;
    // Check whether this particular annotation was disabled
    bool isAnnotationDisabled(const IR::Annotation *a) const;
    // Search and set 'includePathOut' to be the first valid path from the
    // list of possible relative paths.
    bool searchForIncludePath(const char *&includePathOut, std::vector<cstring> relativePaths,
                              const char *);
    bool noIncludes = false;
};
 
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);
    }
 
    DiagnosticAction getDiagnosticAction(cstring diagnostic, DiagnosticAction defaultAction) final {
        return errorReporter().getDiagnosticAction(diagnostic, defaultAction);
    }
 
    void setDiagnosticAction(cstring 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;
};
 
#endif /* FRONTENDS_COMMON_PARSER_OPTIONS_H_*/