parserDriver.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.
*/
 
#ifndef FRONTENDS_PARSERS_PARSERDRIVER_H_
#define FRONTENDS_PARSERS_PARSERDRIVER_H_
 
#include <cstdio>
#include <iostream>
#include <string>
#include <string_view>
 
#include "frontends/p4/symbol_table.h"
#include "frontends/parsers/p4/abstractP4Lexer.hpp"
#include "frontends/parsers/p4/p4AnnotationLexer.hpp"
#include "ir/ir.h"
#include "lib/cstring.h"
#include "lib/source_file.h"
 
namespace P4 {
 
class P4Lexer;
class P4Parser;

class AbstractParserDriver {
 public:
    virtual ~AbstractParserDriver() = 0;
 
 protected:
    AbstractParserDriver();

    // Callbacks.

    void onReadComment(const char *text, bool lineComment);

    void onReadToken(const char *text);

    void onReadLineNumber(const char *text);

    void onReadFileName(const char *text);

    void onReadIdentifier(cstring id);

    void onParseError(const Util::SourceInfo &location, const std::string &message);

    // Shared state manipulated directly by the lexer and parser.

    Util::InputSources *sources;

    Util::SourceInfo yylloc;

    int saveState = -1;
 
 private:
    int lineDirectiveLine = 0;

    cstring lineDirectiveFile;

    cstring lastIdentifier;
};

class P4ParserDriver final : public AbstractParserDriver {
 public:
    static const IR::P4Program *parse(std::istream &in, std::string_view sourceFile,
                                      unsigned sourceLine = 1);
    static const IR::P4Program *parse(FILE *in, std::string_view sourceFile,
                                      unsigned sourceLine = 1);

    static std::pair<const IR::P4Program *, const Util::InputSources *> parseProgramSources(
        std::istream &in, std::string_view sourceFile, unsigned sourceLine = 1);
 
    static std::pair<const IR::P4Program *, const Util::InputSources *> parseProgramSources(
        FILE *in, std::string_view sourceFile, unsigned sourceLine = 1);

    // Lists /////////////////////////////////////////////////////////////////
    static const IR::Vector<IR::Expression> *parseExpressionList(
        const Util::SourceInfo &srcInfo, const IR::Vector<IR::AnnotationToken> &body);
 
    static const IR::IndexedVector<IR::NamedExpression> *parseKvList(
        const Util::SourceInfo &srcInfo, const IR::Vector<IR::AnnotationToken> &body);
 
    static const IR::Vector<IR::Expression> *parseConstantList(
        const Util::SourceInfo &srcInfo, const IR::Vector<IR::AnnotationToken> &body);
 
    static const IR::Vector<IR::Expression> *parseConstantOrStringLiteralList(
        const Util::SourceInfo &srcInfo, const IR::Vector<IR::AnnotationToken> &body);
 
    static const IR::Vector<IR::Expression> *parseStringLiteralList(
        const Util::SourceInfo &srcInfo, const IR::Vector<IR::AnnotationToken> &body);
 
    // Singletons ////////////////////////////////////////////////////////////
    static const IR::Expression *parseExpression(const Util::SourceInfo &srcInfo,
                                                 const IR::Vector<IR::AnnotationToken> &body);
 
    static const IR::Constant *parseConstant(const Util::SourceInfo &srcInfo,
                                             const IR::Vector<IR::AnnotationToken> &body);
 
    static const IR::Expression *parseConstantOrStringLiteral(
        const Util::SourceInfo &srcInfo, const IR::Vector<IR::AnnotationToken> &body);
 
    static const IR::StringLiteral *parseStringLiteral(const Util::SourceInfo &srcInfo,
                                                       const IR::Vector<IR::AnnotationToken> &body);
 
    // Pairs /////////////////////////////////////////////////////////////////
    static const IR::Vector<IR::Expression> *parseExpressionPair(
        const Util::SourceInfo &srcInfo, const IR::Vector<IR::AnnotationToken> &body);
 
    static const IR::Vector<IR::Expression> *parseConstantPair(
        const Util::SourceInfo &srcInfo, const IR::Vector<IR::AnnotationToken> &body);
 
    static const IR::Vector<IR::Expression> *parseStringLiteralPair(
        const Util::SourceInfo &srcInfo, const IR::Vector<IR::AnnotationToken> &body);
 
    // Triples ///////////////////////////////////////////////////////////////
    static const IR::Vector<IR::Expression> *parseExpressionTriple(
        const Util::SourceInfo &srcInfo, const IR::Vector<IR::AnnotationToken> &body);
 
    static const IR::Vector<IR::Expression> *parseConstantTriple(
        const Util::SourceInfo &srcInfo, const IR::Vector<IR::AnnotationToken> &body);
 
    static const IR::Vector<IR::Expression> *parseStringLiteralTriple(
        const Util::SourceInfo &srcInfo, const IR::Vector<IR::AnnotationToken> &body);
 
    // P4Runtime Annotations /////////////////////////////////////////////////
    static const IR::Vector<IR::Expression> *parseP4rtTranslationAnnotation(
        const Util::SourceInfo &srcInfo, const IR::Vector<IR::AnnotationToken> &body);
 
 protected:
    friend class P4::P4Lexer;
    friend class P4::P4Parser;

    //  @return true if this is the first error declaration, false if it has
    //          been combined into a previous one (and should be elided)
    bool onReadErrorDeclaration(IR::Type_Error *error);

    // Shared state manipulated directly by the lexer and parser.

    Util::ProgramStructure *structure = nullptr;

    IR::Node *result = nullptr;

    std::string stringLiteral;
 
    // flag to track when template args are expected, to adjust the precedence
    // of '<'
    bool template_args = false;
 
 private:
    P4ParserDriver();

    bool parse(AbstractP4Lexer &lexer, std::string_view sourceFile, unsigned sourceLine = 1);

    template <typename T>
    const T *parse(P4AnnotationLexer::Type type, const Util::SourceInfo &srcInfo,
                   const IR::Vector<IR::AnnotationToken> &body);

    IR::Type_Error *allErrors = nullptr;
};
 
}  // namespace P4
 
namespace P4::V1 {
 
class V1Lexer;
class V1Parser;

class V1ParserDriver final : public P4::AbstractParserDriver {
 public:
    static const IR::V1Program *parse(std::istream &in, std::string_view sourceFile,
                                      unsigned sourceLine = 1);
    static const IR::V1Program *parse(FILE *in, std::string_view sourceFile,
                                      unsigned sourceLine = 1);
 
 protected:
    friend class V1::V1Lexer;
    friend class V1::V1Parser;

    IR::Constant *constantFold(IR::Expression *expr);

    IR::Vector<IR::Expression> makeExpressionList(const IR::NameList *list);

    void clearPragmas();

    void addPragma(IR::Annotation *pragma);

    IR::Vector<IR::Annotation> takePragmasAsVector();

    // Shared state manipulated directly by the lexer and parser.

    IR::V1Program *global = nullptr;
 
 private:
    IR::Vector<IR::Annotation> currentPragmas;
 
    V1ParserDriver();
};
 
}  // namespace P4::V1
 
#endif /* FRONTENDS_PARSERS_PARSERDRIVER_H_ */