parseInput.h

/*
 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
 * Copyright 2013-present Barefoot Networks, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef FRONTENDS_COMMON_PARSEINPUT_H_
#define FRONTENDS_COMMON_PARSEINPUT_H_
 
#include "frontends/common/options.h"
#include "frontends/common/parser_options.h"
#include "frontends/p4-14/fromv1.0/converters.h"
#include "frontends/parsers/parserDriver.h"
#include "lib/error.h"
 
namespace P4::IR {
class P4Program;
}  // namespace P4::IR
 
namespace P4 {
 
template <typename Input, typename C = P4V1::Converter>
static const IR::P4Program *parseV1Program(Input stream, std::string_view sourceFile,
                                           unsigned sourceLine,
                                           std::optional<DebugHook> debugHook = std::nullopt) {
    // We load the model before parsing the input file, so that the SourceInfo
    // in the model comes first.
    C converter;
    if (debugHook) converter.addDebugHook(*debugHook, true);
    converter.loadModel();
 
    // Parse.
    const IR::Node *v1 = V1::V1ParserDriver::parse(stream, sourceFile, sourceLine);
    if (::P4::errorCount() > 0 || v1 == nullptr) return nullptr;
 
    // Convert to P4-16.
    if (Log::verbose()) std::cerr << "Converting to P4-16" << std::endl;
    v1 = v1->apply(converter);
    if (::P4::errorCount() > 0 || v1 == nullptr) return nullptr;
    BUG_CHECK(v1->is<IR::P4Program>(), "Conversion returned %1%", v1);
    return v1->to<IR::P4Program>();
}

template <typename C = P4V1::Converter>
const IR::P4Program *parseP4File(const ParserOptions &options) {
    BUG_CHECK(&options == &P4CContext::get().options(),
              "Parsing using options that don't match the current "
              "compiler context");
 
    const IR::P4Program *result = nullptr;
    if (options.doNotPreprocess) {
        auto *file = fopen(options.file.c_str(), "r");
        if (file == nullptr) {
            ::P4::error(ErrorType::ERR_NOT_FOUND, "%1%: No such file or directory.", options.file);
            return nullptr;
        }
        result = options.isv1() ? parseV1Program<FILE *, C>(file, options.file.string(), 1,
                                                            options.getDebugHook())
                                : P4ParserDriver::parse(file, options.file.string());
        fclose(file);
    } else {
        auto preprocessorResult = options.preprocess();
        if (!preprocessorResult.has_value()) {
            return nullptr;
        }
        // Need to assign file here because the parser requires an lvalue.
        result =
            options.isv1()
                ? parseV1Program<FILE *, C>(preprocessorResult.value().get(), options.file.string(),
                                            1, options.getDebugHook())
                : P4ParserDriver::parse(preprocessorResult.value().get(), options.file.string());
    }
 
    if (::P4::errorCount() > 0) {
        ::P4::error(ErrorType::ERR_OVERLIMIT, "%1% errors encountered, aborting compilation",
                    ::P4::errorCount());
        return nullptr;
    }
    BUG_CHECK(result != nullptr, "Parsing failed, but we didn't report an error");
    return result;
}

const IR::P4Program *parseP4String(const char *sourceFile, unsigned sourceLine,
                                   const std::string &input,
                                   CompilerOptions::FrontendVersion version);
const IR::P4Program *parseP4String(const std::string &input,
                                   CompilerOptions::FrontendVersion version);
 
}  // namespace P4
 
#endif /* FRONTENDS_COMMON_PARSEINPUT_H_ */