@interface IdleTime: NSObject
{
mach_port_t ioPort;
io_iterator_t ioIterator;
io_object_t ioObject;
}

@property( readonly ) uint64_t timeIdle;
@property( readonly ) NSUInteger secondsIdle;

@end

@implementation IdleTime

- ( id )init
{
if( ( self = [ super init ] ) ) {

}

return self;
}

- ( void )dealloc
{
[ super dealloc ];
}

- ( uint64_t )timeIdle
{
return 0;
}

- ( NSUInteger )secondsIdle
{
uint64_t time;

time = self.timeIdle;

return ( NSUInteger )( time >> 30 );
}

@end

if ( ioObject == 0 ) {

/* Error management */
}

IOObjectRetain( ioObject );
IOObjectRetain( ioIterator );

return time;

foo( bar );

foo( myCallback );

function bar()
{
var str = 'Hello World';

foo(
function()
{
return str;
}
);
}

bar();

int main( void )
{
NSAutoreleasePool * pool;
NSString * ( ^myBlock )( int );

pool = [ [ NSAutoreleasePool alloc ] init ];
myBlock = ^( int number )
{
return [ NSString stringWithFormat: @"Passed number: %i", number ];
};

NSLog( @"%@", myBlock() );

[ pool release ];

return EXIT_SUCCESS;
}

void logBlock( int ( ^theBlock )( void ) )
{
NSLog( @"Closure var X: %i", theBlock() );
}

int main( void )
{
NSAutoreleasePool * pool;
int ( ^myBlock )( void );
int x;

pool = [ [ NSAutoreleasePool alloc ] init ];
x = 27;

myBlock = ^( void )
{
return x;
};

logBlock( myBlock );

[ pool release ];

return EXIT_SUCCESS;
}

return x;
};

+ ( NSArray * )arrayByFilteringArray: ( NSArray * )source withCallback: ( BOOL ( ^ )( id ) )callback;

@end

+ ( NSArray * )arrayByFilteringArray: ( NSArray * )source withCallback: ( BOOL ( ^ )( id ) )callback
{
NSMutableArray * result;
id element;

result = [ NSMutableArray arrayWithCapacity: [ source count ] ];

for( element in source ) {

if( callback( element ) == YES ) {

[ result addObject: element ];
}
}

return result;
}

@end

@interface NSArray( BlockExample )

+ ( NSArray * )arrayByFilteringArray: ( NSArray * )source withCallback: ( BOOL ( ^ )( id ) )callback;

@end

@implementation NSArray( BlockExample )

+ ( NSArray * )arrayByFilteringArray: ( NSArray * )source withCallback: ( BOOL ( ^ )( id ) )callback
{
NSMutableArray * result;
id element;

result = [ NSMutableArray arrayWithCapacity: [ source count ] ];

for( element in source ) {

if( callback( element ) == YES ) {

[ result addObject: element ];
}
}

return result;
}

@end

int main( void )
{
NSAutoreleasePool * pool;
NSArray * array1;
NSArray * array2;

pool = [ [ NSAutoreleasePool alloc ] init ];
array1 = [ NSArray arrayWithObjects: @"Hello World!", [ NSDate date ], @"Hello Universe!", nil ];
array2 = [ NSArray
arrayByFilteringArray: array1
withCallback: ^ BOOL ( id element )
{
return [ element isKindOfClass: [ NSString class ] ];
}
];

NSLog( @"%@", array2 );

[ pool release ];

return EXIT_SUCCESS;
}

/* Definition of the boolean data type */
typedef enum { FALSE, TRUE } boolean;

/**
* Converts a integer to its float representation
*
* This function converts a 32 bits integer to a single precision floating point
* number, as specified by the IEEE Standard for Floating-Point Arithmetic
* (IEEE 754). This standard can be found at the folowing address:
* {@link http://ieeexplore.ieee.org/servlet/opac?punumber=4610933}
*
* @param unsigned long The integer to convert to a floating point value
* @return float The floating point number
* @author Jean-David Gadina <macmade@netinfluence.com>
*/
float binaryToFloat( unsigned long binary )
{
/* Gets the sign field */
/* Bit 0, left to right */
boolean sign = binary >> 31;

/* Gets the exponent field */
/* Bits 1 to 8, left to right */
unsigned char exp = ( ( binary >> 23 ) & 0xFF );

/* Gets the mantissa field */
/* Bits 9 to 32, left to right */
unsigned long mantissa = ( binary & 0x7FFFFF );

/* Storage for the return value */
float floatValue = 0;

/* Counter */
signed int i = 0;

/* Checks the values of the exponent and the mantissa fields to handle special numbers */
if( exp == 0 && mantissa == 0 ) {

/* Zero - No need for a computation even if it can be considered as a denormalized number */
return 0;

} else if( exp == 255 && mantissa == 0 ) {

/* Infinity */
return 0;

} else if( exp == 255 && mantissa != 0 ) {

/* Not a number */
return 0;

} else if( exp == 0 && mantissa != 0 ) {

/* Denormalized number - Exponent is fixed to -126 */
exp = -126;

} else {

/* Computes the real exponent */
exp = exp - 127;

/* Adds the implicit bit to the mantissa */
mantissa = mantissa | 0x800000;
}

/* Process the 24 bits of the mantissa */
for( i = 0; i > -24; i-- ) {

/* Checks if the current bit is set */
if( mantissa & ( 1 << ( i + 23 ) ) ) {

/* Adds the value for the current bit */
/* This is done by computing two raised to the power of the exponent plus the bit position */
/* (negative if it's after the implicit bit, as we are using scientific notation) */
floatValue += ( float )pow( 2, i + exp );
}
}

/* Returns the final float value */
return ( sign == FALSE ) ? floatValue : -floatValue;
}

/**
* C main() function
*
* @return int The exit status
*/
int main( void )
{
printf( "%f\n", binaryToFloat( 0x40B80000 ) );
return EXIT_SUCCESS;
}