types.hpp

/* Copyright 2025 Jonathan S. Arney
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      https://github.com/jarney/gyoji/blob/master/LICENSE
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
#pragma once
 
#include <gyoji-misc/pointers.hpp>
#include <gyoji-context.hpp>
#include <string>
#include <map>
#include <vector>
 
namespace Gyoji::mir {
    class Type;
    class Types;
    class Argument;
    
    class Types {
    public:
    Types();
    ~Types();
    
    Type * get_type(std::string type) const;
 
    const Type * get_pointer_to(const Type *_type, const Gyoji::context::SourceReference & _src_ref);
    
    const Type * get_reference_to(const Type *_type, const Gyoji::context::SourceReference & _src_ref);
    
    const Type * get_array_of(const Type *_type, size_t _length, const Gyoji::context::SourceReference & _src_ref);
 
    void define_type(Gyoji::owned<Type> type);
    
    void dump(FILE *out) const;
 
    const std::map<std::string, Gyoji::owned<Type>> & get_types() const;
    private:
    std::map<std::string, Gyoji::owned<Type>> type_map;
    };
    
    class Argument {
    public:
    Argument(
        const Type *_argument_type,
        const Gyoji::context::SourceReference & _source_ref
        );
    Argument(const Argument & _other);
    ~Argument();
    const Type* get_type() const;
    const Gyoji::context::SourceReference & get_source_ref() const;
    private:
    const Type *argument_type;
    const Gyoji::context::SourceReference *source_ref;
    };
    
    class TypeMember {
    public:
    TypeMember(
        std::string _member_name,
        size_t _index,
        const Type *_member_type,
        const Gyoji::context::SourceReference & _source_ref
        );
    TypeMember(const TypeMember & other);
    ~TypeMember();
    const std::string & get_name() const;
 
    size_t get_index() const;
    
    const Type *get_type() const;
    const Gyoji::context::SourceReference & get_source_ref() const;
    private:
    std::string member_name;
    size_t index;
    const Type *member_type;
    const Gyoji::context::SourceReference *source_ref;
    };
 
    class TypeMethod {
    public:
    TypeMethod(
        std::string _method_name,
        const Gyoji::context::SourceReference & _source_ref,
        const Type *_class_type,
        const Type *_return_type,
        const std::vector<Argument> _arguments
        );
    ~TypeMethod();
 
    const std::string & get_name() const;
    const Gyoji::context::SourceReference & get_source_ref() const;
    const Type *get_class_type() const;
    const Type *get_return_type() const;
    const std::vector<Argument> & get_arguments() const;
    private:
    std::string method_name;
    const Gyoji::context::SourceReference & source_ref;
    const Type *class_type;
    const Type *return_type;
    std::vector<Argument> arguments;
    };
 
    class Type {
    public:
    typedef enum {
        TYPE_PRIMITIVE_u8,
        TYPE_PRIMITIVE_u16,
        TYPE_PRIMITIVE_u32,
        TYPE_PRIMITIVE_u64,
 
        TYPE_PRIMITIVE_i8,
        TYPE_PRIMITIVE_i16,
        TYPE_PRIMITIVE_i32,
        TYPE_PRIMITIVE_i64,
 
        TYPE_PRIMITIVE_f32,
        TYPE_PRIMITIVE_f64,
 
        TYPE_PRIMITIVE_bool,
        TYPE_PRIMITIVE_void,
        
        TYPE_COMPOSITE,
 
        TYPE_ANONYMOUS_STRUCTURE,
        
        TYPE_POINTER,
 
        TYPE_FUNCTION_POINTER,
 
        TYPE_REFERENCE,
        
        TYPE_ENUM,
 
        TYPE_ARRAY
    } TypeType;
 
    Type(
        std::string _name,
        std::string _simple_name,
        TypeType _type,
        bool _complete,
        const Gyoji::context::SourceReference & _source_ref
        );
    
    Type(
        std::string _name,
        TypeType _type,
        bool _complete,
        const Gyoji::context::SourceReference & _source_ref
        );
    Type(
        std::string _name,
        std::string _simple_name,
        const Gyoji::context::SourceReference & _source_ref,
        const Type & _other
        );
    
    ~Type();
    
    const std::string & get_name() const;
 
    const std::string & get_simple_name() const;
    
    bool is_complete() const;
 
    bool is_primitive() const;
    bool is_pointer() const;
    bool is_reference() const;
    bool is_numeric() const;
    bool is_integer() const;
    bool is_unsigned() const;
    bool is_signed() const;
    bool is_float() const;
    bool is_bool() const;
    bool is_void() const;
    bool is_enum() const;
    bool is_composite() const;
 
    bool is_anonymous() const;
    
    bool is_function_pointer() const;
 
    bool is_array() const;
    
    size_t get_primitive_size() const;
 
    TypeType get_type() const;
 
    const std::vector<TypeMember> & get_members() const;
 
    const std::map<std::string, TypeMethod> & get_methods() const;
 
    const TypeMember *member_get(const std::string & member_name) const;
 
    const TypeMethod *method_get(const std::string & member_name) const;
 
    const TypeMethod *method_get_destructor() const;
    
    const Type * get_pointer_target() const;
 
    size_t get_array_length() const;
 
    const Type * get_return_type() const;
 
    const std::vector<Argument> & get_argument_types() const;
 
    bool is_unsafe() const;
    
    const Type * get_class_type() const;
    const Type * get_function_pointer_type() const;
 
    void complete_composite_definition(
        std::vector<TypeMember> _members,
        std::map<std::string, TypeMethod> _methods,
        const Gyoji::context::SourceReference & _source_ref
        );
    
    void complete_pointer_definition(const Type *_type, const Gyoji::context::SourceReference & _source_ref);
 
    void complete_array_definition(const Type *_type, size_t _array_size, const Gyoji::context::SourceReference & _source_ref);
 
    void complete_enum_definition(const Type *_type, const Gyoji::context::SourceReference & _source_ref);
    
    void complete_function_pointer_definition(
        const Type *_return_type,
        const std::vector<Argument> & _argument_types,
        bool _is_unsafe,
        const Gyoji::context::SourceReference & _source_ref
        );
 
    void dump(FILE *out) const;
 
    const Gyoji::context::SourceReference & get_declared_source_ref() const;
    
    const Gyoji::context::SourceReference & get_defined_source_ref() const;
    
    private:
    std::string name;
    std::string simple_name;
    TypeType type;
    bool complete;
    bool m_is_unsafe;
    
    const Gyoji::context::SourceReference *declared_source_ref;
    const Gyoji::context::SourceReference *defined_source_ref;
 
    // Used only for pointer and reference types.
    const Type *pointer_or_ref;
    size_t array_length;
 
    // Used only for function pointer types.
    const Type *return_type;
    std::vector<Argument> argument_types;
 
    // Used only for class/composite types.
    std::vector<TypeMember> members;
    std::map<std::string, const TypeMember*> members_by_name;
 
    // Used only for class/composite types.
    std::map<std::string, TypeMethod> methods;
 
 
    // Used only for class method call types.
    const Type *class_type;
    const Type *function_pointer_type;
    };
};