From 28d87a29cd1ed4ab8f3656f0af8bd2dfeb2c8511 Mon Sep 17 00:00:00 2001 From: mccallum Date: Tue, 28 May 1996 13:37:17 +0000 Subject: [PATCH] Include first! Fix indentation. ([NSLock +initialize]): Method removed. ([NSLock -init]): Assert return value from objc_mutex_allocate(), don't just return nil. ([NSConditionLock -initWithCondition:]): Likewise. ([NSRecursiveLock -init]): Likewise. ([NSConditionLock +initialize]): Method removed. ([NSRecursiveLock +initialize]): Method removed. git-svn-id: svn+ssh://svn.gna.org/svn/gnustep/libs/base/trunk@1566 72102866-910b-0410-8b05-ffd578937521 --- Source/NSLock.m | 297 ++++++++++++++++++++---------------------------- 1 file changed, 125 insertions(+), 172 deletions(-) diff --git a/Source/NSLock.m b/Source/NSLock.m index cc53c6059..26d9d98fe 100644 --- a/Source/NSLock.m +++ b/Source/NSLock.m @@ -1,12 +1,8 @@ -/* - NSLock.m - - Mutual exclusion locking classes - +/* Mutual exclusion locking classes Copyright (C) 1996 Free Software Foundation, Inc. Author: Scott Christley - Date: 1996 + Created: 1996 This file is part of the GNUstep Objective-C Library. @@ -20,284 +16,241 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. - If you are interested in a warranty or support for this source code, - contact Scott Christley for more information. - You should have received a copy of the GNU Library General Public License along with this library; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ +#include #include -// // NSLock class // Simplest lock for protecting critical sections of code -// + @implementation NSLock -// Class initialization -+ (void)initialize -{ - if (self == [NSLock class]) - { - // Initial version - [self setVersion:1]; - } -} - -// Default initializer +// Designated initializer - init { - [super init]; - - // Allocate the mutex from the runtime - mutex = objc_mutex_allocate(); - if (!mutex) - return nil; - else - return self; + [super init]; + + // Allocate the mutex from the runtime + mutex = objc_mutex_allocate(); + NSAssertParameter (mutex); + return self; } -- (void)dealloc +- (void) dealloc { - // Ask the runtime to deallocate the mutex - // If there are outstanding locks then it will block - objc_mutex_deallocate(mutex); - - [super dealloc]; + // Ask the runtime to deallocate the mutex + // If there are outstanding locks then it will block + objc_mutex_deallocate (mutex); + [super dealloc]; } // Try to acquire the lock // Does not block -- (BOOL)tryLock +- (BOOL) tryLock { - // Ask the runtime to acquire a lock on the mutex - if (objc_mutex_trylock(mutex) == -1) - return NO; - else - return YES; + // Ask the runtime to acquire a lock on the mutex + if (objc_mutex_trylock (mutex) == -1) + return NO; + else + return YES; } // NSLocking protocol -- (void)lock +- (void) lock { - // Ask the runtime to acquire a lock on the mutex - // This will block - objc_mutex_lock(mutex); + // Ask the runtime to acquire a lock on the mutex + // This will block + objc_mutex_lock (mutex); } - (void)unlock { - // Ask the runtime to release a lock on the mutex - objc_mutex_unlock(mutex); + // Ask the runtime to release a lock on the mutex + objc_mutex_unlock (mutex); } @end -// + // NSConditionLock -// Allows locking and unlocking to be based upon a condition -// -@implementation NSConditionLock +// Allows locking and unlocking to be based upon an integer condition -// Class initialization -+ (void)initialize -{ - if (self == [NSConditionLock class]) - { - // Initial version - [self setVersion:1]; - } -} +@implementation NSConditionLock - init { - return [self initWithCondition:0]; + return [self initWithCondition: 0]; } -// Default initializer +// Designated initializer // Initialize lock with condition - (id)initWithCondition:(int)value { - [super init]; + [super init]; + + condition = value; - condition = value; - - // Allocate the mutex from the runtime - mutex = objc_mutex_allocate(); - if (!mutex) - return nil; - else - return self; + // Allocate the mutex from the runtime + mutex = objc_mutex_allocate (); + NSParameterAssert (mutex); + return self; } - (void)dealloc { - // Ask the runtime to deallocate the mutex - // If there are outstanding locks then it will block - objc_mutex_deallocate(mutex); - - [super dealloc]; + // Ask the runtime to deallocate the mutex + // If there are outstanding locks then it will block + objc_mutex_deallocate (mutex); + [super dealloc]; } // Return the current condition of the lock - (int)condition { - return condition; + return condition; } // Acquiring and release the lock -- (void)lockWhenCondition:(int)value +- (void) lockWhenCondition: (int)value { - BOOL done; + BOOL done; - done = NO; - while (!done) - { - // Try to get the lock - [self lock]; + done = NO; + while (!done) + { + // Try to get the lock + [self lock]; - // Is it in the condition we are looking for? - if (condition == value) - done = YES; - else - // Release the lock and keep waiting - [self unlock]; - } + // Is it in the condition we are looking for? + if (condition == value) + done = YES; + else + // Release the lock and keep waiting + [self unlock]; + } } -- (void)unlockWithCondition:(int)value +- (void) unlockWithCondition: (int)value { - int depth; + int depth; - // First check to make sure we have the lock - depth= objc_mutex_trylock(mutex); + // First check to make sure we have the lock + depth= objc_mutex_trylock (mutex); - // Another thread has the lock so abort - if (depth == -1) - return; + // Another thread has the lock so abort + if (depth == -1) + return; - // If the depth is only 1 then we just acquired - // the lock above, bogus unlock so abort - if (depth == 1) - return; + // If the depth is only 1 then we just acquired + // the lock above, bogus unlock so abort + if (depth == 1) + return; - // This is a valid unlock so set the condition - // and unlock twice - condition = value; - objc_mutex_unlock(mutex); - objc_mutex_unlock(mutex); + // This is a valid unlock so set the condition + // and unlock twice + condition = value; + objc_mutex_unlock (mutex); + objc_mutex_unlock (mutex); } -- (BOOL)tryLock +- (BOOL) tryLock { - // Ask the runtime to acquire a lock on the mutex - if (objc_mutex_trylock(mutex) == -1) - return NO; - else - return YES; + // Ask the runtime to acquire a lock on the mutex + if (objc_mutex_trylock(mutex) == -1) + return NO; + else + return YES; } -- (BOOL)tryLockWhenCondition:(int)value +- (BOOL) tryLockWhenCondition: (int)value { - // First can we even get the lock? - if (![self tryLock]) - return NO; + // First can we even get the lock? + if (![self tryLock]) + return NO; - // If we got the lock is it the right condition? - if (condition == value) - return YES; - else - { - // Wrong condition so release the lock - [self unlock]; - return NO; - } + // If we got the lock is it the right condition? + if (condition == value) + return YES; + else + { + // Wrong condition so release the lock + [self unlock]; + return NO; + } } // NSLocking protocol // These methods ignore the condition -- (void)lock +- (void) lock { - // Ask the runtime to acquire a lock on the mutex - // This will block - objc_mutex_lock(mutex); + // Ask the runtime to acquire a lock on the mutex + // This will block + objc_mutex_lock (mutex); } - (void)unlock { - // Ask the runtime to release a lock on the mutex - objc_mutex_unlock(mutex); + // Ask the runtime to release a lock on the mutex + objc_mutex_unlock (mutex); } @end -// + // NSRecursiveLock // Allows the lock to be recursively acquired by the same thread // // If the same thread locks the mutex (n) times then that same // thread must also unlock it (n) times before another thread // can acquire the lock. -// -@implementation NSRecursiveLock -// Class initialization -+ (void)initialize -{ - if (self == [NSRecursiveLock class]) - { - // Initial version - [self setVersion:1]; - } -} +@implementation NSRecursiveLock // Default initializer - init { - [super init]; - - // Allocate the mutex from the runtime - mutex = objc_mutex_allocate(); - if (!mutex) - return nil; - else - return self; + [super init]; + // Allocate the mutex from the runtime + mutex = objc_mutex_allocate(); + NSParameterAssert (mutex); + return self; } -- (void)dealloc +- (void) dealloc { - // Ask the runtime to deallocate the mutex - // If there are outstanding locks then it will block. - objc_mutex_deallocate(mutex); - - [super dealloc]; + // Ask the runtime to deallocate the mutex + // If there are outstanding locks then it will block. + objc_mutex_deallocate(mutex); + [super dealloc]; } // Try to acquire the lock // Does not block -- (BOOL)tryLock +- (BOOL) tryLock { - // Ask the runtime to acquire a lock on the mutex - if (objc_mutex_trylock(mutex) == -1) - return NO; - else - return YES; + // Ask the runtime to acquire a lock on the mutex + if (objc_mutex_trylock (mutex) == -1) + return NO; + else + return YES; } // NSLocking protocol -- (void)lock +- (void) lock { - // Ask the runtime to acquire a lock on the mutex - // This will block - objc_mutex_lock(mutex); + // Ask the runtime to acquire a lock on the mutex + // This will block + objc_mutex_lock (mutex); } -- (void)unlock +- (void) unlock { - // Ask the runtime to release a lock onthe mutex - objc_mutex_unlock(mutex); + // Ask the runtime to release a lock onthe mutex + objc_mutex_unlock (mutex); } @end