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 <typeinfo>

namespace Xrtti {

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

typedef XRTTI_U32_ARCH     U32;       
typedef XRTTI_S32_ARCH     S32;       
class Argument;
class AutoRegister;                
class Array;
class Base;
class Class;
class Complete;
class Constructor;
class ConstructorSignature;
class Context;
class Destructor;
class DestructorSignature;
class Enumeration;
class EnumerationValue;
class Field;
typedef struct Generated Generated; 
class Incomplete;
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;


typedef union Value
{
    bool bool_v;                               
    signed char char_v;                 
    unsigned char unsigned_char_v;             
    wchar_t wchar_v;                           
    signed short short_v;               
    unsigned short unsigned_short_v;           
    signed int int_v;                   
    unsigned int unsigned_int_v;               
    signed long long_v;                 
    unsigned long unsigned_long_v;             
    signed long long long_long_v;       
    unsigned long long unsigned_long_long_v;   
    float float_v;                             
    double double_v;                           
    long double long_double_v;                 
    void *pointer_v;                           
}
Value;


class Context
{
public:

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

    virtual Type GetType() const = 0;

    const char *GetName() const
    {
        return pNameM;
    }

    const char *GetFullName() const
    {
        return pFullNameM;
    }

    const Context *GetParent() const
    {
        return pParentM;
    }

private:

    friend class Incomplete;
    friend class Namespace;
    friend class Structure;

    // Only the Xrtti library may create, destroy, or copy Contexts
    Context() { }
    virtual ~Context() { }
    Context(const Context &);
    Context &operator =(const Context &);

    const char *pNameM;

    const char *pFullNameM;
    
    Context *pParentM;
};


class Incomplete : public Context
{
public:

    virtual Type GetType() const
    {
        return Type_Incomplete;
    }

private:

    // Only the Xrtti library may create, destroy, or copy Incompletes
    Incomplete() { }
    virtual ~Incomplete() { }
    Incomplete(const Incomplete &);
    Incomplete &operator =(const Incomplete &);
};


class Namespace : public Context
{
public:

    virtual Type GetType() const
    {
        return Type_Namespace;
    }

private:

    // Only the Xrtti library may create, destroy, or copy Namespaces
    Namespace() { }
    ~Namespace() { }
    Namespace(const Namespace &);
    Namespace &operator =(const Namespace &);
};


class Structure : public Context
{
public:

    AccessType GetAccessType() const
    {
        return accessTypeM;
    }

    const std::type_info *GetTypeInfo() const
    {
        return pTypeInfoM;
    }

    U32 GetBaseCount() const
    {
        return baseCountM;
    }

    const Base &GetBase(U32 index) const;

    U32 GetFieldCount() const
    {
        return fieldCountM;
    }

    const Field &GetField(U32 index) const;

    bool IsAnonymous() const
    {
        return isAnonymousM;
    }

    U32 GetConstructorCount() const
    {
        return constructorCountM;
    }

    const Constructor &GetConstructor(U32 index) const;

    bool HasDestructor() const
    {
        return pDestructorM ? true : false;
    }

    const Destructor &GetDestructor() const;

    void *Create() const
    {
        if (pCreateMethodM) {
            return (*pCreateMethodM)();
        }
        else {
            return 0;
        }
    }

    void *CreateArray(U32 count) const
    {
        if (pCreateArrayMethodM) {
            return (*pCreateArrayMethodM)(count);
        }
        else {
            return 0;
        }
    }

    void Delete(void *pInstance) const
    {
        if (pDeleteMethodM) {
            (*pDeleteMethodM)(pInstance);
        }
    }

    void DeleteArray(void **pInstanceArray) const
    {
        if (pDeleteArrayMethodM) {
            (*pDeleteArrayMethodM)(pInstanceArray);
        }
    }

private:

    friend class Struct;
    friend class Union;
    
    // Only the Xrtti library may create, destroy, or copy Structures
    Structure() { }
    ~Structure() { }
    Structure(const Structure &);
    Structure &operator =(const Structure &);

    AccessType accessTypeM;

    const std::type_info *pTypeInfoM;

    U32 baseCountM;

    Base *pBasesM;

    U32 fieldCountM;
    
    class Field *pFieldsM;

    bool isAnonymousM;

    U32 constructorCountM;

    Constructor *pConstructorsM;

    Destructor *pDestructorM;
    
    void *(*pCreateMethodM)();

    void *(*pCreateArrayMethodM)(U32);

    void (*pDeleteMethodM)(void *);

    void (*pDeleteArrayMethodM)(void *);
};


class Base
{
public:

    const Structure &GetStructure() const
    {
        return *pStructureM;
    }
    
    U32 GetOffset() const
    {
        return offsetM;
    }

private:

    // Only the Xrtti library may create, destroy, or copy Bases
    Base() { }
    ~Base() { }
    Base(const Base &);
    Base &operator =(const Base &);

    Structure *pStructureM;

    U32 offsetM;
};


class Union : public Structure
{
public:

    virtual Type GetType() const
    {
        return Type_Union;
    }

private:

    // Only the Xrtti library may create, destroy, or copy Unions
    Union() { }
    ~Union() { }
    Union(const Union &);
    Union &operator =(const Union &);
};


class Struct : public Structure
{
public:

    virtual Type GetType() const
    {
        return Type_Struct;
    }

    bool IsAbstract() const
    {
        return isAbstractM;
    }

    U32 GetMethodCount() const
    {
        return methodCountM;
    }

    const Method &GetMethod(U32 index) const;
    
private:

    friend class Class;

    // Only the Xrtti library may create, destroy, or copy Structs
    Struct() { }
    ~Struct() { }
    Struct(const Struct &);
    Struct &operator =(const Struct &);

    bool isAbstractM;

    U32 methodCountM;

    Method *pMethodsM;
};


class Class : public Struct
{
public:

    virtual Type GetType() const
    {
        return Type_Class;
    }

private:
    
    // Only the Xrtti library may create, destroy, or copy Classes
    Class() { }
    ~Class() { }
    Class(const Class &);
    Class &operator =(const Class &);
};


class Member
{
public:

    AccessType GetAccessType() const
    {
        return accessTypeM;
    }

    const Context &GetContext() const
    {
        return *pContextM;
    }

    const char *GetName() const
    {
        return pNameM;
    }

    bool IsStatic() const
    {
        return isStaticM;
    }

private:

    friend class Constructor;
    friend class Destructor;
    friend class Field;
    friend class Method;

    // Only the Xrtti library may create, destroy, or copy Members
    Member() { }
    ~Member() { }
    Member(const Member &);
    Member &operator =(const Member &);

    AccessType accessTypeM;

    Context *pContextM;

    const char *pNameM;

    bool isStaticM;
};


class Field : public Member
{
public:

    const Type &GetType() const
    {
        return *pTypeM;
    }

    U32 GetOffset() const
    {
        return offsetM;
    }

    void Get(void *pInstance, Value &returnValue) const
    {
        (*pGetMethodM)(pInstance, returnValue);
    }

    void Set(void *pInstance, const Value &value) const
    {
        (*pSetMethodM)(pInstance, value);
    }

private:

    // Only the Xrtti library may create, destroy, or copy Fields
    Field() { }
    ~Field() { }
    Field(const Field &);
    Field &operator =(const Field &);

    Type *pTypeM;

    U32 offsetM;

    void (*pGetMethodM)(void *, Value &);

    void (*pSetMethodM)(void *, const Value &);
};


class Argument
{
public:

    const Type &GetType() const
    {
        return *pTypeM;
    }

    bool HasDefault() const
    {
        return hasDefaultM;
    }

    const Value &GetDefault() const
    {
        return defaultM;
    }
     
private:

    // Only the Xrtti library may create, destroy, or copy Arguments
    Argument() { }
    ~Argument() { }
    Argument(const Argument &);
    Argument &operator =(const Argument &);

    Type *pTypeM;

    bool hasDefaultM;

    Value defaultM;
};


class DestructorSignature
{
public:

    U32 GetThrowCount() const
    {
        return throwCountM;
    }

    const Type &GetThrow(U32 index) const
    {
        return *(pThrowsM[index]);
    }

private:

    friend class Destructor;
    friend class ConstructorSignature;

    // Only the Xrtti library may create, destroy, or copy DestructorSignature
    // objects
    DestructorSignature() { }
    ~DestructorSignature() { }
    DestructorSignature(const DestructorSignature &);
    DestructorSignature &operator =(const DestructorSignature &);

    U32 throwCountM;
    Type **pThrowsM;
};


class ConstructorSignature : public DestructorSignature
{
public:

    U32 GetArgumentCount() const
    {
        return argumentCountM;
    }

    const Argument &GetArgument(U32 index) const
    {
        return pArgumentsM[index];
    }

    bool HasEllipsis() const
    {
        return hasEllipsisM;
    }

private:

    friend class Constructor;
    friend class MethodSignature;

    // Only the Xrtti library may create, destroy, or copy ConstructorSignature
    // objects
    ConstructorSignature() { }
    ~ConstructorSignature() { }
    ConstructorSignature(const ConstructorSignature &);
    ConstructorSignature &operator =(const ConstructorSignature &);

    U32 argumentCountM;

    Argument *pArgumentsM;

    bool hasEllipsisM;
};


class MethodSignature : public ConstructorSignature
{
public:

    const Type &GetReturnType() const
    {
        return *pReturnTypeM;
    }

private:

    friend class Method;
    friend class TypeFunction;

    // Only the Xrtti library may create, destroy, or copy MethodSignature
    // objects
    MethodSignature() { }
    ~MethodSignature() { }
    MethodSignature(const MethodSignature &);
    MethodSignature &operator =(const MethodSignature &);

    Type *pReturnTypeM;
};


class Destructor : public Member
{
public:

    bool IsVirtual() const
    {
        return isVirtualM;
    }

    bool IsPureVirtual() const
    {
        return isPureVirtualM;
    }

    const DestructorSignature &GetSignature() const
    {
        return signatureM;
    }

    void Invoke(void *pInstance) const
    {
        (*pInvokeDestructorM)(pInstance);
    }

private:

    // Only the Xrtti library may create, destroy, or copy Destructors
    Destructor() { }
    ~Destructor() { }
    Destructor(const Destructor &);
    Destructor &operator =(const Destructor &);

    bool isVirtualM, isPureVirtualM;

    DestructorSignature signatureM;

    void (*pInvokeDestructorM)(void *);
};


class Constructor : public Member
{
public:

    const ConstructorSignature &GetSignature() const
    {
        return signatureM;
    }

    const char *GetArgumentName(U32 index) const
    {
        return pArgumentNamesM[index];
    }

    void *Invoke(Value *pArgumentValues) const
    {
        Value ret;
        (*pInvokeConstructorM)(0, /* returns */ ret, pArgumentValues);
        return ret.pointer_v;
    }

private:

    // Only the Xrtti library may create, destroy, or copy Constructors
    Constructor() { }
    ~Constructor() { }
    Constructor(const Constructor &);
    Constructor &operator =(const Constructor &);

    ConstructorSignature signatureM;

    const char **pArgumentNamesM;
    
    void (*pInvokeConstructorM)(void *, Value &, Value *);
};


class Method : public Member
{
public:

    bool IsConst() const
    {
        return isConstM;
    }

    bool IsVirtual() const
    {
        return isVirtualM;
    }

    bool IsPureVirtual() const
    {
        return isPureVirtualM;
    }

    const MethodSignature &GetSignature() const
    {
        return signatureM;
    }

    const char *GetArgumentName(U32 index) const
    {
        return pArgumentNamesM[index];
    }

    void Invoke(void *pInstance, Value &returnValue, 
                Value *pArgumentValues) const
    {
        (*pInvokeMethodM)(pInstance, returnValue, pArgumentValues);
    }

private:

    // Only the Xrtti library may create, destroy, or copy Methods
    Method() { }
    ~Method() { }
    Method(const Method &);
    Method &operator =(const Method &);

    bool isConstM, isVirtualM, isPureVirtualM;

    MethodSignature signatureM;

    const char **pArgumentNamesM;

    void (*pInvokeMethodM)(void *, Value &, Value *);
};


class Type
{
public:

    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_Bitfield                = 16,
        BaseType_Enumeration             = 17,
        BaseType_Function                = 18,
        BaseType_Structure               = 19
    };

    BaseType GetBaseType() const
    {
        return baseTypeM;
    }

    bool IsConst() const
    {
        return isConstM;
    }

    bool IsVolatile() const
    {
        return isVolatileM;
    }

    bool IsReference() const
    {
        return isReferenceM;
    }

    U32 GetBitfieldBitCount() const
    {
        return bitCountM;
    }

    U32 GetPointerCount() const
    {
        return pointerCountM;
    }

    const Pointer &GetPointer(U32 depth) const;

    U32 GetArrayCount() const
    {
        return arrayCountM;
    }

    const Array &GetArray(U32 dimension) const;

private:

    friend class TypeEnumeration;
    friend class TypeFunction;
    friend class TypeStructure;

    // Only the Xrtti library may create, destroy, or copy Types
    Type() { }
    ~Type() { }
    Type(const Type &);
    Type &operator =(const Type &);

    BaseType baseTypeM;

    bool isConstM;

    bool isVolatileM;

    bool isReferenceM;

    U32 bitCountM;

    U32 pointerCountM;

    Pointer *pPointersM;

    U32 arrayCountM;

    Array *pArraysM;
};


class Pointer
{
public:

    bool IsConst() const
    {
        return isConstM;
    }

    bool IsVolatile() const
    {
        return isVolatileM;
    }

private:

    // Only the Xrtti library may create, destroy, or copy Pointers
    Pointer() { }
    ~Pointer() { }
    Pointer(const Pointer &);
    Pointer &operator =(const Pointer &);

    bool isConstM;

    bool isVolatileM;
};


class Array
{
public:

    bool IsUnbounded() const
    {
        return isUnboundedM;
    }

    U32 GetElementCount() const 
    {
        return elementCountM;
    }

private:

    // Only the Xrtti library may create, destroy, or copy Arrays
    Array() { }
    ~Array() { }
    Array(const Array &);
    Array &operator =(const Array &);

    bool isUnboundedM;

    U32 elementCountM;
};


class Enumeration
{
public:

    AccessType GetAccessType() const
    {
        return accessTypeM;
    }

    const Context &GetContext() const
    {
        return *pContextM;
    };

    const char *GetName() const
    {
        return pNameM;
    }
    
    U32 GetValueCount() const
    {
        return valueCountM;
    }

    const EnumerationValue &GetValue(U32 index) const;

private:

    // Only the Xrtti library may create, destroy, or copy Enumerations
    Enumeration() { }
    ~Enumeration() { }
    Enumeration(const Enumeration &);
    Enumeration &operator =(const Enumeration &);

    AccessType accessTypeM;

    Context *pContextM;

    const char *pNameM;

    U32 valueCountM;

    EnumerationValue *pValuesM;
};


class EnumerationValue
{
public:

    const char *GetName() const
    {
        return pNameM;
    }

    S32 GetValue() const
    {
        return valueM;
    }

private:

    // Only the Xrtti library may create, destroy, or copy EnumerationValues
    EnumerationValue() { }
    ~EnumerationValue() { }
    EnumerationValue(const EnumerationValue &);
    EnumerationValue &operator =(const EnumerationValue &);

    const char *pNameM;

    S32 valueM;
};


class TypeEnumeration : public Type
{
public:

    const Enumeration &GetEnumeration() const
    {
        return *pEnumerationM;
    }

private:

    // Only the Xrtti library may create, destroy, or copy TypeEnumerations
    TypeEnumeration() { }
    ~TypeEnumeration() { }
    TypeEnumeration(const TypeEnumeration &);
    TypeEnumeration &operator =(const TypeEnumeration &);

    Enumeration *pEnumerationM;
};


class TypeFunction : public Type
{
public:

    const MethodSignature &GetSignature() const
    {
        return signatureM;
    }

private:

    // Only the Xrtti library may create, destroy, or copy TypeFunctions
    TypeFunction() { }
    ~TypeFunction() { }
    TypeFunction(const TypeFunction &);
    TypeFunction &operator =(const TypeFunction &);
    
    MethodSignature signatureM;
};


class TypeStructure : public Type
{
public:

    const Structure &GetStructure() const
    {
        return *pStructureM;
    }

private:

    // Only the Xrtti library may create, destroy, or copy TypeFunctions
    TypeStructure() { }
    ~TypeStructure() { }
    TypeStructure(const TypeStructure &);
    TypeStructure &operator =(const TypeStructure &);

    Structure *pStructureM;
};


void Register(const Generated *pGenerated);

U32 GetContextCount();

const Context *GetContext(U32 index);

const Context *LookupContext(const char *pFullName);

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

void ShutDown();

}; // namespace Xrtti

#endif // XRTTI_H

---