test/oop2/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 /* These are not necessary in the demo */
  11 #define InitSemaphore(x)
  12 #define ObtainSemaphore(x)
  13 #define ObtainSemaphoreShared(x)
  14 #define ReleaseSemaphore(x)
  15
  16 #include <string.h>
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19
  20 #include "types.h"
  21 #include "oop.h"
  22 #include "protos.h"
  23
  24 #define DEBUG 0
  25 #include "debug.h"
  26
  27 #define UB(x) ((UBYTE *)x)
  28 /* could go into a library base */
  29 /*struct SignalSemaphore ClassListSema;
  30 */
  31 struct List ClassList;
  32 Class RootClassMem;
  33
  34 /* Method implementations */
  35
  36
  37 /******************************************************************/
  38
  39 /* The oop system code */
  40
  41 static BOOL AllocMTable(Class *cl, ULONG numNewMethods);
  42 static VOID InitMTable(Class *cl, APTR *mDescr);
  43 static VOID FreeMTable(Class *cl);
  44
  45 /****************
  46 **  MakeClass  **
  47 ****************/
  48 Class *MakeClass(STRPTR classID
  49                 ,STRPTR superID
  50                 ,APTR  *mDescr
  51                 ,ULONG instDataSize
  52                 ,ULONG numNewMethods)
  53 {
  54     #define UB(x) ((UBYTE *)x)
  55
  56     #define UnlockCL     ReleaseSemaphore( &ClassListSema )
  57     #define LockCLShared ObtainSemaphoreShared( &ClassListSema )
  58     #define LockCL       ObtainSemaphore( &ClassListSema )
  59
  60     #define ClassID ClassNode.ln_Name
  61
  62     Class *cl, *supercl;
  63
  64     /* Find superclass */
  65     D(bug("CreateClass(classID=%s, superID=%s, mDescr=%p, instDataSize=%ld)\n",
  66                 classID, superID, mDescr, instDataSize));
  67
  68 LockCL;
  69     supercl = (Class *)FindName( &ClassList, superID);
  70     if (supercl)
  71     {
  72         /* Mark the class as busy, so it isn't freed while we are allocating
  73         ** stuff for our class
  74         */
  75         supercl->SubClassCount ++;
  76     }
  77 UnlockCL;
  78
  79     if (!supercl)
  80         return (FALSE);
  81
  82     D(bug("Found superclass %s\n", supercl->ClassID));
  83
  84     /* Allocate class structure */
  85     D(bug("Allocating class of size %d\n", sizeof (Class) ));
  86     cl = malloc(sizeof (Class));
  87     if (cl)
  88     {
  89
  90         cl->ClassID = malloc( strlen(classID) + 1 );
  91
  92         if (cl->ClassID)
  93
  94         {
  95             /* Copy class ID */
  96             strcpy(cl->ClassID, classID);
  97             D(bug("class ID copied\n"));
  98
  99             /* Must be done before calling AllocMethodTable().
 100             ** This is because AllocMethodTable() must know the number
 101             ** of new methods.
 102             */
 103             cl->SuperClass = supercl;
 104             cl->NumMethods = numNewMethods;
 105
 106             D(bug("Number of methods introduced by class: %ld\n", numNewMethods));
 107
 108             /* Allocate method table for class */
 109             if ( AllocMTable(cl, numNewMethods) )
 110             {
 111                 /* Initialize method table with supplied methods */
 112                 InitMTable(cl, mDescr);
 113
 114                 /* Well, same as in BOOPSI */
 115                 cl->InstOffset = supercl->InstOffset + supercl->InstSize;
 116                 cl->InstSize   = instDataSize;
 117
 118                 supercl->SubClassCount ++;
 119
 120                 ReturnPtr ("MakeClass", Class *, cl);
 121
 122
 123             }
 124
 125             free(cl->ClassID);
 126         }
 127         free(cl);
 128     }
 129
 130     /* Initalization failed, free lock on superclass */
 131     supercl->SubClassCount --;
 132
 133     ReturnPtr ("MakeClass", Class *, NULL);
 134
 135 } /* CreateClass */
 136
 137
 138 /*************************
 139 **  AllocMethodTable()  **
 140 *************************/
 141
 142 static BOOL AllocMTable(Class *cl, ULONG numNewMethods)
 143 {
 144
 145     LONG mtable_size;
 146
 147     ULONG nummethods;
 148     struct Method *mtable = NULL;
 149
 150     Class *super;
 151
 152     D(bug("AllocMTable(class=%s, numNewMethods=%ld)\n",
 153         cl->ClassID, numNewMethods));
 154
 155     /* Count the number of methods for superclasses.
 156     ** Note that the same methods are NOT counted twice as
 157     ** class->NumMethods is the number of methods that are new for 'class'.
 158     */
 159     nummethods = numNewMethods;
 160     for (super = cl->SuperClass; super; super = super->SuperClass)
 161         nummethods += super->NumMethods;
 162
 163     D(bug("Total number of methods: %ld\n", nummethods));
 164
 165     /* Calculate method table size, counted in bytes */
 166     mtable_size = UB(&mtable[nummethods]) - UB(&mtable[0]);
 167
 168     D(bug("Method table size: %ld\n", mtable_size));
 169
 170     /* Save hash table size, counted in entries */
 171     cl->MTableSize = nummethods;
 172
 173     /* Allocate hash table */
 174     mtable = malloc(mtable_size);
 175     if (mtable)
 176     {
 177         memset(mtable, 0, mtable_size);
 178         cl->MTable = mtable;
 179         ReturnBool("AllocMTable", TRUE);
 180     }
 181
 182
 183     ReturnBool ("AllocMTable", FALSE);
 184 }
 185
 186
 187 static VOID InitMTable(Class *cl, APTR *mDescr)
 188 {
 189
 190     Class *super = cl->SuperClass;
 191     ULONG i;
 192
 193     D(bug("InitMTable(cl=%s, mDescr=%p\n", cl->ClassID, mDescr));
 194
 195     if (super)
 196     {
 197         ULONG super_mtable_size;
 198
 199         D(bug("Superclass found: %s\n", super->ClassID));
 200         super_mtable_size =   UB(&(super->MTable[super->MTableSize]))
 201                             - UB(&(super->MTable[0]));
 202
 203         memcpy(cl->MTable, super->MTable, super_mtable_size);
 204     }
 205
 206     /* Override using the methods supplied in MakeClass() */
 207     D(bug("Overriding methods\n"));
 208
 209     for (i = 0; i < cl->MTableSize; i ++)
 210     {
 211         if (mDescr[i] != NULL)
 212         {
 213
 214             D(bug("Overriding method %ld\n", i));
 215             cl->MTable[i].MethodFunc = mDescr[i];
 216             cl->MTable[i].m_Class      = cl;
 217         }
 218     }
 219     ReturnVoid("InitMTable");
 220 }
 221
 222
 223 static VOID FreeMTable(Class *cl)
 224 {
 225     free(cl->MTable);
 226     return;
 227 }
 228
 229 /*****************
 230 **  Freelass()  **
 231 *****************/
 232 VOID FreeClass(Class *cl)
 233 {
 234
 235     D(bug("FreeClass(cl=%s)\n", cl->ClassID));
 236
 237
 238     if (cl)
 239     {
 240         /* What level are we ? */
 241         if (cl->SuperClass == NULL) /* Someone trying to remove the rootclass */
 242             ReturnVoid("FreeClass (Someone trying to remove rootclass)");
 243
 244         FreeMTable(cl);
 245         free(cl->ClassID);
 246         free(cl);
 247     }
 248     ReturnVoid("FreeClass");
 249 }
 250
 251 /************************
 252 **  Rootclass methods  **
 253 ************************/
 254 struct RootData
 255 {
 256     ULONG dummy;
 257 };
 258
 259 #define NUMROOTMETHODS 2
 260
 261 Object *Root_New(Class *rootcl, Class *cl, Msg msg)
 262 {
 263     struct _Object *o;
 264
 265     D(bug("Root::New(cl=%s, msg = %p)\n",
 266         cl->ClassNode.ln_Name, msg));
 267
 268     /* Allocate memory for the object */
 269     D(bug("Object size: %ld\n", cl->InstOffset + cl->InstSize + sizeof (struct _Object)));
 270     o = malloc(cl->InstOffset + cl->InstSize + sizeof (struct _Object) );
 271     if (o)
 272     {
 273         D(bug("Mem allocated: %p\n", o));
 274         o->o_Class = cl;
 275
 276         cl->ObjectCount ++;
 277
 278         ReturnPtr ("Root::New", Object *, BASEOBJECT(o) );
 279     }
 280
 281     ReturnPtr ("Root::New", Object *, NULL);
 282 }
 283
 284 VOID Root_Dispose(Class *cl, Object *o, Msg msg)
 285 {
 286     D(bug("Root::Dispose(o=%p, oclass=%s)\n", o, _OBJECT(o)->o_Class->ClassNode.ln_Name));
 287
 288     _OBJECT(o)->o_Class->ObjectCount --;
 289     D(bug("Object mem: %p\n", _OBJECT(o) ));
 290     free(_OBJECT(o));
 291
 292     ReturnVoid("Root::Dispose");
 293 }
 294
 295
 296 /****************
 297 **  InitOOP()  **
 298 ****************/
 299
 300
 301
 302 BOOL InitOOP()
 303 {
 304     Class *RootClass = &RootClassMem;
 305     APTR RootMTable[] =
 306     {
 307         Root_New,
 308         Root_Dispose,
 309         NULL
 310     };
 311
 312     D(bug("InitOOP()\n"));
 313
 314     InitSemaphore(&ClassListSema);
 315     NEWLIST(&ClassList);
 316
 317
 318     /* We must initialize the rootclass by hand */
 319
 320     RootClass->SuperClass = NULL; /* !!! Very important to do before AllocMTable() !!! */
 321     if (AllocMTable(RootClass, NUM_ROOT_METHODS))
 322     {
 323         D(bug("MTable allocated\n"));
 324         InitMTable(RootClass, RootMTable);
 325
 326         /* Fill in other stuff into the class structure */
 327         RootClass->ClassNode.ln_Name = ROOTCLASS;
 328         RootClass->InstOffset    = 0UL;
 329         RootClass->InstSize      = sizeof (struct RootData);
 330         RootClass->NumMethods    = NUMROOTMETHODS;
 331         RootClass->SubClassCount = 0UL;
 332         RootClass->ObjectCount   = 0UL;
 333         RootClass->SuperClass    = NULL;
 334
 335         /* Add the class. Arbitration not necessary, as
 336         ** noone know about us yet
 337         */
 338         AddTail(&ClassList, &(RootClass->ClassNode) );
 339
 340         ReturnBool ("InitOOP", TRUE);
 341
 342     }
 343
 344     ReturnBool ("InitOOP", FALSE);
 345 }
 346
 347
 348 /*******************
 349 **  CleanupOOP()  **
 350 *******************/
 351 VOID CleanupOOP()
 352 {
 353
 354     Class *RootClass = &RootClassMem;
 355
 356     D(bug("CleanupOOP()\n"));
 357
 358     FreeMTable(RootClass);
 359
 360     ReturnVoid("CleanupOOP");
 361 }
 362
 363 /*****************
 364 **  NewObject() **
 365 *****************/
 366 Object *NewObject(Class *cl, STRPTR classID, Msg msg)
 367 {
 368     Object *o;
 369
 370     struct P_New p;
 371
 372     if (!cl)
 373     {
 374 LockCL;
 375         cl = (Class *)FindName(&ClassList, classID);
 376         if (cl)
 377            cl->ObjectCount ++; /* We don't want the class to be freed while we work on it */
 378     }
 379 UnlockCL;
 380
 381     if (!cl)
 382         return (NULL);
 383
 384     /* Create a new instance */
 385
 386     p.MethodID = M_New;
 387     p.ParamPtr = msg;
 388
 389     o = (Object *)CoerceMethodA(cl, (Object *)cl, (Msg)&p);
 390     if (!o)
 391     {
 392         cl->ObjectCount --; /* Object creation failed, release lock */
 393     }
 394     ReturnPtr ("NewInstance", Object *, o);
 395 }
 396
 397 VOID DisposeObject(Object *o)
 398 {
 399     ULONG methodid = M_Dispose;
 400
 401
 402     Class *cl = OCLASS(o);
 403
 404     DoMethodA(o, (Msg)&methodid);
 405
 406     cl->ObjectCount --;
 407
 408     return;
 409 }
 410
 411 /***************
 412 **  AddClass  **
 413 ***************/
 414 VOID AddClass(Class *cl)
 415 {
 416
 417 LockCL;
 418     AddTail(&ClassList, &(cl->ClassNode) );
 419 UnlockCL;
 420     return;
 421 }
 422
 423 /******************
 424 **  RemoveClass  **
 425 ******************/
 426 VOID RemoveClass(Class *cl)
 427 {
 428 LockCL;
 429     Remove(&(cl->ClassNode) );
 430 UnlockCL;
 431
 432     return;
 433 }