![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to core.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc / objc|
Return to core.c CVS log | Up to [GCC 2.x] / gcc / objc |
1.1 root 1: /* Method dispatcher and class-object creator for Objective C.
2: Copyright (C) 1992 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
6: GNU CC is free software; you can redistribute it and/or modify
7: it under the terms of the GNU General Public License as published by
8: the Free Software Foundation; either version 2, or (at your option)
9: any later version.
10:
11: GNU CC is distributed in the hope that it will be useful,
12: but WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: GNU General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GNU CC; see the file COPYING. If not, write to
18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19:
20: /* As a special exception, if you link this library with files
21: compiled with GCC to produce an executable, this does not cause
22: the resulting executable to be covered by the GNU General Public License.
23: This exception does not however invalidate any other reasons why
24: the executable file might be covered by the GNU General Public License. */
25:
26: #include "tconfig.h"
27: #include "assert.h"
28: #include <ctype.h>
29: #include "gstdarg.h"
30: #include <stdio.h>
31: #include "gstddef.h"
32:
33: #include "hash.h"
34: #include "objc.h"
35: #include "objc-proto.h"
36:
37:
38: #define MODULE_HASH_SIZE 32 /* Initial module hash table size.
39: Value doesn't really matter. */
40:
41: #define CLASS_HASH_SIZE 32 /* Initial number of buckets size of
42: class hash table. Value doesn't
43: really matter. */
44:
45:
46: /* Forward declare some functions. */
47: id objc_object_create (Class_t),
48: objc_object_dispose (id),
49: objc_object_realloc (id, unsigned int),
50: objc_object_copy (id);
51: void objc_error (id object, const char *fmt, va_list ap);
52: static id nil_method (id, SEL, ...);
53: static id return_error_static (id, SEL, ...);
54: static IMP handle_runtime_error (id, SEL);
55: static void initialize_dispatch_tables (void);
56: static SEL record_selector (const char*);
57: static void record_methods_from_class (Class_t);
58: static void record_methods_from_list (MethodList_t);
59: static void initialize_class (const char*);
60: /*
61: * This is a hash table of Class_t structures.
62: *
63: * At initialization the executable is searched for all Class_t structures.
64: * Since these structures are created by the compiler they are therefore
65: * located in the TEXT segment.
66: *
67: * A identical structure is allocated from the free store and initialized from
68: * its TEXT counterpart and placed in the hash table using the TEXT part as
69: * its key.
70: *
71: * Since the free store structure is now writable, additional initialization
72: * takes place such as its "info" variable, method cache allocation, and
73: * linking of all of its method and ivar lists from multiple implementations.
74: */
75: cache_ptr class_hash_table = NULL;
76:
77: /*
78: * This variable is a flag used within the messaging routines. If a
79: * application sets it to !0 then the messager will print messages sent to
80: * objects.
81: */
82: BOOL objc_trace = NO;
83:
84: /* This mutex provides a course lock for method dispatch. */
85: MUTEX runtimeMutex;
86:
87: /*
88: * This hash table is used by the initialization routines. When the
89: * constructor function (__objc_execClass) is called it is passed a pointer
90: * to a module structure. That pointer is stored in this table and its
91: * contents are processed in __objcInit.
92: */
93: cache_ptr module_hash_table = NULL;
94:
95: /*
96: * This hash table is used in the constructor subroutine to hold pointers
97: * to categories that have not been attached to a class. Constructors are
98: * received in a random order. Files may contain category implementation
99: * of objects whose constructor hasn't been executed yet. Therefore,
100: * there is no object to attach the categories.
101: *
102: * This hash table holds pointers to categories that haven't been
103: * attached to objects. As objects are processed the category hash
104: * table is searched for attachments. If a category is found for the
105: * object it is attached to the object and deleted from the hash table.
106: */
107: cache_ptr unclaimed_category_hash_table = NULL;
108:
109: /*
110: * This flag is used by the messager routines to determine if the run-time
111: * has been initialized. If the run-time isn't initialized then a
112: * initialization clean up routine is called.
113: */
114: static int initialized = 0;
115:
116: /*
117: * Records that hold pointers to arrays of records. The terminal records are
118: * method implementations.
119: *
120: * The size of the first record is the number of unique classes in the
121: * executable. The second is the number of selectors.
122: *
123: * The second record conatins methods that are visible to the class -- that is,
124: * methods that are not overriden from the classt to the root object.
125: *
126: * The cache pointers of class and meta class structures point to one of these
127: * records.
128: */
129: static struct record *instance_method_record = NULL;
130: static struct record *factory_method_record = NULL;
131:
132: /*
133: * This structure is used to translate between selectors and their ASCII
134: * representation. A NULL terminated array of char*,
135: * OBJC_SELECTOR_REFERENCES, is passed to the constructor routine:
136: * __objc_execClass. That routine places entries from that array into this
137: * structure. The location within OBJC_SELECTOR_REFERENCES where the string
138: * was taken from is replaced with a small integer, the index into the array
139: * inside selectorTranslateTable. That integer then becomes the selector.
140: *
141: * Selectors begin at 1 to numEntries. A selector outside of that range is
142: * considered an error. The selector integers are used as the first index
143: * into the instance_method_record and factory_method_record arrays.
144: */
145: static struct record *selector_record = NULL;
146:
147: /*
148: * This data structure is used in the special case where usual fatal error
149: * functions are called but have been overridden in a class. The value
150: * returned by that function is returned to the calling object. error_static
151: * holds the returned value until it is retrieved by return_error_static
152: * which returns it to the calling function.
153: */
154: static id error_static;
155:
156:
157: /* Given a class and selector, return the selector's implementation. */
158: static inline IMP
159: get_imp (Class_t class, SEL sel)
160: {
161: IMP imp = NULL;
162: imp = record_get (getClassNumber (class),
163: record_get ((unsigned int)sel, *class->cache));
164:
165: return imp;
166: }
167:
168:
169: static void
170: error (msg, arg1, arg2)
171: char *msg, *arg1, *arg2;
172: {
173: #if 0 /* There is no portable way to get the program name. Too bad. */
174: fprintf (stderr, "%s: ", programname);
175: #endif
176: fprintf (stderr, msg, arg1, arg2);
177: fprintf (stderr, "\n");
178: }
179:
180: static void
181: fatal (msg, arg1, arg2)
182: char *msg, *arg1, *arg2;
183: {
184: error (msg, arg1, arg2);
185: exit (1);
186: }
187:
188: static void *
189: xmalloc (unsigned int size)
190: {
191: void *ptr = (void *) malloc (size);
192: if (ptr == 0)
193: fatal ("virtual memory exceeded");
194: return ptr;
195: }
196:
197: static void *
198: xcalloc (unsigned int size, unsigned int units)
199: {
200: void *ptr = (void *) calloc (size, units);
201: if (ptr == 0)
202: fatal ("virtual memory exceeded");
203: return ptr;
204: }
205:
206: void *
207: __objc_xmalloc (unsigned int size)
208: {
209: void *ptr = (void *) malloc (size);
210: if (ptr == 0)
211: fatal ("virtual memory exceeded");
212: return ptr;
213: }
214:
215: void *
216: __objc_xrealloc (void *optr, unsigned int size)
217: {
218: void *ptr = (void *) realloc (optr, size);
219: if (ptr == 0)
220: fatal ("virtual memory exceeded");
221: return ptr;
222: }
223:
224: void *
225: __objc_xcalloc (unsigned int size, unsigned int units)
226: {
227: void *ptr = (void *) calloc (size, units);
228: if (ptr == 0)
229: fatal ("virtual memory exceeded");
230: return ptr;
231: }
232:
233: static inline char *
234: my_strdup (const char *str)
235: {
236: char *new = (char *) xmalloc (strlen (str) + 1);
237: strcpy (new, str);
238:
239: return new;
240: }
241:
242:
243: /*
244: * This function is called by constructor functions generated for each module
245: * compiled.
246: *
247: * The purpose of this function is to gather the module pointers so that they
248: * may be processed by the initialization clean up routine.
249: */
250: void
251: __objc_execClass (Module_t module)
252: {
253: /* Has we processed any constructors previously?
254: Flag used to indicate that some global data structures
255: need to be built. */
256: static BOOL previous_constructors = 0;
257:
258: Symtab_t symtab = module->symtab;
259: Class_t object_class;
260: node_ptr node;
261: SEL *(*selectors)[] = (SEL *(*)[])symtab->refs;
262: int i;
263: BOOL incomplete = 0;
264:
265:
266: assert (module->size == sizeof (Module));
267: DEBUG_PRINTF ("received load module: %s\n",module->name);
268:
269: /* Header file data structure hack test. */
270: assert (sizeof (Class) == sizeof (MetaClass));
271:
272: /* On the first call of this routine, initialize
273: some data structures. */
274: if (!previous_constructors) {
275:
276: /* Enable malloc debugging. This'll slow'er down! */
277: #if defined (DEBUG) && defined (NeXT)
278: malloc_debug (62);
279: #endif
280:
281: /* Allocate and initialize the mutex. */
282: MUTEX_ALLOC (&runtimeMutex);
283: MUTEX_INIT (runtimeMutex);
284:
285: /* Allocate the module hash table. */
286: module_hash_table
287: = hash_new (MODULE_HASH_SIZE, (hash_func_type)hash_ptr,
288: (compare_func_type)compare_ptrs);
289:
290: /* Allocate a table for unclaimed categories. */
291: unclaimed_category_hash_table
292: = hash_new (16, (hash_func_type)hash_ptr,
293: (compare_func_type)compare_ptrs);
294:
295: /* Allocate a master selector table if it doesn't exist. */
296: selector_record = record_new ();
297:
298: previous_constructors = 1;
299: }
300:
301: /* Save the module pointer for later processing. */
302: hash_add (&module_hash_table, module, module);
303:
304: /* Parse the classes in the load module and gather selector information. */
305: DEBUG_PRINTF ("gathering selectors from module: %s\n",module->name);
306: for (i = 0; i < symtab->cls_def_cnt; ++i) {
307: Class_t class = (Class_t)symtab->defs[i];
308:
309: /* Make sure we have what we think. */
310: assert (class->info & CLS_CLASS);
311: assert (class->class_pointer->info & CLS_META);
312: DEBUG_PRINTF ("phase 1, processing class: %s\n", class->name);
313:
314: /* Store the class in the class table and assign class numbers. */
315: addClassToHash (class);
316:
317: /* Store all of the selectors in the class and meta class. */
318: record_methods_from_class (class);
319: record_methods_from_class ((Class_t)class->class_pointer);
320:
321: /* Initialize the cache pointers. */
322: class->cache = &instance_method_record;
323: class->class_pointer->cache = &factory_method_record;
324: }
325:
326: /* Replace referenced selectors. */
327: for (i=0; i < symtab->sel_ref_cnt; ++i)
328: (*selectors)[i] = record_selector ((const char*)(*selectors)[i]);
329:
330: /* Try to build the class hierarchy and initialize the data structures. */
331: object_class = objc_getClass ("Object");
332: if (object_class) {
333:
334: /* Make sure we have what we think we have. */
335: assert (object_class->class_pointer->info & CLS_META);
336: assert (object_class->info & CLS_CLASS);
337:
338: /* Connect the classes together (at least as much as we can). */
339: for (node = hash_next (class_hash_table, NULL); node;
340: node = hash_next (class_hash_table, node)) {
341: Class_t class1 = node->value;
342:
343: /* Make sure we have what we think we have. */
344: assert (class1->info & CLS_CLASS);
345: assert (class1->class_pointer->info & CLS_META);
346:
347: /* The class_pointer of all meta classes point to Object's meta class. */
348: class1->class_pointer->class_pointer = object_class->class_pointer;
349:
350: /* Assign super class pointers */
351: if (class1->super_class) {
352: Class_t aSuperClass = objc_getClass ((char*)class1->super_class);
353:
354: if (aSuperClass) {
355:
356: DEBUG_PRINTF ("making class connections for: %s\n",
357: class1->name);
358:
359: class1->super_class = aSuperClass;
360: if (class1->class_pointer->super_class)
361: class1->class_pointer->super_class = class1->super_class->class_pointer;
362:
363: /* Mark the class as initialized. */
364: class1->info |= CLS_RTI;
365: } else
366: /* Couldn't find the class's super class. */
367: incomplete = 1;
368: }
369: }
370: } else
371: /* Couldn't find class Object. */
372: incomplete = 1;
373:
374: /* Process category information from the module. */
375: for (i = 0; i < symtab->cat_def_cnt; ++i) {
376: Category_t category = symtab->defs[i + symtab->cls_def_cnt];
377: Class_t class = objc_getClass (category->class_name);
378:
379: /* If the class for the category exists then append its
380: methods. */
381: if (class) {
382:
383: DEBUG_PRINTF ("processing categories from (module,object): %s, %s\n",
384: module->name,
385: class_getClassName (class));
386:
387: /* Do instance methods. */
388: if (category->instance_methods)
389: addMethodsToClass (class, category->instance_methods);
390:
391: /* Do class methods. */
392: if (category->class_methods)
393: addMethodsToClass ((Class_t)class->class_pointer, category->class_methods);
394: } else {
395: /* The object to which the category methods belong can't
396: be found. Save the information. */
397: hash_add (&unclaimed_category_hash_table, category, category);
398:
399: incomplete = 1;
400: }
401: }
402:
403: /* Scan the unclaimed category hash.
404: Attempt to attach any unclaimed categories to objects. */
405: for (node = hash_next (unclaimed_category_hash_table, NULL); node;
406: node = hash_next (unclaimed_category_hash_table, node)) {
407: Category_t category = node->value;
408: Class_t class = objc_getClass (category->class_name);
409:
410: if (class) {
411:
412: DEBUG_PRINTF ("attaching stored categories to object: %s\n",
413: class_getClassName (class));
414:
415: /* Delete this class from the hash table. */
416: hash_remove (unclaimed_category_hash_table, category);
417: node = NULL;
418:
419: if (category->instance_methods)
420: addMethodsToClass (class, category->instance_methods);
421:
422: if (category->class_methods)
423: addMethodsToClass ((Class_t)class->class_pointer,
424: category->class_methods);
425: } else
426: incomplete = 1;
427: }
428:
429: /* Can we finish the run time initialization? */
430: if (!incomplete) {
431:
432: initialize_dispatch_tables ();
433:
434: /* Debug run time test.
435: We're initialized! */
436: initialized = 1;
437:
438: /* Print out class tables if debugging. */
439: DEBUG_PRINTF ("dump of class tables from objcInit\n");
440: debug_dump_classes ();
441: }
442:
443: }
444:
445:
446: IMP
447: objc_msgSend (id receiver, SEL sel)
448: {
449: /*
450: * A method is always called by the compiler. If a method wasn't
451: * found then supply a default.
452: */
453: IMP imp = nil_method;
454:
455:
456: /* The run time must be initialized at this point.
457: Otherwise we get a message sent to a object with a bogus selector. */
458: assert (initialized);
459:
460: /* Objective-C allows messages to be sent to a nil object. */
461: if (receiver) {
462:
463: /* Check for common programmer error. */
464: if (!receiver->class_pointer) {
465: fprintf (stderr, "method %s sent to deallocated object %#x\n",
466: sel_getName (sel), receiver);
467: abort ();
468: }
469:
470: /* Initialize the class if need be. */
471: if (!(receiver->class_pointer->info & CLS_INITIALIZED))
472: initialize_class (receiver->class_pointer->name);
473:
474: /*
475: * If we're passed a object then its class_pointer is a Class. If
476: * we're passed a Class then its class_pointer is a MetaClass.
477: * Therefore, searching for a instance or class method
478: * requires no special decision making here.
479: *
480: * Look for the method.
481: */
482: imp = get_imp (receiver->class_pointer, sel);
483:
484: /* If the method cannot be found then perform error handling. */
485: if (!imp)
486: imp = handle_runtime_error (receiver, sel);
487: }
488:
489: /* Nice debugging messages if enabled. */
490: if (objc_trace) {
491: printf ("trace: objc_msgSend , obj=%#x, class=%s, method=%s\n",
492: receiver,
493: receiver->class_pointer->name,
494: sel_getName (sel));
495: fflush (stdout);
496: }
497:
498: return imp;
499: }
500:
501:
502: IMP
503: objc_msgSendSuper (Super_t super, SEL sel)
504: {
505: IMP imp;
506:
507:
508: assert (initialized);
509:
510: if (!(super->class->info & CLS_INITIALIZED))
511: initialize_class (super->class->name);
512: if (!(super->receiver->class_pointer->info & CLS_INITIALIZED))
513: initialize_class (super->receiver->class_pointer->name);
514:
515: imp = get_imp (super->class, sel);
516:
517: if (!imp)
518: imp = handle_runtime_error (super->receiver, sel);
519:
520: if (objc_trace) {
521: printf ("trace: objc_msgSendSuper , obj=%#x, class=%s, method=%s\n",
522: super->receiver,
523: super->receiver->class_pointer->name,
524: sel_getName (sel));
525: fflush (stdout);
526: }
527:
528: return imp;
529: }
530:
531:
532: /*
533: * This function is called by objc_msgSend or objc_msgSendSuper when a
534: * message is sent to a object which it does not recognize.
535: */
536: static IMP
537: handle_runtime_error (id object, SEL sel)
538: {
539: IMP imp;
540:
541:
542: /*
543: * If the object recognizes the doesNotRecognize: method then we're
544: * going to send it.
545: */
546: imp = get_imp (object->class_pointer, sel_getUid ("doesNotRecognize:"));
547: if (imp)
548: error_static = (*imp)(object, sel_getUid ("doesNotRecognize:"), sel);
549: else {
550: /*
551: * The object doesn't recognize the method. Check for
552: * responding to error:. If it does then sent it.
553: */
554: char msg[256 + strlen (sel_getName (sel))
555: + strlen (object->class_pointer->name)];
556:
557: sprintf (msg, "%s does not recognize %s",
558: object->class_pointer->name, sel_getName (sel));
559:
560: imp = get_imp (object->class_pointer, sel_getUid ("error:"));
561: if (imp)
562: error_static = (*imp)(object, sel_getUid ("error:"), msg);
563: else {
564: /*
565: * The object doesn't respond to doesNotRecognize: or
566: * error:; Therefore, a default action is taken.
567: */
568: fprintf (stderr, "%s\n", msg);
569: abort ();
570: }
571: }
572:
573: /*
574: * Either doesNotRecognize: or error: has been overridden. We have
575: * to return that value as the default action.
576: */
577: return return_error_static;
578: }
579:
580:
581: /*
582: * This function is used by the run-time to provide a method where nil
583: * objects can receive messages.
584: *
585: * This method simply returns self.
586: */
587: static id
588: nil_method (id object, SEL sel, ...)
589: {
590: return object;
591: }
592:
593:
594: /*
595: * This function is used by the run-time to provide a method where nil
596: * objects can receive messages.
597: *
598: * This method simply returns self.
599: *
600: * Note: multiple thread problem area.
601: */
602: static id
603: return_error_static (id object, SEL sel, ...)
604: {
605: return error_static;
606: }
607:
608:
609: /*
610: * These variables provide a way for the defalut methods of object
611: * allocation, destruction, and reallocation to be overridden.
612: */
613: id (*_alloc)(Class_t) = objc_object_create;
614: id (*_dealloc)(id) = objc_object_dispose;
615: id (*_realloc)(id, unsigned int) = objc_object_realloc;
616: id (*_copy)(id) = objc_object_copy;
617: void (*_error)(id, const char*, va_list) = objc_error;
618:
619:
620: id
621: objc_object_create (Class_t class)
622: {
623: id object;
624:
625:
626: assert (class);
627:
628: /*
629: * Allocate memory for the object, initialize the memory to 0, and
630: * set the object's class_pointer.
631: *
632: * The object's class_pointer is the class's TEXT image. It is used by
633: * the messager as the key to the class hash for methods.
634: *
635: * No need to initialize the class. That was done in objcInit.
636: */
637: object = (id) xcalloc (1, class->instance_size);
638: object->class_pointer = class;
639:
640: return object;
641: }
642:
643:
644: id
645: objc_object_dispose (id object)
646: {
647: object->class_pointer = NULL;
648: free (object);
649:
650: return nil;
651: }
652:
653:
654: id
655: objc_object_realloc (id object, unsigned int length)
656: {
657: id obj;
658: /* Can't resize a object smaller than its instance size. */
659: /* Don't use assert here;
660: checks for user errors shouldn't depend on NDEBUG. */
661: if (length < object->class_pointer->instance_size)
662: abort ();
663:
664: obj = (id) realloc (object, length);
665: bzero ((char*)obj + object->class_pointer->instance_size,
666: length - object->class_pointer->instance_size);
667:
668: return obj;
669: }
670:
671:
672: id
673: objc_object_copy (id object)
674: {
675: id obj;
676: obj = class_createInstance (object->class_pointer);
677: bcopy (object, obj, objc_classSize (object));
678:
679: return obj;
680: }
681:
682:
683: void
684: objc_error (id object, const char *fmt, va_list ap)
685: {
686: vfprintf (stderr, fmt, ap);
687: abort ();
688: }
689:
690:
691: /* Silly function to skip past a sequence of digits in a string. */
692: static inline const char *
693: skip_digits (const char *str)
694: {
695: while (isdigit (*str))
696: ++str;
697:
698: return str;
699: }
700:
701:
702: unsigned int
703: method_getNumberOfArguments (Method_t method)
704: {
705: unsigned int num = 0;
706: const char *args = &method->method_types[1];
707:
708:
709: while (*args) {
710:
711: /* Skip past size info. */
712: args = skip_digits (args);
713:
714: /* Argument type next. */
715: assert (*args);
716: ++num;
717:
718: /* Step to next arg. */
719: ++args;
720: }
721:
722: assert (num >= 2);
723: return num;
724: }
725:
726:
727: unsigned int
728: method_getArgumentInfo (Method_t method, int indx, const char **type,
729: int *offset)
730: {
731: const char *args = skip_digits (&method->method_types[1]);
732: int i;
733:
734:
735: assert (method_getNumberOfArguments (method) >= indx);
736:
737: /* Step to arg. */
738: for (i = 0; i < indx; ++i) {
739: ++args;
740: args = skip_digits (args);
741: }
742:
743: /* Return arg data. */
744: *type = args++;
745: *offset = atoi (args);
746:
747: return indx;
748: }
749:
750:
751: /* This function is not thread safe. */
752: Ivar_t
753: object_getIvarAddress (id object, const char *name)
754: {
755: Class_t class = object->class_pointer; /* Here is the thread safe problem. */
756: Ivar_t ivar = NULL;
757:
758:
759: do {
760: IvarList_t ivars = class->ivars;
761: int i;
762:
763: /* Look at all of the ivar names. */
764: for (i = 0; i < ivars->ivar_count; ++i)
765: if (!strcmp (name, ivars->ivar_list[i].ivar_name))
766: ivar = &ivars->ivar_list[i];
767:
768: /*
769: * If the ivar wasn't found then lets look to the
770: * super class.
771: *
772: * If the class is Object then the super class is NULL
773: * and we're done.
774: */
775: class = class->super_class;
776:
777: } while (!ivar && class);
778:
779: return ivar;
780: }
781:
782:
783: /*
784: * Search for a method starting from the current class up its hierarchy.
785: *
786: * Return a pointer to the method's method structure if found. NULL otherwise.
787: */
788: Method_t
789: searchForMethodInHierarchy (Class_t class, SEL sel)
790: {
791: Method_t method = NULL;
792: const char* name;
793:
794: if (sel == 0)
795: return NULL;
796:
797: name = sel_getName (sel);
798:
799: if (name == 0)
800: return NULL;
801:
802: /*
803: * Scan the method list of the class. If the method isn't found in
804: * the list then step to its super class.
805: */
806: do {
807:
808: method = searchForMethodInList (class->methods, name);
809: class = class->super_class;
810:
811: } while (!method && class);
812:
813: return method;
814: }
815:
816:
817: /*
818: * Given a linked list of method and a method's name. Search for the named
819: * method's method structure.
820: *
821: * Return a pointer to the method's method structure if found. NULL otherwise.
822: */
823: Method_t
824: searchForMethodInList (MethodList_t list, const char *name)
825: {
826: MethodList_t method_list = list;
827:
828:
829: /* Check for bumbling. */
830: /* ??? Who generates the name? Is it the user, or part of this file?
831: If we crash here, whose fault is it? */
832: assert (name);
833:
834: /* If not found then we'll search the list. */
835: while (method_list) {
836: int i;
837:
838: /* Search the method list. */
839: for (i = 0; i < method_list->method_count; ++i) {
840: Method_t method = &method_list->method_list[i];
841:
842: if (method->method_name)
843: if (!strcmp (method->method_name, name))
844: return method;
845: }
846:
847: /* The method wasn't found. Follow the link to the next list of
848: methods. */
849: method_list = method_list->method_next;
850: }
851:
852: return NULL;
853: }
854:
855:
856: /*
857: * This function adds a method list to a class.
858: *
859: * This function is typically called by another function specific to the
860: * run-time. As such this function does not worry about thread safe issued.
861: */
862: void
863: addMethodsToClass (Class_t class, MethodList_t list)
864: {
865: int i;
866:
867:
868: /* Passing of a linked list is not allowed. Do multiple calls. */
869: assert (!list->method_next);
870:
871: /* Check for duplicates. */
872: for (i = 0; i < list->method_count; ++i) {
873: Method_t method = &list->method_list[i];
874:
875: if (method->method_name) /* Sometimes these are NULL */
876: if (searchForMethodInList (class->methods, method->method_name)) {
877: /*
878: * Duplication. Print a error message an change the
879: * method name to NULL.
880: */
881: fprintf (stderr, "attempt to add a existing method: %s\n",
882: method->method_name);
883: method->method_name = NULL;
884: }
885: }
886:
887: /* Add the methods to the class's method list. */
888: list->method_next = class->methods;
889: class->methods = list;
890: }
891:
892:
893: /*
894: * This function removes the instance and factory methods in the passed list
895: * from a class.
896: *
897: * Methods are removed from a class by replacing the method's name with NULL.
898: *
899: *
900: * This function is typically called by another function specific to the
901: * run-time. As such this function does not worry about thread safe issued.
902: */
903: void
904: class_removeMethods (Class_t class, MethodList_t method_list)
905: {
906: int i;
907:
908:
909: /* Passing of a linked list is not allowed. Do multiple calls. */
910: assert (!method_list->method_next);
911:
912: /*
913: * For each method in the list search the method lists erasing any
914: * entries found.
915: */
916: for (i = 0; i < method_list->method_count; ++i) {
917: Method_t kill_method = &method_list->method_list[i];
918: Method_t method;
919:
920: /* Remove any instance method found. */
921: method = searchForMethodInList (class->methods,
922: kill_method->method_name);
923: if (method)
924: method->method_name = NULL;
925:
926: /* Remove any factory method found. */
927: method = searchForMethodInList (class->class_pointer->methods,
928: kill_method->method_name);
929: if (method)
930: method->method_name = NULL;
931: }
932: }
933:
934:
935: /*
936: * This is a incomplete implementation of posing. This function does the
937: * bulk of the work but does not initialize the class method caches. That is
938: * a run-time specific operation.
939: *
940: * I implement posing by hiding SUPER_CLASS, creating new class and meta
941: * class structures, initializing it with IMPOSTOR, and changing it such
942: * that it is identified as SUPER_CLASS. SUPER_CLASS remains in the
943: * hierarchy but is inaccessible by the means. The class hierarchy is then re
944: * arranged such that all of the subclasses of SUPER_CLASS now inherit from
945: * the new class structures -- except the impostor itself. The only dramatic
946: * effect on the application is that subclasses of SUPER_CLASS cannot do a
947: * [ .... superClass ] and expect their real super class.
948: */
949: Class_t
950: class_poseAs (Class_t impostor, Class_t super_class)
951: {
952: Class_t new_class = (Class_t) calloc (1, sizeof (Class));
953: MetaClass_t new_meta_class = (MetaClass_t) calloc (1, sizeof (MetaClass));
954: node_ptr node;
955: char *new_name = (char *) malloc (strlen (super_class->name) + 12);
956:
957:
958: assert (new_class);
959: assert (new_meta_class);
960: assert (new_name);
961:
962: /* No dispatching while the the posing class is being built.
963: The dispatch tables will be hacked on. */
964: MUTEX_LOCK (runtimeMutex);
965:
966: assert (impostor->info & CLS_CLASS);
967: assert (super_class->info & CLS_CLASS);
968:
969: assert (impostor->instance_size == super_class->instance_size);
970:
971: /* Create the impostor class. */
972: new_class->class_pointer = new_meta_class;
973: new_class->super_class = super_class;
974: new_class->name = super_class->name;
975: new_class->version = super_class->version;
976: new_class->info = super_class->info;
977: new_class->instance_size = super_class->instance_size;
978: new_class->ivars = super_class->ivars;
979: new_class->methods = impostor->methods;
980: new_class->cache = &instance_method_record;
981:
982: /* Create the impostor meta class. */
983: new_meta_class->class_pointer = super_class->class_pointer->class_pointer;
984: new_meta_class->super_class = super_class->class_pointer->super_class;
985: new_meta_class->name = super_class->class_pointer->name;
986: new_meta_class->version = super_class->class_pointer->version;
987: new_meta_class->info = super_class->class_pointer->info;
988: new_meta_class->instance_size = super_class->class_pointer->instance_size;
989: new_meta_class->ivars = super_class->class_pointer->ivars;
990: new_meta_class->methods = impostor->class_pointer->methods;
991: new_meta_class->cache = &factory_method_record;
992:
993: /*
994: * Delete the class from the hash table, change its name so that it
995: * can no longer be found, then place it back into the hash table
996: * using its new name.
997: *
998: * Don't worry about the class number. It is already assigned.
999: *
1000: * Don't worry about dangling pointers. Life's a bitch. (A little bit
1001: * of memory is lost with the hash key.)
1002: */
1003: hash_remove (class_hash_table, super_class->name);
1004: sprintf (new_name, "%s*", super_class->name);
1005: super_class->name = new_name;
1006: super_class->class_pointer->name = new_name;
1007: hash_add (&class_hash_table, super_class->name, super_class);
1008:
1009: /*
1010: * Now change all of the classes derived from super_class to be
1011: * derived from a impostor (except the impostor's impostor.
1012: */
1013: for (node = hash_next (class_hash_table, NULL); node;
1014: node = hash_next (class_hash_table, node)) {
1015:
1016: Class_t class1 = node->value;
1017:
1018: if (class1->super_class == super_class)
1019: if (class1 != impostor)
1020: class1->super_class = new_class;
1021: }
1022:
1023: /* Place the impostor class in class hash table
1024: and assign it a class number. */
1025: addClassToHash (new_class);
1026:
1027: /* Reinitialize the dispatch tables. */
1028: initialize_dispatch_tables ();
1029:
1030: MUTEX_UNLOCK (runtimeMutex);
1031:
1032: /* Print out class tables if debugging. */
1033: DEBUG_PRINTF ("dump of class tables class_poseAs\n");
1034: debug_dump_classes ();
1035:
1036: return new_class;
1037: }
1038:
1039:
1040: /*
1041: * This routine is given a class and records all of the methods in its class
1042: * structure in the record table.
1043: */
1044: static void
1045: record_methods_from_class (Class_t class)
1046: {
1047: MethodList_t method_list;
1048:
1049:
1050: method_list = class->methods;
1051: while (method_list) {
1052: record_methods_from_list (method_list);
1053: method_list = method_list->method_next;
1054: }
1055: }
1056:
1057:
1058: /*
1059: * This routine is given a list of methods and records each of the methods in
1060: * the record table. This is the routine that does the actual recording
1061: * work.
1062: */
1063: static void
1064: record_methods_from_list (MethodList_t method_list)
1065: {
1066: int i;
1067:
1068:
1069: for (i = 0; i < method_list->method_count; ++i) {
1070: Method_t method = &method_list->method_list[i];
1071:
1072: record_selector (method->method_name);
1073: }
1074: }
1075:
1076:
1077: SEL
1078: sel_getUid (const STR name)
1079: {
1080: int i;
1081:
1082:
1083: for (i = 1; i <= record_entries (selector_record); ++i)
1084: if (!strcmp (name, record_get (i, selector_record)))
1085: return (SEL)i;
1086:
1087: /* Unable to locate selector. Return error value. */
1088: return (SEL)0;
1089: }
1090:
1091:
1092: STR
1093: sel_getName (SEL selector)
1094: {
1095: return record_get ((unsigned int)selector, selector_record);
1096: }
1097:
1098:
1099: /*
1100: * Store the passed selector name in the selector record and return its
1101: * selector value (value returned by sel_getUid).
1102: */
1103: static SEL
1104: record_selector (const char *sel)
1105: {
1106: int j;
1107:
1108:
1109: /* Find either the selector in the table or an empty slot. */
1110: for (j = 1; j <= record_entries (selector_record); ++j)
1111: if (!strcmp (sel, record_get (j, selector_record)))
1112: return (SEL)j;
1113:
1114: /* Save the selector name. */
1115: record_store (my_strdup (sel), selector_record);
1116: DEBUG_PRINTF ("Record: %s as: %#x\n", sel, j);
1117:
1118: return (SEL)j;
1119: }
1120:
1121:
1122: /*
1123: * Initialize the dispatch tables. This requires the initialization of the
1124: * instance_method_record and factory_method_record arrays and the arrays they
1125: * point to.
1126: *
1127: * The first array is indexed by a class number. Therefore its size is the
1128: * number of classes in the executable. The second array is indexed by a
1129: * selector id. Therefore its size is the number of unique selectors in the
1130: * application.
1131: *
1132: * When a method is sent to a object its class number is extracted from the
1133: * class structure and used in the first array. The selector id is used in
1134: * the second. The result value is a method implementation.
1135: */
1136: static void
1137: initialize_dispatch_tables (void)
1138: {
1139: int i;
1140:
1141:
1142: /* Check to make sure things are in place. */
1143: assert (selector_record);
1144:
1145: /* Blow away the instance and factory method records. */
1146: if (factory_method_record) {
1147: for (i = 1; i <= record_entries (factory_method_record); ++i)
1148: record_delete (record_get (i, factory_method_record));
1149: record_delete (factory_method_record);
1150: }
1151: if (instance_method_record) {
1152: for (i = 1; i <= record_entries (instance_method_record); ++i)
1153: record_delete (record_get (i, instance_method_record));
1154: record_delete (instance_method_record);
1155: }
1156:
1157: /* Reallocate the instance and factory method records. */
1158: factory_method_record = record_new ();
1159: instance_method_record = record_new ();
1160: for (i = 1; i <= record_entries (selector_record); ++i) {
1161: record_store (record_new (), factory_method_record);
1162: record_store (record_new (), instance_method_record);
1163: }
1164:
1165: /* Fool all of the secondary records into thinking they have data. */
1166: for (i = 1; i <= record_entries (selector_record); ++i) {
1167: struct record *record;
1168: node_ptr node;
1169:
1170: record = record_get (i, factory_method_record);
1171: for (node = hash_next (module_hash_table, NULL); node;
1172: node = hash_next (module_hash_table, node))
1173: record_store (NULL, record);
1174:
1175: record = record_get (i, instance_method_record);
1176: for (node = hash_next (module_hash_table, NULL); node;
1177: node = hash_next (module_hash_table, node))
1178: record_store (NULL, record);
1179: }
1180:
1181: /* For all classes fill in the methods implemented by the class and visiable
1182: from the class in the hierarchy. Those methods are assigned to the
1183: class. */
1184: for (i = 1; i <= record_entries (selector_record); ++i) { /* i is a sel */
1185: node_ptr node;
1186:
1187: for (node = hash_next (class_hash_table, NULL); node;
1188: node = hash_next (class_hash_table, node)) {
1189: Class_t class = node->value;
1190: MetaClass_t meta_class = class->class_pointer;
1191: int class_number = getClassNumber (class);
1192: Method_t method;
1193:
1194: /* DEBUG_PRINTF ("Assignment of sel=%s, class=%s (%#x, %#x)\n",
1195: sel_getName ((SEL)i), class->name,
1196: searchForMethodInHierarchy (class, (SEL)i),
1197: searchForMethodInHierarchy ((Class_t)meta_class, (SEL)i)); */
1198:
1199: method = searchForMethodInHierarchy (class, (SEL)i);
1200: if (method)
1201: record_store_at (class_number, method->method_imp,
1202: record_get (i, instance_method_record));
1203:
1204: assert (class_number == getClassNumber ((Class_t)class->class_pointer));
1205: method = searchForMethodInHierarchy ((Class_t)meta_class, (SEL)i);
1206: if (method)
1207: record_store_at (class_number, method->method_imp,
1208: record_get (i, factory_method_record));
1209: }
1210: }
1211: }
1212:
1213:
1214: /*
1215: * This method is called by the dispatch routines when a class has not been
1216: * initialized. This method is responsible for initializing the class. This
1217: * is accomplished by first testing the class itself for responding to the
1218: * +initialize method. If such a method is implemented then it is called.
1219: * Before exit, irregardless if the class implements +initialize, the class
1220: * is marked as initialized.
1221: */
1222: static void
1223: initialize_class (const char *name)
1224: {
1225: Method_t method = NULL;
1226: Class_t class = objc_getClass (name);
1227: SEL sel = sel_getUid ("initialize");
1228:
1229:
1230: /* The class should not be initialized at this point. */
1231: assert (!(class->info & CLS_INITIALIZED));
1232: assert (!(class->class_pointer->info & CLS_INITIALIZED));
1233:
1234: /* Search for the +initialize method.
1235: Call it if it exists. */
1236: if (sel)
1237: method = searchForMethodInList (class->class_pointer->methods,
1238: sel_getName (sel));
1239: if (method) {
1240: IMP imp;
1241:
1242: DEBUG_PRINTF ("Class: %s sending +%s\n",
1243: name, sel_getName (sel));
1244: imp = get_imp ((Class_t)class->class_pointer, sel);
1245: assert (imp);
1246: (*imp)((id)class, sel);
1247: }
1248:
1249: /* Mark the class as initialized. */
1250: class->info |= CLS_INITIALIZED;
1251: class->class_pointer->info |= CLS_INITIALIZED;
1252: }
1253:
1254:
1255: /*
1256: * Silly little function that checks to make sure the class hash table is
1257: * initialized. If it isn't initialized then do it.
1258: */
1259: static inline void
1260: class_hash_init (void)
1261: {
1262: static unsigned int init = 0;
1263:
1264:
1265: if (!init)
1266: class_hash_table = hash_new (CLASS_HASH_SIZE,
1267: (hash_func_type)hash_string,
1268: (compare_func_type)compare_strings);
1269: init = 1;
1270: }
1271:
1272:
1273: Class_t
1274: objc_getClass (const char *name)
1275: {
1276: Class_t class;
1277:
1278:
1279: /* Make sure the class hash table exists. */
1280: class_hash_init ();
1281:
1282: class = hash_value_for_key (class_hash_table, name);
1283:
1284: return class;
1285: }
1286:
1287:
1288: MetaClass_t
1289: objc_getMetaClass (const char *name)
1290: {
1291: /* Meta classes are pointed to by the class's class_pointer.
1292: Just get the class and return its class_pointer. */
1293: return (objc_getClass (name))->class_pointer;
1294: }
1295:
1296:
1297: void
1298: addClassToHash (Class_t class)
1299: {
1300: Class_t hClass;
1301:
1302:
1303: class_hash_init ();
1304:
1305: /* Check to see if the class is already in the hash table. */
1306: hClass = hash_value_for_key (class_hash_table, class->name);
1307: if (!hClass) {
1308:
1309: /* The class isn't in the hash table. Add the class and
1310: assign a class number. */
1311: static unsigned int class_number = 1;
1312:
1313: setClassNumber (class, class_number);
1314: setClassNumber ((Class_t)class->class_pointer, class_number);
1315: ++class_number;
1316:
1317: hash_add (&class_hash_table, class->name, class);
1318: }
1319: }
1320:
1321:
1322: void
1323: debug_dump_classes (void)
1324: {
1325: node_ptr node;
1326: int i;
1327:
1328:
1329: DEBUG_PRINTF ("class tables\n");
1330: i = 0;
1331: for (node = hash_next (class_hash_table, NULL); node;
1332: node = hash_next (class_hash_table, node)) {
1333:
1334: Class_t class = node->value;
1335:
1336: DEBUG_PRINTF ("Class { /*%#x*/\n", class);
1337: DEBUG_PRINTF (" MetaClass_t class_pointer = %#x\n", class->class_pointer);
1338: DEBUG_PRINTF (" Class_t super_class = %#x\n", class->super_class);
1339: DEBUG_PRINTF (" char *name = %s\n", class->name);
1340: DEBUG_PRINTF (" long version = %ld\n", class->version);
1341: DEBUG_PRINTF (" long info = %#x\n", class->info);
1342: DEBUG_PRINTF (" long instance_size = %ld\n", class->instance_size);
1343: DEBUG_PRINTF (" IvarList_t ivars = %#x\n", class->ivars);
1344: DEBUG_PRINTF (" MethodList_t methods = %#x\n", class->methods);
1345: DEBUG_PRINTF (" cache_ptr cache = %#x\n", class->cache);
1346: DEBUG_PRINTF ("}[%d];\n", i++);
1347: }
1348:
1349: i = 0;
1350: for (node = hash_next (class_hash_table, NULL); node;
1351: node = hash_next (class_hash_table, node)) {
1352:
1353: Class_t class = (Class_t)((Class_t)(node->value))->class_pointer;
1354:
1355: DEBUG_PRINTF ("MetaClass { /*%#x*/\n", class);
1356: DEBUG_PRINTF (" MetaClass_t class_pointer = %#x\n", class->class_pointer);
1357: DEBUG_PRINTF (" MetaClass_t super_class = %#x\n", class->super_class);
1358: DEBUG_PRINTF (" char *name = %s\n", class->name);
1359: DEBUG_PRINTF (" long version = %ld\n", class->version);
1360: DEBUG_PRINTF (" long info = %#x\n", class->info);
1361: DEBUG_PRINTF (" long instance_size = %ld\n", class->instance_size);
1362: DEBUG_PRINTF (" IvarList_t ivars = %#x\n", class->ivars);
1363: DEBUG_PRINTF (" MethodList_t methods = %#x\n", class->methods);
1364: DEBUG_PRINTF (" cache_ptr cache = %#x\n", class->cache);
1365: DEBUG_PRINTF ("}[%d];\n", i++);
1366: }
1367: }
1368:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.