gnustep/libs-base
0
0
Fork 0
mirror of https://github.com/gnustep/libs-base.git synced 2025-04-27 10:40:50 +00:00
Code Issues Projects Releases Packages Wiki Activity
libs-base/Source/Additions/NSObject+GNUstepBase.m

981 lines
22 KiB
Objective-C
Raw Blame History

/* Implementation of extension methods to base additions
Copyright (C) 2010 Free Software Foundation, Inc.
Written by: Richard Frith-Macdonald <rfm@gnu.org>
This file is part of the GNUstep Base Library.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free
Software Foundation, Inc., 31 Milk Street #960789 Boston, MA 02196 USA.
*/
#import "common.h"
#import "GSPThread.h"
#import "Foundation/NSArray.h"
#import "Foundation/NSException.h"
#import "Foundation/NSHashTable.h"
#import "Foundation/NSLock.h"
#import "GNUstepBase/GSObjCRuntime.h"
#import "GNUstepBase/NSObject+GNUstepBase.h"
#import "GNUstepBase/NSDebug+GNUstepBase.h"
#import "GNUstepBase/NSThread+GNUstepBase.h"
#ifdef HAVE_MALLOC_H
#include <malloc.h>
#endif
/* This file contains methods which nominally return an id but in fact
* always rainse an exception and never return.
* We need to suppress the compiler warning about that.
*/
#pragma GCC diagnostic ignored "-Wreturn-type"
/**
* Extension methods for the NSObject class
*/
@implementation NSObject (GNUstepBase)
+ (id) notImplemented: (SEL)selector
{
[NSException raise: NSGenericException
format: @"method %@ not implemented in %@(class)",
selector ? (id)NSStringFromSelector(selector) : (id)@"(null)",
NSStringFromClass(self)];
while (1) ; // Does not return
}
- (NSComparisonResult) compare: (id)anObject
{
NSLog(@"WARNING: The -compare: method for NSObject is deprecated.");
if (anObject == self)
{
return NSOrderedSame;
}
if (anObject == nil)
{
[NSException raise: NSInvalidArgumentException
format: @"nil argument for compare:"];
}
if ([self isEqual: anObject])
{
return NSOrderedSame;
}
/*
* Ordering objects by their address is pretty useless,
* so subclasses should override this is some useful way.
*/
if ((id)self > anObject)
{
return NSOrderedDescending;
}
else
{
return NSOrderedAscending;
}
}
- (BOOL) isInstance
{
GSOnceMLog(@"Warning, the -isInstance method is deprecated. "
@"Use 'class_isMetaClass([self class]) ? NO : YES' instead");
return class_isMetaClass([self class]) ? NO : YES;
}
- (BOOL) makeImmutable
{
return NO;
}
- (id) makeImmutableCopyOnFail: (BOOL)force
{
if (force == YES)
{
return AUTORELEASE([self copy]);
}
return self;
}
- (id) notImplemented: (SEL)aSel
{
char c = (class_isMetaClass(object_getClass(self)) ? '+' : '-');
[NSException
raise: NSInvalidArgumentException
format: @"[%@%c%@] not implemented",
NSStringFromClass([self class]), c,
aSel ? (id)NSStringFromSelector(aSel) : (id)@"(null)"];
while (1) ; // Does not return
}
- (id) shouldNotImplement: (SEL)aSel
{
char c = (class_isMetaClass(object_getClass(self)) ? '+' : '-');
[NSException
raise: NSInvalidArgumentException
format: @"[%@%c%@] should not be implemented",
NSStringFromClass([self class]), c,
aSel ? (id)NSStringFromSelector(aSel) : (id)@"(null)"];
while (1) ; // Does not return
}
- (id) subclassResponsibility: (SEL)aSel
{
char c = (class_isMetaClass(object_getClass(self)) ? '+' : '-');
[NSException raise: NSInvalidArgumentException
format: @"[%@%c%@] should be overridden by subclass",
NSStringFromClass([self class]), c,
aSel ? (id)NSStringFromSelector(aSel) : (id)@"(null)"];
while (1) ; // Does not return
}
@end
#if defined(GNUSTEP)
@interface NSAutoreleasePool (NSThread)
+ (void) _endThread: (NSThread*)thread;
@end
struct exitLink {
struct exitLink *next;
id obj; // Object to release or class for atExit
SEL sel; // Selector for atExit or 0 if releasing
id *at; // Address of static variable or NULL
};
static struct exitLink *exited = 0;
static gs_mutex_t exitLock = GS_MUTEX_INIT_STATIC;
static BOOL enabled = NO;
static BOOL shouldCleanUp = NO;
static BOOL isExiting = NO;
struct trackLink {
struct trackLink *next;
id object; // Instance or Class being tracked.
IMP dealloc; // Original -dealloc implementation
IMP release; // Original -release implementation
IMP retain; // Original -retain implementation
BOOL global; // If all instance are tracked.
BOOL instance; // If the object is an instance.
};
static struct trackLink *tracked = 0;
static gs_mutex_t trackLock = GS_MUTEX_INIT_STATIC;
static void
handleExit()
{
BOOL unknownThread;
isExiting = YES;
/* We turn off zombies during exiting so that we don't leak deallocated
* objects during cleanup.
*/
// NSZombieEnabled = NO;
unknownThread = GSRegisterCurrentThread();
ENTER_POOL
while (exited != 0)
{
struct exitLink *tmp = exited;
exited = tmp->next;
if (0 != tmp->sel)
{
Method method;
IMP msg;
if (shouldCleanUp)
{
fprintf(stderr, "*** clean-up +[%s %s]\n",
class_getName(tmp->obj), sel_getName(tmp->sel));
}
method = class_getClassMethod(tmp->obj, tmp->sel);
msg = method_getImplementation(method);
if (0 != msg)
{
(*msg)(tmp->obj, tmp->sel);
}
}
else if (shouldCleanUp)
{
if (tmp->at)
{
if (tmp->obj != *(tmp->at))
{
fprintf(stderr,
"*** clean-up kept value %p at %p changed to %p\n",
tmp->obj, (const void*)tmp->at, *(tmp->at));
tmp->obj = *(tmp->at);
}
*(tmp->at) = nil;
}
fprintf(stderr, "*** clean-up -[%s release] %p %p\n",
class_getName(object_getClass(tmp->obj)),
tmp->obj, (const void*)tmp->at);
[tmp->obj release];
}
free(tmp);
}
LEAVE_POOL
if (unknownThread == YES)
{
GSUnregisterCurrentThread();
}
else
{
[[NSAutoreleasePool currentPool] dealloc];
[NSAutoreleasePool _endThread: GSCurrentThread()];
}
/* Exit/clean-up done ... we can get rid of tracking data too.
*/
if (tracked)
{
GS_MUTEX_LOCK(trackLock);
while (tracked)
{
struct trackLink *next = tracked->next;
if (tracked->instance)
{
fprintf(stderr, "Tracking ownership -[%p dealloc]"
" not called by exit.\n", tracked->object);
}
free(tracked);
tracked = next;
}
GS_MUTEX_UNLOCK(trackLock);
}
isExiting = NO;
}
static inline void
enable()
{
if (NO == enabled)
{
atexit(handleExit);
enabled = YES;
}
}
@implementation NSObject(GSCleanUp)
+ (BOOL) isExiting
{
return isExiting;
}
+ (id) keep: (id)anObject at: (id*)anAddress
{
struct exitLink *l;
if (isExiting)
{
if (anAddress)
{
[*anAddress release];
*anAddress = nil;
}
return nil;
}
NSAssert([anObject isKindOfClass: [NSObject class]],
NSInvalidArgumentException);
NSAssert(anAddress != NULL, NSInvalidArgumentException);
NSAssert(*anAddress == nil, NSInvalidArgumentException);
GS_MUTEX_LOCK(exitLock);
for (l = exited; l != NULL; l = l->next)
{
if (l->at == anAddress)
{
GS_MUTEX_UNLOCK(exitLock);
[NSException raise: NSInvalidArgumentException
format: @"Repeated use of leak address %p", anAddress];
}
if (anObject != nil && anObject == l->obj)
{
GS_MUTEX_UNLOCK(exitLock);
[NSException raise: NSInvalidArgumentException
format: @"Repeated use of leak object %p", anObject];
}
}
ASSIGN(*anAddress, anObject);
l = (struct exitLink*)malloc(sizeof(struct exitLink));
l->at = anAddress;
l->obj = anObject;
l->sel = 0;
l->next = exited;
exited = l;
enable();
GS_MUTEX_UNLOCK(exitLock);
return l->obj;
}
+ (id) leakAt: (id*)anAddress
{
struct exitLink *l;
l = (struct exitLink*)malloc(sizeof(struct exitLink));
l->at = anAddress;
l->obj = [*anAddress retain];
l->sel = 0;
GS_MUTEX_LOCK(exitLock);
l->next = exited;
exited = l;
enable();
GS_MUTEX_UNLOCK(exitLock);
return l->obj;
}
+ (id) leak: (id)anObject
{
struct exitLink *l;
if (nil == anObject || isExiting)
{
return nil;
}
GS_MUTEX_LOCK(exitLock);
for (l = exited; l != NULL; l = l->next)
{
if (l->obj == anObject || (l->at != NULL && *l->at == anObject))
{
GS_MUTEX_UNLOCK(exitLock);
[NSException raise: NSInvalidArgumentException
format: @"Repeated use of leak object %p", anObject];
}
}
l = (struct exitLink*)malloc(sizeof(struct exitLink));
l->at = 0;
l->obj = [anObject retain];
l->sel = 0;
l->next = exited;
exited = l;
enable();
GS_MUTEX_UNLOCK(exitLock);
return l->obj;
}
+ (BOOL) registerAtExit
{
return [self registerAtExit: @selector(atExit)];
}
+ (BOOL) registerAtExit: (SEL)sel
{
Method m;
Class s;
struct exitLink *l;
if (0 == sel)
{
sel = @selector(atExit);
}
m = class_getClassMethod(self, sel);
if (0 == m)
{
return NO; // method not implemented.
}
s = class_getSuperclass(self);
if (0 != s && class_getClassMethod(s, sel) == m)
{
return NO; // method not implemented in this class
}
GS_MUTEX_LOCK(exitLock);
for (l = exited; l != 0; l = l->next)
{
if (l->obj == self)
{
if (sel_isEqual(l->sel, sel))
{
fprintf(stderr,
"*** +[%s registerAtExit: %s] already registered for %s.\n",
class_getName(self), sel_getName(sel), sel_getName(l->sel));
GS_MUTEX_UNLOCK(exitLock);
return NO; // Already registered
}
}
}
l = (struct exitLink*)malloc(sizeof(struct exitLink));
l->obj = self;
l->sel = sel;
l->at = 0;
l->next = exited;
exited = l;
enable();
GS_MUTEX_UNLOCK(exitLock);
return YES;
}
+ (void) setShouldCleanUp: (BOOL)aFlag
{
if (YES == aFlag)
{
if (NO == enabled)
{
GS_MUTEX_LOCK(exitLock);
enable();
GS_MUTEX_UNLOCK(exitLock);
}
shouldCleanUp = YES;
}
else
{
shouldCleanUp = NO;
}
}
+ (BOOL) shouldCleanUp
{
return shouldCleanUp;
}
static inline const char *
stackTrace(unsigned skip)
{
NSArray *a = [NSThread callStackSymbols];
if ([a count] > skip)
{
a = [a subarrayWithRange: NSMakeRange(skip, [a count] - skip)];
}
return [[a description] UTF8String];
}
static inline struct trackLink *
find(id o)
{
struct trackLink *l = tracked;
while (l)
{
if (l->object == o)
{
return l;
}
l = l->next;
}
return NULL;
}
static inline struct trackLink *
findSuper(Class c)
{
while ((c = class_getSuperclass(c)) != Nil)
{
struct trackLink *l = find((id)c);
if (l)
{
return l;
}
}
return NULL;
}
/* Lookup the object in the tracking list.
* If found as a tracked instance or found as an instance of a class for which
* all instances are tracked, return YES. Otherwise return NO (should not log).
*/
static BOOL
findMethods(id o, IMP *dea, IMP *rel, IMP *ret)
{
struct trackLink *l;
Class c;
GS_MUTEX_LOCK(trackLock);
l = find(o);
if (l)
{
*dea = l->dealloc;
*rel = l->release;
*ret = l->retain;
GS_MUTEX_UNLOCK(trackLock);
return YES;
}
c = object_getClass(o);
l = find((id)c);
if (0 == l)
{
Class s = c;
while (0 == l && (s = class_getSuperclass(s)))
{
l = find((id)s);
}
}
if (l)
{
BOOL all;
*dea = l->dealloc;
*rel = l->release;
*ret = l->retain;
all = l->global;
GS_MUTEX_UNLOCK(trackLock);
return all;
}
GS_MUTEX_UNLOCK(trackLock);
fprintf(stderr, "Tracking ownership - unable to find entry for"
" instance %p of '%s'.\n", o, class_getName(c));
fprintf(stderr, "Tracking ownership %p problem at %s.\n",
o, stackTrace(1));
/* Should never happen because we don't remove class entries, but I suppose
* someone could call the replacement methods directly. The best we can do
* is return the superclass implementation.
*/
*dea = [class_getSuperclass(c) instanceMethodForSelector: @selector(dealloc)];
*rel = [class_getSuperclass(c) instanceMethodForSelector: @selector(release)];
*ret = [class_getSuperclass(c) instanceMethodForSelector: @selector(retain)];
return NO;
}
- (void) _replacementDealloc
{
IMP dealloc = 0;
IMP retain = 0;
IMP release = 0;
if (findMethods(self, &dealloc, &release, &retain) == NO)
{
/* Not a tracked instance ... dealloc without logging.
*/
(*dealloc)(self, _cmd);
}
else
{
struct trackLink *l;
/* If there's a link for tracking this specific instance, remove it.
*/
GS_MUTEX_LOCK(trackLock);
if ((l = tracked) != 0)
{
if (YES == l->instance && l->object == self)
{
tracked = l->next;
free(l);
}
else
{
struct trackLink *n;
while ((n = l->next) != 0)
{
if (YES == n->instance && n->object == self)
{
l->next = n->next;
free(n);
break;
}
l = n;
}
}
}
GS_MUTEX_UNLOCK(trackLock);
fprintf(stderr, "Tracking ownership -[%p dealloc] at %s.\n",
self, stackTrace(2));
(*dealloc)(self, _cmd);
}
}
- (void) _replacementRelease
{
IMP dealloc = 0;
IMP retain = 0;
IMP release = 0;
if (findMethods(self, &dealloc, &release, &retain) == NO)
{
/* Not a tracked instance ... release without logging.
*/
(*release)(self, _cmd);
}
else
{
unsigned rc;
rc = (unsigned)[self retainCount];
fprintf(stderr, "Tracking ownership -[%p release] %u->%u at %s.\n",
self, rc, rc-1, stackTrace(2));
(*release)(self, _cmd);
}
}
- (id) _replacementRetain
{
IMP dealloc = 0;
IMP retain = 0;
IMP release = 0;
id result;
if (findMethods(self, &dealloc, &release, &retain) == NO)
{
/* Not a tracked instance ... retain without logging.
*/
result = (*retain)(self, _cmd);
}
else
{
unsigned rc;
rc = (unsigned)[self retainCount];
result = (*retain)(self, _cmd);
fprintf(stderr, "Tracking ownership -[%p retain] %u->%u at %s.\n",
self, rc, (unsigned)[self retainCount], stackTrace(2));
}
return result;
}
static struct trackLink*
makeLinkForClass(Class c)
{
Method replacementDealloc;
Method replacementRelease;
Method replacementRetain;
IMP idea;
IMP irel;
IMP iret;
const char *tdea;
const char *trel;
const char *tret;
struct trackLink *l;
struct trackLink *s = findSuper(c);
replacementDealloc = class_getInstanceMethod([NSObject class],
@selector(_replacementDealloc));
replacementRelease = class_getInstanceMethod([NSObject class],
@selector(_replacementRelease));
replacementRetain = class_getInstanceMethod([NSObject class],
@selector(_replacementRetain));
idea = method_getImplementation(replacementDealloc);
irel = method_getImplementation(replacementRelease);
iret = method_getImplementation(replacementRetain);
tdea = method_getTypeEncoding(replacementDealloc);
trel = method_getTypeEncoding(replacementRelease);
tret = method_getTypeEncoding(replacementRetain);
l = (struct trackLink*)malloc(sizeof(struct trackLink));
l->object = c;
l->instance = NO;
l->global = NO;
/* The new methods must be *added* to the specific class unless it already
* implementes them, in which case we can just change the implementation.
*/
l->dealloc = class_getMethodImplementation(c, @selector(dealloc));
if (l->dealloc != idea)
{
if (!class_addMethod(c, @selector(dealloc), idea, tdea))
{
method_setImplementation(
class_getInstanceMethod(c, @selector(dealloc)), idea);
}
}
else
{
l->dealloc = s->dealloc; // Already overridden in superclass
}
l->release = class_getMethodImplementation(c, @selector(release));
if (l->release != irel)
{
if (!class_addMethod(c, @selector(release), irel, trel))
{
method_setImplementation(
class_getInstanceMethod(c, @selector(release)), irel);
}
}
else
{
l->release = s->release; // Already overridden in superclass
}
l->retain = class_getMethodImplementation(c, @selector(retain));
if (l->retain != iret)
{
if (!class_addMethod(c, @selector(retain), iret, tret))
{
method_setImplementation(
class_getInstanceMethod(c, @selector(retain)), iret);
}
}
else
{
l->retain = s->retain; // Already overridden in superclass
}
/*
fprintf(stderr, "Tracking ownership add class %p %s %p->%p, %p->%p, %p->%p\n",
c, class_getName(c), l->dealloc, idea, l->release, irel, l->retain, iret);
*/
return l;
}
+ (void) trackOwnership
{
Class c = self;
struct trackLink *l;
NSAssert(NO == class_isMetaClass(object_getClass(self)),
NSInternalInconsistencyException);
GS_MUTEX_LOCK(trackLock);
if ((l = find((id)c)) != 0)
{
/* Class already tracked. Set it so all instances are logged.
*/
l->global = YES;
GS_MUTEX_UNLOCK(trackLock);
return;
}
l = makeLinkForClass(c);
l->global = YES;
l->next = tracked;
tracked = l;
GS_MUTEX_UNLOCK(trackLock);
fprintf(stderr, "Tracking ownership started for class %p at %s.\n",
self, stackTrace(1));
}
- (void) trackOwnership
{
Class c = object_getClass(self);
struct trackLink *l;
struct trackLink *lc;
struct trackLink *li;
NSAssert(NO == class_isMetaClass(c), NSInternalInconsistencyException);
/* If we are tracking allocation and deallocation, we want to log
* the existence of tracked instances at exit so we need to have
* exit handling turned on.
*/
if (NO == enabled)
{
GS_MUTEX_LOCK(exitLock);
enable();
GS_MUTEX_UNLOCK(exitLock);
}
GS_MUTEX_LOCK(trackLock);
if ((l = find(self)) != 0)
{
/* Instance already tracked.
*/
GS_MUTEX_UNLOCK(trackLock);
return;
}
if ((l = find(c)) != 0)
{
/* The class already has tracking set up.
*/
if (l->global)
{
/* All instances are logged, so we have nothing to do.
*/
GS_MUTEX_UNLOCK(trackLock);
return;
}
lc = l;
}
else
{
/* Set this class up for tracking individual instances.
*/
lc = makeLinkForClass(c);
lc->global = NO;
lc->next = tracked;
tracked = lc;
}
/* Now set up a record to track this one instance.
*/
li = (struct trackLink*)malloc(sizeof(struct trackLink));
li->object = self;
li->instance = YES;
li->global = NO;
li->dealloc = lc->dealloc;
li->release = lc->release;
li->retain = lc->retain;
li->next = tracked;
tracked = li;
GS_MUTEX_UNLOCK(trackLock);
fprintf(stderr, "Tracking ownership started for instance %p at %s.\n",
self, stackTrace(1));
}
@end
#else
@implementation NSObject (MemoryFootprint)
+ (NSUInteger) contentSizeOf: (NSObject*)obj
excluding: (NSHashTable*)exclude
{
Class cls = object_getClass(obj);
NSUInteger size = 0;
while (cls != Nil)
{
unsigned count;
Ivar *vars;
if (0 != (vars = class_copyIvarList(cls, &count)))
{
while (count-- > 0)
{
const char *type = ivar_getTypeEncoding(vars[count]);
type = GSSkipTypeQualifierAndLayoutInfo(type);
if ('@' == *type)
{
NSObject *content = object_getIvar(obj, vars[count]);
if (content != nil)
{
size += [content sizeInBytesExcluding: exclude];
}
}
}
free(vars);
}
cls = class_getSuperclass(cls);
}
return size;
}
+ (NSUInteger) sizeInBytes
{
return 0;
}
+ (NSUInteger) sizeInBytesExcluding: (NSHashTable*)exclude
{
return 0;
}
+ (NSUInteger) sizeOfContentExcluding: (NSHashTable*)exclude
{
return 0;
}
+ (NSUInteger) sizeOfInstance
{
return 0;
}
- (NSUInteger) sizeInBytes
{
NSUInteger bytes;
NSHashTable *exclude;
exclude = NSCreateHashTable(NSNonOwnedPointerHashCallBacks, 0);
bytes = [self sizeInBytesExcluding: exclude];
NSFreeHashTable(exclude);
return bytes;
}
- (NSUInteger) sizeInBytesExcluding: (NSHashTable*)exclude
{
if (0 == NSHashGet(exclude, self))
{
NSUInteger size = [self sizeOfInstance];
NSHashInsert(exclude, self);
if (size > 0)
{
size += [self sizeOfContentExcluding: exclude];
}
return size;
}
return 0;
}
- (NSUInteger) sizeOfContentExcluding: (NSHashTable*)exclude
{
return 0;
}
- (NSUInteger) sizeOfInstance
{
NSUInteger size;
#if GS_SIZEOF_VOIDP > 4
NSUInteger xxx = (NSUInteger)(void*)self;
if (xxx & 0x07)
{
return 0; // Small object has no size
}
#endif
#if HAVE_MALLOC_USABLE_SIZE
size = malloc_usable_size((void*)self - sizeof(intptr_t));
#else
size = class_getInstanceSize(object_getClass(self));
#endif
return size;
}
@end
/* Dummy implementation
*/
@implementation NSObject(GSCleanUp)
+ (id) keep: (id)anObject at: (id*)anAddress
{
ASSIGN(*anAddress, anObject);
return *anAddress;
}
+ (id) leakAt: (id*)anAddress
{
[*anAddress retain];
}
+ (id) leak: (id)anObject
{
return [anObject retain];
}
+ (BOOL) registerAtExit
{
return [self registerAtExit: @selector(atExit)];
}
+ (BOOL) registerAtExit: (SEL)sel
{
return NO;
}
+ (void) setShouldCleanUp: (BOOL)aFlag
{
return;
}
+ (BOOL) shouldCleanUp
{
return NO;
}
@end
#endif
Reference in a new issue View git blame Copy permalink