test/oopdemo.c

   1 /*
   2     Copyright © 1995-2002, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Demo of new OOP system
   6  */
   7
   8 /* Prevent inclusion of <intuition/classes.h>,
   9  * which is referenced in the amiga inline macros
  10  * imported below by <proto/exec.h>.
  11  */
  12 #define INTUITION_CLASSES_H
  13
  14 #include <proto/exec.h>
  15 #include <exec/memory.h>
  16 #include <exec/lists.h>
  17 #include <exec/semaphores.h>
  18
  19 #include <string.h>
  20 #include <stdio.h>
  21
  22 #include "class.h"
  23
  24 #define SDEBUG 0
  25 #define DEBUG 0
  26 #include <aros/debug.h>
  27
  28
  29 #define ENABLE_RT 1
  30 #include <aros/rt.h>
  31
  32
  33
  34
  35 /**************** String class definitions ***********************/
  36
  37 /* Subclass of root */
  38 #define CL_Level_String (CL_Level_Root + 1)
  39 #define IF_Level_String (IF_Level_Root + 1)
  40
  41 #define STRINGCLASSNAME "stringclass"
  42
  43 /* Public New() parameter struct */
  44 typedef struct NewStringParam
  45 {
  46      STRPTR InitStr;
  47      ULONG  MaxStrLen;
  48 } P_String;
  49
  50 typedef struct StringInterface
  51 {
  52     VOID (*SetStr)(Object, STRPTR);
  53     VOID (*PrintStr)(Object);
  54 } IString;
  55
  56 typedef struct StringIFStorage
  57 {
  58     IRoot       *IRoot;
  59     IString     *IString;
  60
  61 } IStringTable;
  62
  63
  64 /* Private instance data definition */
  65 struct StringData
  66 {
  67     STRPTR Buffer;
  68     ULONG MaxStrLen;
  69 };
  70
  71 /**************************************************/
  72 VOID CleanupOOP();
  73 BOOL InitOOP();
  74 Object NewInstance(STRPTR classID, APTR, APTR *interfaceStorage);
  75 Class *CreateClass(STRPTR classID, STRPTR superID, struct MTabDescr *mTabDescr,
  76         ULONG instDataSize);
  77 VOID DeleteClass(STRPTR classID);
  78
  79
  80 /* could go into a library base */
  81 struct SignalSemaphore ClassListSema;
  82 struct List ClassList;
  83 Class RootClassMem;
  84
  85 /*************************** String ***************************/
  86
  87
  88 /* Method implementations */
  89
  90 Object String_New(Class *cl, P_String *p)
  91 {
  92     ULONG max = 50;
  93     STRPTR str = "";
  94     /* Get parent interface */
  95     IRoot *ir = (IRoot *)CL_INTERFACE(cl, CL_Level_Root,  IF_Level_Root);
  96     Object o;
  97
  98     /* Whether it accepts NULL initparameter is class dependant.
  99     ** The parameter could very well be a taglist
 100     */
 101     if (p)
 102     {
 103         if (p->InitStr)
 104             str = p->InitStr;
 105         if (p->MaxStrLen)
 106             max = p->MaxStrLen;
 107     }
 108
 109     o = ir->New(cl, NULL);
 110     if (o)
 111     {
 112         STRPTR buffer;
 113
 114         /* Get instance data */
 115         struct StringData *data = INST_DATA(o, CL_Level_String);
 116
 117         data->Buffer  = NULL;
 118         data->MaxStrLen = 0;
 119
 120         buffer = AllocVec(max + 1, MEMF_ANY);
 121         if (buffer)
 122         {
 123
 124             strncpy(buffer, str, max);
 125
 126             data->Buffer = buffer;
 127             data->MaxStrLen = max;
 128
 129             return (o);
 130
 131         }
 132
 133         /* Do a "CoerceMethod" (I get the Root interface from the *String* class) */
 134         ir = (IRoot *)CL_INTERFACE(cl, CL_Level_String, IF_Level_Root);
 135         ir->Dispose(o);
 136     }
 137     return (NULL);
 138 }
 139
 140 VOID String_Dispose(Object o)
 141 {
 142     struct StringData *data = INST_DATA(o, CL_Level_String);
 143
 144     IRoot *ir = (IRoot *)OBJ_INTERFACE(o, CL_Level_Root, IF_Level_Root);
 145
 146
 147     if (data->Buffer)
 148     {
 149         FreeVec(data->Buffer);
 150     }
 151
 152     ir->Dispose(o); /* Call supermethod */
 153
 154     return;
 155 }
 156
 157 VOID String_SetStr(Object o, STRPTR str)
 158 {
 159     struct StringData *data = INST_DATA(o, CL_Level_String);
 160
 161
 162     strncpy(data->Buffer, str, data->MaxStrLen);
 163
 164     return;
 165 };
 166
 167 VOID String_PrintStr(Object o)
 168 {
 169     struct StringData *data;
 170
 171     data = INST_DATA(o, CL_Level_String);
 172
 173     printf("%s", data->Buffer);
 174
 175     return;
 176 }
 177
 178 /* Method tables */
 179 IRoot str_iroot = { (Object (*)(Class *, APTR))String_New, String_Dispose};
 180
 181 IString str_istring = {String_SetStr, String_PrintStr};
 182
 183 struct MTabDescr str_descr[] =
 184 {
 185     {(APTR *)&str_iroot,        2}, /* Table contains two entries */
 186     {(APTR *)&str_istring,      2}  /* Table contains two entries */
 187 };
 188
 189
 190 int main(int argc, char **argv)
 191 {
 192
 193     SDInit();
 194
 195     RT_Init();
 196
 197     if (InitOOP())
 198     {
 199         struct Node *n;
 200         Object o;
 201
 202
 203         printf("Object system initialized\n");
 204
 205         /* Initialize the string class */
 206         if (CreateClass(STRINGCLASSNAME, ROOTCLASSNAME, str_descr, sizeof (struct StringData)) )
 207         {
 208             IStringTable st;
 209             P_String pstr = {"String test", 80};
 210
 211             printf("Class list:\n");
 212             ForeachNode(&ClassList, n)
 213             {
 214                 printf("%s\n", n->ln_Name);
 215             }
 216             printf("\n\n");
 217
 218             /* Create a new instance */
 219             o = NewInstance(STRINGCLASSNAME, &pstr, (APTR *)&st);
 220             if (o)
 221             {
 222                 IString *is = st.IString;
 223
 224                 printf("New instance: %p\n", o);
 225
 226                 printf("Current string:  ");
 227                 is->PrintStr(o);
 228                 printf("\n");
 229
 230                 printf("Setting string\n");
 231                 is->SetStr(o, "Blah");
 232
 233                 printf("New string value:  ");
 234                 is->PrintStr(o);
 235                 printf("\n");
 236
 237                 st.IRoot->Dispose(o);
 238
 239                 printf("object deleted\n");
 240             }
 241             DeleteClass(STRINGCLASSNAME);
 242         }
 243         CleanupOOP();
 244     }
 245
 246     RT_Exit();
 247
 248     return (0);
 249 }
 250
 251
 252
 253
 254 /******************************************************************/
 255
 256 /* The oop system code */
 257
 258 BOOL AllocInterfaces(Class *cl);
 259 VOID FreeInterfaces(Class *cl);
 260
 261
 262
 263
 264 /******************
 265 **  CreateClass  **
 266 ******************/
 267 Class *CreateClass(STRPTR classID, STRPTR superID, struct MTabDescr *mTabDescr,
 268         ULONG instDataSize)
 269 {
 270     #define UB(x) ((UBYTE *)x)
 271
 272     #define UnlockCL     ReleaseSemaphore( &ClassListSema )
 273     #define LockCLShared ObtainSemaphoreShared( &ClassListSema )
 274     #define LockCL       ObtainSemaphore( &ClassListSema )
 275
 276     #define ClassID ClassNode.ln_Name
 277
 278     Class *cl, *supercl;
 279     UWORD super_count;
 280
 281     /* Find superclass */
 282     EnterFunc(bug("CreateClass(classID=%s, superID=%s, mTabDescr=%p, instDataSize=%d)\n",
 283                 classID, superID, mTabDescr, instDataSize));
 284
 285 LockCL;
 286     supercl = (Class *)FindName( &ClassList, superID);
 287     if (supercl)
 288     {
 289         /* Mark the class as busy, so it isn't freed while we are allocating
 290         ** stuff for our class
 291         */
 292         supercl->SubClassCount ++;
 293     }
 294 UnlockCL;
 295
 296     if (!supercl)
 297         return (FALSE);
 298
 299     D(bug("Found superclass %s\n", supercl->ClassID));
 300
 301     /* Allocate class structure */
 302     D(bug("Allocating class of size %d\n", sizeof (Class) ));
 303     cl = AllocMem(sizeof (Class), MEMF_PUBLIC|MEMF_CLEAR); /* Can be made read-only for MP */
 304     if (cl)
 305     {
 306         ULONG cltab_size, iftab_size;
 307
 308         Class *superptr;
 309
 310         D(bug("Allocated class structure\n"));
 311
 312         /* Find this class's level in the hierarchy */
 313
 314         /* How many super-classes are there ? */
 315         super_count = 1; /* have allready found one superclass */
 316         for (superptr = supercl; superptr->SuperClass; superptr = superptr->SuperClass)
 317             super_count ++;
 318
 319         D(bug("Number of superclasses: %d\n", super_count));
 320
 321         /* Get size of interface table */
 322         iftab_size = UB(&(cl->InterfaceTable[super_count + 1])) - UB(&(cl->InterfaceTable[0]));
 323         D(bug("IF tabsize: %d\n", iftab_size));
 324
 325         /* Allocate interface table pointers */
 326         cl->InterfaceTable = AllocMem(iftab_size, MEMF_PUBLIC|MEMF_CLEAR); /* Can be made read-only for MP */
 327
 328         /* Get size of class table */
 329         cltab_size = UB( &(cl->ClassTable[super_count + 1])) - UB( &(cl->ClassTable[0]));
 330         D(bug("CL tabsize: %d\n", cltab_size));
 331
 332         /* Allocate interface methodtable pointers */
 333         cl->ClassTable = AllocMem(cltab_size, MEMF_PUBLIC|MEMF_CLEAR); /* Can be made read-only for MP */
 334         D(bug("Classtable allocated: %p\n"));
 335
 336         cl->ClassID = AllocVec( strlen(classID) + 1, MEMF_PUBLIC);
 337
 338         if (cl->InterfaceTable && cl->ClassTable && cl->ClassID)
 339         {
 340
 341             D(bug("Tables allocated\n"));
 342             /* Copy class ID */
 343             strcpy(cl->ClassID, classID);
 344             D(bug("class ID copied\n"));
 345
 346             /* !!! Important to fill in these before calling AllocInterfaces */
 347             cl->NumMethods = mTabDescr[super_count].NumMethods;
 348             cl->SuperClass = supercl;
 349
 350             D(bug("Number of methods introduced by class: %d\n", cl->NumMethods));
 351
 352             /* Allocate interfaces for class */
 353             if (AllocInterfaces(cl))
 354             {
 355                 IPTR *iftab;
 356                 APTR *mtab;
 357                 WORD idx, m_idx;
 358                 Class *superptr = supercl;
 359                 IPTR *ifptr;
 360
 361                 /* Fill in the interfaces from the superclass */
 362                 for (idx = super_count - 1; idx >= 0; idx -- )
 363                 {
 364                     D(bug("Getting interface %d with %d methods from class %s\n",
 365                         idx, superptr->NumMethods, superptr->ClassID));
 366
 367                     CopyMem(    superptr->InterfaceTable[idx],
 368                         cl->InterfaceTable[idx],
 369                         UB( &ifptr[superptr->NumMethods]) - UB( &ifptr[0]) );
 370
 371                     /* And fill in the class table while we're at it */
 372                     cl->ClassTable[idx] = superptr;
 373                     superptr = superptr->SuperClass;
 374
 375                 }
 376
 377                 /* Fill in ourselves in the classtable */
 378                 cl->ClassTable[super_count] = cl;
 379
 380                 /* Override the interfaces with our own methods */
 381                 for (idx = super_count - 1; idx >= 0; idx -- )
 382                 {
 383                     mtab  = mTabDescr[idx].Table;
 384                     iftab = cl->InterfaceTable[idx];
 385
 386                     for (m_idx = mTabDescr[idx].NumMethods - 1; m_idx >= 0; m_idx -- )
 387                     {
 388                         if (mtab[m_idx] != NULL)
 389                         {
 390                             D(bug("Overriding method at cl_idx=%d, method=%d\n", idx, m_idx));
 391                             D(bug("Method overrided: %p, overrider: %p\n", iftab[m_idx], mtab[m_idx]));
 392                             /* Override method */
 393                             iftab[m_idx] = (IPTR)mtab[m_idx];
 394                         }
 395
 396                     } /* For each method in the method table */
 397
 398                 } /* For each level above us in the hierarchy */
 399
 400                 /* Fill in the methods that are new with this class */
 401                 D(bug("Filling in methods at level %d\n", super_count));
 402                 CopyMem(mTabDescr[super_count].Table,
 403                     cl->InterfaceTable[super_count],
 404                     UB( &ifptr[ mTabDescr[super_count].NumMethods ]) - UB( &ifptr[0]) );
 405
 406
 407                 /* Update instance data info */
 408                 cl->InstOffset = supercl->InstOffset + supercl->InstSize;
 409                 cl->InstSize = instDataSize;
 410
 411                 cl->SuperCount = super_count;
 412
 413 LockCL;
 414                 AddTail(&ClassList, &(cl->ClassNode) );
 415 UnlockCL;
 416
 417                 ReturnPtr ("CreateClass", Class *, cl);
 418
 419             }
 420
 421             if (cl->InterfaceTable)
 422                 FreeMem(cl->InterfaceTable, iftab_size);
 423
 424             if (cl->ClassTable)
 425                 FreeMem(cl->ClassTable, cltab_size);
 426
 427             if (cl->ClassID)
 428                 FreeVec(cl->ClassID);
 429
 430         }
 431
 432         FreeMem(cl, sizeof (struct IClass));
 433
 434     }
 435
 436     /* Initalization failed, free lock on superclass */
 437     supercl->SubClassCount --;
 438
 439     ReturnPtr ("CreateClass", Class *, NULL);
 440
 441 } /* CreateClass */
 442
 443
 444
 445 /************************
 446 **  AllocInterfaces()  **
 447 ************************/
 448 BOOL AllocInterfaces(Class *param_cl)
 449 {
 450     IPTR **ifptr = param_cl->InterfaceTable;
 451     Class *cl;
 452
 453     EnterFunc(bug("AllocInterfaces(cl=%s)\n", param_cl->ClassID));
 454
 455     /* Allocate the interfaces */
 456     for ( cl = param_cl ; cl; cl = cl->SuperClass )
 457     {
 458         ULONG size = UB( &((*ifptr)[cl->NumMethods])) - UB( &((*ifptr)[0]));
 459
 460         D(bug("Allocating interface for class %s, size=%d\n", cl->ClassID, size));
 461         *ifptr = AllocMem(size, MEMF_PUBLIC|MEMF_CLEAR); /* Should be read-only for MP */
 462         D(bug("IF Allocated: %p\n", *ifptr));
 463         if (!*ifptr)
 464         {
 465             FreeInterfaces(param_cl);
 466             ReturnBool ("AllocInterfaces", FALSE);
 467         }
 468
 469         ifptr ++;
 470
 471     }
 472     ReturnBool ("AllocInterfaces", TRUE);
 473 }
 474
 475 /***********************
 476 **  FreeInterfaces()  **
 477 ***********************/
 478 VOID FreeInterfaces(Class *cl)
 479 {
 480     IPTR **ifptr = cl->InterfaceTable;
 481
 482     EnterFunc(bug("FreeInterfaces(cl=%s)\n", cl->ClassID));
 483
 484     for ( ; cl; cl = cl->SuperClass )
 485     {
 486         if (*ifptr)
 487         {
 488             ULONG size = UB( &(*ifptr)[cl->NumMethods]) - UB(&(*ifptr)[0]);
 489
 490             D(bug("Freeing IF %p of size %d\n", *ifptr, size));
 491             FreeMem(*ifptr, size);
 492
 493         }
 494         ifptr ++;
 495     }
 496     ReturnVoid ("FreeInterfaces");
 497 }
 498
 499
 500
 501 /******************
 502 **  DeleteClass  **
 503 ******************/
 504
 505 VOID DeleteClass(STRPTR classID)
 506 {
 507     Class *cl;
 508
 509     EnterFunc(bug("DeleteClass(classID=%s)\n", classID));
 510
 511 LockCLShared;
 512     cl = (Class *)FindName( &ClassList, classID);
 513 UnlockCL;
 514
 515     if (cl)
 516     {
 517         ULONG size;
 518         ULONG tab_entries = cl->SuperCount + 1;
 519
 520
 521         /* What level are we ? */
 522         if (cl->SuperCount == 0) /* Someone trying to remove the rootclass */
 523             ReturnVoid("DeleteClass (Someone trying to remove rootclass)");
 524
 525         /* Free interfaces */
 526         FreeInterfaces(cl);
 527
 528         size = UB(&cl->InterfaceTable[tab_entries]) - UB(&cl->InterfaceTable[0]);
 529         D(bug("Freeing IFTab of size %d\n", size));
 530         FreeMem(cl->InterfaceTable, size);
 531
 532         size = UB(&cl->ClassTable[tab_entries]) - UB(&cl->ClassTable[0]);
 533         D(bug("Freeing ClassTab of size %d at %p\n", size, cl->ClassTable));
 534         FreeMem(cl->ClassTable, size);
 535
 536         /* Free class ID */
 537         D(bug("Freeing class ID %s\n", cl->ClassID));
 538         FreeVec(cl->ClassID);
 539 LockCL;
 540                 Remove(&(cl->ClassNode));
 541 UnlockCL;
 542
 543         FreeMem(cl, sizeof (Class));
 544     }
 545     ReturnVoid("DeleteClass");
 546 }
 547
 548 /************************
 549 **  Rootclass methods  **
 550 ************************/
 551 struct RootData
 552 {
 553     ULONG dummy;
 554 };
 555
 556 #define NUMROOTMETHODS 2
 557
 558 Object Root_New(Class *cl, APTR param)
 559 {
 560     struct _Object *o;
 561     struct RootData *data;
 562
 563     EnterFunc(bug("Root::New(cl=%s, param = %p)\n",
 564         cl->ClassNode.ln_Name, param));
 565
 566     /* Allocate memory for the object */
 567     D(bug("Object size: %d\n", cl->InstOffset + cl->InstSize + sizeof (struct _Object)));
 568     o = AllocVec(cl->InstOffset + cl->InstSize + sizeof (struct _Object), MEMF_ANY);
 569     if (o)
 570     {
 571         D(bug("Mem allocated: %p\n", o));
 572         o->Class = cl;
 573
 574         data = (struct RootData *)BASEOBJECT(o);
 575
 576         cl->ObjectCount ++;
 577
 578         ReturnPtr ("Root::New", Object, BASEOBJECT(o) );
 579     }
 580
 581     ReturnPtr ("Root::New", Object, NULL);
 582 }
 583
 584 VOID Root_Dispose(Object o)
 585 {
 586     EnterFunc(bug("Root::Dispose(o=%p, oclass=%s)\n", o, _OBJECT(o)->Class->ClassNode.ln_Name));
 587
 588     _OBJECT(o)->Class->ObjectCount --;
 589     D(bug("Object mem: %p, size: %d\n", _OBJECT(o), ((ULONG *)_OBJECT(o))[-1] ));
 590     FreeVec(_OBJECT(o));
 591
 592     ReturnVoid("Root::Dispose");
 593 }
 594
 595
 596 /****************
 597 **  InitOOP()  **
 598 ****************/
 599
 600
 601 BOOL InitOOP()
 602 {
 603     Class *RootClass = &RootClassMem;
 604
 605     InitSemaphore(&ClassListSema);
 606     NEWLIST(&ClassList);
 607
 608     /* We must initialize the rootclass by hand */
 609
 610     /* Class table. Only needs place for myself */
 611     RootClass->ClassTable = (struct IClass **)AllocMem( sizeof(Class *), MEMF_PUBLIC);
 612     if (RootClass->ClassTable)
 613     {
 614
 615         /* Interface table. Only needs place for our own interface */
 616         RootClass->InterfaceTable = (IPTR **)AllocMem( sizeof (IPTR *), MEMF_PUBLIC);
 617         if (RootClass->InterfaceTable)
 618         {
 619             IPTR *interface;
 620             ULONG if_size;
 621
 622             /* Allocate interface */
 623             if_size = UB(&interface[NUMROOTMETHODS]) - UB(&interface[0]);
 624             interface = AllocMem(if_size, MEMF_PUBLIC);
 625             if (interface)
 626             {
 627                 /* Fill in methods */
 628                 interface[0] = (IPTR)Root_New;
 629                 interface[1] = (IPTR)Root_Dispose;
 630
 631                 RootClass->InterfaceTable[0] = interface;
 632
 633                 /* Fill in other stuff into the class structure */
 634                 RootClass->ClassNode.ln_Name = ROOTCLASSNAME;
 635                 RootClass->ClassTable[0]  = RootClass;
 636                 RootClass->InstOffset     = 0UL;
 637                 RootClass->InstSize       = sizeof (struct RootData);
 638                 RootClass->NumMethods     = NUMROOTMETHODS;
 639                 RootClass->SubClassCount  = 0UL;
 640                 RootClass->ObjectCount    = 0UL;
 641                 RootClass->SuperClass     = NULL;
 642                 RootClass->SuperCount     = 0UL;
 643
 644                 /* Add the class. Arbitration not necessary, as
 645                 ** noone know about us yet
 646                 */
 647                 AddTail(&ClassList, &(RootClass->ClassNode) );
 648
 649                 return (TRUE);
 650             }
 651
 652             FreeMem(RootClass->InterfaceTable, sizeof (IPTR **));
 653         }
 654         FreeMem(RootClass->ClassTable, sizeof (Class *));
 655
 656     }
 657
 658     return (FALSE);
 659 }
 660
 661
 662 /*******************
 663 **  CleanupOOP()  **
 664 *******************/
 665 VOID CleanupOOP()
 666 {
 667     IPTR *interface;
 668     ULONG if_size;
 669
 670     Class *RootClass = &RootClassMem;
 671
 672     FreeMem(RootClass->ClassTable, sizeof (APTR *));
 673
 674     interface = RootClass->InterfaceTable[0];
 675     if_size = UB(&interface[NUMROOTMETHODS]) - UB(&interface[0]);
 676
 677     FreeMem(interface, if_size);
 678
 679     FreeMem(RootClass->InterfaceTable, sizeof (IPTR **));
 680
 681     return;
 682 }
 683
 684 /*******************
 685 **  NewInstance() **
 686 *******************/
 687 Object NewInstance(STRPTR classID, APTR param, APTR *interfaceStorage)
 688 {
 689     Class *cl;
 690     LONG idx;
 691
 692     Object o;
 693
 694     EnterFunc(bug("NewInstance(classID=%s, param=%p, ifStorage=%p)\n",
 695         classID, param, interfaceStorage));
 696
 697 LockCL;
 698     cl = (Class *)FindName(&ClassList, classID);
 699     if (cl)
 700         cl->ObjectCount ++; /* We don't want the class to be freed while we work on it */
 701 UnlockCL;
 702
 703     if (!cl)
 704         return (NULL);
 705
 706     /* Get interfaces from class */
 707
 708     for ( idx = cl->SuperCount; idx >= 0; idx -- )
 709         interfaceStorage[idx] = cl->InterfaceTable[idx];
 710
 711     /* Create a new instance */
 712     D(bug("Calling New() at %p\n", ((IRoot *) interfaceStorage[cl->SuperCount])->New));
 713     o = ((IRoot *) interfaceStorage[0])->New(cl, param);
 714
 715     if (!o)
 716     {
 717 LockCL;
 718         cl->ObjectCount --; /* Object creation failed, release lock */
 719 UnlockCL;
 720     }
 721     ReturnPtr ("NewInstance", Object, o);
 722 }