builders.hpp

Go to the documentation of this file.

// AI Generated 2026 Ryan P. Nicholl <rnicholl@protonmail.com>
// SPDX-License-Identifier: Apache-2.0

 
#ifndef RPNX_CORTADO_BUILDERS_HPP
#define RPNX_CORTADO_BUILDERS_HPP
 
#include <cstddef>
#include <cstdint>
#include <limits>
#include <map>
#include <optional>
#include <rpnx/cortado/class_file.hpp>
#include <rpnx/cortado/descriptors.hpp>
#include <string>
#include <string_view>
#include <variant>
#include <vector>
 
namespace rpnx::cortado
{
    struct label_owner
    {
        std::uint64_t value{}; 
        RPNX_MEMBER_METADATA(label_owner, value);
    };

    struct label
    {
        label_owner owner; 
        std::size_t id{}; 
        RPNX_MEMBER_METADATA(label, owner, id);
    };

    struct label_binding
    {
        label value; 
        RPNX_MEMBER_METADATA(label_binding, value);
    };

    template < opcode Operation >
    struct labeled_branch_instruction
    {
        static constexpr opcode operation = Operation;
        label target; 
        RPNX_MEMBER_METADATA(labeled_branch_instruction, target);
    };

    struct labeled_lookup_switch_pair
    {
        std::int32_t match{}; 
        label target; 
        RPNX_MEMBER_METADATA(labeled_lookup_switch_pair, match, target);
    };

    struct labeled_tableswitch_instruction
    {
        label default_target; 
        std::int32_t low{}; 
        std::vector< label > targets; 
        RPNX_MEMBER_METADATA(labeled_tableswitch_instruction, default_target, low, targets);
    };

    struct labeled_lookupswitch_instruction
    {
        label default_target; 
        std::vector< labeled_lookup_switch_pair > pairs; 
        RPNX_MEMBER_METADATA(labeled_lookupswitch_instruction, default_target, pairs);
    };

    struct labeled_exception_handler
    {
        label start; 
        label end; 
        label handler; 
        std::optional< std::string > catch_type; 
        RPNX_MEMBER_METADATA(labeled_exception_handler, start, end, handler, catch_type);
    };

    struct labeled_line_number
    {
        label start; 
        std::uint16_t line_number{}; 
        RPNX_MEMBER_METADATA(labeled_line_number, start, line_number);
    };

    struct labeled_local_variable
    {
        label start; 
        label end; 
        std::string name; 
        std::string descriptor; 
        local_variable_index index; 
        RPNX_MEMBER_METADATA(labeled_local_variable, start, end, name, descriptor, index);
    };

    struct labeled_local_variable_type
    {
        label start; 
        label end; 
        std::string name; 
        std::string signature; 
        local_variable_index index; 
        RPNX_MEMBER_METADATA(labeled_local_variable_type, start, end, name, signature, index);
    };

    template < opcode Operation >
    struct symbolic_field_instruction
    {
        static constexpr opcode operation = Operation;
        std::string owner; 
        std::string name; 
        std::string descriptor; 
        RPNX_MEMBER_METADATA(symbolic_field_instruction, owner, name, descriptor);
    };

    enum class method_owner_kind : std::uint8_t { class_, interface };

    template < opcode Operation >
    struct symbolic_method_instruction
    {
        static constexpr opcode operation = Operation;
        std::string owner; 
        std::string name; 
        std::string descriptor; 
        method_owner_kind owner_kind{method_owner_kind::class_}; 
        RPNX_MEMBER_METADATA(symbolic_method_instruction, owner, name, descriptor, owner_kind);
    };

    struct symbolic_invokeinterface_instruction
    {
        std::string owner; 
        std::string name; 
        std::string descriptor; 
        RPNX_MEMBER_METADATA(symbolic_invokeinterface_instruction, owner, name, descriptor);
    };

    template < opcode Operation >
    struct symbolic_class_instruction
    {
        static constexpr opcode operation = Operation;
        std::string internal_name; 
        RPNX_MEMBER_METADATA(symbolic_class_instruction, internal_name);
    };

    struct symbolic_string_instruction
    {
        std::string value; 
        RPNX_MEMBER_METADATA(symbolic_string_instruction, value);
    };

    using assembly_element = std::variant< instruction, label_binding, labeled_branch_instruction< opcode::ifeq >, labeled_branch_instruction< opcode::ifne >, labeled_branch_instruction< opcode::iflt >, labeled_branch_instruction< opcode::ifge >, labeled_branch_instruction< opcode::ifgt >, labeled_branch_instruction< opcode::ifle >, labeled_branch_instruction< opcode::if_icmpeq >, labeled_branch_instruction< opcode::if_icmpne >, labeled_branch_instruction< opcode::if_icmplt >, labeled_branch_instruction< opcode::if_icmpge >, labeled_branch_instruction< opcode::if_icmpgt >, labeled_branch_instruction< opcode::if_icmple >, labeled_branch_instruction< opcode::if_acmpeq >, labeled_branch_instruction< opcode::if_acmpne >, labeled_branch_instruction< opcode::goto_ >, labeled_branch_instruction< opcode::jsr >, labeled_branch_instruction< opcode::ifnull >, labeled_branch_instruction< opcode::ifnonnull >, labeled_tableswitch_instruction, labeled_lookupswitch_instruction, symbolic_field_instruction< opcode::getstatic >, symbolic_field_instruction< opcode::putstatic >, symbolic_field_instruction< opcode::getfield >, symbolic_field_instruction< opcode::putfield >, symbolic_method_instruction< opcode::invokevirtual >, symbolic_method_instruction< opcode::invokespecial >, symbolic_method_instruction< opcode::invokestatic >, symbolic_invokeinterface_instruction, symbolic_class_instruction< opcode::new_ >, symbolic_class_instruction< opcode::anewarray >, symbolic_class_instruction< opcode::checkcast >, symbolic_class_instruction< opcode::instanceof_ >, symbolic_string_instruction >;

    class constant_pool_builder
    {
      public:
        constant_pool_builder() = default;

        explicit constant_pool_builder(std::vector< constant_pool_entry > entries);

        [[nodiscard]] constant_pool_index intern(constant_pool_entry entry);

        [[nodiscard]] constant_pool_index add_utf8(std::string_view bytes);

        [[nodiscard]] constant_pool_index add_class(std::string_view internal_name);

        [[nodiscard]] constant_pool_index add_string(std::string_view bytes);

        [[nodiscard]] constant_pool_index add_name_and_type(std::string_view name, std::string_view descriptor);

        [[nodiscard]] constant_pool_index add_fieldref(std::string_view owner, std::string_view name, std::string_view descriptor);

        [[nodiscard]] constant_pool_index add_methodref(std::string_view owner, std::string_view name, std::string_view descriptor);

        [[nodiscard]] constant_pool_index add_interface_methodref(std::string_view owner, std::string_view name, std::string_view descriptor);

        [[nodiscard]] constant_pool_entry const& entry_at(constant_pool_index index) const;

        [[nodiscard]] std::string_view utf8_at(constant_pool_index index) const;

        [[nodiscard]] std::vector< constant_pool_entry > const& entries() const noexcept;

        [[nodiscard]] std::vector< constant_pool_entry > build() const;
 
      private:
        std::vector< constant_pool_entry > m_entries;
        std::vector< std::size_t > m_slot_to_entry{std::numeric_limits< std::size_t >::max()};
        std::map< constant_pool_entry, constant_pool_index > m_indexes;
    };

    class class_hierarchy_resolver_ref
    {
      public:
        class_hierarchy_resolver_ref() = default;

        template < typename Resolver >
        explicit class_hierarchy_resolver_ref(Resolver& resolver) noexcept :
            m_object(&resolver),
            m_resolve(
                [](void* object, std::string_view left, std::string_view right) -> std::string
                {
                    return static_cast< Resolver* >(object)->common_superclass(left, right);
                })
        {
        }

        [[nodiscard]] explicit operator bool() const noexcept;

        [[nodiscard]] std::string common_superclass(std::string_view left, std::string_view right) const;
 
      private:
        void* m_object{};
        std::string (*m_resolve)(void*, std::string_view, std::string_view){};
    };

    struct code_build_options
    {
        std::optional< std::uint16_t > max_stack; 
        std::optional< std::uint16_t > max_locals; 
        bool perform_dataflow_analysis{true}; 
        bool generate_stack_map_table{true}; 
        processing_mode mode{processing_mode::strict}; 
        RPNX_MEMBER_METADATA(code_build_options, max_stack, max_locals, perform_dataflow_analysis, generate_stack_map_table, mode);
    };

    struct code_build_context
    {
        class_file_version version; 
        constant_pool_index owner_class_index; 
        constant_pool_index super_class_index; 
        std::string method_name; 
        method_access_flags access_flags{method_access_flags::none}; 
        method_descriptor descriptor; 
        code_build_options options; 
        RPNX_MEMBER_METADATA(code_build_context, version, owner_class_index, super_class_index, method_name, access_flags, descriptor, options);
    };

    class code_builder
    {
      public:
        code_builder();

        [[nodiscard]] label new_label();

        auto bind(label value) -> code_builder&;

        auto append(instruction value) -> code_builder&;

        template < opcode Operation >
            requires requires { instruction{simple_instruction< Operation >{}}; }
        auto append() -> code_builder&
        {
            return append(simple_instruction< Operation >{});
        }

        template < opcode Operation >
        auto branch(label target) -> code_builder&
        {
            static_assert(Operation == opcode::ifeq || Operation == opcode::ifne || Operation == opcode::iflt || Operation == opcode::ifge || Operation == opcode::ifgt || Operation == opcode::ifle || Operation == opcode::if_icmpeq || Operation == opcode::if_icmpne || Operation == opcode::if_icmplt || Operation == opcode::if_icmpge || Operation == opcode::if_icmpgt || Operation == opcode::if_icmple || Operation == opcode::if_acmpeq || Operation == opcode::if_acmpne || Operation == opcode::goto_ || Operation == opcode::jsr || Operation == opcode::ifnull || Operation == opcode::ifnonnull, "opcode does not have a labeled 16-bit branch form");
            require_owned_label(target);
            m_elements.emplace_back(labeled_branch_instruction< Operation >{target});
            return *this;
        }

        auto tableswitch(label default_target, std::int32_t low, std::vector< label > targets) -> code_builder&;

        auto lookupswitch(label default_target, std::vector< labeled_lookup_switch_pair > pairs) -> code_builder&;

        auto bipush(std::int8_t value) -> code_builder&;

        auto sipush(std::int16_t value) -> code_builder&;

        auto ldc_string(std::string value) -> code_builder&;

        auto iload(local_variable_index index) -> code_builder&;

        auto lload(local_variable_index index) -> code_builder&;

        auto fload(local_variable_index index) -> code_builder&;

        auto dload(local_variable_index index) -> code_builder&;

        auto aload(local_variable_index index) -> code_builder&;

        auto istore(local_variable_index index) -> code_builder&;

        auto lstore(local_variable_index index) -> code_builder&;

        auto fstore(local_variable_index index) -> code_builder&;

        auto dstore(local_variable_index index) -> code_builder&;

        auto astore(local_variable_index index) -> code_builder&;

        auto iinc(local_variable_index index, std::int16_t amount) -> code_builder&;

        auto getstatic(std::string owner, std::string name, std::string descriptor) -> code_builder&;

        auto putstatic(std::string owner, std::string name, std::string descriptor) -> code_builder&;

        auto getfield(std::string owner, std::string name, std::string descriptor) -> code_builder&;

        auto putfield(std::string owner, std::string name, std::string descriptor) -> code_builder&;

        auto invokevirtual(std::string owner, std::string name, std::string descriptor) -> code_builder&;

        auto invokespecial(std::string owner, std::string name, std::string descriptor, method_owner_kind owner_kind = method_owner_kind::class_) -> code_builder&;

        auto invokestatic(std::string owner, std::string name, std::string descriptor, method_owner_kind owner_kind = method_owner_kind::class_) -> code_builder&;

        auto invokeinterface(std::string owner, std::string name, std::string descriptor) -> code_builder&;

        auto new_(std::string class_name) -> code_builder&;

        auto anewarray(std::string class_name) -> code_builder&;

        auto checkcast(std::string class_name) -> code_builder&;

        auto instanceof_(std::string class_name) -> code_builder&;

        auto add_exception_handler(label start, label end, label handler, std::optional< std::string > catch_type = std::nullopt) -> code_builder&;

        auto add_line_number(label start, std::uint16_t line_number) -> code_builder&;

        auto add_local_variable(label start, label end, std::string name, std::string descriptor, local_variable_index index) -> code_builder&;

        auto add_local_variable_type(label start, label end, std::string name, std::string signature, local_variable_index index) -> code_builder&;

        auto set_stack_map_table(stack_map_table_attribute value) -> code_builder&;

        [[nodiscard]] code_attribute finish(code_build_context const& context, constant_pool_builder& constant_pool, class_hierarchy_resolver_ref hierarchy = {}) const;

        [[nodiscard]] std::vector< assembly_element > const& elements() const noexcept;
 
      private:
        void require_owned_label(label value) const;
 
        std::vector< assembly_element > m_elements;
        std::vector< labeled_exception_handler > m_exception_handlers;
        std::vector< labeled_line_number > m_line_numbers;
        std::vector< labeled_local_variable > m_local_variables;
        std::vector< labeled_local_variable_type > m_local_variable_types;
        std::optional< stack_map_table_attribute > m_stack_map_table;
        label_owner m_label_owner;
        std::size_t m_next_label{};
    };

    class class_file_builder
    {
      public:
        explicit class_file_builder(std::string_view class_name, std::string_view super_class_name = "java/lang/Object", class_file_version version = {0, 70});

        explicit class_file_builder(class_file value);

        [[nodiscard]] auto access_flags() noexcept -> class_access_flags&;

        [[nodiscard]] auto version() noexcept -> class_file_version&;

        [[nodiscard]] auto constant_pool() noexcept -> constant_pool_builder&;

        auto add_interface(std::string_view internal_name) -> class_file_builder&;

        [[nodiscard]] auto fields() noexcept -> std::vector< field_info >&;

        [[nodiscard]] auto methods() noexcept -> std::vector< method_info >&;

        [[nodiscard]] auto attributes() noexcept -> std::vector< class_attribute >&;

        auto add_method(std::string_view name, std::string_view descriptor, method_access_flags flags, code_builder const& code, code_build_options const& options = {}, class_hierarchy_resolver_ref hierarchy = {}) -> method_info&;

        auto add_field(std::string_view name, std::string_view descriptor, field_access_flags flags) -> field_info&;

        [[nodiscard]] class_file build() const;
 
      private:
        class_file m_class;
        constant_pool_builder m_constant_pool;
    };
} // namespace rpnx::cortado
 
#endif // RPNX_CORTADO_BUILDERS_HPP