Welder.hpp

Go to the documentation of this file.

/**
 * @file Welder.hpp
 * @author Lexy Plateau (lexplt.dev@gmail.com)
 * @brief In charge of welding everything needed to compile code
 * @date 2023-03-26
 *
 * @copyright Copyright (c) 2023-2026
 *
 */
 
#ifndef ARK_COMPILER_WELDER_HPP
#define ARK_COMPILER_WELDER_HPP
 
#include <string>
#include <vector>
#include <filesystem>
 
#include <Ark/Compiler/Common.hpp>
#include <Ark/Compiler/AST/Node.hpp>
#include <Ark/Compiler/AST/Parser.hpp>
#include <Ark/Compiler/Lowerer/ASTLowerer.hpp>
#include <Ark/Compiler/IntermediateRepresentation/IROptimizer.hpp>
#include <Ark/Compiler/IntermediateRepresentation/IRCompiler.hpp>
#include <Ark/Constants.hpp>
#include <Ark/Utils/Logger.hpp>
#include <Ark/Compiler/Package/ImportSolver.hpp>
#include <Ark/Compiler/Macros/Processor.hpp>
#include <Ark/Compiler/AST/Optimizer.hpp>
#include <Ark/Compiler/NameResolution/NameResolutionPass.hpp>
 
namespace Ark
{
    class Value;
 
    /**
     * @brief The welder joins all the compiler passes
     */
    class ARK_API Welder final
    {
    public:
        /**
         * @brief Create a new Welder
         * @param debug debug level
         * @param lib_env list of paths to the standard library
         * @param features feature flags to toggle features on/off
         */
        Welder(unsigned debug, const std::vector<std::filesystem::path>& lib_env, uint16_t features = DefaultFeatures);
 
        /**
         * @brief Register a symbol as a global in the compiler
         *
         * @param name
         */
        void registerSymbol(const std::string& name);
 
        /**
         *
         * @param filename
         * @return true on success
         */
        bool computeASTFromFile(const std::string& filename);
 
        /**
         *
         * @param code
         * @return true on success
         */
        bool computeASTFromString(const std::string& code);
 
        /**
         * @brief Compile code from a string, with a set of known symbols (useful for the debugger)
         *
         * @param code
         * @param symbols
         * @return true on success
         */
        bool computeASTFromStringWithKnownSymbols(const std::string& code, const std::vector<std::string>& symbols);
 
        /**
         * @brief Compile the AST processed by computeASTFromFile / computeASTFromString
         *
         * @return true on success
         */
        bool generateBytecode();
 
        /**
         * @brief Compile the AST processed by computeASTFromFile / computeASTFromString, with prefilled symbols and constants tables (useful for the debugger)
         *
         * @param symbols
         * @param constants
         * @param start_page_at_offset
         * @return true on success
         */
        bool generateBytecodeUsingTables(const std::vector<std::string>& symbols, const std::vector<Value>& constants, std::size_t start_page_at_offset);
 
        /**
         * @brief Save the generated bytecode to a given file
         * @param filename
         * @return true on success
         */
        bool saveBytecodeToFile(const std::string& filename);
 
        /**
         * @brief Redirect the logs to a given stream
         * @param os output stream
         */
        void redirectLogsTo(std::ostream& os);
 
        [[nodiscard]] const internal::Node& ast() const noexcept;
        [[nodiscard]] std::string textualIR() const noexcept;
        [[nodiscard]] const bytecode_t& bytecode() const noexcept;
 
    private:
        std::vector<std::filesystem::path> m_lib_env;
        uint16_t m_features;
 
        std::filesystem::path m_root_file;
        std::vector<std::string> m_imports;
        std::vector<internal::IR::Block> m_ir;
        bytecode_t m_bytecode;
        internal::Node m_computed_ast;
 
        internal::Parser m_parser;
        internal::ImportSolver m_import_solver;
        internal::MacroProcessor m_macro_processor;
        internal::Optimizer m_ast_optimizer;
        internal::NameResolutionPass m_name_resolver;
 
        internal::Logger m_logger;
        internal::ASTLowerer m_lowerer;
        internal::IROptimizer m_ir_optimizer;
        internal::IRCompiler m_ir_compiler;
 
        void dumpIRToFile() const;
 
        bool computeAST(const std::string& filename, const std::string& code);
    };
}  // namespace Ark
 
#endif