#import "common.h"

#define EXPOSE_NSRunLoop_IVARS 1

#define EXPOSE_NSTimer_IVARS 1

#import "Foundation/NSMapTable.h"

#import "Foundation/NSDate.h"

#import "Foundation/NSValue.h"

#import "Foundation/NSAutoreleasePool.h"

#import "Foundation/NSPort.h"

#import "Foundation/NSTimer.h"

#import "Foundation/NSNotification.h"

#import "Foundation/NSNotificationQueue.h"

#import "Foundation/NSRunLoop.h"

#import "Foundation/NSStream.h"

#import "Foundation/NSThread.h"

#import "Foundation/NSInvocation.h"

#import "GSRunLoopCtxt.h"

#import "GSRunLoopWatcher.h"

#import "GSStream.h"

#import "GSPrivate.h"

#ifdef HAVE_SYS_TYPES_H

#include <sys/types.h>

#endif

#ifdef HAVE_SYS_TIME_H

#include <sys/time.h>

#endif

#ifdef HAVE_POLL_F

#include <poll.h>

#endif

#include <math.h>

#include <time.h>

#if GS_USE_LIBDISPATCH_RUNLOOP

# define RL_INTEGRATE_DISPATCH 1

# ifdef HAVE_DISPATCH_H

# include <dispatch.h>

# elif HAVE_DISPATCH_PRIVATE_H

# include <dispatch/private.h>

# elif HAVE_DISPATCH_DISPATCH_H

# include <dispatch/dispatch.h>

# endif

#endif

NSRunLoopMode const NSDefaultRunLoopMode = @"NSDefaultRunLoopMode";

NSRunLoopMode const NSRunLoopCommonModes = @"NSRunLoopCommonModes";

static NSDate *theFuture = nil;

@interface NSObject (OptionalPortRunLoop)

- (void) getFds: (NSInteger*)fds count: (NSInteger*)count;



@interface GSRunLoopPerformer: NSObject

{

SEL selector;

id target;

id argument;

unsigned order;

}

- (void) fire;

- (id) initWithSelector: (SEL)aSelector

target: (id)target

argument: (id)argument

order: (NSUInteger)order;

@implementation GSRunLoopPerformer

- (void) dealloc

{

RELEASE(target);

RELEASE(argument);

[super dealloc];

}

- (void) fire

{

NS_DURING

{

[target performSelector: selector withObject: argument];

}

NS_HANDLER

{

NSLog(@"*** NSRunLoop ignoring exception '%@' (reason '%@') "

@"raised during performSelector... with target %s(%s) "

@"and selector '%s'",

[localException name], [localException reason],

GSClassNameFromObject(target),

GSObjCIsInstance(target) ? "instance" : "class",

sel_getName(selector));

}

NS_ENDHANDLER

}

- (id) initWithSelector: (SEL)aSelector

target: (id)aTarget

argument: (id)anArgument

order: (NSUInteger)theOrder

{

self = [super init];

if (self)

{

selector = aSelector;

target = RETAIN(aTarget);

argument = RETAIN(anArgument);

order = theOrder;

}

return self;

}



@interface NSRunLoop (TimedPerformers)

- (NSMutableArray*) _timedPerformers;

@implementation NSRunLoop (TimedPerformers)

- (NSMutableArray*) _timedPerformers

{

return _timedPerformers;

}

@interface GSTimedPerformer: NSObject

{

SEL selector;

id target;

id argument;

NSTimer *timer;

}

- (void) fire;

- (id) initWithSelector: (SEL)aSelector

target: (id)target

argument: (id)argument

delay: (NSTimeInterval)delay;

- (void) invalidate;

@implementation GSTimedPerformer

- (void) dealloc

{

[self finalize];

TEST_RELEASE(timer);

RELEASE(target);

RELEASE(argument);

[super dealloc];

}

- (void) fire

{

DESTROY(timer);

[target performSelector: selector withObject: argument];

[[[NSRunLoop currentRunLoop] _timedPerformers]

removeObjectIdenticalTo: self];

}

- (void) finalize

{

[self invalidate];

}

- (id) initWithSelector: (SEL)aSelector

target: (id)aTarget

argument: (id)anArgument

delay: (NSTimeInterval)delay

{

self = [super init];

if (self != nil)

{

selector = aSelector;

target = RETAIN(aTarget);

argument = RETAIN(anArgument);

timer = [[NSTimer allocWithZone: NSDefaultMallocZone()]

initWithFireDate: nil

interval: delay

target: self

selector: @selector(fire)

userInfo: nil

repeats: NO];

}

return self;

}

- (void) invalidate

{

if (timer != nil)

{

[timer invalidate];

DESTROY(timer);

}

}



#ifndef GSI_ARRAY_TYPES

#define GSI_ARRAY_TYPES GSUNION_OBJ

#define GSI_ARRAY_RELEASE(A, X) [(X).obj release]

#define GSI_ARRAY_RETAIN(A, X) [(X).obj retain]

#include "GNUstepBase/GSIArray.h"

#endif

static inline NSDate *timerDate(NSTimer *t)

{

return t->_date;

}

static inline BOOL timerInvalidated(NSTimer *t)

{

return t->_invalidated;

}



@implementation NSObject (TimedPerformers)

+ (void) cancelPreviousPerformRequestsWithTarget: (id)target

{

NSMutableArray *perf = [[NSRunLoop currentRunLoop] _timedPerformers];

unsigned count = [perf count];

if (count > 0)

{

GSTimedPerformer *array[count];

IF_NO_GC(RETAIN(target));

[perf getObjects: array];

while (count-- > 0)

{

GSTimedPerformer *p = array[count];

if (p->target == target)

{

[p invalidate];

[perf removeObjectAtIndex: count];

}

}

RELEASE(target);

}

}

+ (void) cancelPreviousPerformRequestsWithTarget: (id)target

selector: (SEL)aSelector

object: (id)arg

{

NSMutableArray *perf = [[NSRunLoop currentRunLoop] _timedPerformers];

unsigned count = [perf count];

if (count > 0)

{

GSTimedPerformer *array[count];

IF_NO_GC(RETAIN(target));

IF_NO_GC(RETAIN(arg));

[perf getObjects: array];

while (count-- > 0)

{

GSTimedPerformer *p = array[count];

if (p->target == target && sel_isEqual(p->selector, aSelector)

&& (p->argument == arg || [p->argument isEqual: arg]))

{

[p invalidate];

[perf removeObjectAtIndex: count];

}

}

RELEASE(arg);

RELEASE(target);

}

}

- (void) performSelector: (SEL)aSelector

withObject: (id)argument

afterDelay: (NSTimeInterval)seconds

{

NSRunLoop *loop = [NSRunLoop currentRunLoop];

GSTimedPerformer *item;

item = [[GSTimedPerformer alloc] initWithSelector: aSelector

target: self

argument: argument

delay: seconds];

[[loop _timedPerformers] addObject: item];

RELEASE(item);

[loop addTimer: item->timer forMode: NSDefaultRunLoopMode];

}

- (void) performSelector: (SEL)aSelector

withObject: (id)argument

afterDelay: (NSTimeInterval)seconds

inModes: (NSArray*)modes

{

unsigned count = [modes count];

if (count > 0)

{

NSRunLoop *loop = [NSRunLoop currentRunLoop];

NSString *marray[count];

GSTimedPerformer *item;

unsigned i;

item = [[GSTimedPerformer alloc] initWithSelector: aSelector

target: self

argument: argument

delay: seconds];

[[loop _timedPerformers] addObject: item];

RELEASE(item);

if ([modes isProxy])

{

for (i = 0; i < count; i++)

{

marray[i] = [modes objectAtIndex: i];

}

}

else

{

[modes getObjects: marray];

}

for (i = 0; i < count; i++)

{

[loop addTimer: item->timer forMode: marray[i]];

}

}

}

#ifdef RL_INTEGRATE_DISPATCH

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wimplicit-function-declaration"

@interface GSMainQueueDrainer : NSObject <RunLoopEvents>

+ (void*) mainQueueFileDescriptor;

@implementation GSMainQueueDrainer

+ (void*) mainQueueFileDescriptor

{

#if HAVE_DISPATCH_GET_MAIN_QUEUE_HANDLE_NP

return (void*)(uintptr_t)dispatch_get_main_queue_handle_np();

#elif HAVE__DISPATCH_GET_MAIN_QUEUE_HANDLE_4CF

return (void*)(uintptr_t)_dispatch_get_main_queue_handle_4CF();

#else

#error libdispatch missing main queue handle function

#endif

}

- (void) receivedEvent: (void*)data

type: (RunLoopEventType)type

extra: (void*)extra

forMode: (NSString*)mode

{

#if HAVE_DISPATCH_MAIN_QUEUE_DRAIN_NP

dispatch_main_queue_drain_np();

#elif HAVE__DISPATCH_MAIN_QUEUE_CALLBACK_4CF

_dispatch_main_queue_callback_4CF(NULL);

#else

#error libdispatch missing main queue callback function

#endif

}

#pragma clang diagnostic pop

#endif

@interface NSRunLoop (Private)

- (void) _addWatcher: (GSRunLoopWatcher*)item

forMode: (NSString*)mode;

- (BOOL) _checkPerformers: (GSRunLoopCtxt*)context;

- (GSRunLoopWatcher*) _getWatcher: (void*)data

type: (RunLoopEventType)type

forMode: (NSString*)mode;

- (id) _init;

- (void) _removeWatcher: (void*)data

type: (RunLoopEventType)type

forMode: (NSString*)mode;

@implementation NSRunLoop (Private)

- (void) _addWatcher: (GSRunLoopWatcher*) item forMode: (NSString*)mode

{

GSRunLoopCtxt *context;

GSIArray watchers;

unsigned i;

context = NSMapGet(_contextMap, mode);

if (context == nil)

{

context = [[GSRunLoopCtxt alloc] initWithMode: mode extra: _extra];

NSMapInsert(_contextMap, context->mode, context);

RELEASE(context);

}

watchers = context->watchers;

GSIArrayAddItem(watchers, (GSIArrayItem)((id)item));

i = GSIArrayCount(watchers);

if (i % 1000 == 0 && i > context->maxWatchers)

{

context->maxWatchers = i;

NSLog(@"WARNING ... there are %u watchers scheduled in mode %@ of %@",

i, mode, self);

}

}

- (BOOL) _checkPerformers: (GSRunLoopCtxt*)context

{

BOOL found = NO;

if (context != nil)

{

GSIArray performers = context->performers;

unsigned count = GSIArrayCount(performers);

if (count > 0)

{

NSAutoreleasePool *arp = [NSAutoreleasePool new];

GSRunLoopPerformer *array[count];

NSMapEnumerator enumerator;

GSRunLoopCtxt *original;

void *mode;

unsigned i;

found = YES;

/* We have to remove the performers before firing, so we copy

for (i = 0; i < count; i++)

{

array[i] = GSIArrayItemAtIndex(performers, i).obj;

}

performers->count = 0;

/* Remove the requests that we are about to fire from all modes.

original = context;

enumerator = NSEnumerateMapTable(_contextMap);

while (NSNextMapEnumeratorPair(&enumerator, &mode, (void**)&context))

{

if (context != nil && context != original)

{

GSIArray performers = context->performers;

unsigned tmpCount = GSIArrayCount(performers);

while (tmpCount--)

{

GSRunLoopPerformer *p;

p = GSIArrayItemAtIndex(performers, tmpCount).obj;

for (i = 0; i < count; i++)

{

if (p == array[i])

{

GSIArrayRemoveItemAtIndex(performers, tmpCount);

}

}

}

}

}

NSEndMapTableEnumeration(&enumerator);

/* Finally, fire the requests and release them.

for (i = 0; i < count; i++)

{

[array[i] fire];

RELEASE(array[i]);

IF_NO_GC([arp emptyPool];)

}

[arp drain];

}

}

return found;

}

- (GSRunLoopWatcher*) _getWatcher: (void*)data

type: (RunLoopEventType)type

forMode: (NSString*)mode

{

GSRunLoopCtxt *context;

if (mode == nil)

{

mode = [self currentMode];

if (mode == nil)

{

mode = NSDefaultRunLoopMode;

}

}

context = NSMapGet(_contextMap, mode);

if (context != nil)

{

GSIArray watchers = context->watchers;

unsigned i = GSIArrayCount(watchers);

while (i-- > 0)

{

GSRunLoopWatcher *info;

info = GSIArrayItemAtIndex(watchers, i).obj;

if (info->type == type && info->data == data)

{

return info;

}

}

}

return nil;

}

- (id) _init

{

self = [super init];

if (self != nil)

{

_contextStack = [NSMutableArray new];

_contextMap = NSCreateMapTable (NSNonRetainedObjectMapKeyCallBacks,

NSObjectMapValueCallBacks, 0);

_timedPerformers = [[NSMutableArray alloc] initWithCapacity: 8];

#ifdef HAVE_POLL_F

_extra = NSZoneMalloc(NSDefaultMallocZone(), sizeof(pollextra));

memset(_extra, '\0', sizeof(pollextra));

#endif

}

return self;

}

- (void) _removeWatcher: (void*)data

type: (RunLoopEventType)type

forMode: (NSString*)mode

{

GSRunLoopCtxt *context;

if (mode == nil)

{

mode = [self currentMode];

if (mode == nil)

{

mode = NSDefaultRunLoopMode;

}

}

context = NSMapGet(_contextMap, mode);

if (context != nil)

{

GSIArray watchers = context->watchers;

unsigned i = GSIArrayCount(watchers);

while (i-- > 0)

{

GSRunLoopWatcher *info;

info = GSIArrayItemAtIndex(watchers, i).obj;

if (info->type == type && info->data == data)

{

info->_invalidated = YES;

GSIArrayRemoveItemAtIndex(watchers, i);

}

}

}

}



@implementation NSRunLoop(GNUstepExtensions)

- (void) addEvent: (void*)data

type: (RunLoopEventType)type

watcher: (id<RunLoopEvents>)watcher

forMode: (NSString*)mode

{

GSRunLoopWatcher *info;

if (mode == nil)

{

mode = [self currentMode];

if (mode == nil)

{

mode = NSDefaultRunLoopMode;

}

}

info = [self _getWatcher: data type: type forMode: mode];

if (info != nil && (id)info->receiver == (id)watcher)

{

/* Increment usage count for this watcher. */

info->count++;

}

else

{

/* Remove any existing handler for another watcher. */

[self _removeWatcher: data type: type forMode: mode];

/* Create new object to hold information. */

info = [[GSRunLoopWatcher alloc] initWithType: type

receiver: watcher

data: data];

/* Add the object to the array for the mode. */

[self _addWatcher: info forMode: mode];

RELEASE(info); /* Now held in array. */

}

}

- (void) removeEvent: (void*)data

type: (RunLoopEventType)type

forMode: (NSString*)mode

all: (BOOL)removeAll

{

if (mode == nil)

{

mode = [self currentMode];

if (mode == nil)

{

mode = NSDefaultRunLoopMode;

}

}

if (removeAll)

{

[self _removeWatcher: data type: type forMode: mode];

}

else

{

GSRunLoopWatcher *info;

info = [self _getWatcher: data type: type forMode: mode];

if (info)

{

if (info->count == 0)

{

[self _removeWatcher: data type: type forMode: mode];

}

else

{

info->count--;

}

}

}

}

@implementation NSRunLoop

+ (void) initialize

{

if (self == [NSRunLoop class])

{

[self currentRunLoop];

theFuture = RETAIN([NSDate distantFuture]);

RELEASE([NSObject leakAt: &theFuture]);

}

}

+ (NSRunLoop*) _runLoopForThread: (NSThread*) aThread

{

GSRunLoopThreadInfo *info = GSRunLoopInfoForThread(aThread);

NSRunLoop *current = info->loop;

if (nil == current)

{

current = info->loop = [[self alloc] _init];

/* If this is the main thread, set up a housekeeping timer.

if (nil != current && [GSCurrentThread() isMainThread] == YES)

{

NSAutoreleasePool *arp = [NSAutoreleasePool new];

NSNotificationCenter *ctr;

NSNotification *not;

NSInvocation *inv;

NSTimer *timer;

SEL sel;

ctr = [NSNotificationCenter defaultCenter];

not = [NSNotification notificationWithName: @"GSHousekeeping"

object: nil

userInfo: nil];

sel = @selector(postNotification:);

inv = [NSInvocation invocationWithMethodSignature:

[ctr methodSignatureForSelector: sel]];

[inv setTarget: ctr];

[inv setSelector: sel];

[inv setArgument: &not atIndex: 2];

[inv retainArguments];

timer = [[NSTimer alloc] initWithFireDate: nil

interval: 30.0

target: inv

selector: NULL

userInfo: nil

repeats: YES];

[current addTimer: timer forMode: NSDefaultRunLoopMode];

#ifdef RL_INTEGRATE_DISPATCH

// We leak the queue drainer, because it's integral part of RL

// operations

GSMainQueueDrainer *drain =

[NSObject leak: [[GSMainQueueDrainer new] autorelease]];

[current addEvent: [GSMainQueueDrainer mainQueueFileDescriptor]

#ifdef _WIN32

type: ET_HANDLE

#else

type: ET_RDESC

#endif

watcher: drain

forMode: NSDefaultRunLoopMode];

#endif

[arp drain];

}

}

return current;

}

+ (NSRunLoop*) currentRunLoop

{

return [self _runLoopForThread: nil];

}

+ (NSRunLoop*) mainRunLoop

{

return [self _runLoopForThread: [NSThread mainThread]];

}

- (id) init

{

DESTROY(self);

return nil;

}

- (void) dealloc

{

#ifdef HAVE_POLL_F

if (_extra != 0)

{

pollextra *e = (pollextra*)_extra;

if (e->index != 0)

NSZoneFree(NSDefaultMallocZone(), e->index);

NSZoneFree(NSDefaultMallocZone(), e);

}

#endif

RELEASE(_contextStack);

if (_contextMap != 0)

{

NSFreeMapTable(_contextMap);

}

RELEASE(_timedPerformers);

[super dealloc];

}

- (NSString*) currentMode

{

return _currentMode;

}



- (void) addTimer: (NSTimer*)timer

forMode: (NSString*)mode

{

GSRunLoopCtxt *context;

GSIArray timers;

unsigned i;

if ([timer isKindOfClass: [NSTimer class]] == NO

|| [timer isProxy] == YES)

{

[NSException raise: NSInvalidArgumentException

format: @"[%@-%@] not a valid timer",

NSStringFromClass([self class]), NSStringFromSelector(_cmd)];

}

if ([mode isKindOfClass: [NSString class]] == NO)

{

[NSException raise: NSInvalidArgumentException

format: @"[%@-%@] not a valid mode",

NSStringFromClass([self class]), NSStringFromSelector(_cmd)];

}

NSDebugMLLog(@"NSRunLoop", @"add timer for %f in %@",

[[timer fireDate] timeIntervalSinceReferenceDate], mode);

context = NSMapGet(_contextMap, mode);

if (context == nil)

{

context = [[GSRunLoopCtxt alloc] initWithMode: mode extra: _extra];

NSMapInsert(_contextMap, context->mode, context);

RELEASE(context);

}

timers = context->timers;

i = GSIArrayCount(timers);

while (i-- > 0)

{

if (timer == GSIArrayItemAtIndex(timers, i).obj)

{

return; /* Timer already present */

}

}

/*

GSIArrayAddItem(timers, (GSIArrayItem)((id)timer));

i = GSIArrayCount(timers);

if (i % 1000 == 0 && i > context->maxTimers)

{

context->maxTimers = i;

NSLog(@"WARNING ... there are %u timers scheduled in mode %@ of %@",

i, mode, self);

}

}



static BOOL

updateTimer(NSTimer *t, NSDate *d, NSTimeInterval now)

{

if (timerInvalidated(t) == YES)

{

return NO;

}

if (timerDate(t) == d)

{

NSTimeInterval ti = [d timeIntervalSinceReferenceDate];

NSTimeInterval increment = [t timeInterval];

if (increment <= 0.0)

{

/* Should never get here ... unless a subclass is returning

NSLog(@"WARNING timer %@ had bad interval ... removed", t);

return NO;

}

ti += increment; // Hopefully a single increment will do.

if (ti < now)

{

NSTimeInterval add;

/* Just incrementing the date was insufficient to bring it to

add = floor((now - ti) / increment);

ti += (increment * add);

if (ti < now)

{

ti += increment;

}

}

RELEASE(t->_date);

t->_date = [[NSDate alloc] initWithTimeIntervalSinceReferenceDate: ti];

}

return YES;

}

- (NSDate*) _limitDateForContext: (GSRunLoopCtxt *)context

{

NSDate *when = nil;

NSAutoreleasePool *arp = [NSAutoreleasePool new];

GSIArray timers = context->timers;