---

type.h

#ifndef __TYPE_H__
#define __TYPE_H__

#include <string.h>

class RTTIClassDescriptor;
class RTTIFieldDescriptor;

class RTTI_DLL_ENTRY RTTIType { 
  public:
    int  getTag() { 
        return tag;
    }

    virtual void getTypeName(char* buf);

    static RTTIType voidType;
    static RTTIType charType;
    static RTTIType ucharType;
    static RTTIType scharType;
    static RTTIType shortType;
    static RTTIType ushortType;
    static RTTIType intType;
    static RTTIType uintType;
    static RTTIType longType;
    static RTTIType ulongType;
    static RTTIType floatType;
    static RTTIType doubleType;
    static RTTIType boolType;
    static RTTIType unknownType;

    enum TypeTag { 
        RTTI_UNKNOWN, 
        RTTI_VOID, 
        RTTI_CHAR, 
        RTTI_UCHAR, 
        RTTI_SCHAR, 
        RTTI_SHORT, 
        RTTI_USHORT, 
        RTTI_INT, 
        RTTI_UINT, 
        RTTI_LONG, 
        RTTI_ULONG, 
        RTTI_FLOAT, 
        RTTI_DOUBLE, 
        RTTI_BOOL, 
        RTTI_ARRAY, 
        RTTI_STRUCT, 
        RTTI_PTR,  
        RTTI_DERIVED,
        RTTI_METHOD 
    };
    
    bool isBuiltin() { 
        return tag <= RTTI_BOOL;
    }
    
    bool isScalar() { 
        return tag > RTTI_VOID && tag <= RTTI_BOOL;
    } 
        
    bool isArray() { 
        return tag == RTTI_ARRAY;
    }

    bool isPointer() { 
        return tag == RTTI_PTR;
    }

    bool isClass() { 
        return tag == RTTI_STRUCT;
    }

    bool isBaseClass() { 
        return tag == RTTI_DERIVED;
    }
    
    ~RTTIType();

  protected:
    friend class RTTIClassDescriptor;
    friend class RTTIFieldDescriptor;
    friend class RTTIMethodDescriptor;

    int   tag;

    void destroy() {
        if (!isBuiltin()) { 
            delete this;
        }
    }

    RTTIType(int tag) { 
        this->tag = tag;
    }
};
 

class RTTI_DLL_ENTRY RTTIPtrType : public RTTIType {     
  public:
    RTTIPtrType(RTTIType* ptrType) : RTTIType(RTTI_PTR) {
        this->ptrType = ptrType;
    }
    void getTypeName(char* buf);
  protected:
    RTTIType* ptrType;
};

class RTTI_DLL_ENTRY RTTIArrayType : public RTTIType {     
  public:
    RTTIArrayType(RTTIType* elemType, int nElems) : RTTIType(RTTI_ARRAY) {
        this->elemType = elemType;
        this->nElems = nElems;
    }
    void getTypeName(char* buf);

    int  getArraySize() { 
        return nElems;
    }

    RTTIType* getElementType() { 
        return elemType;
    }

  protected:
    RTTIType* elemType;
    int       nElems;
};

class RTTI_DLL_ENTRY RTTIDerivedType : public RTTIType {     
  public:
    RTTIDerivedType(RTTIClassDescriptor* baseClass) : RTTIType(RTTI_DERIVED) {
        this->baseClass = baseClass;
    }
    
    RTTIClassDescriptor* getBaseClass() { 
        return baseClass;
    }

    void getTypeName(char* buf);

  protected:
    RTTIClassDescriptor* baseClass;
};

class RTTI_DLL_ENTRY RTTIMethodType : public RTTIType { 
  public:
    void getTypeName(char* buf);
    
    void getMethodDeclaration(char* buf, char const* name);

    virtual void invoke(void* result, void* obj, void* parameters[]) = 0;

    RTTIClassDescriptor* getClass() { 
        return methodClass;
    }

    RTTIType* getReturnType() { 
        return returnType;
    }

    RTTIType** getParameterTypes() { 
        return paramTypes;
    }

    int getNumberOfParameters() { 
        return nParams;
    }

    RTTIMethodType() : RTTIType(RTTI_METHOD) {}
    ~RTTIMethodType() { 
        delete[] paramTypes;
    }
  protected:
    friend class RTTIMethodDescriptor;
    friend class RTTIBfdRepository;

    RTTIType*  returnType;
    int        nParams;
    RTTIType** paramTypes;
    RTTIClassDescriptor* methodClass;
    bool       isStatic;
};
        

#endif

---