Xrtti.h

/*****************************************************************************\
 *                                                                           *
 * Xrtti.h                                                                   *
 *                                                                           *
 * ------------------------------------------------------------------------- *
 * Copyright (C) 2007 Bryan Ischo <bryan@ischo.com>                          *
 *                                                                           *
 * This program is free software; you can redistribute it and/or modify it   *
 * under the terms of the GNU General Public License Version 2 as published  *
 * by the Free Software Foundation.                                          *
 *                                                                           *
 * This program is distributed in the hope that it will be useful, but       *
 * WITHOUT ANY WARRANTY; without even the implied warranty of                *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General *
 * Public License for more details.                                          *
 *                                                                           *
 * You should have received a copy of the GNU General Public License         *
 * along with this program; if not, write to:                                *
 * The Free Software Foundation, Inc.                                        *
 * 51 Franklin Street, Fifth Floor                                           *
 * Boston, MA 02110-1301, USA.                                               *
 * ------------------------------------------------------------------------- *
 *                                                                           *
\*****************************************************************************/


#ifndef XRTTI_H
#define XRTTI_H

#include <inttypes.h>
#include <typeinfo>

namespace Xrtti {

#if 0 // This fixes indentation in emacs
}
#endif


typedef uint32_t           u32;       
typedef int32_t            s32;       
class Argument;
class Array;
class ArrayOrPointer;
class Base;
class Class;
class Constructor;
class ConstructorSignature;
class Context;
class Destructor;
class DestructorSignature;
class Enumeration;
class EnumerationValue;
class Field;
class Method;
class MethodSignature;
class Namespace;
class Pointer;
class Structure;
class Struct;
class Type;
class TypeEnumeration;
class TypeFunction;
class TypeStructure;
class TypeUnion;
class Union;


typedef enum AccessType
{
        AccessType_Public,
        AccessType_Protected,
        AccessType_Private
} AccessType;


class Context
{
public:

    enum Type
    {
                Type_Class          = 0,
                Type_Namespace      = 1,
                Type_Struct         = 2,
                Type_Union          = 3
        };

    virtual ~Context() { }

    bool operator ==(const Context &other) const;

    bool operator !=(const Context &other) const
    { return !(*this == other); }

    virtual Type GetType() const = 0;

    virtual const char *GetName() const = 0;

    virtual const char *GetFullName() const = 0;

    virtual const Context *GetContext() const = 0;
};


class Namespace : public Context
{
public:

    virtual ~Namespace() { }

    virtual Type GetType() const
    {
        return Type_Namespace;
    }
};


class Structure : public Context
{
public:

    virtual ~Structure() { }

    bool operator ==(const Structure &other) const;

    bool operator !=(const Structure &other) const
    { return !(*this == other); }

    virtual bool IsIncomplete() const = 0;

    virtual bool HasSizeof() const = 0;

    virtual u32 GetSizeof() const = 0;

    virtual bool HasStructureName() const = 0;
    
    virtual AccessType GetAccessType() const = 0;

    virtual const std::type_info *GetTypeInfo() const = 0;

    virtual u32 GetBaseCount() const = 0;

    virtual const Base &GetBase(u32 index) const = 0;

    virtual u32 GetFriendCount() const = 0;

    virtual const Structure &GetFriend(u32 index) const = 0;

    virtual u32 GetFieldCount() const = 0;

    virtual const Field &GetField(u32 index) const = 0;

    virtual bool IsAnonymous() const = 0;

    virtual u32 GetConstructorCount() const = 0;

    virtual const Constructor &GetConstructor(u32 index) const = 0;

    virtual bool HasDestructor() const = 0;

    virtual const Destructor &GetDestructor() const = 0;

    virtual bool IsCreatable() const = 0;

    virtual void *Create() const = 0;

    virtual void *CreateArray(u32 count) const = 0;

    virtual bool IsDeletable() const = 0;

    virtual void Delete(void *pInstance) const = 0;

    virtual void DeleteArray(void *pInstanceArray) const = 0;
};


class Base
{
public:

    virtual ~Base() { }

    bool operator ==(const Base &other) const;

    bool operator !=(const Base &other) const
    { return !(*this == other); }

    virtual AccessType GetAccessType() const = 0;

    virtual bool IsVirtual() const = 0;

    virtual const Structure &GetStructure() const = 0;
    
    virtual bool IsCastable() const = 0;

    virtual void *CastSubclass(void *pObject) const = 0;
};


class Union : public Structure
{
public:

    virtual ~Union() { }

    bool operator ==(const Context &other) const
    {
        if (other.GetType() != Type_Union) {
            return false;
        }

        return (*this == (const Union &) other);
    }

    bool operator !=(const Context &other) const
    { return !(*this == other); }

    bool operator ==(const Union &other) const
    { return (((const Structure *) this)->Structure::operator == 
              ((const Structure &) other)); }

    bool operator !=(const Union &other) const
    { return !(*this == other); }

    virtual Type GetType() const
    {
        return Type_Union;
    }
};


class Struct : public Structure
{
public:

    virtual ~Struct() { }

    bool operator ==(const Context &other) const
    {
        if (other.GetType() != Type_Struct) {
            return false;
        }

        return (*this == (const Struct &) other);
    }

    bool operator !=(const Context &other) const
    { return !(*this == other); }

    bool operator ==(const Struct &other) const;

    bool operator !=(const Struct &other) const
    { return !(*this == other); }

    virtual Type GetType() const
    {
        return Type_Struct;
    }

    virtual bool IsAbstract() const = 0;

    virtual u32 GetMethodCount() const = 0;

    virtual const Method &GetMethod(u32 index) const = 0;
};


class Class : public Struct
{
public:

    virtual ~Class() { }

    bool operator ==(const Context &other) const
    {
        if (other.GetType() != Type_Class) {
            return false;
        }

        return (*this == (const Class &) other);
    }

    bool operator !=(const Context &other) const
    { return !(*this == other); }

    bool operator ==(const Class &other) const
    { return (((const Struct *) this)->Struct::operator == 
              ((const Struct &) other)); }

    bool operator !=(const Class &other) const
    { return !(*this == other); }

    virtual Type GetType() const
    {
        return Type_Class;
    }
};


class Member
{
public:

    virtual ~Member() { }

    bool operator ==(const Member &other) const;

    bool operator !=(const Member &other) const
    { return !(*this == other); }

    virtual AccessType GetAccessType() const = 0;

    virtual const Context &GetContext() const = 0;

    virtual const char *GetName() const = 0;

    virtual bool IsStatic() const = 0;
};


class Field : public Member
{
public:

    virtual ~Field() { }

    bool operator ==(const Field &other) const;

    bool operator !=(const Field &other) const
    { return !(*this == other); }

    virtual const Type &GetType() const = 0;

    virtual u32 GetBitfieldBitCount() const = 0;
    
    virtual bool HasOffset() const = 0;

    virtual u32 GetOffset() const = 0;

    virtual bool IsAccessible() const = 0;

    virtual void *Get(void *pInstance) const = 0;
};


class Argument
{
public:

    virtual ~Argument() { }

    bool operator ==(const Argument &other) const;

    bool operator !=(const Argument &other) const
    { return !(*this == other); }

    virtual const Type &GetType() const = 0;

    virtual bool HasDefault() const = 0;

    virtual const char *GetDefault() const = 0;
};


class DestructorSignature
{
public:

    virtual ~DestructorSignature() { }

    bool operator ==(const DestructorSignature &other) const;

    bool operator !=(const DestructorSignature &other) const
    { return !(*this == other); }

    virtual u32 GetThrowCount() const = 0;

    virtual const Type &GetThrow(u32 index) const = 0;
};


class ConstructorSignature : public DestructorSignature
{
public:

    virtual ~ConstructorSignature() { }

    bool operator ==(const ConstructorSignature &other) const;

    bool operator !=(const ConstructorSignature &other) const
    { return !(*this == other); }

    virtual u32 GetArgumentCount() const = 0;

    virtual const Argument &GetArgument(u32 index) const = 0;

    virtual bool HasEllipsis() const = 0;
};


class MethodSignature : public ConstructorSignature
{
public:

    virtual ~MethodSignature() { }

    bool operator ==(const MethodSignature &other) const;

    bool operator !=(const MethodSignature &other) const
    { return !(*this == other); }

    virtual const Type &GetReturnType() const = 0;
};


class Destructor : public Member
{
public:

    virtual ~Destructor() { }

    bool operator ==(const Destructor &other) const;

    bool operator !=(const Destructor &other) const
    { return !(*this == other); }

    virtual bool IsVirtual() const = 0;

    virtual bool IsPureVirtual() const = 0;

    virtual const DestructorSignature &GetSignature() const = 0;

    virtual bool IsInvokeable() const = 0;

    virtual void Invoke(void *pInstance) const = 0;
};


class Constructor : public Member
{
public:

    virtual ~Constructor() { }

    bool operator ==(const Constructor &other) const;

    bool operator !=(const Constructor &other) const
    { return !(*this == other); }

    virtual const ConstructorSignature &GetSignature() const = 0;

    virtual const char *GetArgumentName(u32 index) const = 0;

    virtual bool IsInvokeable() const = 0;

    virtual void *Invoke(void **pArgumentValues) const = 0;
};


class Method : public Member
{
public:

    virtual ~Method() { }

    bool operator ==(const Method &other) const;

    bool operator !=(const Method &other) const
    { return !(*this == other); }

    virtual bool IsOperatorMethod() const = 0;

    virtual bool IsConst() const = 0;

    virtual bool IsVirtual() const = 0;

    virtual bool IsPureVirtual() const = 0;

    virtual const MethodSignature &GetSignature() const = 0;

    virtual const char *GetArgumentName(u32 index) const = 0;

    virtual bool IsInvokeable() const = 0;

    virtual void Invoke(void *pInstance, void *pReturnValue, 
                        void **pArgumentValues) const = 0;
};


class Type
{
public:
    
    virtual ~Type() { }

    bool operator ==(const Type &other) const;

    bool operator !=(const Type &other) const
    { return !(*this == other); }

    enum BaseType
    {
        BaseType_Void                    = 0,
        BaseType_Bool                    = 1,
        BaseType_Char                    = 2,
        BaseType_Unsigned_Char           = 3,
        BaseType_WChar                   = 4,
        BaseType_Short                   = 5,
        BaseType_Unsigned_Short          = 6,
        BaseType_Int                     = 7,
        BaseType_Unsigned_Int            = 8,
        BaseType_Long                    = 9,
        BaseType_Unsigned_Long           = 10,
        BaseType_Long_Long               = 11,
        BaseType_Unsigned_Long_Long      = 12,
        BaseType_Float                   = 13,
        BaseType_Double                  = 14,
        BaseType_Long_Double             = 15,
        BaseType_Enumeration             = 16,
        BaseType_Function                = 17,
        BaseType_Structure               = 18
    };

    virtual BaseType GetBaseType() const = 0;

    virtual bool IsConst() const = 0;

    virtual bool IsVolatile() const = 0;

    virtual bool IsReference() const = 0;

    virtual u32 GetArrayOrPointerCount() const = 0;

    virtual const ArrayOrPointer &GetArrayOrPointer(u32 index) const = 0;
};


class ArrayOrPointer
{
public:

    enum Type
    {
                Type_Array       = 0,
                Type_Pointer     = 1
        };

    virtual ~ArrayOrPointer() { }

    virtual Type GetType() const = 0;
};


class Array : public ArrayOrPointer
{
public:

    virtual ~Array() { }

    bool operator ==(const ArrayOrPointer &other) const
    {
        if (other.GetType() != Type_Array) {
            return false;
        }

        return (*this == (const Array &) other);
    }

    bool operator !=(const ArrayOrPointer &other) const
    { return !(*this == other); }

    bool operator ==(const Array &other) const;

    bool operator !=(const Array &other) const
    { return !(*this == other); }

    virtual Type GetType() const
    {
        return Type_Array;
    }

    virtual bool IsUnbounded() const = 0;

    virtual u32 GetElementCount() const  = 0;
};


class Pointer : public ArrayOrPointer
{
public:

    virtual ~Pointer() { }

    bool operator ==(const ArrayOrPointer &other) const
    {
        if (other.GetType() != Type_Pointer) {
            return false;
        }

        return (*this == (const Pointer &) other);
    }

    bool operator !=(const ArrayOrPointer &other) const
    { return !(*this == other); }

    bool operator ==(const Pointer &other) const;

    bool operator !=(const Pointer &other) const
    { return !(*this == other); }

    virtual Type GetType() const
    {
        return Type_Pointer;
    }

    virtual bool IsConst() const = 0;

    virtual bool IsVolatile() const = 0;
};


class Enumeration
{
public:

    virtual ~Enumeration() { }

    bool operator ==(const Enumeration &other) const;

    bool operator !=(const Enumeration &other) const
    { return !(*this == other); }

    virtual AccessType GetAccessType() const = 0;

    virtual const Context &GetContext() const = 0;

    virtual const char *GetName() const = 0;
    
    virtual u32 GetValueCount() const = 0;

    virtual const EnumerationValue &GetValue(u32 index) const = 0;
};


class EnumerationValue
{
public:

    virtual ~EnumerationValue() { }

    bool operator ==(const EnumerationValue &other) const;

    bool operator !=(const EnumerationValue &other) const
    { return !(*this == other); }

    virtual const char *GetName() const = 0;

    virtual s32 GetValue() const = 0;
};


class TypeEnumeration : public Type
{
public:

    virtual ~TypeEnumeration() { }

    bool operator ==(const TypeEnumeration &other) const;

    bool operator !=(const TypeEnumeration &other) const
    { return !(*this == other); }

    virtual const Enumeration &GetEnumeration() const = 0;
};


class TypeFunction : public Type
{
public:

    bool operator ==(const TypeFunction &other) const;

    bool operator !=(const TypeFunction &other) const
    { return !(*this == other); }

    virtual const MethodSignature &GetSignature() const = 0;
};


class TypeStructure : public Type
{
public:

    virtual ~TypeStructure() { }

    bool operator ==(const TypeStructure &other) const;

    bool operator !=(const TypeStructure &other) const
    { return !(*this == other); }

    virtual const Structure &GetStructure() const = 0;
};


bool Equals(const Context &c1, const Context &c2);

bool Equals(const Type &type1, const Type &type2);


u32 GetContextCount();

const Context *GetContext(u32 index);

const Context *LookupContext(const char *pFullName);

const Structure *LookupStructure(const std::type_info &typeinfo);

}; // namespace Xrtti


#endif // XRTTI_H

---