gcc/objc/selector.c

   1 /* GNU Objective C Runtime selector related functions
   2    Copyright (C) 1993, 1995, 1996 Free Software Foundation, Inc.
   3    Contributed by Kresten Krab Thorup
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify it under the
   8 terms of the GNU General Public License as published by the Free Software
   9 Foundation; either version 2, or (at your option) any later version.
  10
  11 GNU CC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  13 FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  14 details.
  15
  16 You should have received a copy of the GNU General Public License along with
  17 GNU CC; see the file COPYING.  If not, write to the Free Software
  18 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20 /* As a special exception, if you link this library with files compiled with
  21    GCC to produce an executable, this does not cause the resulting executable
  22    to be covered by the GNU General Public License. This exception does not
  23    however invalidate any other reasons why the executable file might be
  24    covered by the GNU General Public License.  */
  25
  26 #include "runtime.h"
  27 #include "objc/sarray.h"
  28 #include "encoding.h"
  29
  30 /* Initial selector hash table size. Value doesn't matter much */
  31 #define SELECTOR_HASH_SIZE 128
  32
  33 /* Tables mapping selector names to uid and opposite */
  34 static struct sarray* __objc_selector_array = 0; /* uid -> sel  !T:MUTEX */
  35 static struct sarray* __objc_selector_names = 0; /* uid -> name !T:MUTEX */
  36 static cache_ptr      __objc_selector_hash  = 0; /* name -> uid !T:MUTEX */
  37
  38 static void register_selectors_from_list(MethodList_t);
  39
  40 /* Number of selectors stored in each of the above tables */
  41 int __objc_selector_max_index = 0;              /* !T:MUTEX */
  42
  43 void __objc_init_selector_tables()
  44 {
  45   __objc_selector_array = sarray_new (SELECTOR_HASH_SIZE, 0);
  46   __objc_selector_names = sarray_new (SELECTOR_HASH_SIZE, 0);
  47   __objc_selector_hash
  48     = hash_new (SELECTOR_HASH_SIZE,
  49                 (hash_func_type) hash_string,
  50                 (compare_func_type) compare_strings);
  51 }
  52
  53 /* This routine is given a class and records all of the methods in its class
  54    structure in the record table.  */
  55 void
  56 __objc_register_selectors_from_class (Class class)
  57 {
  58   MethodList_t method_list;
  59
  60   method_list = class->methods;
  61   while (method_list)
  62     {
  63       register_selectors_from_list (method_list);
  64       method_list = method_list->method_next;
  65     }
  66 }
  67
  68
  69 /* This routine is given a list of methods and records each of the methods in
  70    the record table.  This is the routine that does the actual recording
  71    work.
  72
  73    This one is only called for Class objects.  For categories,
  74    class_add_method_list is called.
  75    */
  76 static void
  77 register_selectors_from_list (MethodList_t method_list)
  78 {
  79   int i = 0;
  80   while (i < method_list->method_count)
  81     {
  82       Method_t method = &method_list->method_list[i];
  83       method->method_name
  84         = sel_register_typed_name ((const char*)method->method_name,
  85                                      method->method_types);
  86       i += 1;
  87     }
  88 }
  89
  90
  91 /* Returns YES iff t1 and t2 have same method types, but we ignore
  92    the argframe layout */
  93 BOOL
  94 sel_types_match (const char* t1, const char* t2)
  95 {
  96   if (!t1 || !t2)
  97     return NO;
  98   while (*t1 && *t2)
  99     {
 100       if (*t1 == '+') t1++;
 101       if (*t2 == '+') t2++;
 102       while (isdigit(*t1)) t1++;
 103       while (isdigit(*t2)) t2++;
 104       /* xxx Remove these next two lines when qualifiers are put in
 105          all selectors, not just Protocol selectors. */
 106       t1 = objc_skip_type_qualifiers(t1);
 107       t2 = objc_skip_type_qualifiers(t2);
 108       if (!*t1 && !*t2)
 109         return YES;
 110       if (*t1 != *t2)
 111         return NO;
 112       t1++;
 113       t2++;
 114     }
 115   return NO;
 116 }
 117
 118 /* return selector representing name */
 119 SEL
 120 sel_get_typed_uid (const char *name, const char *types)
 121 {
 122   struct objc_list *l;
 123   sidx i;
 124
 125   objc_mutex_lock(__objc_runtime_mutex);
 126
 127   i = (sidx) hash_value_for_key (__objc_selector_hash, name);
 128   if (i == 0)
 129     {
 130       objc_mutex_unlock(__objc_runtime_mutex);
 131       return 0;
 132     }
 133
 134   for (l = (struct objc_list*)sarray_get (__objc_selector_array, i);
 135        l; l = l->tail)
 136     {
 137       SEL s = (SEL)l->head;
 138       if (types == 0 || s->sel_types == 0)
 139         {
 140           if (s->sel_types == types)
 141             {
 142               objc_mutex_unlock(__objc_runtime_mutex);
 143               return s;
 144             }
 145         }
 146       else if (sel_types_match (s->sel_types, types))
 147         {
 148           objc_mutex_unlock(__objc_runtime_mutex);
 149           return s;
 150         }
 151     }
 152
 153   objc_mutex_unlock(__objc_runtime_mutex);
 154   return 0;
 155 }
 156
 157 /* Return selector representing name; prefer a selector with non-NULL type */
 158 SEL
 159 sel_get_any_typed_uid (const char *name)
 160 {
 161   struct objc_list *l;
 162   sidx i;
 163   SEL s;
 164
 165   objc_mutex_lock(__objc_runtime_mutex);
 166
 167   i = (sidx) hash_value_for_key (__objc_selector_hash, name);
 168   if (i == 0)
 169     {
 170       objc_mutex_unlock(__objc_runtime_mutex);
 171       return 0;
 172     }
 173
 174   for (l = (struct objc_list*)sarray_get (__objc_selector_array, i);
 175        l; l = l->tail)
 176     {
 177       s = (SEL) l->head;
 178       if (s->sel_types)
 179         {
 180             objc_mutex_unlock(__objc_runtime_mutex);
 181             return s;
 182         }
 183     }
 184
 185   objc_mutex_unlock(__objc_runtime_mutex);
 186   return s;
 187 }
 188
 189 /* return selector representing name */
 190 SEL
 191 sel_get_any_uid (const char *name)
 192 {
 193   struct objc_list *l;
 194   sidx i;
 195
 196   objc_mutex_lock(__objc_runtime_mutex);
 197
 198   i = (sidx) hash_value_for_key (__objc_selector_hash, name);
 199   if (soffset_decode (i) == 0)
 200     {
 201       objc_mutex_unlock(__objc_runtime_mutex);
 202       return 0;
 203     }
 204
 205   l = (struct objc_list*)sarray_get (__objc_selector_array, i);
 206   objc_mutex_unlock(__objc_runtime_mutex);
 207
 208   if (l == 0)
 209     return 0;
 210
 211   return (SEL)l->head;
 212 }
 213
 214 /* return selector representing name */
 215 SEL
 216 sel_get_uid (const char *name)
 217 {
 218   return sel_register_typed_name (name, 0);
 219 }
 220
 221 /* Get name of selector.  If selector is unknown, the empty string ""
 222    is returned */
 223 const char*
 224 sel_get_name (SEL selector)
 225 {
 226   const char *ret;
 227
 228   objc_mutex_lock(__objc_runtime_mutex);
 229   if ((soffset_decode((sidx)selector->sel_id) > 0)
 230       && (soffset_decode((sidx)selector->sel_id) <= __objc_selector_max_index))
 231     ret = sarray_get (__objc_selector_names, (sidx) selector->sel_id);
 232   else
 233     ret = 0;
 234   objc_mutex_unlock(__objc_runtime_mutex);
 235   return ret;
 236 }
 237
 238 BOOL
 239 sel_is_mapped (SEL selector)
 240 {
 241   unsigned int idx = soffset_decode ((sidx)selector->sel_id);
 242   return ((idx > 0) && (idx <= __objc_selector_max_index));
 243 }
 244
 245
 246 const char*
 247 sel_get_type (SEL selector)
 248 {
 249   if (selector)
 250     return selector->sel_types;
 251   else
 252     return 0;
 253 }
 254
 255 /* The uninstalled dispatch table */
 256 extern struct sarray* __objc_uninstalled_dtable;
 257
 258 /* Store the passed selector name in the selector record and return its
 259    selector value (value returned by sel_get_uid).
 260    Assumes that the calling function has locked down __objc_runtime_mutex. */
 261 SEL
 262 __sel_register_typed_name (const char *name, const char *types,
 263                            struct objc_selector *orig)
 264 {
 265   struct objc_selector* j;
 266   sidx i;
 267   struct objc_list *l;
 268
 269   i = (sidx) hash_value_for_key (__objc_selector_hash, name);
 270   if (soffset_decode (i) != 0)
 271     {
 272       for (l = (struct objc_list*)sarray_get (__objc_selector_array, i);
 273            l; l = l->tail)
 274         {
 275           SEL s = (SEL)l->head;
 276           if (types == 0 || s->sel_types == 0)
 277             {
 278               if (s->sel_types == types)
 279                 {
 280                   if (orig)
 281                     {
 282                       orig->sel_id = (void*)i;
 283                       return orig;
 284                     }
 285                   else
 286                     return s;
 287                 }
 288             }
 289           else if (!strcmp (s->sel_types, types))
 290             {
 291               if (orig)
 292                 {
 293                   orig->sel_id = (void*)i;
 294                   return orig;
 295                 }
 296               else
 297                 return s;
 298             }
 299         }
 300       if (orig)
 301         j = orig;
 302       else
 303         j = __objc_xmalloc (sizeof (struct objc_selector));
 304
 305       j->sel_id = (void*)i;
 306       j->sel_types = (const char*)types;
 307       l = (struct objc_list*)sarray_get (__objc_selector_array, i);
 308     }
 309   else
 310     {
 311       __objc_selector_max_index += 1;
 312       i = soffset_encode(__objc_selector_max_index);
 313       if (orig)
 314         j = orig;
 315       else
 316         j = __objc_xmalloc (sizeof (struct objc_selector));
 317
 318       j->sel_id = (void*)i;
 319       j->sel_types = (const char*)types;
 320       l = 0;
 321     }
 322
 323   DEBUG_PRINTF ("Record selector %s[%s] as: %ld\n", name, types,
 324                 soffset_decode (i));
 325
 326   {
 327     int is_new = (l == 0);
 328     l = list_cons ((void*)j, l);
 329     sarray_at_put_safe (__objc_selector_names, i, (void *) name);
 330     sarray_at_put_safe (__objc_selector_array, i, (void *) l);
 331     if (is_new)
 332       hash_add (&__objc_selector_hash, (void *) name, (void *) i);
 333   }
 334
 335   sarray_realloc(__objc_uninstalled_dtable, __objc_selector_max_index+1);
 336
 337   return (SEL) j;
 338 }
 339
 340 SEL
 341 sel_register_name (const char *name)
 342 {
 343   SEL ret;
 344
 345   objc_mutex_lock(__objc_runtime_mutex);
 346   ret = __sel_register_typed_name (name, 0, 0);
 347   objc_mutex_unlock(__objc_runtime_mutex);
 348
 349   return ret;
 350 }
 351
 352 SEL
 353 sel_register_typed_name (const char *name, const char *type)
 354 {
 355   SEL ret;
 356
 357   objc_mutex_lock(__objc_runtime_mutex);
 358   ret = __sel_register_typed_name (name, type, 0);
 359   objc_mutex_unlock(__objc_runtime_mutex);
 360
 361   return ret;
 362 }
 363