Return to sendmsg.c CVS log

Up to [GCC 2.x] / gcc / objc

Annotation of gcc/objc/sendmsg.c, revision 1.1

1.1     ! root        1: /* GNU Objective C Runtime message lookup 
        !             2:    Copyright (C) 1993 Free Software Foundation, Inc.
        !             3: 
        !             4: Author: Kresten Krab Thorup
        !             5: 
        !             6: This file is part of GNU CC.
        !             7: 
        !             8: GNU CC is free software; you can redistribute it and/or modify it under the
        !             9:    terms of the GNU General Public License as published by the Free Software
        !            10:    Foundation; either version 2, or (at your option) any later version.
        !            11: 
        !            12: GNU CC is distributed in the hope that it will be useful, but WITHOUT ANY
        !            13:    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
        !            14:    FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
        !            15:    details.
        !            16: 
        !            17: You should have received a copy of the GNU General Public License along with
        !            18:    GNU CC; see the file COPYING.  If not, write to the Free Software
        !            19:    Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
        !            20: 
        !            21: /* As a special exception, if you link this library with files compiled with
        !            22:    GCC to produce an executable, this does not cause the resulting executable
        !            23:    to be covered by the GNU General Public License. This exception does not
        !            24:    however invalidate any other reasons why the executable file might be
        !            25:    covered by the GNU General Public License.  */
        !            26: 
        !            27: #include "runtime.h"
        !            28: #include "sarray.h"
        !            29: 
        !            30: /* The uninstalled dispatch table */
        !            31: struct sarray* __objc_uninstalled_dtable = 0;
        !            32: 
        !            33: /* Send +initialize to class */
        !            34: static void __objc_send_initialize(Class*);
        !            35: 
        !            36: static void __objc_install_dispatch_table_for_class (Class*);
        !            37: 
        !            38: /* Forward declare some functions */
        !            39: static void __objc_init_install_dtable(id, SEL);
        !            40: static id __objc_missing_method(id, SEL, ...);
        !            41: static Method_t search_for_method_in_hierarchy (Class* class, SEL sel);
        !            42: static Method_t search_for_method_in_list(MethodList_t list, SEL op);
        !            43: id nil_method(id, SEL, ...);
        !            44: 
        !            45: id
        !            46: nil_method(id receiver, SEL op, ...)
        !            47: {
        !            48:   return receiver;
        !            49: }
        !            50: 
        !            51: /* Given a class and selector, return the selector's implementation.  */
        !            52: __inline__ IMP
        !            53: get_imp (Class* class, SEL sel)
        !            54: {
        !            55:   void* res = sarray_get (class->dtable, (size_t) sel);
        !            56:   if(res == __objc_init_install_dtable)
        !            57:     __objc_install_dispatch_table_for_class (class);
        !            58:   return sarray_get (class->dtable, (size_t) sel);
        !            59: }
        !            60: 
        !            61: __inline__ BOOL
        !            62: __objc_responds_to (id object, SEL sel)
        !            63: {
        !            64:   return get_imp (object->class_pointer, sel) != __objc_missing_method;
        !            65: }
        !            66: 
        !            67: /* This is the lookup function.  All entries in the table are either a 
        !            68:    valid method *or* one of `__objc_missing_method' which calls
        !            69:    forward:: etc, or `__objc_init_install_dtable' which installs the
        !            70:    real dtable */
        !            71: __inline__ IMP
        !            72: objc_msg_lookup(id receiver, SEL op)
        !            73: {
        !            74:   if(receiver)
        !            75:     return sarray_get(receiver->class_pointer->dtable, (sidx)op);
        !            76:   else
        !            77:     return nil_method;
        !            78: }
        !            79: 
        !            80: IMP
        !            81: objc_msg_lookup_super (Super_t super, SEL sel)
        !            82: {
        !            83:   if (super->self)
        !            84:     return get_imp (super->class, sel);
        !            85:   else
        !            86:     return nil_method;
        !            87: }
        !            88: 
        !            89: retval_t
        !            90: objc_msg_sendv(id object, SEL op, size_t frame_size, arglist_t arg_frame)
        !            91: {
        !            92: #ifdef __objc_frame_receiver
        !            93:   __objc_frame_receiver(arg_frame) = object;
        !            94:   __objc_frame_selector(arg_frame) = op;
        !            95:   return __builtin_apply((apply_t)get_imp(object->class_pointer, op),
        !            96:                         arg_frame,
        !            97:                         frame_size);
        !            98: #else
        !            99: #warning performv:: will not work
        !           100:   va_list nothing;
        !           101:   (*_objc_error)(object, "objc_msg_sendv (performv::) not supported\n", nothing);
        !           102:   return 0;
        !           103: #endif
        !           104: }
        !           105: 
        !           106: void __objc_init_dispatch_tables()
        !           107: {
        !           108:   __objc_uninstalled_dtable
        !           109:     = sarray_new(200, __objc_init_install_dtable);
        !           110: }
        !           111: 
        !           112: /* This one is a bit hairy.  This function is installed in the 
        !           113:    premature dispatch table, and thus called once for each class,
        !           114:    namely when the very first message is send to it.  */
        !           115: 
        !           116: static void __objc_init_install_dtable(id receiver, SEL op)
        !           117: {
        !           118:   __label__ allready_initialized;
        !           119:   IMP imp;
        !           120:   void* args;
        !           121:   void* result;
        !           122: 
        !           123:   /* This may happen, if the programmer has taken the address of a 
        !           124:      method before the dtable was initialized... too bad for him! */
        !           125:   if(receiver->class_pointer->dtable != __objc_uninstalled_dtable)
        !           126:     goto allready_initialized;
        !           127: 
        !           128:   if(CLS_ISCLASS(receiver->class_pointer))
        !           129:     {
        !           130:       /* receiver is an ordinary object */
        !           131:       assert(CLS_ISCLASS(receiver->class_pointer));
        !           132: 
        !           133:       /* install instance methods table */
        !           134:       __objc_install_dispatch_table_for_class (receiver->class_pointer);
        !           135: 
        !           136:       /* call +initialize -- this will in turn install the factory 
        !           137:         dispatch table if not already done :-) */
        !           138:       __objc_send_initialize(receiver->class_pointer);
        !           139:     }
        !           140:   else
        !           141:     {
        !           142:       /* receiver is a class object */
        !           143:       assert(CLS_ISCLASS((Class*)receiver));
        !           144:       assert(CLS_ISMETA(receiver->class_pointer));
        !           145: 
        !           146:       /* Install real dtable for factory methods */
        !           147:       __objc_install_dispatch_table_for_class (receiver->class_pointer);
        !           148:       
        !           149:       if(op != sel_get_uid ("initialize"))
        !           150:        __objc_send_initialize((Class*)receiver);
        !           151:       else
        !           152:        CLS_SETINITIALIZED((Class*)receiver);
        !           153:     }
        !           154: 
        !           155: allready_initialized:
        !           156:   
        !           157:   /* Get real method for this in newly installed dtable */
        !           158:   imp = get_imp(receiver->class_pointer, op);
        !           159: 
        !           160:   args = __builtin_apply_args();
        !           161:   result = __builtin_apply((apply_t)imp, args, 96);
        !           162:   __builtin_return (result);
        !           163:   
        !           164: }
        !           165: 
        !           166: /* Install dummy table for class which causes the first message to
        !           167:    that class (or instances hereof) to be initialized properly */
        !           168: void __objc_install_premature_dtable(Class* class)
        !           169: {
        !           170:   assert(__objc_uninstalled_dtable);
        !           171:   class->dtable = __objc_uninstalled_dtable;
        !           172: }   
        !           173: 
        !           174: /* Send +initialize to class if not already done */
        !           175: static void __objc_send_initialize(Class* class)
        !           176: {
        !           177:   Method_t m;
        !           178: 
        !           179:   /* This *must* be a class object */
        !           180:   assert(CLS_ISCLASS(class));
        !           181:   assert(!CLS_ISMETA(class));
        !           182: 
        !           183:   if (!CLS_ISINITIALIZED(class))
        !           184:     {
        !           185:       CLS_SETINITIALIZED(class);
        !           186:       CLS_SETINITIALIZED(class->class_pointer);
        !           187:       
        !           188:       if(class->super_class)
        !           189:        __objc_send_initialize(class->super_class);
        !           190: 
        !           191:       {
        !           192:        MethodList_t method_list = class->class_pointer->methods;
        !           193:        SEL op = sel_register_name ("initialize");
        !           194: 
        !           195:        /* If not found then we'll search the list.  */
        !           196:        while (method_list)
        !           197:          {
        !           198:            int i;
        !           199: 
        !           200:            /* Search the method list.  */
        !           201:            for (i = 0; i < method_list->method_count; ++i)
        !           202:              {
        !           203:                Method_t method = &method_list->method_list[i];
        !           204:                
        !           205:                
        !           206:                if (method->method_name == op)
        !           207:                  (*method->method_imp)((id) class, op);
        !           208:              }
        !           209: 
        !           210:            /* The method wasn't found.  Follow the link to the next list of
        !           211:               methods.  */
        !           212:            method_list = method_list->method_next;
        !           213:          }
        !           214:       }
        !           215:     }
        !           216: }  
        !           217: 
        !           218: static void
        !           219: __objc_install_dispatch_table_for_class (Class* class)
        !           220: {
        !           221:   Class* super;
        !           222:   MethodList_t mlist;
        !           223:   int counter;
        !           224: 
        !           225:   /* If the class has not yet had it's class links resolved, we must 
        !           226:      re-compute all class links */
        !           227:   if(!CLS_ISRESOLV(class))
        !           228:     __objc_resolve_class_links();
        !           229: 
        !           230:   super = class->super_class;
        !           231: 
        !           232:   if (super != 0 && (super->dtable == __objc_uninstalled_dtable))
        !           233:     __objc_install_dispatch_table_for_class (super);
        !           234: 
        !           235:   /* Allocate dtable if nessecary */
        !           236:   if (super == 0)
        !           237:     {
        !           238:       class->dtable = sarray_new (__objc_selector_max_index,
        !           239:                                  __objc_missing_method);
        !           240:     }
        !           241:   else
        !           242:     class->dtable = sarray_lazy_copy (super->dtable);
        !           243: 
        !           244:   for (mlist = class->methods; mlist; mlist = mlist->method_next)
        !           245:     {
        !           246:       counter = mlist->method_count - 1;
        !           247:       while (counter >= 0)
        !           248:         {
        !           249:           Method_t method = &(mlist->method_list[counter]);
        !           250:          sarray_at_put (class->dtable,
        !           251:                         (sidx) method->method_name,
        !           252:                         method->method_imp);
        !           253:           counter -= 1;
        !           254:         }
        !           255:     }
        !           256: }
        !           257: 
        !           258: void __objc_update_dispatch_table_for_class (Class* class)
        !           259: {
        !           260:   Class* next;
        !           261:   struct sarray* save;
        !           262: 
        !           263:   /* not yet installed -- skip it */
        !           264:   if (class->dtable == __objc_uninstalled_dtable) 
        !           265:     return;
        !           266: 
        !           267:   save = class->dtable;
        !           268:   __objc_install_premature_dtable (class);
        !           269:   sarray_free (save);
        !           270: 
        !           271: 
        !           272:   if (class->subclass_list)    /* Traverse subclasses */
        !           273:     for (next = class->subclass_list; next; next = next->sibling_class)
        !           274:       __objc_update_dispatch_table_for_class (next);
        !           275: }
        !           276: 
        !           277: 
        !           278: /* This function adds a method list to a class.  This function is
        !           279:    typically called by another function specific to the run-time.  As
        !           280:    such this function does not worry about thread safe issued.
        !           281: 
        !           282:    This one is only called for categories. Class objects have their
        !           283:    methods installed rightaway, and their selectors are made into
        !           284:    SEL's by the function __objc_register_selectors_from_class. */ 
        !           285: void
        !           286: class_add_method_list (Class* class, MethodList_t list)
        !           287: {
        !           288:   int i;
        !           289:   static SEL initialize_sel = 0;
        !           290:   if (!initialize_sel)
        !           291:     initialize_sel = sel_register_name ("initialize");
        !           292: 
        !           293:   /* Passing of a linked list is not allowed.  Do multiple calls.  */
        !           294:   assert (!list->method_next);
        !           295: 
        !           296:   /* Check for duplicates.  */
        !           297:   for (i = 0; i < list->method_count; ++i)
        !           298:     {
        !           299:       Method_t method = &list->method_list[i];
        !           300: 
        !           301:       if (method->method_name)  /* Sometimes these are NULL */
        !           302:        {
        !           303:          /* This is where selector names are transmogriffed to SEL's */
        !           304:          method->method_name = sel_register_name ((char*)method->method_name);
        !           305: 
        !           306:          if (search_for_method_in_list (class->methods, method->method_name)
        !           307:              && method->method_name != initialize_sel)
        !           308:            {
        !           309:              /* Duplication. Print a error message an change the method name
        !           310:                 to NULL. */
        !           311:              fprintf (stderr, "attempt to add a existing method: %s\n",
        !           312:                       sel_get_name(method->method_name));
        !           313:              method->method_name = 0;
        !           314:            }
        !           315:        }
        !           316:     }
        !           317: 
        !           318:   /* Add the methods to the class's method list.  */
        !           319:   list->method_next = class->methods;
        !           320:   class->methods = list;
        !           321: }
        !           322: 
        !           323: 
        !           324: Method_t
        !           325: class_get_instance_method(Class* class, SEL op)
        !           326: {
        !           327:   return search_for_method_in_hierarchy(class, op);
        !           328: }
        !           329: 
        !           330: Method_t
        !           331: class_get_class_method(MetaClass* class, SEL op)
        !           332: {
        !           333:   return search_for_method_in_hierarchy(class, op);
        !           334: }
        !           335: 
        !           336: 
        !           337: /* Search for a method starting from the current class up its hierarchy.
        !           338:    Return a pointer to the method's method structure if found.  NULL
        !           339:    otherwise. */   
        !           340: 
        !           341: static Method_t
        !           342: search_for_method_in_hierarchy (Class* cls, SEL sel)
        !           343: {
        !           344:   Method_t method = NULL;
        !           345:   Class* class;
        !           346: 
        !           347:   if (! sel_is_mapped (sel))
        !           348:     return NULL;
        !           349: 
        !           350:   /* Scan the method list of the class.  If the method isn't found in the
        !           351:      list then step to its super class. */
        !           352:   for (class = cls; ((! method) && class); class = class->super_class)
        !           353:     method = search_for_method_in_list (class->methods, sel);
        !           354: 
        !           355:   return method;
        !           356: }
        !           357: 
        !           358: 
        !           359: 
        !           360: /* Given a linked list of method and a method's name.  Search for the named
        !           361:    method's method structure.  Return a pointer to the method's method
        !           362:    structure if found.  NULL otherwise. */  
        !           363: static Method_t
        !           364: search_for_method_in_list (MethodList_t list, SEL op)
        !           365: {
        !           366:   MethodList_t method_list = list;
        !           367: 
        !           368:   if (! sel_is_mapped (op))
        !           369:     return NULL;
        !           370: 
        !           371:   /* If not found then we'll search the list.  */
        !           372:   while (method_list)
        !           373:     {
        !           374:       int i;
        !           375: 
        !           376:       /* Search the method list.  */
        !           377:       for (i = 0; i < method_list->method_count; ++i)
        !           378:         {
        !           379:           Method_t method = &method_list->method_list[i];
        !           380: 
        !           381:           if (method->method_name)
        !           382:             if (method->method_name == op)
        !           383:               return method;
        !           384:         }
        !           385: 
        !           386:       /* The method wasn't found.  Follow the link to the next list of
        !           387:          methods.  */
        !           388:       method_list = method_list->method_next;
        !           389:     }
        !           390: 
        !           391:   return NULL;
        !           392: }
        !           393: 
        !           394: 
        !           395: /* This fuction is installed in the dispatch table for all methods which are
        !           396:    not implemented.  Thus, it is called when a selector is not recognized. */
        !           397: static id
        !           398: __objc_missing_method (id object, SEL sel, ...)
        !           399: {
        !           400:   IMP imp;
        !           401:   SEL frwd_sel;
        !           402:   SEL err_sel;
        !           403: 
        !           404:   /* first try if the object understands forward:: */
        !           405:   frwd_sel = sel_get_uid("forward::");
        !           406:   imp = get_imp(object->class_pointer, frwd_sel);
        !           407:   if(imp != __objc_missing_method)
        !           408:     {
        !           409:       void *result, *args = __builtin_apply_args();
        !           410:       result = (*imp)(object, frwd_sel, sel, args);
        !           411:       __builtin_return(result);
        !           412:     }
        !           413: 
        !           414:   /* If the object recognizes the doesNotRecognize: method then we're going
        !           415:      to send it. */
        !           416:   err_sel = sel_get_uid ("doesNotRecognize:");
        !           417:   imp = get_imp (object->class_pointer, err_sel);
        !           418:   if (imp != __objc_missing_method)
        !           419:     {
        !           420:       return (*imp) (object, err_sel, sel);
        !           421:     }
        !           422:   
        !           423:   /* The object doesn't recognize the method.  Check for responding to
        !           424:      error:.  If it does then sent it. */
        !           425:   {
        !           426:     char msg[256 + strlen ((char*)sel_get_name (sel))
        !           427:              + strlen ((char*)object->class_pointer->name)];
        !           428: 
        !           429:     sprintf (msg, "(%s) %s does not recognize %s",
        !           430:             (CLS_ISMETA(object->class_pointer)
        !           431:              ? "class"
        !           432:              : "instance" ),
        !           433:              object->class_pointer->name, sel_get_name (sel));
        !           434: 
        !           435:     err_sel = sel_get_uid ("error:");
        !           436:     imp = get_imp (object->class_pointer, err_sel);
        !           437:     if (imp != __objc_missing_method)
        !           438:       return (*imp) (object, sel_get_uid ("error:"), msg);
        !           439: 
        !           440:     /* The object doesn't respond to doesNotRecognize: or error:;  Therefore,
        !           441:        a default action is taken. */
        !           442:     fprintf (stderr, "fatal: %s\n", msg);
        !           443:     abort ();
        !           444:   }
        !           445: }
        !           446: 
        !           447: void __objc_print_dtable_stats()
        !           448: {
        !           449:   int total = 0;
        !           450:   printf("memory usage: (%s)\n",
        !           451: #ifdef OBJC_SPARSE2
        !           452:         "2-level sparse arrays"
        !           453: #else
        !           454:         "3-level sparse arrays"
        !           455: #endif
        !           456:         );
        !           457: 
        !           458:   printf("arrays: %d = %d bytes\n", narrays, narrays*sizeof(struct sarray));
        !           459:   total += narrays*sizeof(struct sarray);
        !           460:   printf("buckets: %d = %d bytes\n", nbuckets, nbuckets*sizeof(struct sbucket));
        !           461:   total += nbuckets*sizeof(struct sbucket);
        !           462: 
        !           463:   printf("idxtables: %d = %d bytes\n", idxsize, idxsize*sizeof(void*));
        !           464:   total += idxsize*sizeof(void*);
        !           465:   printf("-----------------------------------\n");
        !           466:   printf("total: %d bytes\n", total);
        !           467:   printf("===================================\n");
        !           468: }
        !           469: 
        !           470: 
        !           471: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.