/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */
#ifndef TYPE_H
#define TYPE_H


#include <image.h>

#include <Referenceable.h>
#include <Variant.h>

#include "Types.h"


enum type_kind {
        TYPE_PRIMITIVE,
        TYPE_COMPOUND,
        TYPE_MODIFIED,
        TYPE_TYPEDEF,
        TYPE_ADDRESS,
        TYPE_ENUMERATION,
        TYPE_SUBRANGE,
        TYPE_ARRAY,
        TYPE_UNSPECIFIED,
        TYPE_FUNCTION,
        TYPE_POINTER_TO_MEMBER
};


enum compound_type_kind {
        COMPOUND_TYPE_CLASS,
        COMPOUND_TYPE_STRUCT,
        COMPOUND_TYPE_UNION,
        COMPOUND_TYPE_INTERFACE
};


enum address_type_kind {
        DERIVED_TYPE_POINTER,
        DERIVED_TYPE_REFERENCE
};


enum template_type_kind {
        TEMPLATE_TYPE_TYPE,
        TEMPLATE_TYPE_VALUE
};


enum {
        TYPE_MODIFIER_CONST             = 0x01,
        TYPE_MODIFIER_VOLATILE  = 0x02,
        TYPE_MODIFIER_RESTRICT  = 0x04,
        TYPE_MODIFIER_PACKED    = 0x08,
        TYPE_MODIFIER_SHARED    = 0x10
};


class AddressType;
class ArrayIndexPath;
class ArrayType;
class BString;
class Type;
class ValueLocation;


class BaseType : public BReferenceable {
public:
        virtual                                         ~BaseType();

        virtual Type*                           GetType() const = 0;
};


class DataMember : public BReferenceable {
public:
        virtual                                         ~DataMember();

        virtual const char*                     Name() const = 0;
        virtual Type*                           GetType() const = 0;
};


class EnumeratorValue : public BReferenceable {
public:
        virtual                                         ~EnumeratorValue();

        virtual const char*                     Name() const = 0;
        virtual BVariant                        Value() const = 0;
};


class ArrayDimension : public BReferenceable {
public:
        virtual                                         ~ArrayDimension();

        virtual Type*                           GetType() const = 0;
                                                                        // subrange or enumeration
        virtual uint64                          CountElements() const;
                                                                        // returns 0, if unknown
};


class FunctionParameter : public BReferenceable {
public:
        virtual                                         ~FunctionParameter();

        virtual const char*                     Name() const = 0;
        virtual Type*                           GetType() const = 0;
};


class TemplateParameter : public BReferenceable {
public:
        virtual                                         ~TemplateParameter();

        virtual template_type_kind      Kind() const = 0;
        virtual Type*                           GetType() const = 0;
        virtual BVariant                        Value() const = 0;
};


class Type : public BReferenceable {
public:
        virtual                                         ~Type();

        virtual image_id                        ImageID() const = 0;
        virtual const BString&          ID() const = 0;
        virtual const BString&          Name() const = 0;
        virtual type_kind                       Kind() const = 0;
        virtual target_size_t           ByteSize() const = 0;
        virtual Type*                           ResolveRawType(bool nextOneOnly) const;
                                                                        // strips modifiers and typedefs (only one,
                                                                        // if requested)


        virtual status_t                        CreateDerivedAddressType(
                                                                        address_type_kind kind,
                                                                        AddressType*& _resultType);

        virtual status_t                        CreateDerivedArrayType(
                                                                        int64 lowerBound,
                                                                        int64 elementCount,
                                                                        bool extendExisting,
                                                                                // if the current object is already
                                                                                // an array type, attach an extra
                                                                                // dimension to it rather than
                                                                                // creating a new encapsulating
                                                                                // type object
                                                                        ArrayType*& _resultType);


        virtual status_t                        ResolveObjectDataLocation(
                                                                        const ValueLocation& objectLocation,
                                                                        ValueLocation*& _location) = 0;
                                                                        // returns a reference
        virtual status_t                        ResolveObjectDataLocation(
                                                                        target_addr_t objectAddress,
                                                                        ValueLocation*& _location) = 0;
                                                                        // returns a reference
};


class PrimitiveType : public virtual Type {
public:
        virtual                                         ~PrimitiveType();

        virtual type_kind                       Kind() const;

        virtual uint32                          TypeConstant() const = 0;
};


class CompoundType : public virtual Type {
public:
        virtual                                         ~CompoundType();

        virtual type_kind                       Kind() const;
        virtual compound_type_kind      CompoundKind() const = 0;

        virtual int32                           CountBaseTypes() const = 0;
        virtual BaseType*                       BaseTypeAt(int32 index) const = 0;

        virtual int32                           CountDataMembers() const = 0;
        virtual DataMember*                     DataMemberAt(int32 index) const = 0;

        virtual int32                           CountTemplateParameters() const = 0;
        virtual TemplateParameter*      TemplateParameterAt(int32 index) const = 0;


        virtual status_t                        ResolveBaseTypeLocation(BaseType* baseType,
                                                                        const ValueLocation& parentLocation,
                                                                        ValueLocation*& _location) = 0;
                                                                        // returns a reference
        virtual status_t                        ResolveDataMemberLocation(DataMember* member,
                                                                        const ValueLocation& parentLocation,
                                                                        ValueLocation*& _location) = 0;
                                                                        // returns a reference
};


class ModifiedType : public virtual Type {
public:
        virtual                                         ~ModifiedType();

        virtual type_kind                       Kind() const;

        virtual uint32                          Modifiers() const = 0;
        virtual Type*                           BaseType() const = 0;
        virtual Type*                           ResolveRawType(bool nextOneOnly) const;
};


class TypedefType : public virtual Type {
public:
        virtual                                         ~TypedefType();

        virtual type_kind                       Kind() const;

        virtual Type*                           BaseType() const = 0;
        virtual Type*                           ResolveRawType(bool nextOneOnly) const;
};


class AddressType : public virtual Type {
public:
        virtual                                         ~AddressType();

        virtual type_kind                       Kind() const;

        virtual address_type_kind       AddressKind() const = 0;
        virtual Type*                           BaseType() const = 0;
};


class EnumerationType : public virtual Type {
public:
        virtual                                         ~EnumerationType();

        virtual type_kind                       Kind() const;

        virtual Type*                           BaseType() const = 0;
                                                                        // may return NULL

        virtual int32                           CountValues() const = 0;
        virtual EnumeratorValue*        ValueAt(int32 index) const = 0;
        virtual EnumeratorValue*        ValueFor(const BVariant& value) const;
};


class SubrangeType : public virtual Type {
public:
        virtual                                         ~SubrangeType();

        virtual type_kind                       Kind() const;

        virtual Type*                           BaseType() const = 0;

        virtual BVariant                        LowerBound() const = 0;
        virtual BVariant                        UpperBound() const = 0;
};


class ArrayType : public virtual Type {
public:
        virtual                                         ~ArrayType();

        virtual type_kind                       Kind() const;

        virtual Type*                           BaseType() const = 0;

        virtual int32                           CountDimensions() const = 0;
        virtual ArrayDimension*         DimensionAt(int32 index) const = 0;

        virtual status_t                        ResolveElementLocation(
                                                                        const ArrayIndexPath& indexPath,
                                                                        const ValueLocation& parentLocation,
                                                                        ValueLocation*& _location) = 0;
                                                                        // returns a reference
};


class UnspecifiedType : public virtual Type {
public:
        virtual                                         ~UnspecifiedType();

        virtual type_kind                       Kind() const;
};


class FunctionType : public virtual Type {
public:
        virtual                                         ~FunctionType();

        virtual type_kind                       Kind() const;

        virtual Type*                           ReturnType() const = 0;

        virtual int32                           CountParameters() const = 0;
        virtual FunctionParameter*      ParameterAt(int32 index) const = 0;

        virtual bool                            HasVariableArguments() const = 0;
};


class PointerToMemberType : public virtual Type {
public:
        virtual                                         ~PointerToMemberType();

        virtual type_kind                       Kind() const;

        virtual CompoundType*           ContainingType() const = 0;
        virtual Type*                           BaseType() const = 0;
};


#endif  // TYPE_H