rom/oop/intern.h

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