test/OOPDemos/oop.c

   1 /*
   2    Copyright © 1997-98, The AROS Development Team. All rights reserved.
   3    $Id$
   4
   5    Desc: Demo of new OOP system
   6    Lang: english
   7 */
   8
   9
  10 #include "protos.h"
  11
  12 #include <string.h>
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15
  16 #include "oop.h"
  17
  18 #define SDEBUG 0
  19 #define DEBUG 0
  20 #include "debug.h"
  21
  22 /**************************************************/
  23 VOID CleanupOOP();
  24 BOOL InitOOP();
  25 Class *MakeClass(STRPTR classID, STRPTR superID, struct InterfaceDescr *ifDescr,
  26         ULONG instDataSize);
  27 VOID FreeClass(Class * cl);
  28
  29 /* could go into a library base */
  30 // struct SignalSemaphore ClassListSema;
  31 Class RootClassMem;
  32 struct OOPBase oopbasemem;
  33 struct OOPBase *oopbase = &oopbasemem;
  34
  35 /******************************************************************/
  36
  37 /* The oop system code */
  38
  39 BOOL AllocDispatchTables(Class *cl, struct InterfaceDescr *iDescr);
  40 VOID FreeDispatchTables(Class *cl);
  41
  42 /******************
  43 **  MakeClass()  **
  44 ******************/
  45 Class *MakeClass(STRPTR classID, STRPTR superID, struct InterfaceDescr *cl_Descr,
  46         ULONG instDataSize)
  47 {
  48     #define UB(x) ((UBYTE *)x)
  49
  50     #define UnlockCL     ReleaseSemaphore( &ClassListSema )
  51     #define LockCLShared ObtainSemaphoreShared( &ClassListSema )
  52     #define LockCL       ObtainSemaphore( &ClassListSema )
  53
  54     #define ClassID ClassNode.ln_Name
  55
  56     Class *cl, *supercl;
  57
  58     /* Find superclass */
  59     EnterFunc(bug("MakeClass(classID=%s, superID=%s, ifDescr=%p, instDataSize=%ld)\n",
  60                 classID, superID, cl_Descr, instDataSize));
  61
  62 LockCL;
  63     supercl = (Class *)FindName( &(oopbase->ClassList), superID);
  64     if (supercl)
  65     {
  66         /* Mark the class as busy, so it isn't freed while we are allocating
  67         ** stuff for our class
  68         */
  69         supercl->SubClassCount ++;
  70     }
  71 UnlockCL;
  72
  73     if (!supercl)
  74         return (FALSE);
  75
  76     D(bug("Found superclass %s\n", supercl->ClassID));
  77
  78     /* Allocate class structure */
  79     D(bug("Allocating class of size %d\n", sizeof (Class) ));
  80     cl = malloc(sizeof (Class));
  81     if (cl)
  82     {
  83
  84         D(bug("Allocated class structure\n"));
  85
  86         cl->ClassID = malloc( strlen(classID) + 1);
  87         if (cl->ClassID)
  88         {
  89             D(bug("Allocated class id\n"));
  90             strcpy(cl->ClassID, classID);
  91
  92
  93             /* Must do this before calling AllocDispatchTables(), so that
  94             ** it knows from where to copy dispatch tables.
  95             */
  96             cl->SuperClass = supercl;
  97             if (AllocDispatchTables(cl, cl_Descr))
  98             {
  99
 100                 /* Update instance data info */
 101                 cl->InstOffset = supercl->InstOffset + supercl->InstSize;
 102                 cl->InstSize = instDataSize;
 103
 104                 ReturnPtr("MakeClass", Class *, cl);
 105
 106             }
 107
 108             free(cl->ClassID);
 109
 110         }
 111
 112         free(cl);
 113
 114     }
 115
 116     /* Initalization failed, free lock on superclass */
 117     supercl->SubClassCount --;
 118
 119     ReturnPtr ("MakeClass", Class *, NULL);
 120
 121 } /* CreateClass */
 122
 123
 124
 125 /******************
 126 **  FreeClass()  **
 127 ******************/
 128
 129 VOID FreeClass(Class *cl)
 130 {
 131
 132     EnterFunc(bug("FreeClass(classID=%s)\n", cl->ClassID));
 133
 134     if (cl)
 135     {
 136
 137         /* What level are we ? */
 138         if (cl->SuperClass == NULL) /* Someone trying to remove the rootclass */
 139             ReturnVoid("FreeClass (Someone trying to remove rootclass)");
 140
 141         FreeDispatchTables(cl);
 142
 143         /* Free class ID */
 144         D(bug("Freeing class ID %s\n", cl->ClassID));
 145         free(cl->ClassID);
 146     }
 147     ReturnVoid("FreeClass");
 148 }
 149
 150 /************************
 151 **  Rootclass methods  **
 152 ************************/
 153 struct RootData
 154 {
 155     ULONG dummy;
 156 };
 157
 158 #define NUMROOTMETHODS 2
 159
 160 Object *_Root_New(Class *root_cl, Class *cl, APTR param)
 161 {
 162     struct _Object *o;
 163     struct RootData *data;
 164
 165     EnterFunc(bug("Root::New(cl=%s, param = %p)\n",
 166         cl->ClassNode.ln_Name, param));
 167
 168     /* Allocate memory for the object */
 169     D(bug("Object size: %ld\n", cl->InstOffset + cl->InstSize + sizeof (struct _Object)));
 170     o = malloc(cl->InstOffset + cl->InstSize + sizeof (struct _Object));
 171     if (o)
 172     {
 173         D(bug("Mem allocated: %p\n", o));
 174         o->o_Class = cl;
 175
 176         data = (struct RootData *)BASEOBJECT(o);
 177
 178         cl->ObjectCount ++;
 179
 180         ReturnPtr ("Root::New", Object *, BASEOBJECT(o) );
 181     }
 182
 183     ReturnPtr ("Root::New", Object *, NULL);
 184 }
 185
 186 VOID _Root_Dispose(Class *cl, Object *o, Msg msg)
 187 {
 188     EnterFunc(bug("Root::Dispose(o=%p, oclass=%s)\n", o, _OBJECT(o)->o_Class->ClassNode.ln_Name));
 189
 190     _OBJECT(o)->o_Class->ObjectCount --;
 191     D(bug("Object mem: %p, size: %ld\n", _OBJECT(o), ((ULONG *)_OBJECT(o))[-1] ));
 192     free(_OBJECT(o));
 193
 194     ReturnVoid("Root::Dispose");
 195 }
 196
 197
 198 /****************
 199 **  InitOOP()  **
 200 ****************/
 201
 202
 203 BOOL InitOOP()
 204 {
 205 #if (HASHED_STRINGS)
 206     struct MethodDescr mdescr[]=
 207     {
 208         { (IPTR (*)())_Root_New,                M_New           },
 209         { (IPTR (*)())_Root_Dispose,            M_Dispose       }
 210     };
 211
 212     struct InterfaceDescr _Root_Descr[] =
 213     {
 214         {mdescr, "Root", 2},
 215         {NULL, NULL, 0UL}
 216     };
 217
 218 #endif
 219 #if (HASHED_IFS || HASHED_METHODS)
 220     IPTR (*_Root_MTab[])() =
 221     {
 222         (IPTR (*)())_Root_New,
 223         (IPTR (*)())_Root_Dispose
 224
 225     };
 226     struct InterfaceDescr _Root_Descr[] =
 227     {
 228         {_Root_MTab, I_Root, 2},
 229         {NULL, 0UL, 0UL},
 230     };
 231 #endif
 232
 233     Class *RootClass = &RootClassMem;
 234
 235     InitSemaphore(&ClassListSema);
 236     NEWLIST(&(oopbase->ClassList));
 237
 238     EnterFunc(bug("InitOOP()\n"));
 239
 240     /* Initialize rootclass */
 241     RootClass->SuperClass = NULL;
 242     if (AllocDispatchTables(RootClass, _Root_Descr))
 243     {
 244         RootClass->ClassID       = ROOTCLASS;
 245         RootClass->InstOffset    = 0UL;
 246         RootClass->InstSize      = 0UL;
 247         RootClass->SubClassCount = 0UL;
 248         RootClass->ObjectCount   = 0UL;
 249
 250 #ifdef HASHED_IFS
 251         RootClass->NumInterfaces = 1UL;
 252 #endif
 253
 254         AddClass(RootClass);
 255
 256         ReturnBool ("InitOOP", TRUE);
 257
 258     }
 259
 260
 261     ReturnBool ("InitOOP", FALSE);
 262 }
 263
 264
 265 /*******************
 266 **  CleanupOOP()  **
 267 *******************/
 268 VOID CleanupOOP()
 269 {
 270     Class *RootClass = &RootClassMem;
 271
 272     EnterFunc(bug("CleanupOOP()\n"));
 273
 274     FreeDispatchTables(RootClass);
 275
 276     ReturnVoid("CleanupOOP");
 277 }
 278
 279
 280 /*****************
 281 **  NewObject() **
 282 *****************/
 283 Object *NewObject(Class *cl, STRPTR classID, Msg msg)
 284 {
 285     Object *o;
 286
 287     struct P_New p;
 288
 289     if (!cl)
 290     {
 291 LockCL;
 292         cl = (Class *)FindName(&(oopbase->ClassList), classID);
 293         if (cl)
 294            cl->ObjectCount ++; /* We don't want the class to be freed while we work on it */
 295     }
 296 UnlockCL;
 297
 298     if (!cl)
 299         return (NULL);
 300
 301     /* Create a new instance */
 302
 303     p.MethodID = (IPTR)M_New;
 304     p.ParamPtr = msg;
 305
 306     o = (Object *)CoerceMethodA(cl, (Object *)cl, (Msg)&p);
 307     if (!o)
 308     {
 309         cl->ObjectCount --; /* Object creation failed, release lock */
 310     }
 311     return (o);
 312 }
 313
 314 VOID DisposeObject(Object *o)
 315 {
 316     IPTR methodid = (IPTR)M_Dispose;
 317
 318
 319     Class *cl = OCLASS(o);
 320
 321     DoMethodA(o, (Msg)&methodid);
 322
 323     cl->ObjectCount --;
 324
 325     return;
 326 }
 327
 328 /***************
 329 **  AddClass  **
 330 ***************/
 331 VOID AddClass(Class *cl)
 332 {
 333
 334 LockCL;
 335     AddTail(&(oopbase->ClassList), &(cl->ClassNode) );
 336 UnlockCL;
 337     return;
 338 }
 339
 340 /******************
 341 **  RemoveClass  **
 342 ******************/
 343 VOID RemoveClass(Class *cl)
 344 {
 345 LockCL;
 346     Remove(&(cl->ClassNode) );
 347 UnlockCL;
 348
 349     return;
 350 }