![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Object.m 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 Object.m CVS log | Up to [GCC 2.x] / gcc / objc |
1.1 root 1: /* The implementation of class Object for Objective-C. 1.1.1.3 ! root 2: Copyright (C) 1993, 1994 Free Software Foundation, Inc. 1.1 root 3: 4: This file is part of GNU CC. 5: 6: GNU CC is free software; you can redistribute it and/or modify it 7: under the terms of the GNU General Public License as published by the 8: Free Software Foundation; either version 2, or (at your option) any 9: later version. 10: 11: GNU CC is distributed in the hope that it will be useful, but WITHOUT 12: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13: or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public 14: 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 compiled 21: with GCC to produce an executable, this does not cause the resulting 22: executable to be covered by the GNU General Public License. This 23: exception does not however invalidate any other reasons why the 24: executable file might be covered by the GNU General Public License. */ 25: 1.1.1.3 ! root 26: #include <stdarg.h> 1.1 root 27: #include "objc/Object.h" 28: #include "objc/Protocol.h" 29: #include "objc/objc-api.h" 30: 31: extern void (*_objc_error)(id object, const char *format, va_list); 32: 33: extern int errno; 34: 35: #define MAX_CLASS_NAME_LEN 256 36: 37: @implementation Object 38: 39: + initialize 40: { 41: return self; 42: } 43: 44: - init 45: { 46: return self; 47: } 48: 49: + new 50: { 51: return [[self alloc] init]; 52: } 53: 54: + alloc 55: { 56: return class_create_instance(self); 57: } 58: 59: - free 60: { 61: return object_dispose(self); 62: } 63: 64: - copy 65: { 66: return [[self shallowCopy] deepen]; 67: } 68: 69: - shallowCopy 70: { 71: return object_copy(self); 72: } 73: 74: - deepen 75: { 76: return self; 77: } 78: 79: - deepCopy 80: { 81: return [self copy]; 82: } 83: 84: - (Class*)class 85: { 86: return object_get_class(self); 87: } 88: 89: - (Class*)superClass 90: { 91: return object_get_super_class(self); 92: } 93: 94: - (MetaClass*)metaClass 95: { 96: return object_get_meta_class(self); 97: } 98: 99: - (const char *)name 100: { 101: return object_get_class_name(self); 102: } 103: 104: - self 105: { 106: return self; 107: } 108: 109: - (unsigned int)hash 110: { 111: return (size_t)self; 112: } 113: 114: - (BOOL)isEqual:anObject 115: { 116: return self==anObject; 117: } 118: 1.1.1.2 root 119: - (int)compare:anotherObject; 120: { 121: if ([self isEqual:anotherObject]) 122: return 0; 123: // Ordering objects by their address is pretty useless, 124: // so subclasses should override this is some useful way. 125: else if (self > anotherObject) 126: return 1; 127: else 128: return -1; 129: } 130: 1.1 root 131: - (BOOL)isMetaClass 132: { 133: return NO; 134: } 135: 136: - (BOOL)isClass 137: { 138: return object_is_class(self); 139: } 140: 141: - (BOOL)isInstance 142: { 143: return object_is_instance(self); 144: } 145: 146: - (BOOL)isKindOf:(Class*)aClassObject 147: { 148: Class* class; 149: 150: for (class = self->isa; class!=Nil; class = class_get_super_class(class)) 151: if (class==aClassObject) 152: return YES; 153: return NO; 154: } 155: 156: - (BOOL)isMemberOf:(Class*)aClassObject 157: { 158: return self->isa==aClassObject; 159: } 160: 161: - (BOOL)isKindOfClassNamed:(const char *)aClassName 162: { 163: Class* class; 164: 165: if (aClassName!=NULL) 166: for (class = self->isa; class!=Nil; class = class_get_super_class(class)) 167: if (!strcmp(class_get_class_name(class), aClassName)) 168: return YES; 169: return NO; 170: } 171: 172: - (BOOL)isMemberOfClassNamed:(const char *)aClassName 173: { 174: return ((aClassName!=NULL) 175: &&!strcmp(class_get_class_name(self->isa), aClassName)); 176: } 177: 178: + (BOOL)instancesRespondTo:(SEL)aSel 179: { 180: return class_get_instance_method(self, aSel)!=METHOD_NULL; 181: } 182: 183: - (BOOL)respondsTo:(SEL)aSel 184: { 185: return ((object_is_instance(self) 186: ?class_get_instance_method(self->isa, aSel) 187: :class_get_class_method(self->isa, aSel))!=METHOD_NULL); 188: } 189: 190: + (IMP)instanceMethodFor:(SEL)aSel 191: { 192: return method_get_imp(class_get_instance_method(self, aSel)); 193: } 194: 195: // Indicates if the receiving class or instance conforms to the given protocol 196: // not usually overridden by subclasses 1.1.1.3 ! root 197: // ! 198: // Modified 9/5/94 to always search the class object's protocol list, rather ! 199: // than the meta class. ! 200: ! 201: + (BOOL) conformsTo: (Protocol*)aProtocol 1.1 root 202: { 203: int i; 204: struct objc_protocol_list* proto_list; 1.1.1.3 ! root 205: id parent; 1.1 root 206: 1.1.1.3 ! root 207: for (proto_list = ((Class*)self)->protocols; 1.1 root 208: proto_list; proto_list = proto_list->next) 209: { 210: for (i=0; i < proto_list->count; i++) 211: { 212: if ([proto_list->list[i] conformsTo: aProtocol]) 213: return YES; 214: } 215: } 216: 1.1.1.3 ! root 217: if (parent = [self superClass]) ! 218: return [parent conformsTo: aProtocol]; 1.1 root 219: else 220: return NO; 221: } 222: 1.1.1.3 ! root 223: - (BOOL) conformsTo: (Protocol*)aProtocol ! 224: { ! 225: return [[self class] conformsTo:aProtocol]; ! 226: } ! 227: 1.1 root 228: - (IMP)methodFor:(SEL)aSel 229: { 230: return (method_get_imp(object_is_instance(self) 231: ?class_get_instance_method(self->isa, aSel) 232: :class_get_class_method(self->isa, aSel))); 233: } 234: 235: + (struct objc_method_description *)descriptionForInstanceMethod:(SEL)aSel 236: { 237: return ((struct objc_method_description *) 238: class_get_instance_method(self, aSel)); 239: } 240: 241: - (struct objc_method_description *)descriptionForMethod:(SEL)aSel 242: { 243: return ((struct objc_method_description *) 244: (object_is_instance(self) 245: ?class_get_instance_method(self->isa, aSel) 246: :class_get_class_method(self->isa, aSel))); 247: } 248: 249: - perform:(SEL)aSel 250: { 251: IMP msg = objc_msg_lookup(self, aSel); 252: if (!msg) 253: return [self error:"invalid selector passed to %s", sel_get_name(_cmd)]; 254: return (*msg)(self, aSel); 255: } 256: 257: - perform:(SEL)aSel with:anObject 258: { 259: IMP msg = objc_msg_lookup(self, aSel); 260: if (!msg) 261: return [self error:"invalid selector passed to %s", sel_get_name(_cmd)]; 262: return (*msg)(self, aSel, anObject); 263: } 264: 265: - perform:(SEL)aSel with:anObject1 with:anObject2 266: { 267: IMP msg = objc_msg_lookup(self, aSel); 268: if (!msg) 269: return [self error:"invalid selector passed to %s", sel_get_name(_cmd)]; 270: return (*msg)(self, aSel, anObject1, anObject2); 271: } 272: 1.1.1.3 ! root 273: - (retval_t)forward:(SEL)aSel :(arglist_t)argFrame 1.1 root 274: { 1.1.1.3 ! root 275: return (retval_t)[self doesNotRecognize: aSel]; 1.1 root 276: } 277: 1.1.1.3 ! root 278: - (retval_t)performv:(SEL)aSel :(arglist_t)argFrame 1.1 root 279: { 1.1.1.2 root 280: return objc_msg_sendv(self, aSel, argFrame); 1.1 root 281: } 282: 283: + poseAs:(Class*)aClassObject 284: { 285: return class_pose_as(self, aClassObject); 286: } 287: 288: - (Class*)transmuteClassTo:(Class*)aClassObject 289: { 290: if (object_is_instance(self)) 291: if (class_is_class(aClassObject)) 292: if (class_get_instance_size(aClassObject)==class_get_instance_size(isa)) 293: if ([self isKindOf:aClassObject]) 294: { 295: Class* old_isa = isa; 296: isa = aClassObject; 297: return old_isa; 298: } 299: return nil; 300: } 301: 302: - subclassResponsibility:(SEL)aSel 303: { 304: return [self error:"subclass should override %s", sel_get_name(aSel)]; 305: } 306: 307: - notImplemented:(SEL)aSel 308: { 309: return [self error:"method %s not implemented", sel_get_name(aSel)]; 310: } 311: 1.1.1.2 root 312: - shouldNotImplement:(SEL)aSel 313: { 314: return [self error:"%s should not implement %s", 315: object_get_class_name(self), sel_get_name(aSel)]; 316: } 317: 1.1 root 318: - doesNotRecognize:(SEL)aSel 319: { 320: return [self error:"%s does not recognize %s", 321: object_get_class_name(self), sel_get_name(aSel)]; 322: } 323: 1.1.1.3 ! root 324: #ifdef __alpha__ ! 325: extern size_t strlen(const char*); ! 326: #endif ! 327: 1.1 root 328: - error:(const char *)aString, ... 329: { 330: #define FMT "error: %s (%s)\n%s\n" 331: char fmt[(strlen((char*)FMT)+strlen((char*)object_get_class_name(self)) 332: +((aString!=NULL)?strlen((char*)aString):0)+8)]; 333: va_list ap; 334: 335: sprintf(fmt, FMT, object_get_class_name(self), 336: object_is_instance(self)?"instance":"class", 337: (aString!=NULL)?aString:""); 338: va_start(ap, aString); 339: (*_objc_error)(self, fmt, ap); 340: va_end(ap); 341: return nil; 342: #undef FMT 343: } 344: 345: + (int)version 346: { 347: return class_get_version(self); 348: } 349: 350: + setVersion:(int)aVersion 351: { 352: class_set_version(self, aVersion); 353: return self; 354: } 355: 356: + (int)streamVersion: (TypedStream*)aStream 357: { 358: if (aStream->mode == OBJC_READONLY) 359: return objc_get_stream_class_version (aStream, self); 360: else 361: return class_get_version (self); 362: } 363: 364: // These are used to write or read the instance variables 365: // declared in this particular part of the object. Subclasses 366: // should extend these, by calling [super read/write: aStream] 367: // before doing their own archiving. These methods are private, in 368: // the sense that they should only be called from subclasses. 369: 370: - read: (TypedStream*)aStream 371: { 372: // [super read: aStream]; 373: return self; 374: } 375: 376: - write: (TypedStream*)aStream 377: { 378: // [super write: aStream]; 379: return self; 380: } 381: 382: - awake 383: { 384: // [super awake]; 385: return self; 386: } 387: 388: @end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.