rom/oop/intern.h

   1 #ifndef INTERN_H
   2 #define INTERN_H
   3
   4 /*
   5     Copyright © 1995-2008, 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     IPTR 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     OOP_Class *superclass;
 200     ULONG subclasscount;
 201     ULONG objectcount;
 202     ULONG instsize;
 203     BOOL  disptabs_inited;
 204     ULONG numinterfaces;
 205
 206 };
 207
 208 #define NUM_BASEMETA_IFS 2
 209 struct basemetaobject /* Real instance data of the base meta class */
 210 {
 211     OOP_Class  *oclass; /* The meta object's class */
 212     struct basemeta_inst
 213     {
 214         struct metadata data;
 215         struct IFMethod *iftable[NUM_BASEMETA_IFS]; /* has two interfaces: root and meta */
 216
 217         /* The interface tables */
 218         struct IFMethod rootif[num_Root_Methods];
 219         struct IFMethod metaif[NUMTOTAL_M_Meta];
 220     } inst;
 221 };
 222
 223 struct rootclassobject
 224 {
 225     OOP_Class *oclass; /* The rootclass object's class */
 226     struct rootinst
 227     {
 228         struct metadata data;
 229         struct IFMethod rootif[num_Root_Methods];
 230     } inst;
 231 };
 232
 233
 234 /* IFMeta class */
 235
 236 struct ifmeta_data
 237 {
 238
 239     /* The hashtable containing the interfaces (method tables) */
 240     struct HashTable *iftable;
 241
 242     /* A direct pointer into the hashtable, for faster lookup */
 243     struct IFBucket **iftab_directptr;
 244
 245     /* Used by the hash function. As the above field, it is put
 246     ** here for speed
 247     */
 248     ULONG hashmask;
 249
 250     /* Number of interfaces in the hashtable */
 251     ULONG numinterfaces;
 252
 253 };
 254
 255
 256 struct ifmetaobject
 257 {
 258     OOP_Class *oclass; /* The interface metaclass' class (itself) */
 259     struct ifmeta_inst
 260     {
 261         struct metadata base;
 262         struct ifmeta_data data;
 263
 264     } inst;
 265 };
 266
 267
 268
 269 /*************************
 270 ** Library Base struct  **
 271 *************************/
 272 struct IntOOPBase
 273 {
 274     struct Library               ob_LibNode;
 275
 276     struct SignalSemaphore       ob_ClassListLock;
 277     struct MinList               ob_ClassList;
 278
 279     struct SignalSemaphore       ob_ServerListLock;
 280     struct MinList               ob_ServerList;
 281
 282     /* rootclass object */
 283     struct rootclassobject       ob_RootClassObject;
 284
 285     /* base metaclass object */
 286     struct basemetaobject        ob_BaseMetaObject;
 287
 288     /* interface metaclass object */
 289     struct ifmetaobject          ob_IFMetaObject;
 290
 291     /* HIDD metaclass */
 292     OOP_Class                    *ob_HIDDMetaClass;
 293
 294     /* Store pointers to some usefull classes here */
 295     OOP_Class                    *ob_MethodClass;
 296     OOP_Class                    *ob_ServerClass;
 297     OOP_Class                    *ob_ProxyClass;
 298     OOP_Class                    *ob_InterfaceClass;
 299
 300     /* Hashtable containing string interface ID => Numeric interface
 301     ** ID mappings. Used by GetMethodID() and GetAttrBase()
 302     */
 303     struct HashTable           * ob_IIDTable;
 304     struct SignalSemaphore       ob_IIDTableLock;
 305
 306     /* The currently lowest available numeric interfaceID that
 307     ** we can map a new interface string ID onto.
 308     ** Used by GetID()
 309     */
 310
 311     ULONG                        ob_CurrentMethodBase;
 312     ULONG                        ob_CurrentAttrBase;
 313
 314     /* An array of the interface IDs used internally. */
 315     ULONG                        ob_InternIDs[NUM_Indexes];
 316 };
 317
 318 #define ROOTCLASSPTR (& (OOPBase)->ob_RootClassObject.inst.data.public)
 319 #define BASEMETAPTR (& (OOPBase)->ob_BaseMetaObject.inst.data.public)
 320
 321 #endif /* INTERN_H */