type_array.hpp

#ifndef FORBCC_ARRAY_TYPE_H
#define FORBCC_ARRAY_TYPE_H

#include <string>
#include <algorithm>
#include <cassert>

#include <types/type.hpp>
#include <templates/shareable.hpp>

namespace forbcc {

    class type_array : public type, public shareable<type_array> {

        /* ************************************************* ALIAS ************************************************** */
    public:
        using length_t = long;

        /* *********************************************** ATTRIBUTES *********************************************** */
    private:
        std::shared_ptr<const type> _item_type;

        length_t _length = 0;

        size_t _size = 0;

        /* ************************************************* STATIC ************************************************* */
    public:
        using type_array_list = ordered_unique_list<std::shared_ptr<const type_array>>;

        static type_array_list arrays;

        static std::string to_identifier(const std::shared_ptr<const type> &item_type, const length_t length) {
            // FIXME: This could probably lead to conflicts, but they would be extremely rare.
            std::string codename = item_type->codename();
            std::replace(codename.begin(), codename.end(), ':', '_');
            return "_Forb_Array_" + item_type->codename() + "_D_" + std::to_string(length) + "_";
        };

        /* ********************************************** CONSTRUCTORS ********************************************** */
    public:
        type_array() : type(), _item_type(nullptr) {};

        type_array(const std::shared_ptr<const type> &item_type, const length_t length)
                : type(nullptr, to_identifier(item_type, length)),
                  _item_type(item_type),
                  _length(length),
                  _size(item_type->size_of() * length) {
            assert((length > 0 && "The length of the array must be strictly positive!"));
        };

        type_array(const type_array *item_type, const int length) = delete;

        /**************************************************************************************************************/

        ~type_array() override = default;

        type_array(type_array &&) = default;

        type_array &operator=(type_array &&) = default;

        type_array(const type_array &) = default;

        type_array &operator=(const type_array &) = default;

        /**************************************************************************************************************/

        void print_declaration(code_ostream &) const override {};

        void print_definition(code_ostream &) const override {};

        std::shared_ptr<const type> item_type() const {
            return _item_type;
        };

        length_t length() const {
            return _length;
        };

        void print_var_declaration(code_ostream &out, const std::string &var_name) const override;

        void print_var_definition(code_ostream &out, const std::string &var_name, bool force_stack) const override;

        void print_var_lvalue(code_ostream &out, const std::string &var_name, bool is_stack) const override;

        void print_var_reference(code_ostream &out, const std::string &var_name) const override;

        void print_var_marshal(code_ostream &out, const std::string &var_name, const marshal &do_undo,
                               bool force_stack) const override;

        void print_var_serialize(code_ostream &out, const std::string &var_name, const serialize &do_undo,
                                 bool force_stack) const override;

        size_t size_of() const override {
            return _size;
        };

        size_t alignment() const override {
            return item_type()->alignment();
        };
    };

} // namespace forbcc

#endif //FORBCC_ARRAY_TYPE_H