test/OOPDemos/method.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 "types.h"
  10 #include "oop.h"
  11 #include "hash.h"
  12
  13 #include "sysdep/sysdep.h"
  14
  15 #define SDEBUG 0
  16 #define DEBUG 0
  17 #include "debug.h"
  18
  19
  20 #ifdef DIRECT_LOOKUP
  21
  22 #   define CallMethod(cl, o, msg)                                       \
  23     {                                                                   \
  24         return ( cl->MTable[msg->MethodID].MethodFunc(cl, o, msg));     \
  25     }
  26
  27 #endif /* DIRECT_LOOKUP */
  28
  29 /*********************** HASHED_METHODS ***************************/
  30 #ifdef HASHED_METHODS
  31
  32
  33 /* Using for () below, take 5,915 s.
  34
  35 #   define CallMethod(cl, o, msg)                                       \
  36     {                                                                   \
  37         register struct MethodBucket *b;                                \
  38         register ULONG mid = msg->MethodID;                             \
  39                                                                         \
  40         for (b = cl->HashTable[mid & cl->HashMask];             \
  41                 b; b = b->Next)                                         \
  42         {                                                               \
  43             if (b->MethodID == mid)                                     \
  44             {                                                           \
  45                 return (b->MethodFunc(b->mClass, o, msg));              \
  46             }                                                           \
  47         }                                                               \
  48         return (NULL);                                                  \
  49     }
  50
  51 */
  52
  53 /* Using while() takes 5,915 s (Same as above)
  54
  55 #   define CallMethod(cl, o, msg)                                       \
  56     {                                                                   \
  57         register struct MethodBucket *b;                                \
  58         register ULONG mid = msg->MethodID;                             \
  59                                                                         \
  60         b = cl->HashTable[mid & cl->HashMask];                          \
  61                                                                         \
  62         while (b)                                                       \
  63         {                                                               \
  64             if (b->MethodID == mid)                                     \
  65             {                                                           \
  66                 return (b->MethodFunc(b->mClass, o, msg));              \
  67             }                                                           \
  68             b = b->Next;                                                \
  69                                                                         \
  70         }                                                               \
  71         return (NULL);                                                  \
  72     }
  73 */
  74
  75 /* Using if - goto: 5,78 s.
  76 #   define CallMethod(cl, o, msg)                                       \
  77     {                                                                   \
  78         register struct MethodBucket *b;                                \
  79         register ULONG mid = msg->MethodID;                             \
  80                                                                         \
  81         b = cl->HashTable[mid & cl->HashMask];                          \
  82 loop:                                                                   \
  83         if (b)                                                          \
  84         {                                                               \
  85             if (b->MethodID == mid)                                     \
  86             {                                                           \
  87                 return (b->MethodFunc(b->mClass, o, msg));              \
  88             }                                                           \
  89             b = b->Next;                                                \
  90             goto loop;                                                  \
  91         }                                                               \
  92         return (NULL);                                                  \
  93     }
  94
  95 */
  96
  97 /* Surprisingly, when avoiding to put methodid into
  98 ** a separate var, it comes down to 5,109 s.
  99 ** even if MethodID is used (at least) two times
 100 ** pr. invocation.
 101 */
 102 #   define CallMethod(cl, o, msg)                                       \
 103     {                                                                   \
 104         register struct MethodBucket *b;                                \
 105                                                                         \
 106         b = cl->HashTable[((msg->MethodID >> NUM_METHOD_BITS) ^ msg->MethodID) & cl->HashMask];                 \
 107 loop:                                                                   \
 108         if (b)                                                          \
 109         {                                                               \
 110             if (b->MethodID == msg->MethodID)                           \
 111             {                                                           \
 112                 return (b->MethodFunc(b->mClass, o, msg));              \
 113             }                                                           \
 114             b = b->Next;                                                \
 115             goto loop;                                                  \
 116         }                                                               \
 117         return (NULL);                                                  \
 118     }
 119
 120
 121 #endif /* HASHED_METHODS */
 122
 123
 124 /*********************** HASHED_IFS ***************************/
 125 #ifdef HASHED_IFS
 126
 127
 128 #   define CallMethod(cl, o, msg)                                       \
 129     {                                                                   \
 130         register struct InterfaceBucket *b;                             \
 131         register ULONG mid = msg->MethodID;                             \
 132         register ULONG ifid = mid >> NUM_METHOD_BITS;                   \
 133         register struct IFMethod *method;                               \
 134                                                                         \
 135         mid &= METHOD_MASK;                                             \
 136                                                                         \
 137         b = cl->HashTable[ifid & cl->HashMask];                         \
 138 loop:   if (b)                                                          \
 139         {                                                               \
 140             if (b->InterfaceID == ifid)                                 \
 141             {                                                           \
 142                 method = &(b->MethodTable[mid]);                        \
 143                 return (method->MethodFunc(method->mClass, o, msg));    \
 144             }                                                           \
 145             b = b->Next;                                                \
 146             goto loop;                                                  \
 147         }                                                               \
 148         return (NULL);                                                  \
 149      }
 150 #endif /* HASHED_IFS */
 151
 152 /*********************** HASHED_STRINGS ***************************/
 153 #ifdef HASHED_STRINGS
 154 #   define CallMethod(cl, o, msg)                               \
 155     {                                                           \
 156         register struct MethodBucket *b;        ULONG val;      \
 157         register STRPTR str1 = (STRPTR)msg->MethodID;           \
 158         register LONG i;                                        \
 159         register STRPTR str2;                                   \
 160         for (i = 0, val = 0; (i < MAX_HASH_CHARS) && *str1; str1 ++)            \
 161             { val += *str1; i ++; }                             \
 162         for (b = cl->HashTable[val & cl->HashMask];             \
 163                 b; b = b->Next)                                 \
 164         {                                                       \
 165             str2 = (STRPTR)b->MethodID;                         \
 166             str1 = (STRPTR)msg->MethodID;                       \
 167             while ( (!(i = *str1 - *str2)) && *str1)            \
 168                 { str1 ++; str2 ++; }                           \
 169             if (!i)                                             \
 170                 return (b->MethodFunc(b->mClass, o, msg));      \
 171         }                                                       \
 172         return (NULL);                                          \
 173     }
 174
 175 #endif /* HASHED_STRINGS */
 176 IPTR CoerceMethodA(Class *cl, Object *o, Msg msg)
 177 {
 178     CallMethod(cl, o, msg);
 179 }
 180
 181 IPTR DoMethodA(Object *o, Msg msg)
 182 {
 183     register Class *cl = OCLASS(o);
 184
 185     CallMethod(cl, o, msg);
 186 }
 187
 188 IPTR DoSuperMethodA(Class *cl, Object *o, Msg msg)
 189 {
 190     Class *super = cl->SuperClass;
 191     CallMethod(super, o, msg);
 192 }