This directory contains the source code and build logic to build the platform assemblies.

These are the symbols defined for each platform assembly:

To build core for only one platform, use the platform unique variables IOS, MONOMAC, WATCH or TVOS.

Currently 3 variations of the core Xamarin.iOS assembly and 5 variations of the core Xamarin.Mac assembly are produced:

### Xamarin.iOS ###

• A 32-bit Classic assembly (uses System.Int32 in place of NSInteger, etc.)
• A 32-bit Unified assembly (uses System.nint in place of NSInteger, etc.)
• A 64-bit Unified assembly (same as 32-bit Unified)

### Xamarin.Mac ###

• A 32-bit Classic assembly (uses System.Int32 in place of NSInteger, etc.)
• A 32-bit Unified assembly (uses System.nint in place of NSInteger, etc.)
• A 64-bit Unified assembly (same as 32-bit Unified)
• A 32-bit Full assembly (uses System.nint in place of NSInteger, and references the v4.5 BCL)
• A 64-bit Full assembly (same as 32-bit Full)

The Classic assembly will exist in order to not break customer code. Customers can choose to continue using this assembly, but we will encourage customers to move to our Unified assemblies.

The Unified assemblies provides many improvements and support for 64-bit iOS and OS X APIs.

Most native APIs use NSInteger (and related) typedefs. On 32-bit systems, these are 32-bit underlying types; on 64-bit systems, these are 64-bit underlying types.

Historically Xamarin.iOS and Xamarin.Mac have bound these explicitly as 32-bit (System.Int32, etc). With the move to 64-bit that has been ongoing in OS X for a few versions (10.6/Snow Leopard) and more recently with the anouncement of 64-bit support in iOS, we needed a solution to support both worlds.

We have introduced 6 new types to make this possible:

In the Classic assembly, the System.Drawing types are backed by the 32-bit System.Single type. In the Unified assemblies, the CoreGraphics types are backed by 32/64-bit System.nfloat type.

When binding APIs, it is important to use the new types (nint, CGRect, etc), even though they do not exist in the Classic assembly.

Before compilation, all source code is preprocessed by pmcs, an internal tool for performing C#-aware preprocessing.

For the Classic assembly, instances of the new types are translated to the legacy types. For the Unified assemblies, these types are not translated, and the native types are included in the build.

Enums are handled specially. Most native enums are backed by NSInteger or NSUInteger. Unfortunately in C#, the backing type of an enum may only be one of the primitive integral C# types. Thus, an enum cannot be backed by System.nint or System.nuint.

The convention is to make all enums that are backed natively by NSInteger or NSUInteger backed by a 64-bit primitive integral C# type (long or ulong) and then annotated with the [Native] attribute. This ensures that API is identical between the 32/64-bit assemblies but also hints to the code generator that Objective-C runtime calls should first cast the enum to a System.nint or System.nuint.

However, this also presents a problem of keeping the enum 32-bit on the Classic assemblies. Therefore, enums should actually be backed in source code nuint_compat_int. This will be preprocessed to int on the Classic assembly and ulong on the 32/64-bit assemblies.

Native Enum Definition

typedef NS_ENUM(NSUInteger, NSTableViewDropOperation) {
	NSTableViewDropOn,
	NSTableViewDropAbove
};

Managed Enum Definition

[Native]
public enum NSTableViewDropOperation : nuint_compat_int {
	DropOn,
	DropAbove
}

When dealing with enums in P/Invokes, one must never pass such an enum directly. The P/Invoke signature should take a System.nint or System.nuint and a wrapper API must cast the enum manually (as mentioned above, this is handled automatically for Objective-C APIs by the generator).

Objective-C Binding

public interface Fooable {
	[Export ("foo:")]
	void Foo (NSTableViewDropOperation dropOp);
}

C Binding

public partial class Fooable {
	[DllImport ("foo")]
	static extern void Foo (nuint dropOp);

	public static void Foo (NSTableViewDropOperation dropOp)
	{
		Foo ((nuint)(ulong)dropOp);
	}
}

pmcs is a wrapper around a regular mcs invocation. In addition to any regular arguments passed to mcs, pmcs accepts instructions on how to translate some tokens from one value to another. This is used to translate instances of native types in source code to legacy types for the 32-bit Classic assembly.

pmcs lives in the xamarin-macios repository and is used for both Xamarin.Mac and Xamarin.iOS. Explore pmcs documentation.

There are a few preprocessor variables that can be used within sources for conditional compilation:

For example, to build an API for all of iOS but only 64-bit OS X (Xamarin.Mac):

#if !MONOMAC || (MONOMAC && ARCH_64)
...
#endif