bpp_codegen.h

Go to the documentation of this file.

 
#ifndef SRC_BPP_INCLUDE_BPP_CODEGEN_H_
#define SRC_BPP_INCLUDE_BPP_CODEGEN_H_
 
#include <string>
#include <memory>
#include <optional>
#include <deque>
#include <type_traits>
#include <antlr4-runtime.h>
 
#include "bpp.h"
#include "../antlr/BashppLexer.h"
#include "../internal_error.h"
 
namespace bpp {
// Minimal forward declarations
class bpp_program;
class bash_while_condition;
class bpp_class;
class bpp_object;
 
struct code_segment {
    std::string pre_code;
    std::string code;
    std::string post_code;
 
    std::string full_code() const {
        return pre_code + (pre_code.empty() ? "" : "\n") + code + (post_code.empty() ? "" : "\n") + post_code;
    }
};
 
code_segment generate_supershell_code(
    const std::string&                      code_to_run,
    bool                                    in_while_condition,
    std::shared_ptr<bash_while_condition>   current_while_condition,
    std::shared_ptr<bpp::bpp_program>       program
    );
 
code_segment generate_delete_code(
    std::shared_ptr<bpp_object>         object,
    const std::string&                  object_ref,
    std::shared_ptr<bpp::bpp_program>   program
    );
 
code_segment generate_method_call_code(
    const std::string&                  reference_code,
    const std::string&                  method_name,
    std::shared_ptr<bpp_class>          assumed_class,
    bool force_static_reference,
    std::shared_ptr<bpp::bpp_program>   program
    );
 
code_segment generate_dynamic_cast_code(
    const std::string&                  reference_code,
    const std::string&                  class_name,
    std::shared_ptr<bpp::bpp_program>   program
    );
 
code_segment generate_typeof_code(
    const std::string&                  reference_code,
    std::shared_ptr<bpp::bpp_program>   program
    );
 
code_segment inline_new(
    const std::string&                  new_address,
    std::shared_ptr<bpp::bpp_class>     new_class
    );
 
 
 
// Entity reference resolution
 
struct entity_reference {
    std::shared_ptr<bpp::bpp_entity> entity;
    code_segment reference_code;
    bool created_first_temporary_variable = false;
    bool created_second_temporary_variable = false;
    std::shared_ptr<bpp::bpp_class> class_containing_the_method;
    
    struct reference_error {
        std::string message;
        antlr4::tree::TerminalNode* token = nullptr;
    };
 
    std::optional<reference_error> error;
};
 
entity_reference resolve_reference_impl(
    const std::string& file,
    std::shared_ptr<bpp::bpp_entity> context,
    std::deque<antlr4::tree::TerminalNode*>* identifiers,
    std::deque<std::string>* identifier_texts,
    bool declare_local,
    std::shared_ptr<bpp::bpp_program> program
);
 
inline entity_reference resolve_reference(
    const std::string& file,
    std::shared_ptr<bpp::bpp_entity> context,
    auto identifiers,
    bool declare_local,
    std::shared_ptr<bpp::bpp_program> program
) {
    // identifiers should be either:
    // 1. A pointer to a container of strings (eg, std::deque<std::string>*)
    // 2. A pointer to a container of antlr4::tree::TerminalNode* (eg, std::deque<antlr4::tree::TerminalNode*>*)
 
    using ident_t = std::remove_cvref_t<decltype(identifiers)>;
    using container_t = std::remove_pointer_t<ident_t>;
    using value_t = typename container_t::value_type;
 
    std::deque<antlr4::tree::TerminalNode*> node_deque;
    std::deque<std::string> text_deque;
 
    if constexpr (std::is_convertible_v<value_t, std::string>) {
        // identifiers: deque<string>*
        for (const auto& id : *identifiers) {
            text_deque.push_back(id);
        }
        return resolve_reference_impl(file, context, &node_deque, &text_deque, declare_local, program);
    } else if constexpr (std::is_convertible_v<value_t, antlr4::tree::TerminalNode*>) {
        // identifiers: deque<TerminalNode*>*
        for (const auto& node : *identifiers) {
            node_deque.push_back(node);
        }
        for (const auto& node : node_deque) {
            text_deque.push_back(node->getText());
        }
        return resolve_reference_impl(file, context, &node_deque, &text_deque, declare_local, program);
    } else {
        static_assert(sizeof(value_t) == 0,
            "resolve_reference: Identifiers must be either strings or TerminalNode pointers.");
    }
 
}
 
} // namespace bpp
 
#endif // SRC_BPP_INCLUDE_BPP_CODEGEN_H_