@swiftbrowser/wasm-sdk-foundation 0.0.0-stage → 0.9.0

package/wasm32-unknown-wasip1/swift.xctoolchain/usr/lib/swift_static/CoreFoundation/CFAttributedString.h

@@ -0,0 +1,157 @@
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+
+/*	CFAttributedString.h
+	Copyright (c) 2004-2019, Apple Inc. All rights reserved.
+*/
+
+/*! @header CFAttributedString
+Instances of CFAttributedString manage character strings and associated sets of attributes (for example, font and kerning) that apply to individual characters or ranges of characters in the string. CFAttributedString as defined in CoreFoundation provides the basic container functionality, while higher levels provide definitions for standard attributes, their values, and additional behaviors involving these. 
+
+CFAttributedString is not a "subclass" of CFString; that is, it does not respond to CFString function calls. CFAttributedString conceptually contains a CFString to which it applies attributes. This protects users of attributed strings from ambiguities caused by the semantic differences between simple and attributed strings.
+
+Attributes are identified by key/value pairs stored in CFDictionaryRefs. Keys must be CFStrings, while the values are arbitrary CFTypeRefs.
+*/
+
+#if !defined(__COREFOUNDATION_CFATTRIBUTEDSTRING__)
+#define __COREFOUNDATION_CFATTRIBUTEDSTRING__ 1
+
+#include "CFBase.h"
+#include "CFString.h"
+#include "CFDictionary.h"
+
+CF_IMPLICIT_BRIDGING_ENABLED
+CF_EXTERN_C_BEGIN
+
+
+/* CFAttributedString comes in immutable and mutable flavors.
+*/
+typedef const struct CF_BRIDGED_TYPE(NSAttributedString) __CFAttributedString *CFAttributedStringRef;
+typedef struct CF_BRIDGED_MUTABLE_TYPE(NSMutableAttributedString) __CFAttributedString *CFMutableAttributedStringRef;
+
+/*! @function CFAttributedStringGetTypeID
+Returns the type identifier of all CFAttributedString instances.
+*/
+CF_EXPORT CFTypeID CFAttributedStringGetTypeID(void);
+
+
+
+/*** CFAttributedString ***/
+
+/*! @function CFAttributedStringCreate
+Creates an attributed string with the specified string and attributes (both copied).
+*/
+CF_EXPORT CFAttributedStringRef CFAttributedStringCreate(CFAllocatorRef alloc, CFStringRef str, CFDictionaryRef attributes);
+
+/*! @function CFAttributedStringCreateWithSubstring
+Creates a sub-attributed string from the specified range. It's a programming error for range to specify characters outside the bounds of aStr.
+*/
+CF_EXPORT CFAttributedStringRef CFAttributedStringCreateWithSubstring(CFAllocatorRef alloc, CFAttributedStringRef aStr, CFRange range);
+
+/*! @function CFAttributedStringCreateCopy
+Creates an immutable attributed string copy.
+*/
+CF_EXPORT CFAttributedStringRef CFAttributedStringCreateCopy(CFAllocatorRef alloc, CFAttributedStringRef aStr);
+
+/*! @function CFAttributedStringGetString
+Returns the string for the attributed string. For performance reasons, this will often point at the backing store of the attributed string, and it might change if the attributed string is edited.  However, this is an implementation detail, and definitely not something that should be counted on.
+*/
+CF_EXPORT CFStringRef CFAttributedStringGetString(CFAttributedStringRef aStr);
+
+/*! @function CFAttributedStringGetLength
+Returns the length of the attributed string in characters; same as CFStringGetLength(CFAttributedStringGetString(aStr))
+*/
+CF_EXPORT CFIndex CFAttributedStringGetLength(CFAttributedStringRef aStr);
+
+/*! @function CFAttributedStringGetAttributes
+Returns the attributes at the specified location. If effectiveRange is not NULL, upon return *effectiveRange contains a range over which the exact same set of attributes apply. Note that for performance reasons, the returned effectiveRange is not necessarily the maximal range - for that, use CFAttributedStringGetAttributesAndLongestEffectiveRange().  It's a programming error for loc to specify a location outside the bounds of the attributed string.
+
+Note that the returned attribute dictionary might change in unpredictable ways from under the caller if the attributed string is edited after this call. If you wish to hang on to the dictionary long-term, you should make an actual copy of it rather than just retaining it.  Also, no assumptions should be made about the relationship of the actual CFDictionaryRef returned by this call and the dictionary originally used to set the attributes, other than the fact that the values stored in the dictionary will be identical (that is, ==) to those originally specified.
+*/
+CF_EXPORT CFDictionaryRef CFAttributedStringGetAttributes(CFAttributedStringRef aStr, CFIndex loc, CFRange *effectiveRange);
+
+/*! @function CFAttributedStringGetAttribute
+Returns the value of a single attribute at the specified location. If the specified attribute doesn't exist at the location, returns NULL. If effectiveRange is not NULL, upon return *effectiveRange contains a range over which the exact same attribute value applies. Note that for performance reasons, the returned effectiveRange is not necessarily the maximal range - for that, use CFAttributedStringGetAttributeAndLongestEffectiveRange(). It's a programming error for loc to specify a location outside the bounds of the attributed string.
+*/
+CF_EXPORT CFTypeRef CFAttributedStringGetAttribute(CFAttributedStringRef aStr, CFIndex loc, CFStringRef attrName, CFRange *effectiveRange);
+
+/*! @function CFAttributedStringGetAttributesAndLongestEffectiveRange
+Returns the attributes at the specified location. If longestEffectiveRange is not NULL, upon return *longestEffectiveRange contains the maximal range within inRange over which the exact same set of attributes apply. The returned range is clipped to inRange. It's a programming error for loc or inRange to specify locations outside the bounds of the attributed string.
+*/
+CF_EXPORT CFDictionaryRef CFAttributedStringGetAttributesAndLongestEffectiveRange(CFAttributedStringRef aStr, CFIndex loc, CFRange inRange, CFRange *longestEffectiveRange);
+
+/*! @function CFAttributedStringGetAttributeAndLongestEffectiveRange
+Returns the value of a single attribute at the specified location. If longestEffectiveRange is not NULL, upon return *longestEffectiveRange contains the maximal range within inRange over which the exact same attribute value applies. The returned range is clipped to inRange. It's a programming error for loc or inRange to specify locations outside the bounds of the attributed string.
+*/
+CF_EXPORT CFTypeRef CFAttributedStringGetAttributeAndLongestEffectiveRange(CFAttributedStringRef aStr, CFIndex loc, CFStringRef attrName, CFRange inRange, CFRange *longestEffectiveRange);
+
+
+
+/*** CFMutableAttributedString ***/
+
+/*! @function CFAttributedStringCreateMutableCopy
+Creates a mutable attributed string copy. maxLength, if not 0, is a hard bound on the length of the attributed string; exceeding this size limit during any editing operation is a programming error. If 0, there is no limit on the length.
+*/
+CF_EXPORT CFMutableAttributedStringRef CFAttributedStringCreateMutableCopy(CFAllocatorRef alloc, CFIndex maxLength, CFAttributedStringRef aStr);
+
+/*! @function CFAttributedStringCreateMutable
+Creates a mutable empty attributed string. maxLength, if not 0, is a hard bound on the length of the attributed string; exceeding this size limit during any editing operation is a programming error. If 0, there is no limit on the length.
+*/
+CF_EXPORT CFMutableAttributedStringRef CFAttributedStringCreateMutable(CFAllocatorRef alloc, CFIndex maxLength);
+
+/*! @function CFAttributedStringReplaceString
+Modifies the string for the attributed string, much like CFStringReplace().  It's an error for range to specify characters outside the bounds of aStr. 
+
+(Note: This function is a convenience on CFAttributedStringGetMutableString(); however, until CFAttributedStringGetMutableString() is implemented, it remains the only way to edit the string of the attributed string.)
+*/
+CF_EXPORT void CFAttributedStringReplaceString(CFMutableAttributedStringRef aStr, CFRange range, CFStringRef replacement);
+
+/*! @function CFAttributedStringGetMutableString
+Gets the string for the attributed string as a mutable string, allowing editing the character contents of the string as if it were an CFMutableString. Attributes corresponding to the edited range are appropriately modified. If, as a result of the edit, new characters are introduced into the string, they inherit the attributes of the first replaced character from range. If no existing characters are replaced by the edit, the new characters inherit the attributes of the character preceding range if it has any, otherwise of the character following range. If the initial string is empty, the attributes for the new characters are also empty.
+
+(Note: This function is not yet implemented and will return NULL except for toll-free bridged instances.)
+*/
+CF_EXPORT CFMutableStringRef CFAttributedStringGetMutableString(CFMutableAttributedStringRef aStr);
+
+/*! @function CFAttributedStringSetAttributes
+Sets the value of multiple attributes over the specified range, which should be valid. If clearOtherAttributes is false, existing attributes (which aren't being replaced) are left alone; otherwise they are cleared. The dictionary should be setup for "usual" CF type usage --- CFString keys, and arbitrary CFType values. Note that after this call, further mutations to the replacement dictionary argument by the caller will not affect the contents of the attributed string.
+*/
+CF_EXPORT void CFAttributedStringSetAttributes(CFMutableAttributedStringRef aStr, CFRange range, CFDictionaryRef replacement, Boolean clearOtherAttributes);
+
+/*! @function CFAttributedStringSetAttribute
+Sets the value of a single attribute over the specified range, which should be valid. value should not be NULL. 
+*/
+CF_EXPORT void CFAttributedStringSetAttribute(CFMutableAttributedStringRef aStr, CFRange range, CFStringRef attrName, CFTypeRef value);
+
+/*! @function CFAttributedStringRemoveAttribute
+Removes the value of a single attribute over the specified range, which should be valid. It's OK for the attribute not the exist over the specified range.
+*/
+CF_EXPORT void CFAttributedStringRemoveAttribute(CFMutableAttributedStringRef aStr, CFRange range, CFStringRef attrName);
+
+/*! @function CFAttributedStringReplaceAttributedString
+Replaces the attributed substring over the specified range with the attributed string specified in replacement. range should be valid. To delete a range of the attributed string, call CFAttributedStringReplaceString() with empty string and specified range. 
+*/
+CF_EXPORT void CFAttributedStringReplaceAttributedString(CFMutableAttributedStringRef aStr, CFRange range, CFAttributedStringRef replacement);
+
+/*! @function CFAttributedStringBeginEditing
+In cases where attributed string might do a bunch of work to assure self-consistency, CFAttributedStringBeginEditing/CFAttributedStringEndEditing allow disabling that to allow deferring and coalescing any work. It's a good idea to call these around a set of related mutation calls which don't require the string to be in consistent state in between. These calls can be nested. 
+*/
+CF_EXPORT void CFAttributedStringBeginEditing(CFMutableAttributedStringRef aStr);
+
+/*! @function CFAttributedStringEndEditing
+In cases where attributed string might do a bunch of work to assure self-consistency, CFAttributedStringBeginEditing/CFAttributedStringEndEditing allow disabling that to allow deferring and coalescing any work. It's a good idea to call these around a set of related mutation calls which don't require the string to be in consistent state in between. These calls can be nested. 
+*/
+CF_EXPORT void CFAttributedStringEndEditing(CFMutableAttributedStringRef aStr);
+
+
+CF_EXTERN_C_END
+CF_IMPLICIT_BRIDGING_DISABLED
+
+#endif /* ! __COREFOUNDATION_CFATTRIBUTEDSTRING__ */
+

package/wasm32-unknown-wasip1/swift.xctoolchain/usr/lib/swift_static/CoreFoundation/CFAttributedStringPriv.h

@@ -0,0 +1,25 @@
+/*	CFAttributedStringPriv.h
+	Copyright (c) 2004-2019, Apple Inc. All rights reserved.
+*/
+
+#if !defined(__COREFOUNDATION_CFATTRIBUTEDSTRINGPRIV__)
+#define __COREFOUNDATION_CFATTRIBUTEDSTRINGPRIV__ 1
+
+#include "CFAttributedString.h"
+
+CF_EXTERN_C_BEGIN
+
+/* CFAttributedStringCreateWithRuns() creates an attributed string from the specified string and a list of sparse attribute dictionaries. The ranges for the dictionaries do not have to cover the string, but they should be ordered from low to high indexes, and they shouldn't overlap. CFAttributedStringGetRuns() will return conformant arrays.
+*/
+CF_EXPORT CFAttributedStringRef _CFAttributedStringCreateWithRuns(CFAllocatorRef alloc, CFStringRef str, const CFDictionaryRef *attrDictionaries, const CFRange *runRanges, CFIndex numRuns);
+
+/* The next two functions are SPI which allow return bulk information about attributes. The includeEmpty argument enables choosing to ignore or include runs where the attribute dictionaries are empty. The size of the CFRange and CFDictionaryRef arguments passed to CFAttributedStringGetRuns() should be obtained from CFAttributedStringGetNumberOfRuns(), called with the same value for includeEmpty.
+*/
+CF_EXPORT void _CFAttributedStringGetRuns(CFAttributedStringRef attrStr, Boolean includeEmpty, CFDictionaryRef *attrDictionaries, CFRange *runRanges);
+CF_EXPORT CFIndex _CFAttributedStringGetNumberOfRuns(CFAttributedStringRef attrStr, Boolean includeEmpty);
+
+
+CF_EXTERN_C_END
+
+#endif /* ! __COREFOUNDATION_CFATTRIBUTEDSTRINGPRIV__ */
+

package/wasm32-unknown-wasip1/swift.xctoolchain/usr/lib/swift_static/CoreFoundation/CFAvailability.h

@@ -0,0 +1,236 @@
+/*	CFAvailability.h
+	Copyright (c) 2013-2019, Apple Inc. and the Swift project authors
+ 
+	Portions Copyright (c) 2014-2019, Apple Inc. and the Swift project authors
+	Licensed under Apache License v2.0 with Runtime Library Exception
+	See http://swift.org/LICENSE.txt for license information
+	See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+*/
+
+#ifndef DEPLOYMENT_RUNTIME_SWIFT
+#define DEPLOYMENT_RUNTIME_SWIFT 1
+#endif
+
+#if !defined(__COREFOUNDATION_CFAVAILABILITY__)
+#define __COREFOUNDATION_CFAVAILABILITY__ 1
+
+#include "CFTargetConditionals.h"
+
+#if __has_include(<Availability.h>) && __has_include(<os/availability.h>) && __has_include(<AvailabilityMacros.h>)
+#include <Availability.h>
+#include <os/availability.h>
+// Even if unused, these must remain here for compatibility, because projects rely on them being included.
+#include <AvailabilityMacros.h>
+#else
+#define API_AVAILABLE(...)
+#define API_DEPRECATED(...)
+#define API_UNAVAILABLE(...)
+#endif
+
+#ifndef __has_feature
+#define __has_feature(x) 0
+#endif
+#ifndef __has_attribute
+#define __has_attribute(x) 0
+#endif
+#ifndef __has_extension
+#define __has_extension(x) 0
+#endif
+
+// The arguments to these availability macros is a version number, e.g. 10_6, 3_0 or 'NA'
+// To use a deprecation message with the macro, add a string as the last argument.
+#if __has_feature(attribute_availability_with_version_underscores) || (__has_feature(attribute_availability_with_message) && __clang__ && __clang_major__ >= 7)
+#if TARGET_OS_OSX
+// This section is for compilers targeting OS X which support attribute_availability_with_message
+
+#define CF_AVAILABLE(_mac, _ios) __attribute__((availability(macosx,introduced=_mac)))
+#define CF_AVAILABLE_MAC(_mac) __attribute__((availability(macosx,introduced=_mac)))
+#define CF_AVAILABLE_IOS(_ios) __attribute__((availability(macosx,unavailable)))
+#define CF_DEPRECATED(_macIntro, _macDep, _iosIntro, _iosDep, ...) __attribute__((availability(macosx,introduced=_macIntro,deprecated=_macDep,message="" __VA_ARGS__)))
+#define CF_DEPRECATED_MAC(_macIntro, _macDep, ...) __attribute__((availability(macosx,introduced=_macIntro,deprecated=_macDep,message="" __VA_ARGS__)))
+#define CF_DEPRECATED_IOS(_iosIntro, _iosDep, ...) __attribute__((availability(macosx,unavailable)))
+
+#elif TARGET_OS_IPHONE
+// This section is for compilers targeting iOS which support attribute_availability_with_message
+
+#define CF_AVAILABLE(_mac, _ios) __attribute__((availability(ios,introduced=_ios)))
+#define CF_AVAILABLE_MAC(_mac) __attribute__((availability(ios,unavailable)))
+#define CF_AVAILABLE_IOS(_ios) __attribute__((availability(ios,introduced=_ios)))
+#define CF_DEPRECATED(_macIntro, _macDep, _iosIntro, _iosDep, ...) __attribute__((availability(ios,introduced=_iosIntro,deprecated=_iosDep,message="" __VA_ARGS__)))
+#define CF_DEPRECATED_MAC(_macIntro, _macDep, ...) __attribute__((availability(ios,unavailable)))
+#define CF_DEPRECATED_IOS(_iosIntro, _iosDep, ...) __attribute__((availability(ios,introduced=_iosIntro,deprecated=_iosDep,message="" __VA_ARGS__)))
+
+#endif
+
+#elif TARGET_OS_OSX || TARGET_OS_IPHONE
+// This section is for OS X or iOS, and compilers without support for attribute_availability_with_message. We fall back to Availability.h.
+
+#ifndef __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_0
+#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_0 __AVAILABILITY_INTERNAL_DEPRECATED
+#endif
+
+#define CF_AVAILABLE(_mac, _ios) __OSX_AVAILABLE_STARTING(__MAC_##_mac, __IPHONE_##_ios)
+#define CF_AVAILABLE_MAC(_mac) __OSX_AVAILABLE_STARTING(__MAC_##_mac, __IPHONE_NA)
+#define CF_AVAILABLE_IOS(_ios) __OSX_AVAILABLE_STARTING(__MAC_NA, __IPHONE_##_ios)
+#define CF_DEPRECATED(_macIntro, _macDep, _iosIntro, _iosDep, ...) __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_##_macIntro, __MAC_##_macDep, __IPHONE_##_iosIntro, __IPHONE_##_iosDep)
+#define CF_DEPRECATED_MAC(_macIntro, _macDep, ...) __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_##_macIntro, __MAC_##_macDep, __IPHONE_NA, __IPHONE_NA)
+#define CF_DEPRECATED_IOS(_iosIntro, _iosDep, ...) __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_NA, __MAC_NA, __IPHONE_##_iosIntro, __IPHONE_##_iosDep)
+
+#endif // __has_feature(attribute_availability_with_message)
+
+#ifndef CF_AVAILABLE
+// This section is for platforms which do not support availability
+#define CF_AVAILABLE(_mac, _ios)
+#define CF_AVAILABLE_MAC(_mac)
+#define CF_AVAILABLE_IOS(_ios)
+#define CF_DEPRECATED(_macIntro, _macDep, _iosIntro, _iosDep, ...)
+#define CF_DEPRECATED_MAC(_macIntro, _macDep, ...)
+#define CF_DEPRECATED_IOS(_iosIntro, _iosDep, ...)
+#endif
+
+// Older versions of these macros; use iOS versions instead
+#define CF_AVAILABLE_IPHONE(_ios) CF_AVAILABLE_IOS(_ios)
+#define CF_DEPRECATED_IPHONE(_iosIntro, _iosDep) CF_DEPRECATED_IOS(_iosIntro, _iosDep)
+
+// Enum availability macros
+#if __has_feature(enumerator_attributes) && __has_attribute(availability)
+#define CF_ENUM_AVAILABLE(_mac, _ios) CF_AVAILABLE(_mac, _ios)
+#define CF_ENUM_AVAILABLE_MAC(_mac) CF_AVAILABLE_MAC(_mac)
+#define CF_ENUM_AVAILABLE_IOS(_ios) CF_AVAILABLE_IOS(_ios)
+#define CF_ENUM_DEPRECATED(_macIntro, _macDep, _iosIntro, _iosDep, ...) CF_DEPRECATED(_macIntro, _macDep, _iosIntro, _iosDep, __VA_ARGS__)
+#define CF_ENUM_DEPRECATED_MAC(_macIntro, _macDep, ...) CF_DEPRECATED_MAC(_macIntro, _macDep, __VA_ARGS__)
+#define CF_ENUM_DEPRECATED_IOS(_iosIntro, _iosDep, ...) CF_DEPRECATED_IOS(_iosIntro, _iosDep, __VA_ARGS__)
+#else
+#define CF_ENUM_AVAILABLE(_mac, _ios)
+#define CF_ENUM_AVAILABLE_MAC(_mac)
+#define CF_ENUM_AVAILABLE_IOS(_ios)
+#define CF_ENUM_DEPRECATED(_macIntro, _macDep, _iosIntro, _iosDep, ...)
+#define CF_ENUM_DEPRECATED_MAC(_macIntro, _macDep, ...)
+#define CF_ENUM_DEPRECATED_IOS(_iosIntro, _iosDep, ...)
+#endif
+
+// "Soft" deprecation.
+#ifndef API_TO_BE_DEPRECATED
+/// This macro is used as a version number in API that will be deprecated in an upcoming release. We call this API "soft deprecated". Soft deprecation is an intermediate step before formal deprecation, used as a way to give you a heads-up about the API before you start getting a compiler warning.
+/// You can find all places in your code that use soft deprecated API by redefining the value of this macro to your current minimum deployment target, for example:
+///   (macOS)
+///    clang -DAPI_TO_BE_DEPRECATED=10.12 other compiler flags
+///   (iOS)
+///    clang -DAPI_TO_BE_DEPRECATED=11.0 other compiler flags
+#define API_TO_BE_DEPRECATED 100000
+#endif
+
+// Enums and Options
+#if __has_attribute(enum_extensibility)
+#define __CF_ENUM_ATTRIBUTES __attribute__((enum_extensibility(open)))
+#define __CF_CLOSED_ENUM_ATTRIBUTES __attribute__((enum_extensibility(closed)))
+#define __CF_OPTIONS_ATTRIBUTES __attribute__((flag_enum,enum_extensibility(open)))
+#else
+#define __CF_ENUM_ATTRIBUTES
+#define __CF_CLOSED_ENUM_ATTRIBUTES
+#define __CF_OPTIONS_ATTRIBUTES
+#endif
+
+#define __CF_ENUM_GET_MACRO(_1, _2, NAME, ...) NAME
+#define __CF_ENUM_FIXED_IS_AVAILABLE (__cplusplus && __cplusplus >= 201103L && (__has_extension(cxx_strong_enums) || __has_feature(objc_fixed_enum))) || (!__cplusplus && (__has_feature(objc_fixed_enum) || __has_extension(cxx_fixed_enum)))
+
+#if __CF_ENUM_FIXED_IS_AVAILABLE
+#define __CF_NAMED_ENUM(_type, _name)     int __CF_ENUM_ ## _name; enum __CF_ENUM_ATTRIBUTES _name : _type; typedef enum _name _name; enum _name : _type
+#define __CF_ANON_ENUM(_type)             enum __CF_ENUM_ATTRIBUTES : _type
+#define CF_CLOSED_ENUM(_type, _name)      int __CF_ENUM_ ## _name; enum __CF_CLOSED_ENUM_ATTRIBUTES _name : _type; typedef enum _name _name; enum _name : _type
+#if (__cplusplus)
+#define CF_OPTIONS(_type, _name) _type _name; enum __CF_OPTIONS_ATTRIBUTES : _type
+#else
+#define CF_OPTIONS(_type, _name) int __CF_OPTIONS_ ## _name; enum __CF_OPTIONS_ATTRIBUTES _name : _type; typedef enum _name _name; enum _name : _type
+#endif
+#else
+#define __CF_NAMED_ENUM(_type, _name) _type _name; enum
+#define __CF_ANON_ENUM(_type) enum
+#define CF_CLOSED_ENUM(_type, _name) _type _name; enum
+#define CF_OPTIONS(_type, _name) _type _name; enum
+#endif
+
+/* CF_ENUM supports the use of one or two arguments. The first argument is always the integer type used for the values of the enum. The second argument is an optional type name for the macro. When specifying a type name, you must precede the macro with 'typedef' like so:
+
+typedef CF_ENUM(CFIndex, CFComparisonResult) {
+    ...
+};
+
+If you do not specify a type name, do not use 'typdef', like so:
+
+CF_ENUM(CFIndex) {
+    ...
+};
+*/
+#define CF_ENUM(...) __CF_ENUM_GET_MACRO(__VA_ARGS__, __CF_NAMED_ENUM, __CF_ANON_ENUM, )(__VA_ARGS__)
+
+#if __has_attribute(swift_wrapper)
+#define _CF_TYPED_ENUM __attribute__((swift_wrapper(enum)))
+#else
+#define _CF_TYPED_ENUM
+#endif
+
+#if __has_attribute(swift_wrapper)
+#define _CF_TYPED_EXTENSIBLE_ENUM __attribute__((swift_wrapper(struct)))
+#else
+#define _CF_TYPED_EXTENSIBLE_ENUM
+#endif
+
+#if DEPLOYMENT_RUNTIME_SWIFT
+#define CF_STRING_ENUM
+#define CF_EXTENSIBLE_STRING_ENUM
+
+#define CF_TYPED_ENUM
+#define CF_TYPED_EXTENSIBLE_ENUM
+#else
+#define CF_STRING_ENUM _CF_TYPED_ENUM
+#define CF_EXTENSIBLE_STRING_ENUM _CF_TYPED_EXTENSIBLE_ENUM
+
+#define CF_TYPED_ENUM _CF_TYPED_ENUM
+#define CF_TYPED_EXTENSIBLE_ENUM _CF_TYPED_EXTENSIBLE_ENUM
+#endif
+
+#define __CF_ERROR_ENUM_GET_MACRO(_1, _2, NAME, ...) NAME
+#if ((__cplusplus && __cplusplus >= 201103L && (__has_extension(cxx_strong_enums) || __has_feature(objc_fixed_enum))) || (!__cplusplus && __has_feature(objc_fixed_enum))) && __has_attribute(ns_error_domain)
+#define __CF_NAMED_ERROR_ENUM(_domain, _name)     enum __attribute__((ns_error_domain(_domain))) _name : CFIndex _name; enum _name : CFIndex
+#define __CF_ANON_ERROR_ENUM(_domain)             enum __attribute__((ns_error_domain(_domain))) : CFIndex
+#else
+#define __CF_NAMED_ERROR_ENUM(_domain, _name) __CF_NAMED_ENUM(CFIndex, _name)
+#define __CF_ANON_ERROR_ENUM(_domain) __CF_ANON_ENUM(CFIndex)
+#endif
+
+/* CF_ERROR_ENUM supports the use of one or two arguments. The first argument is always the domain specifier for the enum. The second argument is an optional name of the typedef for the macro. When specifying a name for of the typedef, you must precede the macro with 'typedef' like so:
+ 
+ typedef CF_ERROR_ENUM(kCFSomeErrorDomain, SomeErrorCodes) {
+ ...
+ };
+ 
+ If you do not specify a typedef name, do not use 'typedef', like so:
+ 
+ CF_ERROR_ENUM(kCFSomeErrorDomain) {
+ ...
+ };
+ */
+#define CF_ERROR_ENUM(...) __CF_ERROR_ENUM_GET_MACRO(__VA_ARGS__, __CF_NAMED_ERROR_ENUM, __CF_ANON_ERROR_ENUM)(__VA_ARGS__)
+
+#ifndef CF_SWIFT_BRIDGED_TYPEDEF
+#if __has_attribute(swift_bridged_typedef)
+#define CF_SWIFT_BRIDGED_TYPEDEF __attribute__((swift_bridged_typedef))
+#else
+#define CF_SWIFT_BRIDGED_TYPEDEF
+#endif
+#endif
+
+// Extension availability macros
+#define CF_EXTENSION_UNAVAILABLE(_msg)      __OS_EXTENSION_UNAVAILABLE(_msg)
+#define CF_EXTENSION_UNAVAILABLE_MAC(_msg)  __OSX_EXTENSION_UNAVAILABLE(_msg)
+#define CF_EXTENSION_UNAVAILABLE_IOS(_msg)  __IOS_EXTENSION_UNAVAILABLE(_msg)
+
+// Swift availability macro
+#if __has_feature(attribute_availability_swift)
+#define CF_SWIFT_UNAVAILABLE(_msg) __attribute__((availability(swift, unavailable, message=_msg)))
+#else
+#define CF_SWIFT_UNAVAILABLE(_msg)
+#endif
+
+#endif // __COREFOUNDATION_CFAVAILABILITY__

package/wasm32-unknown-wasip1/swift.xctoolchain/usr/lib/swift_static/CoreFoundation/CFBag.h

@@ -0,0 +1,97 @@
+/*	CFBag.h
+	Copyright (c) 1998-2019, Apple Inc. and the Swift project authors
+ 
+	Portions Copyright (c) 2014-2019, Apple Inc. and the Swift project authors
+	Licensed under Apache License v2.0 with Runtime Library Exception
+	See http://swift.org/LICENSE.txt for license information
+	See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+*/
+
+#if !defined(__COREFOUNDATION_CFBAG__)
+#define __COREFOUNDATION_CFBAG__ 1
+
+#include "CFBase.h"
+
+CF_IMPLICIT_BRIDGING_ENABLED
+CF_EXTERN_C_BEGIN
+
+typedef const void *	(*CFBagRetainCallBack)(CFAllocatorRef allocator, const void *value);
+typedef void		(*CFBagReleaseCallBack)(CFAllocatorRef allocator, const void *value);
+typedef CFStringRef	(*CFBagCopyDescriptionCallBack)(const void *value);
+typedef Boolean		(*CFBagEqualCallBack)(const void *value1, const void *value2);
+typedef CFHashCode	(*CFBagHashCallBack)(const void *value);
+typedef struct {
+    CFIndex				version;
+    CFBagRetainCallBack			retain;
+    CFBagReleaseCallBack		release;
+    CFBagCopyDescriptionCallBack	copyDescription;
+    CFBagEqualCallBack			equal;
+    CFBagHashCallBack			hash;
+} CFBagCallBacks;
+
+CF_EXPORT
+const CFBagCallBacks kCFTypeBagCallBacks;
+CF_EXPORT
+const CFBagCallBacks kCFCopyStringBagCallBacks;
+
+typedef void (*CFBagApplierFunction)(const void *value, void *context);
+
+typedef const struct CF_BRIDGED_TYPE(id) __CFBag * CFBagRef;
+typedef struct CF_BRIDGED_MUTABLE_TYPE(id) __CFBag * CFMutableBagRef;
+
+CF_EXPORT
+CFTypeID CFBagGetTypeID(void);
+
+CF_EXPORT
+CFBagRef CFBagCreate(CFAllocatorRef allocator, const void **values, CFIndex numValues, const CFBagCallBacks *callBacks);
+
+CF_EXPORT
+CFBagRef CFBagCreateCopy(CFAllocatorRef allocator, CFBagRef theBag);
+
+CF_EXPORT
+CFMutableBagRef CFBagCreateMutable(CFAllocatorRef allocator, CFIndex capacity, const CFBagCallBacks *callBacks);
+
+CF_EXPORT
+CFMutableBagRef CFBagCreateMutableCopy(CFAllocatorRef allocator, CFIndex capacity, CFBagRef theBag);
+
+CF_EXPORT
+CFIndex CFBagGetCount(CFBagRef theBag);
+
+CF_EXPORT
+CFIndex CFBagGetCountOfValue(CFBagRef theBag, const void *value);
+
+CF_EXPORT
+Boolean CFBagContainsValue(CFBagRef theBag, const void *value);
+
+CF_EXPORT
+const void *CFBagGetValue(CFBagRef theBag, const void *value);
+
+CF_EXPORT
+Boolean CFBagGetValueIfPresent(CFBagRef theBag, const void *candidate, const void **value);
+
+CF_EXPORT
+void CFBagGetValues(CFBagRef theBag, const void **values);
+
+CF_EXPORT
+void CFBagApplyFunction(CFBagRef theBag, CFBagApplierFunction CF_NOESCAPE applier, void *context);
+
+CF_EXPORT
+void CFBagAddValue(CFMutableBagRef theBag, const void *value);
+
+CF_EXPORT
+void CFBagReplaceValue(CFMutableBagRef theBag, const void *value);
+
+CF_EXPORT
+void CFBagSetValue(CFMutableBagRef theBag, const void *value);
+
+CF_EXPORT
+void CFBagRemoveValue(CFMutableBagRef theBag, const void *value);
+
+CF_EXPORT
+void CFBagRemoveAllValues(CFMutableBagRef theBag);
+
+CF_EXTERN_C_END
+CF_IMPLICIT_BRIDGING_DISABLED
+
+#endif /* ! __COREFOUNDATION_CFBAG__ */
+