test/OOPDemos/sysdep/hashed_methods.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 #include <stdlib.h>
  10
  11 #define SDEBUG 1
  12 #define DEBUG 1
  13 #include "debug.h"
  14
  15 #include "oop.h"
  16 #include "hash.h"
  17 #include "sysdep/hashed_methods.h"
  18
  19 static struct Bucket *CopyBucket(struct Bucket *old_b);
  20 static VOID FreeBucket(struct Bucket *b);
  21
  22 /**********************
  23 **  NumNewMethods()  **
  24 **********************/
  25
  26 static ULONG NumNewMethods(Class *cl, struct InterfaceDescr *ifDescr)
  27 {
  28     struct Bucket **ht;
  29     ULONG numnewmethods = 0;
  30
  31     if (cl->SuperClass)
  32     {
  33         ht = (struct Bucket **)cl->SuperClass->HashTable;
  34         for (; ifDescr->MethodTable; ifDescr ++)
  35         {
  36             ULONG i;
  37
  38             for (i = 0; i < ifDescr->NumMethods; i ++)
  39             {
  40                 ULONG mid;
  41                 mid = (ifDescr->InterfaceID << NUM_METHOD_BITS) + i;
  42
  43                 if (!HashLookupULONG(ht, mid))
  44                 {
  45                     numnewmethods ++;
  46                 }
  47
  48            }
  49
  50        }
  51
  52     }
  53     else
  54     {
  55         /* This is rootclass, count the methods */
  56         ht = (struct Bucket **)cl->HashTable;
  57         for (; ifDescr->MethodTable; ifDescr ++)
  58         {
  59            numnewmethods += ifDescr->NumMethods;
  60         }
  61     }
  62     return (numnewmethods);
  63 }
  64
  65 /***************************
  66 **  AllocDispatchTales()  **
  67 ***************************/
  68
  69 BOOL AllocDispatchTables(Class *cl, struct InterfaceDescr *ifDescr)
  70 {
  71     ULONG entries;
  72
  73     entries = NumNewMethods(cl, ifDescr);
  74
  75     cl->HashTable = (struct MethodBucket **)NewHash(entries);
  76     if (cl->HashTable)
  77     {
  78         /* Save hashtable mask for speed */
  79         cl->HashMask = HashMask(cl->HashTable);
  80
  81         if (cl->SuperClass)
  82         {
  83             /* Copy the superclass hash table */
  84             if ( !CopyHash((struct Bucket **)cl->HashTable
  85                         ,(struct Bucket **)cl->SuperClass->HashTable
  86                         ,CopyBucket
  87                         ,NULL))
  88             {
  89                 goto failure;
  90             }
  91         }
  92
  93         /* Insert our own methods */
  94         for (; ifDescr->MethodTable; ifDescr ++)
  95         {
  96             IPTR (**mtab)() = ifDescr->MethodTable;
  97             ULONG i;
  98
  99             for (i = 0; i < ifDescr->NumMethods; i ++)
 100             {
 101                 struct MethodBucket *b;
 102                 ULONG mid;
 103
 104                 mid = (ifDescr->InterfaceID << NUM_METHOD_BITS) + i;
 105
 106
 107                 /* Method existed in superclass ? */
 108                 b = (struct MethodBucket *)HashLookupULONG((struct Bucket **)cl->HashTable, mid);
 109                 if (b)
 110                 {
 111                     b->MethodFunc = mtab[i];
 112                     b->mClass = cl;
 113                 }
 114                 else
 115                 {
 116                     /* Must allocate new bucket */
 117                     struct MethodBucket *new_b;
 118                     new_b = (struct MethodBucket *)malloc( sizeof (struct MethodBucket) );
 119                     if (!new_b)
 120                     {
 121                         goto failure;
 122                     }
 123                     /* Initialize bucket */
 124                     new_b->MethodID   = mid;
 125                     new_b->MethodFunc = mtab[i];
 126                     new_b->mClass     = cl;
 127
 128                     /* Add bucket to hashtable */
 129                     InsertBucket((struct Bucket **)cl->HashTable, (struct Bucket *)new_b);
 130                 }
 131
 132             } /* for (each method in methodtable) */
 133
 134         } /* for (each interface) */
 135
 136     }
 137     ReturnBool ("AllocDispatchTables", TRUE);
 138 failure:
 139     FreeHash((struct Bucket **)cl->HashTable, FreeBucket);
 140     ReturnBool ("AllocDispatchTables", FALSE);
 141
 142 }
 143
 144 VOID FreeDispatchTables(Class *cl)
 145 {
 146     FreeHash((struct Bucket **)cl->HashTable, FreeBucket);
 147
 148     return;
 149 }
 150
 151
 152 /**************************
 153 **  Hash handling hooks  **
 154 **************************/
 155 #define MB(x) ((struct MethodBucket *)x)
 156 static struct Bucket *CopyBucket(struct Bucket *old_b)
 157 {
 158     struct MethodBucket *new_b;
 159
 160     new_b = (struct MethodBucket *)malloc(sizeof (struct MethodBucket) );
 161     if (new_b)
 162     {
 163         new_b->MethodID   = MB(old_b)->MethodID;
 164         new_b->MethodFunc = MB(old_b)->MethodFunc;
 165         new_b->mClass     = MB(old_b)->mClass;
 166         return ((struct Bucket *)new_b);
 167     }
 168     return (NULL);
 169 }
 170
 171 static VOID FreeBucket(struct Bucket *b)
 172 {
 173     free(b);
 174 }