ObjFW  Check-in [469a496cd2]

 *
 * This is only available if `OF_HAVE_SANDBOX` is defined.
 *
 * @param sandbox The sandbox to activate
 */
+ (void)activateSandbox: (OFSandbox *)sandbox;
#endif

- init OF_UNAVAILABLE;

/*!
 * @brief Gets argc and argv.
 *
 * @param argc A pointer where a pointer to argc should be stored
 * @param argv A pointer where a pointer to argv should be stored
 */

#ifdef HAVE_SIGACTION
# ifndef SA_RESTART
#  define SA_RESTART 0
# endif
#endif

@interface OFApplication ()
- (instancetype)OF_init OF_METHOD_FAMILY(init);
- (void)OF_setArgumentCount: (int *)argc
	  andArgumentValues: (char **[])argv;
#ifdef OF_WINDOWS
- (void)OF_setArgumentCount: (int)argc
      andWideArgumentValues: (wchar_t *[])argv;
#endif
- (void)OF_run;

		    "application delegate!\n  Most likely, you wanted to "
		    "subclass OFObject instead or specified\n  the wrong class "
		    "with OF_APPLICATION_DELEGATE().\n",
		    class_getName(cls), class_getName(cls));
		exit(1);
	}

	app = [[OFApplication alloc] init];
	app = [[OFApplication alloc] OF_init];

	[app OF_setArgumentCount: argc
	       andArgumentValues: argv];

#ifdef OF_WINDOWS
	__wgetmainargs(&wargc, &wargv, &wenvp, _CRT_glob, &si);
	[app OF_setArgumentCount: wargc

#ifdef OF_HAVE_SANDBOX
+ (void)activateSandbox: (OFSandbox *)sandbox
{
	[app activateSandbox: sandbox];
}
#endif

- init
- OF_init
{
	self = [super init];

	@try {
		void *pool;
		OFMutableDictionary *environment;
#if defined(OF_MACOS)

 * @brief Initializes an already allocated OFDeflateStream with the specified
 *	  underlying stream.
 *
 * @param stream The underlying stream to which compressed data is written or
 *		 from which compressed data is read
 * @return A initialized OFDeflateStream
 */
- initWithStream: (OFStream *)stream;
- initWithStream: (OFStream *)stream OF_DESIGNATED_INITIALIZER;
@end

OF_ASSUME_NONNULL_END

	uint8_t _buffer[4];
	OFDate *_modificationDate;
	uint16_t _extraLength;
	uint32_t _CRC32, _uncompressedSize;
}

+ (instancetype)streamWithStream: (OFStream *)stream;
- init OF_UNAVAILABLE;
- initWithStream: (OFStream *)stream;
- initWithStream: (OFStream *)stream OF_DESIGNATED_INITIALIZER;
@end

OF_ASSUME_NONNULL_END

#import "OFInvalidFormatException.h"

@implementation OFGZIPStream
+ (instancetype)streamWithStream: (OFStream *)stream
{
	return [[[self alloc] initWithStream: stream] autorelease];
}

- init
{
	OF_INVALID_INIT_METHOD
}

- initWithStream: (OFStream *)stream
{
	self = [super init];

	@try {
		_stream = [stream retain];

 * @brief Returns a new OFHMAC with the specified hashing algorithm.
 *
 * @param hashClass The class of the hashing algorithm
 * @return A new, autoreleased OFHMAC
 */
+ (instancetype)HMACWithHashClass: (Class <OFCryptoHash>)hashClass;

- init OF_UNAVAILABLE;

/*!
 * @brief Initialized an already allocated OFHMAC with the specified hashing
 *	  algorithm.
 *
 * @param hashClass The class of the hashing algorithm
 * @return An initialized OFHMAC
 */
- initWithHashClass: (Class <OFCryptoHash>)hashClass;
- initWithHashClass: (Class <OFCryptoHash>)hashClass OF_DESIGNATED_INITIALIZER;

/*!
 * @brief Sets the key for the HMAC.
 *
 * @note This resets the HMAC!
 *
 * @warning This invalidates any pointer previously returned by @ref digest. If

@implementation OFHMAC
@synthesize hashClass = _hashClass;

+ (instancetype)HMACWithHashClass: (Class <OFCryptoHash>)class
{
	return [[[self alloc] initWithHashClass: class] autorelease];
}

- init
{
	OF_INVALID_INIT_METHOD
}

- initWithHashClass: (Class <OFCryptoHash>)class
{
	self = [super init];

	_hashClass = class;

 *	  and value.
 *
 * @param name The name of the cookie
 * @param value The value of the cookie
 * @return An initialized OFHTTPCookie
 */
- initWithName: (OFString *)name
	 value: (OFString *)value;
	 value: (OFString *)value OF_DESIGNATED_INITIALIZER;
@end

#import "OFString.h"

OF_ASSUME_NONNULL_BEGIN

@class OFStream;

@interface OFINICategory ()
- (instancetype)OF_init;
- (instancetype)OF_init OF_METHOD_FAMILY(init);
- (void)OF_parseLine: (OFString *)line;
- (bool)OF_writeToStream: (OFStream *)stream
		encoding: (of_string_encoding_t)encoding
		   first: (bool)first;
@end

OF_ASSUME_NONNULL_END

 *
 * @param path The path to the file whose contents the OFINIFile should contain
 * @param encoding The encoding of the specified file
 *
 * @return An initialized OFINIFile with the contents of the specified file
 */
- initWithPath: (OFString *)path
      encoding: (of_string_encoding_t)encoding;
      encoding: (of_string_encoding_t)encoding OF_DESIGNATED_INITIALIZER;

/*!
 * @brief Returns an @ref OFINICategory for the category with the specified
 *	  name.
 *
 * @param name The name of the category for which an @ref OFINICategory should
 *	       be returned

/*!
 * @brief Initializes an already allocated OFIntrospection with the specified
 *	  class.
 *
 * @return An initialized OFIntrospection
 */
- initWithClass: (Class)class_;
- initWithClass: (Class)class_ OF_DESIGNATED_INITIALIZER;
@end

OF_ASSUME_NONNULL_END

 * @param objectFunctions A structure of functions for handling objects
 * @param capacity A hint about the count of elements expected to be in the map
 *	  table
 * @return An initialized OFMapTable
 */
- initWithKeyFunctions: (of_map_table_functions_t)keyFunctions
       objectFunctions: (of_map_table_functions_t)objectFunctions
	      capacity: (size_t)capacity;
	      capacity: (size_t)capacity OF_DESIGNATED_INITIALIZER;

/*!
 * @brief Returns the number of objects in the map table.
 *
 * @return The number of objects in the map table
 */
- (size_t)count;

		hash: (uint32_t)hash;
@end

@interface OFMapTableEnumerator ()
- (instancetype)OF_initWithMapTable: (OFMapTable *)mapTable
			    buckets: (struct of_map_table_bucket **)buckets
			   capacity: (uint32_t)capacity
		   mutationsPointer: (unsigned long *)mutationsPtr;
		   mutationsPointer: (unsigned long *)mutationsPtr
    OF_METHOD_FAMILY(init);
@end

@interface OFMapTableKeyEnumerator: OFMapTableEnumerator
@end

@interface OFMapTableObjectEnumerator: OFMapTableEnumerator
@end

 *	  specified type and data.
 *
 * @param type The MessagePack extension type
 * @param data The data for the extension
 * @return An initialized OFMessagePackRepresentation
 */
- initWithType: (int8_t)type
	  data: (OFDataArray *)data;
	  data: (OFDataArray *)data OF_DESIGNATED_INITIALIZER;
@end

OF_ASSUME_NONNULL_END

 *
 * @param options An array of @ref of_options_parser_option_t specifying all
 *		  accepted options, terminated with an option whose short
 *		  option is `\0` and long option is `nil`.
 *
 * @return An initialized OFOptionsParser
 */
- initWithOptions: (const of_options_parser_option_t *)options;
- initWithOptions: (const of_options_parser_option_t *)options
    OF_DESIGNATED_INITIALIZER;

/*!
 * @brief Returns the next option.
 *
 * If the option is only available as a long option, `-` is returned.
 * Otherwise, the short option is returned, even if it was specified as a long
 * option.@n

 *		      environment first, copy it, modify it and then pass it.
 * @return An initialized OFProcess.
 */
- initWithProgram: (OFString *)program
      programName: (OFString *)programName
	arguments: (nullable OFArray OF_GENERIC(OFString *) *)arguments
      environment: (nullable OFDictionary
		       OF_GENERIC(OFString *, OFString *) *)environment;
		       OF_GENERIC(OFString *, OFString *) *)environment
    OF_DESIGNATED_INITIALIZER;

/*!
 * @brief Closes the write direction of the process.
 *
 * This method needs to be called for some programs before data can be read,
 * since some programs don't start processing before the write direction is
 * closed.
 */
- (void)closeForWriting;
@end

OF_ASSUME_NONNULL_END

 * @brief Initializes an already allocated OFSettings instance with the
 *	  specified application name.
 *
 * @param applicationName The name of the application whose settings should be
 *			  accessed
 * @return An initialized OFSettings instance
 */
- initWithApplicationName: (OFString *)applicationName;
- initWithApplicationName: (OFString *)applicationName
    OF_DESIGNATED_INITIALIZER;

/*!
 * @brief Sets the specified path to the specified string.
 *
 * @param string The string to set
 * @param path The path to store the string at
 */

 */

#import "OFStdIOStream.h"

OF_ASSUME_NONNULL_BEGIN

@interface OFStdIOStream ()
- (instancetype)OF_initWithFileDescriptor: (int)fd;
- (instancetype)OF_initWithFileDescriptor: (int)fd OF_METHOD_FAMILY(init);
@end

OF_ASSUME_NONNULL_END

#import "OFString_UTF8.h"

OF_ASSUME_NONNULL_BEGIN

@interface OFString_UTF8 ()
- (instancetype)OF_initWithUTF8String: (const char *)UTF8String
			       length: (size_t)UTF8StringLength
			      storage: (char *)storage;
			      storage: (char *)storage OF_METHOD_FAMILY(init);
@end

OF_ASSUME_NONNULL_END

/*!
 * @brief Initializes an already allocated OFTarArchive object with the
 *	  specified stream.
 *
 * @param stream A stream from which the tar archive will be read
 * @return An initialized OFTarArchive
 */
- initWithStream: (OFStream *)stream;
- initWithStream: (OFStream *)stream OF_DESIGNATED_INITIALIZER;

#ifdef OF_HAVE_FILES
/*!
 * @brief Initializes an already allocated OFTarArchive object with the
 *	  specified file.
 *
 * @param path The path to the tar archive

	return self;
}

#ifdef OF_HAVE_FILES
- initWithPath: (OFString *)path
{
	self = [super init];

	@try {
		_stream = [[OFFile alloc] initWithPath: path
						  mode: @"rb"];
	} @catch (id e) {
		[self release];
	OFFile *file = [[OFFile alloc] initWithPath: path
					       mode: @"rb"];
	@try {
		return [self initWithStream: file];
	} @finally {
		[file release];
		@throw e;
	}

	return self;
}
#endif

- (void)dealloc
{
	[_stream release];
	[_lastReturnedEntry release];

#import "OFTarArchiveEntry.h"

OF_ASSUME_NONNULL_BEGIN

@interface OFTarArchiveEntry ()
- (instancetype)OF_initWithHeader: (char[_Nonnull 512])header
			   stream: (OFStream *)stream;
			   stream: (OFStream *)stream OF_METHOD_FAMILY(init);
- (void)OF_skip;
@end

OF_ASSUME_NONNULL_END

 */
@property (readonly) uint32_t deviceMajor;

/*!
 * The device major (if the file is a device).
 */
@property (readonly) uint32_t deviceMinor;

- init OF_UNAVAILABLE;
@end

OF_ASSUME_NONNULL_END

@implementation OFTarArchiveEntry
@synthesize fileName = _fileName, mode = _mode, size = _size;
@synthesize modificationDate = _modificationDate, type = _type;
@synthesize targetFileName = _targetFileName;
@synthesize owner = _owner, group = _group;
@synthesize deviceMajor = _deviceMajor, deviceMinor = _deviceMinor;

- init
{
	OF_INVALID_INIT_METHOD
}

- (instancetype)OF_initWithHeader: (char[512])header
			   stream: (OFStream *)stream
{
	self = [super init];

	@try {

/*!
 * @brief Initializes an already allocated OFThreadPool with the specified
 *	  number of threads.
 *
 * @param size The number of threads for the pool
 * @return An initialized OFThreadPool with the specified number of threads
 */
- initWithSize: (size_t)size;
- initWithSize: (size_t)size OF_DESIGNATED_INITIALIZER;

/*!
 * @brief Execute the specified selector on the specified target with the
 *	  specified object as soon as a thread is ready.
 *
 * @param target The target on which to perform the selector
 * @param selector The selector to perform on the target

}

#ifdef OF_HAVE_FILES
- (void)parseFile: (OFString *)path
{
	OFFile *file = [[OFFile alloc] initWithPath: path
					       mode: @"rb"];

	@try {
		[self parseStream: file];
	} @finally {
		[file release];
	}
}
#endif

/*!
 * @brief Initializes an already allocated OFZIPArchive object with the
 *	  specified seekable stream.
 *
 * @param stream A seekable stream from which the ZIP archive will be read
 * @return An initialized OFZIPArchive
 */
- initWithSeekableStream: (OFSeekableStream *)stream;
- initWithSeekableStream: (OFSeekableStream *)stream OF_DESIGNATED_INITIALIZER;

#ifdef OF_HAVE_FILES
/*!
 * @brief Initializes an already allocated OFZIPArchive object with the
 *	  specified file.
 *
 * @param path The path to the ZIP file

	return self;
}

#ifdef OF_HAVE_FILES
- initWithPath: (OFString *)path
{
	self = [super init];

	@try {
		_stream = [[OFFile alloc] initWithPath: path
						  mode: @"rb"];

		[self OF_readZIPInfo];
	OFFile *file = [[OFFile alloc] initWithPath: path
					       mode: @"rb"];
	@try {
		return [self initWithSeekableStream: file];
		[self OF_readEntries];
	} @catch (id e) {
		[self release];
	} @finally {
		[file release];
		@throw e;
	}

	return self;
}
#endif

- (void)dealloc
{
	[_stream release];
	[_archiveComment release];

OF_ASSUME_NONNULL_BEGIN

@interface OFZIPArchiveEntry ()
@property (readonly) uint16_t OF_lastModifiedFileTime, OF_lastModifiedFileDate;
@property (readonly) int64_t OF_localFileHeaderOffset;

- (instancetype)OF_initWithStream: (OFStream *)stream;
- (instancetype)OF_initWithStream: (OFStream *)stream OF_METHOD_FAMILY(init);
@end

OF_ASSUME_NONNULL_END

/*!
 * The general purpose bit flag of the entry.
 *
 * See the ZIP specification for details.
 */
@property (readonly) uint16_t generalPurposeBitFlag;

- init OF_UNAVAILABLE;

/*!
 * @brief Returns the last modification date of the entry's file.
 *
 * @return The last modification date of the entry's file
 */
- (OFDate *)modificationDate;

@synthesize uncompressedSize = _uncompressedSize;
@synthesize CRC32 = _CRC32;
@synthesize versionSpecificAttributes = _versionSpecificAttributes;
@synthesize generalPurposeBitFlag = _generalPurposeBitFlag;
@synthesize OF_lastModifiedFileTime = _lastModifiedFileTime;
@synthesize OF_lastModifiedFileDate = _lastModifiedFileDate;
@synthesize OF_localFileHeaderOffset = _localFileHeaderOffset;

- init
{
	OF_INVALID_INIT_METHOD
}

- (instancetype)OF_initWithStream: (OFStream *)stream
{
	self = [super init];

	@try {
		void *pool = objc_autoreleasePoolPush();

#if __has_attribute(__objc_subclassing_restricted__)
# define OF_SUBCLASSING_RESTRICTED \
    __attribute__((__objc_subclassing_restricted__))
#else
# define OF_SUBCLASSING_RESTRICTED
#endif

#if __has_attribute(__objc_method_family__)
# define OF_METHOD_FAMILY(f) __attribute__((__objc_method_family__(f)))
#else
# define OF_METHOD_FAMILY(f)
#endif

#if __has_attribute(__objc_designated_initializer__)
# define OF_DESIGNATED_INITIALIZER \
    __attribute__((__objc_designated_initializer__))
#else
# define OF_DESIGNATED_INITIALIZER
#endif

#ifdef __GNUC__
# ifdef OF_X86_64
#  define OF_X86_64_ASM
# endif
# ifdef OF_X86
#  define OF_X86_ASM