rom/oop/intern.h

   1 #ifndef INTERN_H
   2 #define INTERN_H
   3
   4 /*
   5     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   6     $Id$
   7
   8     Desc:
   9     Lang: english
  10 */
  11
  12 #ifndef EXEC_LISTS_H
  13 #   include <exec/lists.h>
  14 #endif
  15
  16 #ifndef EXEC_LIBRARIES_H
  17 #   include <exec/libraries.h>
  18 #endif
  19
  20 #ifndef EXEC_SEMAPHORES_H
  21 #   include <exec/semaphores.h>
  22 #endif
  23
  24 #ifndef DOS_BPTR_H
  25 #   include <dos/bptr.h>
  26 #endif
  27
  28 #ifndef UTILITY_TAGITEM_H
  29 #   include <utility/tagitem.h>
  30 #endif
  31
  32 #ifndef OOP_OOP_H
  33 #   include <oop/oop.h>
  34 #endif
  35
  36
  37 /* Predeclaration */
  38 struct IntOOPBase;
  39
  40 #ifndef PRIVATE_H
  41 #   include "private.h"
  42 #endif
  43
  44 #define SDEBUG 0
  45 #define DEBUG 0
  46
  47 #define NUM_METHOD_BITS 10
  48 #define METHOD_MASK ((1 << NUM_METHOD_BITS) - 1)
  49
  50
  51 /* These are used to index an array in the library base
  52    from which we get the IDs for the used interfaces.
  53 */
  54
  55 enum {
  56     IDX_IRoot = 0,
  57     IDX_IMeta,
  58     IDX_IMethod,
  59     IDX_IServer,
  60     IDX_IProxy,
  61     IDX_IInterface,
  62     NUM_Indexes
  63 };
  64
  65
  66
  67 /* Used by the internal GetIDs() functions, to get several
  68 IDs at a time */
  69
  70 struct IDDescr
  71 {
  72     STRPTR ID;
  73     ULONG *Storage;
  74 };
  75
  76
  77
  78
  79 /* defines used to access the interface IDs stored in the library base */
  80
  81 #define __IRoot         (GetOBase(OOPBase)->ob_InternIDs[IDX_IRoot])
  82 #define __IMeta         (GetOBase(OOPBase)->ob_InternIDs[IDX_IMeta])
  83 #define __IMethod       (GetOBase(OOPBase)->ob_InternIDs[IDX_IMethod])
  84 #define __IServer       (GetOBase(OOPBase)->ob_InternIDs[IDX_IServer])
  85 #define __IProxy        (GetOBase(OOPBase)->ob_InternIDs[IDX_IProxy])
  86 #define __IInterface    (GetOBase(OOPBase)->ob_InternIDs[IDX_IInterface])
  87
  88 #define GetOBase(lib)           ((struct IntOOPBase *)(lib))
  89
  90 /*****************
  91 **  Prototypes  **
  92 *****************/
  93
  94 BOOL GetIDs(struct IDDescr *idDesr, struct IntOOPBase *OOPBase);
  95
  96
  97 /* rootclass.c */
  98 BOOL init_rootclass(struct IntOOPBase *OOPBase);
  99
 100 /* metaclass.c */
 101 BOOL init_basemeta(struct IntOOPBase *OOPBase);
 102 BOOL init_ifmetaclass(struct IntOOPBase *OOPBase);
 103
 104 /* methodclass.c */
 105 OOP_Class *init_methodclass(struct IntOOPBase *OOPBase);
 106
 107 /* serverclass.c */
 108 OOP_Class *init_serverclass(struct Library *OOPBase);
 109
 110 /* proxyclass.c */
 111 OOP_Class *init_proxyclass(struct Library *OOPBase);
 112
 113 /* interfaceclass.c */
 114 OOP_Class *init_interfaceclass(struct Library *OOPBase);
 115
 116
 117 OOP_Class *init_hiddmetaclass(struct IntOOPBase *OOPBase);
 118
 119 /* support.c */
 120 BOOL hasinterface(OOP_Class *cl, STRPTR interface_id);
 121 struct IFMethod *findinterface(OOP_Class *cl, STRPTR interface_id);
 122 struct IFMethod *findmethod(OOP_Class *cl, STRPTR interface_id, ULONG method_offset);
 123 BOOL init_methodbase(STRPTR interface_id, ULONG methodbase, ULONG *methodbase_ptr, struct IntOOPBase *OOPBase);
 124 BOOL init_mi_methodbase(STRPTR interface_id, ULONG *methodbase_ptr, struct IntOOPBase *OOPBase);
 125 VOID release_idbucket(STRPTR interface_id, struct IntOOPBase *OOPBase);
 126 VOID obtain_idbucket(STRPTR interface_id, struct IntOOPBase *OOPBase);
 127 /*****************
 128 **  Structures  **
 129 *****************/
 130
 131 /* Bucket for hashtable used to map string interface IDs to
 132 ** numeric interface IDs and attrbases.
 133 */
 134
 135 struct iid_bucket
 136 {
 137     struct iid_bucket *next;
 138     STRPTR interface_id;
 139     ULONG  methodbase;
 140     ULONG  attrbase;
 141     ULONG refcount;
 142 };
 143
 144
 145
 146 /* Definition of bucket for hashtable used to store
 147 ** the interfaces (method tables)
 148 */
 149
 150 struct IFBucket
 151 {
 152     struct IFBucket *Next;
 153     ULONG InterfaceID;
 154     STRPTR GlobalInterfaceID;
 155     struct IFMethod *MethodTable;
 156     ULONG NumMethods;
 157 };
 158
 159
 160 /* Definition of an entry in a method table.
 161 ** Ie. the method tables are arrays of these.
 162 ** One has to store the class for each method
 163 ** because we skip unimplemented class calls, and
 164 ** therefore a method can go directly to a parent
 165 ** class of OCLASS(o)
 166 */
 167
 168 struct IFMethod
 169 {
 170     IPTR (*MethodFunc)();
 171     OOP_Class *mClass;
 172 };
 173
 174
 175 /* Message struct used for sending object message structs across
 176 ** to another task
 177 */
 178 struct ProxyMsg
 179 {
 180     struct Message      pm_Message;
 181     OOP_Msg             pm_ObjMsg;
 182     IPTR                pm_RetVal;
 183     OOP_Object          *pm_Object;
 184 };
 185
 186 /* Listnode that helps keeping track of servers. */
 187 struct ServerNode
 188 {
 189     struct Node sn_Node;
 190     OOP_Object  *sn_Server;
 191 };
 192
 193
 194 /* Instance data of base metaclass and rootclass */
 195
 196 struct metadata
 197 {
 198     OOP_Class public; /* public part of class objects */
 199     ULONG subclasscount;
 200     ULONG objectcount;
 201     ULONG instsize;
 202     BOOL  disptabs_inited;
 203     ULONG numinterfaces;
 204
 205 };
 206
 207 #define MD(x) ((struct metadata *)x)
 208
 209 #define NUM_BASEMETA_IFS 2
 210 struct basemetaobject /* Real instance data of the base meta class */
 211 {
 212     OOP_Class  *oclass; /* The meta object's class */
 213     struct basemeta_inst
 214     {
 215         struct metadata data;
 216         struct IFMethod *iftable[NUM_BASEMETA_IFS]; /* has two interfaces: root and meta */
 217
 218         /* The interface tables */
 219         struct IFMethod rootif[num_Root_Methods];
 220         struct IFMethod metaif[NUMTOTAL_M_Meta];
 221     } inst;
 222 };
 223
 224 struct rootclassobject
 225 {
 226     OOP_Class *oclass; /* The rootclass object's class */
 227     struct rootinst
 228     {
 229         struct metadata data;
 230         struct IFMethod rootif[num_Root_Methods];
 231     } inst;
 232 };
 233
 234
 235 /* IFMeta class */
 236
 237 struct ifmeta_data
 238 {
 239
 240     /* The hashtable containing the interfaces (method tables) */
 241     struct HashTable *iftable;
 242
 243     /* A direct pointer into the hashtable, for faster lookup */
 244     struct IFBucket **iftab_directptr;
 245
 246     /* Used by the hash function. As the above field, it is put
 247     ** here for speed
 248     */
 249     ULONG hashmask;
 250
 251     /* Number of interfaces in the hashtable */
 252     ULONG numinterfaces;
 253
 254 };
 255
 256
 257 struct ifmetaobject
 258 {
 259     OOP_Class *oclass; /* The interface metaclass' class (itself) */
 260     struct ifmeta_inst
 261     {
 262         struct metadata base;
 263         struct ifmeta_data data;
 264
 265     } inst;
 266 };
 267
 268
 269
 270 /*************************
 271 ** Library Base struct  **
 272 *************************/
 273 struct IntOOPBase
 274 {
 275     struct Library               ob_LibNode;
 276
 277     struct SignalSemaphore       ob_ClassListLock;
 278     struct MinList               ob_ClassList;
 279
 280     struct SignalSemaphore       ob_ServerListLock;
 281     struct MinList               ob_ServerList;
 282
 283     /* rootclass object */
 284     struct rootclassobject       ob_RootClassObject;
 285
 286     /* base metaclass object */
 287     struct basemetaobject        ob_BaseMetaObject;
 288
 289     /* interface metaclass object */
 290     struct ifmetaobject          ob_IFMetaObject;
 291
 292     /* HIDD metaclass */
 293     OOP_Class                    *ob_HIDDMetaClass;
 294
 295     /* Store pointers to some usefull classes here */
 296     OOP_Class                    *ob_MethodClass;
 297     OOP_Class                    *ob_ServerClass;
 298     OOP_Class                    *ob_ProxyClass;
 299     OOP_Class                    *ob_InterfaceClass;
 300
 301     /* Hashtable containing string interface ID => Numeric interface
 302     ** ID mappings. Used by GetMethodID() and GetAttrBase()
 303     */
 304     struct HashTable           * ob_IIDTable;
 305     struct SignalSemaphore       ob_IIDTableLock;
 306
 307     /* The currently lowest available numeric interfaceID that
 308     ** we can map a new interface string ID onto.
 309     ** Used by GetID()
 310     */
 311
 312     ULONG                        ob_CurrentMethodBase;
 313     ULONG                        ob_CurrentAttrBase;
 314
 315     /* An array of the interface IDs used internally. */
 316     ULONG                        ob_InternIDs[NUM_Indexes];
 317 };
 318
 319 #define ROOTCLASSPTR (& (OOPBase)->ob_RootClassObject.inst.data.public)
 320 #define BASEMETAPTR (& (OOPBase)->ob_BaseMetaObject.inst.data.public)
 321
 322 #endif /* INTERN_H */