code_generator.h

Go to the documentation of this file.

#pragma once
 
#include <filesystem>
#include <string>
#include <utility>
 
#include "code_snippet_factory.h"
#include "sdfg/codegen/instrumentation/arg_capture_plan.h"
#include "sdfg/codegen/instrumentation/instrumentation_plan.h"
#include "sdfg/codegen/utils.h"
#include "sdfg/structured_sdfg.h"
#include "sdfg/types/type.h"
 
namespace sdfg {
namespace codegen {

class CodeGenerator {
protected:
    StructuredSDFG& sdfg_;

    analysis::AnalysisManager& analysis_manager_;

    InstrumentationPlan& instrumentation_plan_;
    ArgCapturePlan& arg_capture_plan_;

    PrettyPrinter includes_stream_;

    PrettyPrinter classes_stream_;

    PrettyPrinter globals_stream_;

    std::shared_ptr<CodeSnippetFactory> library_snippet_factory_;

    PrettyPrinter main_stream_;

    std::string externals_prefix_;
 
public:
    CodeGenerator(
        StructuredSDFG& sdfg,
        analysis::AnalysisManager& analysis_manager,
        InstrumentationPlan& instrumentation_plan,
        ArgCapturePlan& arg_capture_plan,
        std::shared_ptr<CodeSnippetFactory> library_snippet_factory = std::make_shared<CodeSnippetFactory>(),
        const std::string& externals_prefix = ""
    )
        : sdfg_(sdfg), analysis_manager_(analysis_manager), instrumentation_plan_(instrumentation_plan),
          arg_capture_plan_(arg_capture_plan), library_snippet_factory_(std::move(library_snippet_factory)),
          externals_prefix_(externals_prefix) {};
 
 
    virtual ~CodeGenerator() = default;
 
    [[nodiscard]] const StructuredSDFG& sdfg() const {
        return this->sdfg_;
    };

    virtual bool generate() = 0;

    virtual std::string function_definition() = 0;

    virtual bool emit_header(PrettyPrinter& out) = 0;

    virtual bool emit_main_source(std::ostream& out, const std::filesystem::path& header_path) = 0;

    virtual bool as_source(const std::filesystem::path& header_path, const std::filesystem::path& source_path) = 0;

    virtual void append_function_source(std::ostream& ofs_source) = 0;

    const PrettyPrinter& includes() const {
        return this->includes_stream_;
    };

    const PrettyPrinter& classes() const {
        return this->classes_stream_;
    };

    const PrettyPrinter& globals() const {
        return this->globals_stream_;
    };

    const std::unordered_map<std::string, CodeSnippet>& library_snippets() const {
        return this->library_snippet_factory_->snippets();
    };

    const PrettyPrinter& main() const {
        return this->main_stream_;
    };
};
 
} // namespace codegen
} // namespace sdfg